Add files using upload-large-folder tool

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/algorithm_wrapper.h

@@ -0,0 +1,27 @@
+/*
+ *  Copyright 2020 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+// When a compiler uses Thrust as part of its implementation of Standard C++
+// algorithms, a cycle of included files may result when Thrust code tries to
+// use a standard algorithm.  Having a macro that is defined only when Thrust
+// is including an algorithms-related header gives the compiler a chance to
+// detect and break the cycle of includes.
+
+#define THRUST_INCLUDING_ALGORITHMS_HEADER
+#include <algorithm>
+#undef  THRUST_INCLUDING_ALGORITHMS_HEADER

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/allocator/copy_construct_range.h

@@ -0,0 +1,46 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename System, typename Allocator, typename InputIterator, typename Pointer>
+__host__ __device__
+  Pointer copy_construct_range(thrust::execution_policy<System> &from_system,
+                               Allocator &a,
+                               InputIterator first,
+                               InputIterator last,
+                               Pointer result);
+
+template<typename System, typename Allocator, typename InputIterator, typename Size, typename Pointer>
+__host__ __device__
+  Pointer copy_construct_range_n(thrust::execution_policy<System> &from_system,
+                                 Allocator &a,
+                                 InputIterator first,
+                                 Size n,
+                                 Pointer result);
+
+} // end detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/copy_construct_range.inl>
+

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/allocator/copy_construct_range.inl

@@ -0,0 +1,310 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/allocator/allocator_traits.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/copy.h>
+#include <thrust/tuple.h>
+#include <thrust/advance.h>
+#include <thrust/distance.h>
+#include <thrust/iterator/zip_iterator.h>
+#include <thrust/for_each.h>
+#include <thrust/detail/memory_wrapper.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace allocator_traits_detail
+{
+
+
+template<typename Allocator, typename InputType, typename OutputType>
+  struct copy_construct_with_allocator
+{
+  Allocator &a;
+
+  __host__ __device__
+  copy_construct_with_allocator(Allocator &a)
+    : a(a)
+  {}
+
+  template<typename Tuple>
+  inline __host__ __device__
+  void operator()(Tuple t)
+  {
+    const InputType &in = thrust::get<0>(t);
+    OutputType &out = thrust::get<1>(t);
+
+    allocator_traits<Allocator>::construct(a, &out, in);
+  }
+};
+
+
+// we need to use allocator_traits<Allocator>::construct() to
+// copy construct a T if either:
+// 1. Allocator has a 2-argument construct() member or
+// 2. T has a non-trivial copy constructor
+template<typename Allocator, typename T>
+  struct needs_copy_construct_via_allocator
+    : integral_constant<
+        bool,
+        (has_member_construct2<Allocator,T,T>::value || !has_trivial_copy_constructor<T>::value)
+      >
+{};
+
+
+// we know that std::allocator::construct's only effect is to call T's
+// copy constructor, so we needn't consider or use its construct() member for copy construction
+template<typename U, typename T>
+  struct needs_copy_construct_via_allocator<std::allocator<U>, T>
+    : integral_constant<
+        bool,
+        !has_trivial_copy_constructor<T>::value
+      >
+{};
+
+
+// XXX it's regrettable that this implementation is copied almost
+//     exactly from system::detail::generic::uninitialized_copy
+//     perhaps generic::uninitialized_copy could call this routine
+//     with a default allocator
+template<typename Allocator, typename FromSystem, typename ToSystem, typename InputIterator, typename Pointer>
+__host__ __device__
+  typename enable_if_convertible<
+    FromSystem,
+    ToSystem,
+    Pointer
+  >::type
+    uninitialized_copy_with_allocator(Allocator &a,
+                                      const thrust::execution_policy<FromSystem> &,
+                                      const thrust::execution_policy<ToSystem> &to_system,
+                                      InputIterator first,
+                                      InputIterator last,
+                                      Pointer result)
+{
+  // zip up the iterators
+  typedef thrust::tuple<InputIterator,Pointer> IteratorTuple;
+  typedef thrust::zip_iterator<IteratorTuple>  ZipIterator;
+
+  ZipIterator begin = thrust::make_zip_iterator(thrust::make_tuple(first,result));
+  ZipIterator end = begin;
+
+  // get a zip_iterator pointing to the end
+  const typename thrust::iterator_difference<InputIterator>::type n = thrust::distance(first,last);
+  thrust::advance(end,n);
+
+  // create a functor
+  typedef typename iterator_traits<InputIterator>::value_type InputType;
+  typedef typename iterator_traits<Pointer>::value_type       OutputType;
+
+  // do the for_each
+  // note we use to_system to dispatch the for_each
+  thrust::for_each(to_system, begin, end, copy_construct_with_allocator<Allocator,InputType,OutputType>(a));
+
+  // return the end of the output range
+  return thrust::get<1>(end.get_iterator_tuple());
+}
+
+
+// XXX it's regrettable that this implementation is copied almost
+//     exactly from system::detail::generic::uninitialized_copy_n
+//     perhaps generic::uninitialized_copy_n could call this routine
+//     with a default allocator
+template<typename Allocator, typename FromSystem, typename ToSystem, typename InputIterator, typename Size, typename Pointer>
+__host__ __device__
+  typename enable_if_convertible<
+    FromSystem,
+    ToSystem,
+    Pointer
+  >::type
+    uninitialized_copy_with_allocator_n(Allocator &a,
+                                        const thrust::execution_policy<FromSystem> &,
+                                        const thrust::execution_policy<ToSystem> &to_system,
+                                        InputIterator first,
+                                        Size n,
+                                        Pointer result)
+{
+  // zip up the iterators
+  typedef thrust::tuple<InputIterator,Pointer> IteratorTuple;
+  typedef thrust::zip_iterator<IteratorTuple>  ZipIterator;
+
+  ZipIterator begin = thrust::make_zip_iterator(thrust::make_tuple(first,result));
+
+  // create a functor
+  typedef typename iterator_traits<InputIterator>::value_type InputType;
+  typedef typename iterator_traits<Pointer>::value_type       OutputType;
+
+  // do the for_each_n
+  // note we use to_system to dispatch the for_each_n
+  ZipIterator end = thrust::for_each_n(to_system, begin, n, copy_construct_with_allocator<Allocator,InputType,OutputType>(a));
+
+  // return the end of the output range
+  return thrust::get<1>(end.get_iterator_tuple());
+}
+
+
+template<typename Allocator, typename FromSystem, typename ToSystem, typename InputIterator, typename Pointer>
+__host__ __device__
+  typename disable_if_convertible<
+    FromSystem,
+    ToSystem,
+    Pointer
+  >::type
+    uninitialized_copy_with_allocator(Allocator &,
+                                      const thrust::execution_policy<FromSystem> &from_system,
+                                      const thrust::execution_policy<ToSystem> &to_system,
+                                      InputIterator first,
+                                      InputIterator last,
+                                      Pointer result)
+{
+  // the systems aren't trivially interoperable
+  // just call two_system_copy and hope for the best
+  return thrust::detail::two_system_copy(from_system, to_system, first, last, result);
+} // end uninitialized_copy_with_allocator()
+
+
+template<typename Allocator, typename FromSystem, typename ToSystem, typename InputIterator, typename Size, typename Pointer>
+__host__ __device__
+  typename disable_if_convertible<
+    FromSystem,
+    ToSystem,
+    Pointer
+  >::type
+    uninitialized_copy_with_allocator_n(Allocator &,
+                                        const thrust::execution_policy<FromSystem> &from_system,
+                                        const thrust::execution_policy<ToSystem> &to_system,
+                                        InputIterator first,
+                                        Size n,
+                                        Pointer result)
+{
+  // the systems aren't trivially interoperable
+  // just call two_system_copy_n and hope for the best
+  return thrust::detail::two_system_copy_n(from_system, to_system, first, n, result);
+} // end uninitialized_copy_with_allocator_n()
+
+
+template<typename FromSystem, typename Allocator, typename InputIterator, typename Pointer>
+__host__ __device__
+  typename disable_if<
+    needs_copy_construct_via_allocator<
+      Allocator,
+      typename pointer_element<Pointer>::type
+    >::value,
+    Pointer
+  >::type
+    copy_construct_range(thrust::execution_policy<FromSystem> &from_system,
+                         Allocator &a,
+                         InputIterator first,
+                         InputIterator last,
+                         Pointer result)
+{
+  // just call two_system_copy
+  return thrust::detail::two_system_copy(from_system, allocator_system<Allocator>::get(a), first, last, result);
+}
+
+
+template<typename FromSystem, typename Allocator, typename InputIterator, typename Size, typename Pointer>
+__host__ __device__
+  typename disable_if<
+    needs_copy_construct_via_allocator<
+      Allocator,
+      typename pointer_element<Pointer>::type
+    >::value,
+    Pointer
+  >::type
+    copy_construct_range_n(thrust::execution_policy<FromSystem> &from_system,
+                           Allocator &a,
+                           InputIterator first,
+                           Size n,
+                           Pointer result)
+{
+  // just call two_system_copy_n
+  return thrust::detail::two_system_copy_n(from_system, allocator_system<Allocator>::get(a), first, n, result);
+}
+
+
+template<typename FromSystem, typename Allocator, typename InputIterator, typename Pointer>
+__host__ __device__
+  typename enable_if<
+    needs_copy_construct_via_allocator<
+      Allocator,
+      typename pointer_element<Pointer>::type
+    >::value,
+    Pointer
+  >::type
+    copy_construct_range(thrust::execution_policy<FromSystem> &from_system,
+                         Allocator &a,
+                         InputIterator first,
+                         InputIterator last,
+                         Pointer result)
+{
+  return uninitialized_copy_with_allocator(a, from_system, allocator_system<Allocator>::get(a), first, last, result);
+}
+
+
+template<typename FromSystem, typename Allocator, typename InputIterator, typename Size, typename Pointer>
+__host__ __device__
+  typename enable_if<
+    needs_copy_construct_via_allocator<
+      Allocator,
+      typename pointer_element<Pointer>::type
+    >::value,
+    Pointer
+  >::type
+    copy_construct_range_n(thrust::execution_policy<FromSystem> &from_system,
+                           Allocator &a,
+                           InputIterator first,
+                           Size n,
+                           Pointer result)
+{
+  return uninitialized_copy_with_allocator_n(a, from_system, allocator_system<Allocator>::get(a), first, n, result);
+}
+
+
+} // end allocator_traits_detail
+
+
+template<typename System, typename Allocator, typename InputIterator, typename Pointer>
+__host__ __device__
+  Pointer copy_construct_range(thrust::execution_policy<System> &from_system,
+                               Allocator &a,
+                               InputIterator first,
+                               InputIterator last,
+                               Pointer result)
+{
+  return allocator_traits_detail::copy_construct_range(from_system, a, first, last, result);
+}
+
+
+template<typename System, typename Allocator, typename InputIterator, typename Size, typename Pointer>
+__host__ __device__
+  Pointer copy_construct_range_n(thrust::execution_policy<System> &from_system,
+                                 Allocator &a,
+                                 InputIterator first,
+                                 Size n,
+                                 Pointer result)
+{
+  return allocator_traits_detail::copy_construct_range_n(from_system, a, first, n, result);
+}
+
+
+} // end detail
+THRUST_NAMESPACE_END
+

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/allocator/default_construct_range.h

@@ -0,0 +1,36 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+inline void default_construct_range(Allocator &a, Pointer p, Size n);
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/default_construct_range.inl>
+
+

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/allocator/destroy_range.inl

@@ -0,0 +1,167 @@
+/*
+ *  Copyright 2008-2021 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/detail/allocator/destroy_range.h>
+#include <thrust/detail/allocator/allocator_traits.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/for_each.h>
+#include <thrust/detail/memory_wrapper.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace allocator_traits_detail
+{
+
+
+// destroy_range has three cases:
+// if Allocator has an effectful member function destroy:
+//   1. destroy via the allocator
+// else
+//   2. if T has a non-trivial destructor, destroy the range without using the allocator
+//   3. if T has a trivial destructor, do a no-op
+
+template<typename Allocator, typename T>
+  struct has_effectful_member_destroy
+    : has_member_destroy<Allocator,T>
+{};
+
+// std::allocator::destroy's only effect is to invoke its argument's destructor
+template<typename U, typename T>
+  struct has_effectful_member_destroy<std::allocator<U>, T>
+    : thrust::detail::false_type
+{};
+
+// case 1: Allocator has an effectful 1-argument member function "destroy"
+template<typename Allocator, typename Pointer>
+  struct enable_if_destroy_range_case1
+    : thrust::detail::enable_if<
+        has_effectful_member_destroy<
+          Allocator,
+          typename pointer_element<Pointer>::type
+        >::value
+      >
+{};
+
+// case 2: Allocator has no member function "destroy", but T has a non-trivial destructor
+template<typename Allocator, typename Pointer>
+  struct enable_if_destroy_range_case2
+    : thrust::detail::enable_if<
+        !has_effectful_member_destroy<
+          Allocator,
+          typename pointer_element<Pointer>::type
+        >::value &&
+        !has_trivial_destructor<
+          typename pointer_element<Pointer>::type
+        >::value
+      >
+{};
+
+// case 3: Allocator has no member function "destroy", and T has a trivial destructor
+template<typename Allocator, typename Pointer>
+  struct enable_if_destroy_range_case3
+    : thrust::detail::enable_if<
+        !has_effectful_member_destroy<
+          Allocator,
+          typename pointer_element<Pointer>::type
+        >::value &&
+        has_trivial_destructor<
+          typename pointer_element<Pointer>::type
+        >::value
+      >
+{};
+
+
+
+template<typename Allocator>
+  struct destroy_via_allocator
+{
+  Allocator &a;
+
+  __host__ __device__
+  destroy_via_allocator(Allocator &a)
+    : a(a)
+  {}
+
+  template<typename T>
+  inline __host__ __device__
+  void operator()(T &x)
+  {
+    allocator_traits<Allocator>::destroy(a, &x);
+  }
+};
+
+
+// destroy_range case 1: destroy via allocator
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+  typename enable_if_destroy_range_case1<Allocator,Pointer>::type
+    destroy_range(Allocator &a, Pointer p, Size n)
+{
+  thrust::for_each_n(allocator_system<Allocator>::get(a), p, n, destroy_via_allocator<Allocator>(a));
+}
+
+
+// we must prepare for His coming
+struct gozer
+{
+  __thrust_exec_check_disable__
+  template<typename T>
+  inline __host__ __device__
+  void operator()(T &x)
+  {
+    x.~T();
+  }
+};
+
+// destroy_range case 2: destroy without the allocator
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+  typename enable_if_destroy_range_case2<Allocator,Pointer>::type
+    destroy_range(Allocator &a, Pointer p, Size n)
+{
+  thrust::for_each_n(allocator_system<Allocator>::get(a), p, n, gozer());
+}
+
+
+// destroy_range case 3: no-op
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+  typename enable_if_destroy_range_case3<Allocator,Pointer>::type
+    destroy_range(Allocator &, Pointer, Size)
+{
+  // no op
+}
+
+
+} // end allocator_traits_detail
+
+
+template<typename Allocator, typename Pointer, typename Size>
+__host__ __device__
+  void destroy_range(Allocator &a, Pointer p, Size n)
+{
+  return allocator_traits_detail::destroy_range(a,p,n);
+}
+
+
+} // end detail
+THRUST_NAMESPACE_END
+

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/allocator/fill_construct_range.h

@@ -0,0 +1,35 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+
+template<typename Allocator, typename Pointer, typename Size, typename T>
+__host__ __device__
+inline void fill_construct_range(Allocator &a, Pointer p, Size n, const T &value);
+
+
+} // end detail
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/allocator/fill_construct_range.inl>
+

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/allocator/no_throw_allocator.h

@@ -0,0 +1,72 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <nv/target>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename BaseAllocator>
+  struct no_throw_allocator : BaseAllocator
+{
+  private:
+    typedef BaseAllocator super_t;
+  
+  public:
+    inline __host__ __device__
+    no_throw_allocator(const BaseAllocator &other = BaseAllocator())
+      : super_t(other)
+    {}
+
+    template<typename U>
+      struct rebind
+    {
+      typedef no_throw_allocator<typename super_t::template rebind<U>::other> other;
+    }; // end rebind
+
+    __host__ __device__
+    void deallocate(typename super_t::pointer p, typename super_t::size_type n)
+    {
+      NV_IF_TARGET(NV_IS_HOST, (
+        try
+        {
+          super_t::deallocate(p, n);
+        } // end try
+        catch(...)
+        {
+          // catch anything
+        } // end catch
+      ), (
+        super_t::deallocate(p, n);
+      ));
+    } // end deallocate()
+
+    inline __host__ __device__
+    bool operator==(no_throw_allocator const &other) { return super_t::operator==(other); }
+
+    inline __host__ __device__
+    bool operator!=(no_throw_allocator const &other) { return super_t::operator!=(other); }
+}; // end no_throw_allocator
+
+} // end detail
+THRUST_NAMESPACE_END
+
+

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/allocator/tagged_allocator.inl

@@ -0,0 +1,104 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/allocator/tagged_allocator.h>
+#include <limits>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+
+template<typename T, typename Tag, typename Pointer>
+  __host__ __device__
+  tagged_allocator<T,Tag,Pointer>
+    ::tagged_allocator()
+{}
+
+
+template<typename T, typename Tag, typename Pointer>
+  __host__ __device__
+  tagged_allocator<T,Tag,Pointer>
+    ::tagged_allocator(const tagged_allocator<T,Tag,Pointer> &)
+{}
+
+
+template<typename T, typename Tag, typename Pointer>
+  template<typename U, typename OtherPointer>
+    __host__ __device__
+    tagged_allocator<T,Tag,Pointer>
+      ::tagged_allocator(const tagged_allocator<U,Tag,OtherPointer> &)
+{}
+
+
+template<typename T, typename Tag, typename Pointer>
+  __host__ __device__
+  tagged_allocator<T,Tag,Pointer>
+    ::~tagged_allocator()
+{}
+
+
+template<typename T, typename Tag, typename Pointer>
+  __host__ __device__
+  typename tagged_allocator<T,Tag,Pointer>::pointer
+    tagged_allocator<T,Tag,Pointer>
+      ::address(reference x) const
+{
+  return &x;
+}
+
+
+template<typename T, typename Tag, typename Pointer>
+  __host__ __device__
+  typename tagged_allocator<T,Tag,Pointer>::const_pointer
+    tagged_allocator<T,Tag,Pointer>
+      ::address(const_reference x) const
+{
+  return &x;
+}
+
+
+template<typename T, typename Tag, typename Pointer>
+  typename tagged_allocator<T,Tag,Pointer>::size_type
+    tagged_allocator<T,Tag,Pointer>
+      ::max_size() const
+{
+  return (std::numeric_limits<size_type>::max)() / sizeof(T);
+}
+
+
+template<typename T1, typename Pointer1, typename T2, typename Pointer2, typename Tag>
+__host__ __device__
+bool operator==(const tagged_allocator<T1,Pointer1,Tag> &, const tagged_allocator<T2,Pointer2,Tag> &)
+{
+  return true;
+}
+
+
+template<typename T1, typename Pointer1, typename T2, typename Pointer2, typename Tag>
+__host__ __device__
+bool operator!=(const tagged_allocator<T1,Pointer1,Tag> &, const tagged_allocator<T2,Pointer2,Tag> &)
+{
+  return false;
+}
+
+
+} // end detail
+THRUST_NAMESPACE_END
+

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/binary_search.inl

@@ -0,0 +1,480 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/binary_search.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/binary_search.h>
+#include <thrust/system/detail/adl/binary_search.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy, typename ForwardIterator, typename LessThanComparable>
+__host__ __device__
+ForwardIterator lower_bound(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            const LessThanComparable &value)
+{
+    using thrust::system::detail::generic::lower_bound;
+    return lower_bound(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, value);
+}
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator, typename T, typename StrictWeakOrdering>
+__host__ __device__
+ForwardIterator lower_bound(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            const T &value,
+                            StrictWeakOrdering comp)
+{
+    using thrust::system::detail::generic::lower_bound;
+    return lower_bound(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, value, comp);
+}
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator, typename LessThanComparable>
+__host__ __device__
+ForwardIterator upper_bound(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            const LessThanComparable &value)
+{
+    using thrust::system::detail::generic::upper_bound;
+    return upper_bound(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, value);
+}
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator, typename T, typename StrictWeakOrdering>
+__host__ __device__
+ForwardIterator upper_bound(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            const T &value,
+                            StrictWeakOrdering comp)
+{
+    using thrust::system::detail::generic::upper_bound;
+    return upper_bound(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, value, comp);
+}
+
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy, typename ForwardIterator, typename LessThanComparable>
+__host__ __device__
+bool binary_search(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                   ForwardIterator first,
+                   ForwardIterator last,
+                   const LessThanComparable& value)
+{
+    using thrust::system::detail::generic::binary_search;
+    return binary_search(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, value);
+}
+
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy, typename ForwardIterator, typename T, typename StrictWeakOrdering>
+__host__ __device__
+bool binary_search(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                   ForwardIterator first,
+                   ForwardIterator last,
+                   const T& value,
+                   StrictWeakOrdering comp)
+{
+    using thrust::system::detail::generic::binary_search;
+    return binary_search(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, value, comp);
+}
+
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy, typename ForwardIterator, typename T, typename StrictWeakOrdering>
+__host__ __device__
+thrust::pair<ForwardIterator, ForwardIterator>
+equal_range(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+            ForwardIterator first,
+            ForwardIterator last,
+            const T& value,
+            StrictWeakOrdering comp)
+{
+    using thrust::system::detail::generic::equal_range;
+    return equal_range(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, value, comp);
+}
+
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy, typename ForwardIterator, typename LessThanComparable>
+__host__ __device__
+thrust::pair<ForwardIterator, ForwardIterator>
+equal_range(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+            ForwardIterator first,
+            ForwardIterator last,
+            const LessThanComparable& value)
+{
+    using thrust::system::detail::generic::equal_range;
+    return equal_range(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, value);
+}
+
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator>
+__host__ __device__
+OutputIterator lower_bound(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           ForwardIterator first,
+                           ForwardIterator last,
+                           InputIterator values_first,
+                           InputIterator values_last,
+                           OutputIterator output)
+{
+    using thrust::system::detail::generic::lower_bound;
+    return lower_bound(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, values_first, values_last, output);
+}
+
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator, typename StrictWeakOrdering>
+__host__ __device__
+OutputIterator lower_bound(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           ForwardIterator first,
+                           ForwardIterator last,
+                           InputIterator values_first,
+                           InputIterator values_last,
+                           OutputIterator output,
+                           StrictWeakOrdering comp)
+{
+    using thrust::system::detail::generic::lower_bound;
+    return lower_bound(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, values_first, values_last, output, comp);
+}
+
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator>
+__host__ __device__
+OutputIterator upper_bound(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           ForwardIterator first,
+                           ForwardIterator last,
+                           InputIterator values_first,
+                           InputIterator values_last,
+                           OutputIterator output)
+{
+    using thrust::system::detail::generic::upper_bound;
+    return upper_bound(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, values_first, values_last, output);
+}
+
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator, typename StrictWeakOrdering>
+__host__ __device__
+OutputIterator upper_bound(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           ForwardIterator first,
+                           ForwardIterator last,
+                           InputIterator values_first,
+                           InputIterator values_last,
+                           OutputIterator output,
+                           StrictWeakOrdering comp)
+{
+    using thrust::system::detail::generic::upper_bound;
+    return upper_bound(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, values_first, values_last, output, comp);
+}
+
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator>
+__host__ __device__
+OutputIterator binary_search(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                             ForwardIterator first,
+                             ForwardIterator last,
+                             InputIterator values_first,
+                             InputIterator values_last,
+                             OutputIterator output)
+{
+    using thrust::system::detail::generic::binary_search;
+    return binary_search(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, values_first, values_last, output);
+}
+
+
+__thrust_exec_check_disable__
+template <typename DerivedPolicy, typename ForwardIterator, typename InputIterator, typename OutputIterator, typename StrictWeakOrdering>
+__host__ __device__
+OutputIterator binary_search(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                             ForwardIterator first,
+                             ForwardIterator last,
+                             InputIterator values_first,
+                             InputIterator values_last,
+                             OutputIterator output,
+                             StrictWeakOrdering comp)
+{
+    using thrust::system::detail::generic::binary_search;
+    return binary_search(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, values_first, values_last, output, comp);
+}
+
+
+//////////////////////
+// Scalar Functions //
+//////////////////////
+
+template <typename ForwardIterator, typename LessThanComparable>
+ForwardIterator lower_bound(ForwardIterator first,
+                            ForwardIterator last,
+                            const LessThanComparable& value)
+{
+    using thrust::system::detail::generic::select_system;
+
+    typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+    System system;
+
+    return thrust::lower_bound(select_system(system), first, last, value);
+}
+
+template <typename ForwardIterator, typename T, typename StrictWeakOrdering>
+ForwardIterator lower_bound(ForwardIterator first,
+                            ForwardIterator last,
+                            const T& value,
+                            StrictWeakOrdering comp)
+{
+    using thrust::system::detail::generic::select_system;
+
+    typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+    System system;
+
+    return thrust::lower_bound(select_system(system), first, last, value, comp);
+}
+
+template <typename ForwardIterator, typename LessThanComparable>
+ForwardIterator upper_bound(ForwardIterator first,
+                            ForwardIterator last,
+                            const LessThanComparable& value)
+{
+    using thrust::system::detail::generic::select_system;
+
+    typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+    System system;
+
+    return thrust::upper_bound(select_system(system), first, last, value);
+}
+
+template <typename ForwardIterator, typename T, typename StrictWeakOrdering>
+ForwardIterator upper_bound(ForwardIterator first,
+                            ForwardIterator last,
+                            const T& value,
+                            StrictWeakOrdering comp)
+{
+    using thrust::system::detail::generic::select_system;
+
+    typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+    System system;
+
+    return thrust::upper_bound(select_system(system), first, last, value, comp);
+}
+
+template <typename ForwardIterator, typename LessThanComparable>
+bool binary_search(ForwardIterator first,
+                   ForwardIterator last,
+                   const LessThanComparable& value)
+{
+    using thrust::system::detail::generic::select_system;
+
+    typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+    System system;
+
+    return thrust::binary_search(select_system(system), first, last, value);
+}
+
+template <typename ForwardIterator, typename T, typename StrictWeakOrdering>
+bool binary_search(ForwardIterator first,
+                   ForwardIterator last,
+                   const T& value,
+                   StrictWeakOrdering comp)
+{
+    using thrust::system::detail::generic::select_system;
+
+    typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+    System system;
+
+    return thrust::binary_search(select_system(system), first, last, value, comp);
+}
+
+template <typename ForwardIterator, typename LessThanComparable>
+thrust::pair<ForwardIterator, ForwardIterator>
+equal_range(ForwardIterator first,
+            ForwardIterator last,
+            const LessThanComparable& value)
+{
+    using thrust::system::detail::generic::select_system;
+
+    typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+    System system;
+
+    return thrust::equal_range(select_system(system), first, last, value);
+}
+
+template <typename ForwardIterator, typename T, typename StrictWeakOrdering>
+thrust::pair<ForwardIterator, ForwardIterator>
+equal_range(ForwardIterator first,
+            ForwardIterator last,
+            const T& value,
+            StrictWeakOrdering comp)
+{
+    using thrust::system::detail::generic::select_system;
+
+    typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+    System system;
+
+    return thrust::equal_range(select_system(system), first, last, value, comp);
+}
+
+//////////////////////
+// Vector Functions //
+//////////////////////
+
+template <typename ForwardIterator, typename InputIterator, typename OutputIterator>
+OutputIterator lower_bound(ForwardIterator first,
+                           ForwardIterator last,
+                           InputIterator values_first,
+                           InputIterator values_last,
+                           OutputIterator output)
+{
+    using thrust::system::detail::generic::select_system;
+
+    typedef typename thrust::iterator_system<ForwardIterator>::type System1;
+    typedef typename thrust::iterator_system<InputIterator>::type   System2;
+    typedef typename thrust::iterator_system<OutputIterator>::type  System3;
+
+    System1 system1;
+    System2 system2;
+    System3 system3;
+
+    return thrust::lower_bound(select_system(system1,system2,system3), first, last, values_first, values_last, output);
+}
+
+template <typename ForwardIterator, typename InputIterator, typename OutputIterator, typename StrictWeakOrdering>
+OutputIterator lower_bound(ForwardIterator first,
+                           ForwardIterator last,
+                           InputIterator values_first,
+                           InputIterator values_last,
+                           OutputIterator output,
+                           StrictWeakOrdering comp)
+{
+    using thrust::system::detail::generic::select_system;
+
+    typedef typename thrust::iterator_system<ForwardIterator>::type System1;
+    typedef typename thrust::iterator_system<InputIterator>::type   System2;
+    typedef typename thrust::iterator_system<OutputIterator>::type  System3;
+
+    System1 system1;
+    System2 system2;
+    System3 system3;
+
+    return thrust::lower_bound(select_system(system1,system2,system3), first, last, values_first, values_last, output, comp);
+}
+
+template <typename ForwardIterator, typename InputIterator, typename OutputIterator>
+OutputIterator upper_bound(ForwardIterator first,
+                           ForwardIterator last,
+                           InputIterator values_first,
+                           InputIterator values_last,
+                           OutputIterator output)
+{
+    using thrust::system::detail::generic::select_system;
+
+    typedef typename thrust::iterator_system<ForwardIterator>::type System1;
+    typedef typename thrust::iterator_system<InputIterator>::type   System2;
+    typedef typename thrust::iterator_system<OutputIterator>::type  System3;
+
+    System1 system1;
+    System2 system2;
+    System3 system3;
+
+    return thrust::upper_bound(select_system(system1,system2,system3), first, last, values_first, values_last, output);
+}
+
+template <typename ForwardIterator, typename InputIterator, typename OutputIterator, typename StrictWeakOrdering>
+OutputIterator upper_bound(ForwardIterator first,
+                           ForwardIterator last,
+                           InputIterator values_first,
+                           InputIterator values_last,
+                           OutputIterator output,
+                           StrictWeakOrdering comp)
+{
+    using thrust::system::detail::generic::select_system;
+
+    typedef typename thrust::iterator_system<ForwardIterator>::type System1;
+    typedef typename thrust::iterator_system<InputIterator>::type   System2;
+    typedef typename thrust::iterator_system<OutputIterator>::type  System3;
+
+    System1 system1;
+    System2 system2;
+    System3 system3;
+
+    return thrust::upper_bound(select_system(system1,system2,system3), first, last, values_first, values_last, output, comp);
+}
+
+template <typename ForwardIterator, typename InputIterator, typename OutputIterator>
+OutputIterator binary_search(ForwardIterator first,
+                             ForwardIterator last,
+                             InputIterator values_first,
+                             InputIterator values_last,
+                             OutputIterator output)
+{
+    using thrust::system::detail::generic::select_system;
+
+    typedef typename thrust::iterator_system<ForwardIterator>::type System1;
+    typedef typename thrust::iterator_system<InputIterator>::type   System2;
+    typedef typename thrust::iterator_system<OutputIterator>::type  System3;
+
+    System1 system1;
+    System2 system2;
+    System3 system3;
+
+    return thrust::binary_search(select_system(system1,system2,system3), first, last, values_first, values_last, output);
+}
+
+template <typename ForwardIterator, typename InputIterator, typename OutputIterator, typename StrictWeakOrdering>
+OutputIterator binary_search(ForwardIterator first,
+                             ForwardIterator last,
+                             InputIterator values_first,
+                             InputIterator values_last,
+                             OutputIterator output,
+                             StrictWeakOrdering comp)
+{
+    using thrust::system::detail::generic::select_system;
+
+    typedef typename thrust::iterator_system<ForwardIterator>::type System1;
+    typedef typename thrust::iterator_system<InputIterator>::type   System2;
+    typedef typename thrust::iterator_system<OutputIterator>::type  System3;
+
+    System1 system1;
+    System2 system2;
+    System3 system3;
+
+    return thrust::binary_search(select_system(system1,system2,system3), first, last, values_first, values_last, output, comp);
+}
+
+THRUST_NAMESPACE_END

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config.h

@@ -0,0 +1,24 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+/*! \file config.h
+ *  \brief Defines platform configuration.
+ */
+
+#pragma once
+
+#include <thrust/version.h>
+#include <thrust/detail/config/config.h>
+

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/compiler.h

@@ -0,0 +1,189 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file compiler.h
+ *  \brief Compiler-specific configuration
+ */
+
+#pragma once
+
+// enumerate host compilers we know about
+#define THRUST_HOST_COMPILER_UNKNOWN 0
+#define THRUST_HOST_COMPILER_MSVC    1
+#define THRUST_HOST_COMPILER_GCC     2
+#define THRUST_HOST_COMPILER_CLANG   3
+#define THRUST_HOST_COMPILER_INTEL   4
+
+// enumerate device compilers we know about
+#define THRUST_DEVICE_COMPILER_UNKNOWN 0
+#define THRUST_DEVICE_COMPILER_MSVC    1
+#define THRUST_DEVICE_COMPILER_GCC     2
+#define THRUST_DEVICE_COMPILER_CLANG   3
+#define THRUST_DEVICE_COMPILER_NVCC    4
+
+// figure out which host compiler we're using
+// XXX we should move the definition of THRUST_DEPRECATED out of this logic
+#if   defined(_MSC_VER)
+#define THRUST_HOST_COMPILER THRUST_HOST_COMPILER_MSVC
+#define THRUST_MSVC_VERSION _MSC_VER
+#define THRUST_MSVC_VERSION_FULL _MSC_FULL_VER
+#elif defined(__ICC)
+#define THRUST_HOST_COMPILER THRUST_HOST_COMPILER_INTEL
+#elif defined(__clang__)
+#define THRUST_HOST_COMPILER THRUST_HOST_COMPILER_CLANG
+#define THRUST_CLANG_VERSION (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__)
+#elif defined(__GNUC__)
+#define THRUST_HOST_COMPILER THRUST_HOST_COMPILER_GCC
+#define THRUST_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+#if (THRUST_GCC_VERSION >= 50000)
+#define THRUST_MODERN_GCC
+#else
+#define THRUST_LEGACY_GCC
+#endif
+#else
+#define THRUST_HOST_COMPILER THRUST_HOST_COMPILER_UNKNOWN
+#endif // THRUST_HOST_COMPILER
+
+// figure out which device compiler we're using
+#if defined(__CUDACC__) || defined(_NVHPC_CUDA)
+#define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_NVCC
+#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC
+#define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_MSVC
+#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC
+#define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_GCC
+#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_CLANG
+// CUDA-capable clang should behave similar to NVCC.
+#if defined(__CUDA__)
+#define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_NVCC
+#else
+#define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_CLANG
+#endif
+#else
+#define THRUST_DEVICE_COMPILER THRUST_DEVICE_COMPILER_UNKNOWN
+#endif
+
+// is the device compiler capable of compiling omp?
+#if defined(_OPENMP) || defined(_NVHPC_STDPAR_OPENMP)
+#define THRUST_DEVICE_COMPILER_IS_OMP_CAPABLE THRUST_TRUE
+#else
+#define THRUST_DEVICE_COMPILER_IS_OMP_CAPABLE THRUST_FALSE
+#endif // _OPENMP
+
+
+#if (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC) && !defined(__CUDA_ARCH__)
+  #define THRUST_DISABLE_MSVC_WARNING_BEGIN(x)                                \
+    __pragma(warning(push))                                                   \
+    __pragma(warning(disable : x))                                            \
+    /**/
+  #define THRUST_DISABLE_MSVC_WARNING_END(x)                                  \
+    __pragma(warning(pop))                                                    \
+    /**/
+#else
+  #define THRUST_DISABLE_MSVC_WARNING_BEGIN(x)
+  #define THRUST_DISABLE_MSVC_WARNING_END(x)
+#endif
+
+#if (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_CLANG) && !defined(__CUDA_ARCH__)
+  #define THRUST_IGNORE_CLANG_WARNING_IMPL(x)                                 \
+    THRUST_PP_STRINGIZE(clang diagnostic ignored x)                           \
+    /**/
+  #define THRUST_IGNORE_CLANG_WARNING(x)                                      \
+    THRUST_IGNORE_CLANG_WARNING_IMPL(THRUST_PP_STRINGIZE(x))                  \
+    /**/
+
+  #define THRUST_DISABLE_CLANG_WARNING_BEGIN(x)                               \
+    _Pragma("clang diagnostic push")                                          \
+    _Pragma(THRUST_IGNORE_CLANG_WARNING(x))                                   \
+    /**/
+  #define THRUST_DISABLE_CLANG_WARNING_END(x)                                 \
+    _Pragma("clang diagnostic pop")                                           \
+    /**/
+#else
+  #define THRUST_DISABLE_CLANG_WARNING_BEGIN(x)
+  #define THRUST_DISABLE_CLANG_WARNING_END(x)
+#endif
+
+#if (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC) && !defined(__CUDA_ARCH__)
+  #define THRUST_IGNORE_GCC_WARNING_IMPL(x)                                   \
+    THRUST_PP_STRINGIZE(GCC diagnostic ignored x)                             \
+    /**/
+  #define THRUST_IGNORE_GCC_WARNING(x)                                        \
+    THRUST_IGNORE_GCC_WARNING_IMPL(THRUST_PP_STRINGIZE(x))                    \
+    /**/
+
+  #define THRUST_DISABLE_GCC_WARNING_BEGIN(x)                                 \
+    _Pragma("GCC diagnostic push")                                            \
+    _Pragma(THRUST_IGNORE_GCC_WARNING(x))                                     \
+    /**/
+  #define THRUST_DISABLE_GCC_WARNING_END(x)                                   \
+    _Pragma("GCC diagnostic pop")                                             \
+    /**/
+#else
+  #define THRUST_DISABLE_GCC_WARNING_BEGIN(x)
+  #define THRUST_DISABLE_GCC_WARNING_END(x)
+#endif
+
+#define THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING_BEGIN               \
+  THRUST_DISABLE_MSVC_WARNING_BEGIN(4244 4267)                                \
+  /**/
+#define THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING_END                 \
+  THRUST_DISABLE_MSVC_WARNING_END(4244 4267)                                  \
+  /**/
+#define THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING(x)                  \
+  THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING_BEGIN                     \
+  x;                                                                          \
+  THRUST_DISABLE_MSVC_POSSIBLE_LOSS_OF_DATA_WARNING_END                       \
+  /**/
+
+#define THRUST_DISABLE_MSVC_FORCING_VALUE_TO_BOOL_WARNING_BEGIN               \
+  THRUST_DISABLE_MSVC_WARNING_BEGIN(4800)                                     \
+  /**/
+#define THRUST_DISABLE_MSVC_FORCING_VALUE_TO_BOOL_WARNING_END                 \
+  THRUST_DISABLE_MSVC_WARNING_END(4800)                                       \
+  /**/
+#define THRUST_DISABLE_MSVC_FORCING_VALUE_TO_BOOL_WARNING(x)                  \
+  THRUST_DISABLE_MSVC_FORCING_VALUE_TO_BOOL_WARNING_BEGIN                     \
+  x;                                                                          \
+  THRUST_DISABLE_MSVC_FORCING_VALUE_TO_BOOL_WARNING_END                       \
+  /**/
+
+#define THRUST_DISABLE_CLANG_SELF_ASSIGNMENT_WARNING_BEGIN                    \
+  THRUST_DISABLE_CLANG_WARNING_BEGIN(-Wself-assign)                           \
+  /**/
+#define THRUST_DISABLE_CLANG_SELF_ASSIGNMENT_WARNING_END                      \
+  THRUST_DISABLE_CLANG_WARNING_END(-Wself-assign)                             \
+  /**/
+#define THRUST_DISABLE_CLANG_SELF_ASSIGNMENT_WARNING(x)                       \
+  THRUST_DISABLE_CLANG_SELF_ASSIGNMENT_WARNING_BEGIN                          \
+  x;                                                                          \
+  THRUST_DISABLE_CLANG_SELF_ASSIGNMENT_WARNING_END                            \
+  /**/
+
+#define THRUST_DISABLE_CLANG_AND_GCC_INITIALIZER_REORDERING_WARNING_BEGIN     \
+  THRUST_DISABLE_CLANG_WARNING_BEGIN(-Wreorder)                               \
+  THRUST_DISABLE_GCC_WARNING_BEGIN(-Wreorder)                                 \
+  /**/
+#define THRUST_DISABLE_CLANG_AND_GCC_INITIALIZER_REORDERING_WARNING_END       \
+  THRUST_DISABLE_CLANG_WARNING_END(-Wreorder)                                 \
+  THRUST_DISABLE_GCC_WARNING_END(-Wreorder)                                   \
+  /**/
+#define THRUST_DISABLE_CLANG_AND_GCC_INITIALIZER_REORDERING_WARNING(x)        \
+  THRUST_DISABLE_CLANG_AND_GCC_INITIALIZER_REORDERING_WARNING_BEGIN           \
+  x;                                                                          \
+  THRUST_DISABLE_CLANG_AND_GCC_INITIALIZER_REORDERING_WARNING_END             \
+  /**/
+
+

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/compiler_fence.h

@@ -0,0 +1,62 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/preprocessor.h>
+
+// TODO: Enable this or remove this file once nvGRAPH/CUSP migrates off of it.
+//#if THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC
+//  #pragma message("warning: The functionality in this header is unsafe, deprecated, and will soon be removed. Use C++11 or C11 atomics instead.")
+//#else
+//  #warning The functionality in this header is unsafe, deprecated, and will soon be removed. Use C++11 or C11 atomics instead.
+//#endif
+
+// msvc case
+#if THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC
+
+#ifndef _DEBUG
+
+#include <intrin.h>
+#pragma intrinsic(_ReadWriteBarrier)
+#define __thrust_compiler_fence() _ReadWriteBarrier()
+#else
+
+#define __thrust_compiler_fence() do {} while (0)
+
+#endif // _DEBUG
+
+// gcc case
+#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC
+
+#if THRUST_GCC_VERSION >= 40200 // atomic built-ins were introduced ~4.2
+#define __thrust_compiler_fence() __sync_synchronize()
+#else
+// allow the code to compile without any guarantees
+#define __thrust_compiler_fence() do {} while (0)
+#endif // THRUST_GCC_VERSION
+
+// unknown case
+#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_CLANG
+#define __thrust_compiler_fence() __sync_synchronize()
+#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_UNKNOWN
+
+// allow the code to compile without any guarantees
+#define __thrust_compiler_fence() do {} while (0)
+
+#endif
+

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/config.h

@@ -0,0 +1,40 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file config.h
+ *  \brief Defines platform configuration.
+ */
+
+#pragma once
+
+// NOTE: The order of these #includes matters.
+
+#include <thrust/detail/config/simple_defines.h>
+#include <thrust/detail/config/compiler.h>
+#include <thrust/detail/config/cpp_dialect.h>
+#include <thrust/detail/config/cpp_compatibility.h>
+#include <thrust/detail/config/deprecated.h>
+// host_system.h & device_system.h must be #included as early as possible
+// because other config headers depend on it
+#include <thrust/detail/config/host_system.h>
+#include <thrust/detail/config/device_system.h>
+#include <thrust/detail/config/host_device.h>
+#include <thrust/detail/config/debug.h>
+#include <thrust/detail/config/forceinline.h>
+#include <thrust/detail/config/exec_check_disable.h>
+#include <thrust/detail/config/global_workarounds.h>
+#include <thrust/detail/config/namespace.h>
+

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/cpp_compatibility.h

@@ -0,0 +1,101 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config/cpp_dialect.h>
+
+#include <cstddef>
+
+#ifndef __has_cpp_attribute
+#  define __has_cpp_attribute(X) 0
+#endif
+
+// Trailing return types seem to confuse Doxygen, and cause it to interpret
+// parts of the function's body as new function signatures.
+#if defined(THRUST_DOXYGEN)
+#  define THRUST_TRAILING_RETURN(...)
+#else
+#  define THRUST_TRAILING_RETURN(...) -> __VA_ARGS__
+#endif
+
+#if THRUST_CPP_DIALECT >= 2014 && __has_cpp_attribute(nodiscard)
+#  define THRUST_NODISCARD [[nodiscard]]
+#else
+#  define THRUST_NODISCARD
+#endif
+
+#if THRUST_CPP_DIALECT >= 2017 && __cpp_if_constexpr
+#  define THRUST_IF_CONSTEXPR if constexpr
+#else
+#  define THRUST_IF_CONSTEXPR if
+#endif
+
+// FIXME: Combine THRUST_INLINE_CONSTANT and
+// THRUST_INLINE_INTEGRAL_MEMBER_CONSTANT into one macro when NVCC properly
+// supports `constexpr` globals in host and device code.
+#if defined(__CUDA_ARCH__) || defined(_NVHPC_CUDA)
+// FIXME: Add this when NVCC supports inline variables.
+//#  if   THRUST_CPP_DIALECT >= 2017
+//#    define THRUST_INLINE_CONSTANT                 inline constexpr
+//#    define THRUST_INLINE_INTEGRAL_MEMBER_CONSTANT inline constexpr
+#  if THRUST_CPP_DIALECT >= 2011
+#    define THRUST_INLINE_CONSTANT                 static const __device__
+#    define THRUST_INLINE_INTEGRAL_MEMBER_CONSTANT static constexpr
+#  else
+#    define THRUST_INLINE_CONSTANT                 static const __device__
+#    define THRUST_INLINE_INTEGRAL_MEMBER_CONSTANT static const
+#  endif
+#else
+// FIXME: Add this when NVCC supports inline variables.
+//#  if   THRUST_CPP_DIALECT >= 2017
+//#    define THRUST_INLINE_CONSTANT                 inline constexpr
+//#    define THRUST_INLINE_INTEGRAL_MEMBER_CONSTANT inline constexpr
+#  if THRUST_CPP_DIALECT >= 2011
+#    define THRUST_INLINE_CONSTANT                 static constexpr
+#    define THRUST_INLINE_INTEGRAL_MEMBER_CONSTANT static constexpr
+#  else
+#    define THRUST_INLINE_CONSTANT                 static const
+#    define THRUST_INLINE_INTEGRAL_MEMBER_CONSTANT static const
+#  endif
+#endif
+
+// These definitions were intended for internal use only and are now obsolete.
+// If you relied on them, consider porting your code to use the functionality
+// in libcu++'s <nv/target> header.
+// For a temporary workaround, define THRUST_PROVIDE_LEGACY_ARCH_MACROS to make
+// them available again. These should be considered deprecated and will be
+// fully removed in a future version.
+#ifdef THRUST_PROVIDE_LEGACY_ARCH_MACROS
+  #ifndef THRUST_IS_DEVICE_CODE
+    #if defined(_NVHPC_CUDA)
+      #define THRUST_IS_DEVICE_CODE __builtin_is_device_code()
+      #define THRUST_IS_HOST_CODE (!__builtin_is_device_code())
+      #define THRUST_INCLUDE_DEVICE_CODE 1
+      #define THRUST_INCLUDE_HOST_CODE 1
+    #elif defined(__CUDA_ARCH__)
+      #define THRUST_IS_DEVICE_CODE 1
+      #define THRUST_IS_HOST_CODE 0
+      #define THRUST_INCLUDE_DEVICE_CODE 1
+      #define THRUST_INCLUDE_HOST_CODE 0
+    #else
+      #define THRUST_IS_DEVICE_CODE 0
+      #define THRUST_IS_HOST_CODE 1
+      #define THRUST_INCLUDE_DEVICE_CODE 0
+      #define THRUST_INCLUDE_HOST_CODE 1
+    #endif
+  #endif
+#endif // THRUST_PROVIDE_LEGACY_ARCH_MACROS

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/cpp_dialect.h

@@ -0,0 +1,140 @@
+/*
+ *  Copyright 2020 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file cpp_dialect.h
+ *  \brief Detect the version of the C++ standard used by the compiler.
+ */
+
+#pragma once
+
+#include <thrust/detail/config/compiler.h>
+
+// Deprecation warnings may be silenced by defining the following macros. These
+// may be combined.
+// - THRUST_IGNORE_DEPRECATED_CPP_DIALECT:
+//   Ignore all deprecated C++ dialects and outdated compilers.
+// - THRUST_IGNORE_DEPRECATED_CPP_11:
+//   Ignore deprecation warnings when compiling with C++11. C++03 and outdated
+//   compilers will still issue warnings.
+// - THRUST_IGNORE_DEPRECATED_COMPILER
+//   Ignore deprecation warnings when using deprecated compilers. Compiling
+//   with C++03 and C++11 will still issue warnings.
+
+// Check for the CUB opt-outs as well:
+#if !defined(THRUST_IGNORE_DEPRECATED_CPP_DIALECT) && \
+     defined(CUB_IGNORE_DEPRECATED_CPP_DIALECT)
+#  define    THRUST_IGNORE_DEPRECATED_CPP_DIALECT
+#endif
+#if !defined(THRUST_IGNORE_DEPRECATED_CPP_11) && \
+     defined(CUB_IGNORE_DEPRECATED_CPP_11)
+#  define    THRUST_IGNORE_DEPRECATED_CPP_11
+#endif
+#if !defined(THRUST_IGNORE_DEPRECATED_COMPILER) && \
+     defined(CUB_IGNORE_DEPRECATED_COMPILER)
+#  define    THRUST_IGNORE_DEPRECATED_COMPILER
+#endif
+
+#ifdef THRUST_IGNORE_DEPRECATED_CPP_DIALECT
+#  define THRUST_IGNORE_DEPRECATED_CPP_11
+#  define THRUST_IGNORE_DEPRECATED_COMPILER
+#endif
+
+// Define this to override the built-in detection.
+#ifndef THRUST_CPP_DIALECT
+
+// MSVC does not define __cplusplus correctly. _MSVC_LANG is used instead.
+// This macro is only defined in MSVC 2015U3+.
+#  ifdef _MSVC_LANG // Do not replace with THRUST_HOST_COMPILER test (see above)
+// MSVC2015 reports C++14 but lacks extended constexpr support. Treat as C++11.
+#    if THRUST_MSVC_VERSION < 1910 && _MSVC_LANG > 201103L /* MSVC < 2017 && CPP > 2011 */
+#      define THRUST_CPLUSPLUS 201103L /* Fix to 2011 */
+#    else
+#      define THRUST_CPLUSPLUS _MSVC_LANG /* We'll trust this for now. */
+#    endif // MSVC 2015 C++14 fix
+#  else
+#    define THRUST_CPLUSPLUS __cplusplus
+#  endif
+
+// Detect current dialect:
+#  if THRUST_CPLUSPLUS < 201103L
+#    define THRUST_CPP_DIALECT 2003
+#  elif THRUST_CPLUSPLUS < 201402L
+#    define THRUST_CPP_DIALECT 2011
+#  elif THRUST_CPLUSPLUS < 201703L
+#    define THRUST_CPP_DIALECT 2014
+#  elif THRUST_CPLUSPLUS == 201703L
+#    define THRUST_CPP_DIALECT 2017
+#  elif THRUST_CPLUSPLUS > 201703L // unknown, but is higher than 2017.
+#    define THRUST_CPP_DIALECT 2020
+#  endif
+
+#  undef THRUST_CPLUSPLUS // cleanup
+
+#endif // !THRUST_CPP_DIALECT
+
+// Define THRUST_COMPILER_DEPRECATION macro:
+#if THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC
+#  define THRUST_COMP_DEPR_IMPL(msg) \
+    __pragma(message(__FILE__ ":" THRUST_COMP_DEPR_IMPL0(__LINE__) ": warning: " #msg))
+#  define THRUST_COMP_DEPR_IMPL0(x) THRUST_COMP_DEPR_IMPL1(x)
+#  define THRUST_COMP_DEPR_IMPL1(x) #x
+#else // clang / gcc:
+#  define THRUST_COMP_DEPR_IMPL(msg) THRUST_COMP_DEPR_IMPL0(GCC warning #msg)
+#  define THRUST_COMP_DEPR_IMPL0(expr) _Pragma(#expr)
+#  define THRUST_COMP_DEPR_IMPL1 /* intentionally blank */
+#endif
+
+#define THRUST_COMPILER_DEPRECATION(REQ) \
+  THRUST_COMP_DEPR_IMPL(Thrust requires at least REQ. Define THRUST_IGNORE_DEPRECATED_CPP_DIALECT to suppress this message.)
+
+#define THRUST_COMPILER_DEPRECATION_SOFT(REQ, CUR) \
+  THRUST_COMP_DEPR_IMPL(Thrust requires at least REQ. CUR is deprecated but still supported. CUR support will be removed in a future release. Define THRUST_IGNORE_DEPRECATED_CPP_DIALECT to suppress this message.)
+
+#ifndef THRUST_IGNORE_DEPRECATED_COMPILER
+
+// Compiler checks:
+#  if THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC && THRUST_GCC_VERSION < 50000
+     THRUST_COMPILER_DEPRECATION(GCC 5.0);
+#  elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_CLANG && THRUST_CLANG_VERSION < 70000
+     THRUST_COMPILER_DEPRECATION(Clang 7.0);
+#  elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC && THRUST_MSVC_VERSION < 1910
+     // <2017. Hard upgrade message:
+     THRUST_COMPILER_DEPRECATION(MSVC 2019 (19.20/16.0/14.20));
+#  elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC && THRUST_MSVC_VERSION < 1920
+     // >=2017, <2019. Soft deprecation message:
+     THRUST_COMPILER_DEPRECATION_SOFT(MSVC 2019 (19.20/16.0/14.20), MSVC 2017);
+#  endif
+
+#endif // THRUST_IGNORE_DEPRECATED_COMPILER
+
+#ifndef THRUST_IGNORE_DEPRECATED_DIALECT
+
+// Dialect checks:
+#  if THRUST_CPP_DIALECT < 2011
+     // <C++11. Hard upgrade message:
+     THRUST_COMPILER_DEPRECATION(C++14);
+#  elif THRUST_CPP_DIALECT == 2011 && !defined(THRUST_IGNORE_DEPRECATED_CPP_11)
+     // =C++11. Soft upgrade message:
+     THRUST_COMPILER_DEPRECATION_SOFT(C++14, C++11);
+#  endif
+
+#endif // THRUST_IGNORE_DEPRECATED_DIALECT
+
+#undef THRUST_COMPILER_DEPRECATION_SOFT
+#undef THRUST_COMPILER_DEPRECATION
+#undef THRUST_COMP_DEPR_IMPL
+#undef THRUST_COMP_DEPR_IMPL0
+#undef THRUST_COMP_DEPR_IMPL1

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/deprecated.h

@@ -0,0 +1,42 @@
+/*
+ *  Copyright 2018-2020 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file deprecated.h
+ *  \brief Defines the THRUST_DEPRECATED macro
+ */
+
+#pragma once
+
+#include <thrust/detail/config/compiler.h>
+#include <thrust/detail/config/cpp_dialect.h>
+
+#if defined(CUB_IGNORE_DEPRECATED_API) && !defined(THRUST_IGNORE_DEPRECATED_API)
+#  define THRUST_IGNORE_DEPRECATED_API
+#endif
+
+#ifdef THRUST_IGNORE_DEPRECATED_API
+#  define THRUST_DEPRECATED
+#elif THRUST_CPP_DIALECT >= 2014
+#  define THRUST_DEPRECATED [[deprecated]]
+#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC
+#  define THRUST_DEPRECATED __declspec(deprecated)
+#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_CLANG
+#  define THRUST_DEPRECATED __attribute__((deprecated))
+#elif THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC
+#  define THRUST_DEPRECATED __attribute__((deprecated))
+#else
+#  define THRUST_DEPRECATED
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/device_system.h

@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+// reserve 0 for undefined
+#define THRUST_DEVICE_SYSTEM_CUDA    1
+#define THRUST_DEVICE_SYSTEM_OMP     2
+#define THRUST_DEVICE_SYSTEM_TBB     3
+#define THRUST_DEVICE_SYSTEM_CPP     4
+
+#ifndef THRUST_DEVICE_SYSTEM
+#define THRUST_DEVICE_SYSTEM THRUST_DEVICE_SYSTEM_CUDA
+#endif // THRUST_DEVICE_SYSTEM
+
+#ifdef THRUST_DEVICE_BACKEND
+#  error THRUST_DEVICE_BACKEND is no longer supported; use THRUST_DEVICE_SYSTEM instead.
+#endif // THRUST_DEVICE_BACKEND
+
+#if THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_CUDA
+#define __THRUST_DEVICE_SYSTEM_NAMESPACE cuda
+#elif THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_OMP
+#define __THRUST_DEVICE_SYSTEM_NAMESPACE omp
+#elif THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_TBB
+#define __THRUST_DEVICE_SYSTEM_NAMESPACE tbb
+#elif THRUST_DEVICE_SYSTEM == THRUST_DEVICE_SYSTEM_CPP
+#define __THRUST_DEVICE_SYSTEM_NAMESPACE cpp
+#endif
+
+#define __THRUST_DEVICE_SYSTEM_ROOT thrust/system/__THRUST_DEVICE_SYSTEM_NAMESPACE
+

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/exec_check_disable.h

@@ -0,0 +1,43 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file exec_check_disable.h
+ *  \brief Defines __thrust_exec_check_disable__
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+// #pragma nv_exec_check_disable is only recognized by NVCC.  Having a macro
+// expand to a #pragma (rather than _Pragma) only works with NVCC's compilation
+// model, not with other compilers.
+#if defined(__CUDACC__) && !defined(_NVHPC_CUDA) && \
+    !(defined(__CUDA__) && defined(__clang__))
+
+#if THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC
+#define __thrust_exec_check_disable__ __pragma("nv_exec_check_disable")
+#else // MSVC
+#define __thrust_exec_check_disable__ _Pragma("nv_exec_check_disable")
+#endif // MSVC
+
+#else
+
+#define __thrust_exec_check_disable__
+
+#endif
+
+

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/forceinline.h

@@ -0,0 +1,36 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file forceinline.h
+ *  \brief Defines __thrust_forceinline__
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if defined(__CUDACC__) || defined(_NVHPC_CUDA)
+
+#define __thrust_forceinline__ __forceinline__
+
+#else
+
+// TODO add 
+
+#define __thrust_forceinline__
+
+#endif
+

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/global_workarounds.h

@@ -0,0 +1,27 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config/compiler.h>
+
+// XXX workaround gcc 4.8+'s complaints about unused local typedefs by silencing them globally
+#if defined(THRUST_GCC_VERSION) && (THRUST_GCC_VERSION >= 40800)
+#  if defined(__NVCC__) && (CUDART_VERSION >= 6000)
+#    pragma GCC diagnostic ignored "-Wunused-local-typedefs"
+#  endif // nvcc & cuda 6+
+#endif // gcc 4.8
+

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/host_device.h

@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file host_device.h
+ *  \brief Defines __host__ and __device__
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+// since nvcc defines __host__ and __device__ for us,
+// and only nvcc knows what to do with __host__ and __device__,
+// define them to be the empty string for other compilers
+
+#if THRUST_DEVICE_COMPILER != THRUST_DEVICE_COMPILER_NVCC
+
+// since __host__ & __device__ might have already be defined, only
+// #define them if not defined already
+// XXX this will break if the client does #include <host_defines.h> later
+
+#ifndef __host__
+#define __host__
+#endif // __host__
+
+#ifndef __device__
+#define __device__
+#endif // __device__
+
+#endif
+

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/host_system.h

@@ -0,0 +1,41 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+// reserve 0 for undefined
+#define THRUST_HOST_SYSTEM_CPP    1
+#define THRUST_HOST_SYSTEM_OMP    2
+#define THRUST_HOST_SYSTEM_TBB    3
+
+#ifndef THRUST_HOST_SYSTEM
+#define THRUST_HOST_SYSTEM THRUST_HOST_SYSTEM_CPP
+#endif // THRUST_HOST_SYSTEM
+
+#ifdef THRUST_HOST_BACKEND
+#  error THRUST_HOST_BACKEND is no longer supported; use THRUST_HOST_SYSTEM instead.
+#endif // THRUST_HOST_BACKEND
+
+#if THRUST_HOST_SYSTEM == THRUST_HOST_SYSTEM_CPP
+#define __THRUST_HOST_SYSTEM_NAMESPACE cpp
+#elif THRUST_HOST_SYSTEM == THRUST_HOST_SYSTEM_OMP
+#define __THRUST_HOST_SYSTEM_NAMESPACE omp
+#elif THRUST_HOST_SYSTEM == THRUST_HOST_SYSTEM_TBB
+#define __THRUST_HOST_SYSTEM_NAMESPACE tbb
+#endif
+
+#define __THRUST_HOST_SYSTEM_ROOT thrust/system/__THRUST_HOST_SYSTEM_NAMESPACE
+

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/memory_resource.h

@@ -0,0 +1,35 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <cstddef>
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/alignment.h>
+#include <thrust/detail/config/cpp_compatibility.h>
+
+#define THRUST_MR_DEFAULT_ALIGNMENT THRUST_ALIGNOF(THRUST_NS_QUALIFIER::detail::max_align_t)
+
+#if THRUST_CPP_DIALECT >= 2017
+#  if __has_include(<memory_resource>)
+#    define THRUST_MR_STD_MR_HEADER <memory_resource>
+#    define THRUST_MR_STD_MR_NS std::pmr
+#  elif __has_include(<experimental/memory_resource>)
+#    define THRUST_MR_STD_MR_HEADER <experimental/memory_resource>
+#    define THRUST_MR_STD_MR_NS std::experimental::pmr
+#  endif
+#endif

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/namespace.h

@@ -0,0 +1,120 @@
+/*
+ *  Copyright 2021 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+/**
+ * \file namespace.h
+ * \brief Utilities that allow `thrust::` to be placed inside an
+ * application-specific namespace.
+ */
+
+/**
+ * \def THRUST_CUB_WRAPPED_NAMESPACE
+ * If defined, this value will be used as the name of a namespace that wraps the
+ * `thrust::` and `cub::` namespaces.
+ * This macro should not be used with any other Thrust namespace macros.
+ */
+#ifdef THRUST_CUB_WRAPPED_NAMESPACE
+#define THRUST_WRAPPED_NAMESPACE THRUST_CUB_WRAPPED_NAMESPACE
+#endif
+
+/**
+ * \def THRUST_WRAPPED_NAMESPACE
+ * If defined, this value will be used as the name of a namespace that wraps the
+ * `thrust::` namespace.
+ * If THRUST_CUB_WRAPPED_NAMESPACE is set, this will inherit that macro's value.
+ * This macro should not be used with any other Thrust namespace macros.
+ */
+#ifdef THRUST_WRAPPED_NAMESPACE
+#define THRUST_NS_PREFIX                                                       \
+  namespace THRUST_WRAPPED_NAMESPACE                                           \
+  {
+
+#define THRUST_NS_POSTFIX }
+
+#define THRUST_NS_QUALIFIER ::THRUST_WRAPPED_NAMESPACE::thrust
+#endif
+
+/**
+ * \def THRUST_NS_PREFIX
+ * This macro is inserted prior to all `namespace thrust { ... }` blocks. It is
+ * derived from THRUST_WRAPPED_NAMESPACE, if set, and will be empty otherwise.
+ * It may be defined by users, in which case THRUST_NS_PREFIX,
+ * THRUST_NS_POSTFIX, and THRUST_NS_QUALIFIER must all be set consistently.
+ */
+#ifndef THRUST_NS_PREFIX
+#define THRUST_NS_PREFIX
+#endif
+
+/**
+ * \def THRUST_NS_POSTFIX
+ * This macro is inserted following the closing braces of all
+ * `namespace thrust { ... }` block. It is defined appropriately when
+ * THRUST_WRAPPED_NAMESPACE is set, and will be empty otherwise. It may be
+ * defined by users, in which case THRUST_NS_PREFIX, THRUST_NS_POSTFIX, and
+ * THRUST_NS_QUALIFIER must all be set consistently.
+ */
+#ifndef THRUST_NS_POSTFIX
+#define THRUST_NS_POSTFIX
+#endif
+
+/**
+ * \def THRUST_NS_QUALIFIER
+ * This macro is used to qualify members of thrust:: when accessing them from
+ * outside of their namespace. By default, this is just `::thrust`, and will be
+ * set appropriately when THRUST_WRAPPED_NAMESPACE is defined. This macro may be
+ * defined by users, in which case THRUST_NS_PREFIX, THRUST_NS_POSTFIX, and
+ * THRUST_NS_QUALIFIER must all be set consistently.
+ */
+#ifndef THRUST_NS_QUALIFIER
+#define THRUST_NS_QUALIFIER ::thrust
+#endif
+
+/**
+ * \def THRUST_NAMESPACE_BEGIN
+ * This macro is used to open a `thrust::` namespace block, along with any
+ * enclosing namespaces requested by THRUST_WRAPPED_NAMESPACE, etc.
+ * This macro is defined by Thrust and may not be overridden.
+ */
+#define THRUST_NAMESPACE_BEGIN                                                 \
+  THRUST_NS_PREFIX                                                             \
+  namespace thrust                                                             \
+  {
+
+/**
+ * \def THRUST_NAMESPACE_END
+ * This macro is used to close a `thrust::` namespace block, along with any
+ * enclosing namespaces requested by THRUST_WRAPPED_NAMESPACE, etc.
+ * This macro is defined by Thrust and may not be overridden.
+ */
+#define THRUST_NAMESPACE_END                                                   \
+  } /* end namespace thrust */                                                 \
+  THRUST_NS_POSTFIX
+
+// The following is just here to add docs for the thrust namespace:
+
+THRUST_NS_PREFIX
+
+/*! \namespace thrust
+ *  \brief \p thrust is the top-level namespace which contains all Thrust
+ *         functions and types.
+ */
+namespace thrust
+{
+}
+
+THRUST_NS_POSTFIX

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/config/simple_defines.h

@@ -0,0 +1,30 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file simple_defines.h
+ *  \brief Primitive macros without dependencies.
+ */
+
+#pragma once
+
+#define THRUST_UNKNOWN 0
+#define THRUST_FALSE   0
+#define THRUST_TRUE    1
+
+#define THRUST_UNUSED_VAR(expr) do { (void)(expr); } while (0)
+
+#define THRUST_PREVENT_MACRO_SUBSTITUTION
+

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/contiguous_storage.h

@@ -0,0 +1,235 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/iterator/detail/normal_iterator.h>
+#include <thrust/detail/execution_policy.h>
+#include <thrust/detail/allocator/allocator_traits.h>
+#include <thrust/detail/config.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+struct copy_allocator_t {};
+
+// XXX parameter T is redundant with parameter Alloc
+template<typename T, typename Alloc>
+  class contiguous_storage
+{
+  private:
+    typedef thrust::detail::allocator_traits<Alloc> alloc_traits;
+
+  public:
+    typedef Alloc                                      allocator_type;
+    typedef T                                          value_type;
+    typedef typename alloc_traits::pointer             pointer;
+    typedef typename alloc_traits::const_pointer       const_pointer;
+    typedef typename alloc_traits::size_type           size_type;
+    typedef typename alloc_traits::difference_type     difference_type;
+    typedef typename alloc_traits::reference           reference;
+    typedef typename alloc_traits::const_reference     const_reference;
+
+    typedef thrust::detail::normal_iterator<pointer>       iterator;
+    typedef thrust::detail::normal_iterator<const_pointer> const_iterator;
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    explicit contiguous_storage(const allocator_type &alloc = allocator_type());
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    explicit contiguous_storage(size_type n, const allocator_type &alloc = allocator_type());
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    explicit contiguous_storage(copy_allocator_t, const contiguous_storage &other);
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    explicit contiguous_storage(copy_allocator_t, const contiguous_storage &other, size_type n);
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    ~contiguous_storage();
+
+    __host__ __device__
+    size_type size() const;
+
+    __host__ __device__
+    size_type max_size() const;
+
+    __host__ __device__
+    pointer data();
+
+    __host__ __device__
+    const_pointer data() const;
+
+    __host__ __device__
+    iterator begin();
+
+    __host__ __device__
+    const_iterator begin() const;
+
+    __host__ __device__
+    iterator end();
+
+    __host__ __device__
+    const_iterator end() const;
+
+    __host__ __device__
+    reference operator[](size_type n);
+
+    __host__ __device__
+    const_reference operator[](size_type n) const;
+
+    __host__ __device__
+    allocator_type get_allocator() const;
+
+    // note that allocate does *not* automatically call deallocate
+    __host__ __device__
+    void allocate(size_type n);
+
+    __host__ __device__
+    void deallocate();
+
+    __host__ __device__
+    void swap(contiguous_storage &x);
+
+    __host__ __device__
+    void default_construct_n(iterator first, size_type n);
+
+    __host__ __device__
+    void uninitialized_fill_n(iterator first, size_type n, const value_type &value);
+
+    template<typename InputIterator>
+    __host__ __device__
+    iterator uninitialized_copy(InputIterator first, InputIterator last, iterator result);
+
+    template<typename System, typename InputIterator>
+    __host__ __device__
+    iterator uninitialized_copy(thrust::execution_policy<System> &from_system,
+                                InputIterator first,
+                                InputIterator last,
+                                iterator result);
+
+    template<typename InputIterator, typename Size>
+    __host__ __device__
+    iterator uninitialized_copy_n(InputIterator first, Size n, iterator result);
+
+    template<typename System, typename InputIterator, typename Size>
+    __host__ __device__
+    iterator uninitialized_copy_n(thrust::execution_policy<System> &from_system,
+                                  InputIterator first,
+                                  Size n,
+                                  iterator result);
+
+    __host__ __device__
+    void destroy(iterator first, iterator last);
+
+    __host__ __device__
+    void deallocate_on_allocator_mismatch(const contiguous_storage &other);
+
+    __host__ __device__
+    void destroy_on_allocator_mismatch(const contiguous_storage &other,
+        iterator first, iterator last);
+
+    __host__ __device__
+    void set_allocator(const allocator_type &alloc);
+
+    __host__ __device__
+    bool is_allocator_not_equal(const allocator_type &alloc) const;
+
+    __host__ __device__
+    bool is_allocator_not_equal(const contiguous_storage &other) const;
+
+    __host__ __device__
+    void propagate_allocator(const contiguous_storage &other);
+
+#if THRUST_CPP_DIALECT >= 2011
+    __host__ __device__
+    void propagate_allocator(contiguous_storage &other);
+
+    // allow move assignment for a sane implementation of allocator propagation
+    // on move assignment
+    __host__ __device__
+    contiguous_storage &operator=(contiguous_storage &&other);
+#endif
+
+  private:
+    // XXX we could inherit from this to take advantage of empty base class optimization
+    allocator_type m_allocator;
+
+    iterator m_begin;
+
+    size_type m_size;
+
+    // disallow assignment
+    contiguous_storage &operator=(const contiguous_storage &x);
+
+    __host__ __device__
+    void swap_allocators(true_type, const allocator_type &);
+
+    __host__ __device__
+    void swap_allocators(false_type, allocator_type &);
+
+    __host__ __device__
+    bool is_allocator_not_equal_dispatch(true_type, const allocator_type &) const;
+
+    __host__ __device__
+    bool is_allocator_not_equal_dispatch(false_type, const allocator_type &) const;
+
+    __host__ __device__
+    void deallocate_on_allocator_mismatch_dispatch(true_type, const contiguous_storage &other);
+
+    __host__ __device__
+    void deallocate_on_allocator_mismatch_dispatch(false_type, const contiguous_storage &other);
+
+    __host__ __device__
+    void destroy_on_allocator_mismatch_dispatch(true_type, const contiguous_storage &other,
+        iterator first, iterator last);
+
+    __host__ __device__
+    void destroy_on_allocator_mismatch_dispatch(false_type, const contiguous_storage &other,
+        iterator first, iterator last);
+
+    __host__ __device__
+    void propagate_allocator_dispatch(true_type, const contiguous_storage &other);
+
+    __host__ __device__
+    void propagate_allocator_dispatch(false_type, const contiguous_storage &other);
+
+#if THRUST_CPP_DIALECT >= 2011
+    __host__ __device__
+    void propagate_allocator_dispatch(true_type, contiguous_storage &other);
+
+    __host__ __device__
+    void propagate_allocator_dispatch(false_type, contiguous_storage &other);
+#endif
+}; // end contiguous_storage
+
+} // end detail
+
+template<typename T, typename Alloc>
+__host__ __device__
+void swap(detail::contiguous_storage<T,Alloc> &lhs, detail::contiguous_storage<T,Alloc> &rhs);
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/contiguous_storage.inl>
+

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/contiguous_storage.inl

@@ -0,0 +1,550 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/contiguous_storage.h>
+#include <thrust/detail/swap.h>
+#include <thrust/detail/allocator/allocator_traits.h>
+#include <thrust/detail/allocator/copy_construct_range.h>
+#include <thrust/detail/allocator/default_construct_range.h>
+#include <thrust/detail/allocator/destroy_range.h>
+#include <thrust/detail/allocator/fill_construct_range.h>
+
+#include <nv/target>
+
+#include <stdexcept> // for std::runtime_error
+#include <utility> // for use of std::swap in the WAR below
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+class allocator_mismatch_on_swap : public std::runtime_error
+{
+public:
+  allocator_mismatch_on_swap()
+    :std::runtime_error("swap called on containers with allocators that propagate on swap, but compare non-equal")
+  {
+  }
+};
+
+__thrust_exec_check_disable__
+template<typename T, typename Alloc>
+__host__ __device__
+  contiguous_storage<T,Alloc>
+    ::contiguous_storage(const Alloc &alloc)
+      :m_allocator(alloc),
+       m_begin(pointer(static_cast<T*>(0))),
+       m_size(0)
+{
+  ;
+} // end contiguous_storage::contiguous_storage()
+
+__thrust_exec_check_disable__
+template<typename T, typename Alloc>
+__host__ __device__
+  contiguous_storage<T,Alloc>
+    ::contiguous_storage(size_type n, const Alloc &alloc)
+      :m_allocator(alloc),
+       m_begin(pointer(static_cast<T*>(0))),
+       m_size(0)
+{
+  allocate(n);
+} // end contiguous_storage::contiguous_storage()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  contiguous_storage<T,Alloc>
+    ::contiguous_storage(copy_allocator_t,
+        const contiguous_storage &other)
+      :m_allocator(other.m_allocator),
+       m_begin(pointer(static_cast<T*>(0))),
+       m_size(0)
+{
+} // end contiguous_storage::contiguous_storage()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  contiguous_storage<T,Alloc>
+    ::contiguous_storage(copy_allocator_t,
+        const contiguous_storage &other, size_type n)
+      :m_allocator(other.m_allocator),
+       m_begin(pointer(static_cast<T*>(0))),
+       m_size(0)
+{
+  allocate(n);
+} // end contiguous_storage::contiguous_storage()
+
+__thrust_exec_check_disable__
+template<typename T, typename Alloc>
+__host__ __device__
+  contiguous_storage<T,Alloc>
+    ::~contiguous_storage()
+{
+  deallocate();
+} // end contiguous_storage::~contiguous_storage()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  typename contiguous_storage<T,Alloc>::size_type
+    contiguous_storage<T,Alloc>
+      ::size() const
+{
+  return m_size;
+} // end contiguous_storage::size()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  typename contiguous_storage<T,Alloc>::size_type
+    contiguous_storage<T,Alloc>
+      ::max_size() const
+{
+  return alloc_traits::max_size(m_allocator);
+} // end contiguous_storage::max_size()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  typename contiguous_storage<T,Alloc>::iterator
+    contiguous_storage<T,Alloc>
+      ::begin()
+{
+  return m_begin;
+} // end contiguous_storage::begin()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  typename contiguous_storage<T,Alloc>::const_iterator
+    contiguous_storage<T,Alloc>
+      ::begin() const
+{
+  return m_begin;
+} // end contiguous_storage::begin()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  typename contiguous_storage<T,Alloc>::iterator
+    contiguous_storage<T,Alloc>
+      ::end()
+{
+  return m_begin + size();
+} // end contiguous_storage::end()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  typename contiguous_storage<T,Alloc>::const_iterator
+    contiguous_storage<T,Alloc>
+      ::end() const
+{
+  return m_begin + size();
+} // end contiguous_storage::end()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  typename contiguous_storage<T,Alloc>::pointer
+    contiguous_storage<T,Alloc>
+      ::data()
+{
+  return &*m_begin;
+} // end contiguous_storage::data()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  typename contiguous_storage<T,Alloc>::const_pointer
+    contiguous_storage<T,Alloc>
+      ::data() const
+{
+  return &*m_begin;
+} // end contiguous_storage::data()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  typename contiguous_storage<T,Alloc>::reference
+    contiguous_storage<T,Alloc>
+      ::operator[](size_type n)
+{
+  return m_begin[n];
+} // end contiguous_storage::operator[]()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  typename contiguous_storage<T,Alloc>::const_reference
+    contiguous_storage<T,Alloc>
+      ::operator[](size_type n) const
+{
+  return m_begin[n];
+} // end contiguous_storage::operator[]()
+
+__thrust_exec_check_disable__
+template<typename T, typename Alloc>
+__host__ __device__
+  typename contiguous_storage<T,Alloc>::allocator_type
+    contiguous_storage<T,Alloc>
+      ::get_allocator() const
+{
+  return m_allocator;
+} // end contiguous_storage::get_allocator()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::allocate(size_type n)
+{
+  if(n > 0)
+  {
+    m_begin = iterator(alloc_traits::allocate(m_allocator,n));
+    m_size = n;
+  } // end if
+  else
+  {
+    m_begin = iterator(pointer(static_cast<T*>(0)));
+    m_size = 0;
+  } // end else
+} // end contiguous_storage::allocate()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::deallocate()
+{
+  if(size() > 0)
+  {
+    alloc_traits::deallocate(m_allocator,m_begin.base(), size());
+    m_begin = iterator(pointer(static_cast<T*>(0)));
+    m_size = 0;
+  } // end if
+} // end contiguous_storage::deallocate()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::swap(contiguous_storage &x)
+{
+  thrust::swap(m_begin, x.m_begin);
+  thrust::swap(m_size, x.m_size);
+
+  swap_allocators(
+    integral_constant<
+      bool,
+      allocator_traits<Alloc>::propagate_on_container_swap::value
+    >(),
+    x.m_allocator);
+
+  thrust::swap(m_allocator, x.m_allocator);
+} // end contiguous_storage::swap()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::default_construct_n(iterator first, size_type n)
+{
+  default_construct_range(m_allocator, first.base(), n);
+} // end contiguous_storage::default_construct_n()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::uninitialized_fill_n(iterator first, size_type n, const value_type &x)
+{
+  fill_construct_range(m_allocator, first.base(), n, x);
+} // end contiguous_storage::uninitialized_fill()
+
+template<typename T, typename Alloc>
+  template<typename System, typename InputIterator>
+  __host__ __device__
+    typename contiguous_storage<T,Alloc>::iterator
+      contiguous_storage<T,Alloc>
+        ::uninitialized_copy(thrust::execution_policy<System> &from_system, InputIterator first, InputIterator last, iterator result)
+{
+  return iterator(copy_construct_range(from_system, m_allocator, first, last, result.base()));
+} // end contiguous_storage::uninitialized_copy()
+
+template<typename T, typename Alloc>
+  template<typename InputIterator>
+  __host__ __device__
+    typename contiguous_storage<T,Alloc>::iterator
+      contiguous_storage<T,Alloc>
+        ::uninitialized_copy(InputIterator first, InputIterator last, iterator result)
+{
+  // XXX assumes InputIterator's associated System is default-constructible
+  typename thrust::iterator_system<InputIterator>::type from_system;
+
+  return iterator(copy_construct_range(from_system, m_allocator, first, last, result.base()));
+} // end contiguous_storage::uninitialized_copy()
+
+template<typename T, typename Alloc>
+  template<typename System, typename InputIterator, typename Size>
+  __host__ __device__
+    typename contiguous_storage<T,Alloc>::iterator
+      contiguous_storage<T,Alloc>
+        ::uninitialized_copy_n(thrust::execution_policy<System> &from_system, InputIterator first, Size n, iterator result)
+{
+  return iterator(copy_construct_range_n(from_system, m_allocator, first, n, result.base()));
+} // end contiguous_storage::uninitialized_copy_n()
+
+template<typename T, typename Alloc>
+  template<typename InputIterator, typename Size>
+  __host__ __device__
+    typename contiguous_storage<T,Alloc>::iterator
+      contiguous_storage<T,Alloc>
+        ::uninitialized_copy_n(InputIterator first, Size n, iterator result)
+{
+  // XXX assumes InputIterator's associated System is default-constructible
+  typename thrust::iterator_system<InputIterator>::type from_system;
+
+  return iterator(copy_construct_range_n(from_system, m_allocator, first, n, result.base()));
+} // end contiguous_storage::uninitialized_copy_n()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::destroy(iterator first, iterator last)
+{
+  destroy_range(m_allocator, first.base(), last - first);
+} // end contiguous_storage::destroy()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::deallocate_on_allocator_mismatch(const contiguous_storage &other)
+{
+  integral_constant<
+    bool,
+    allocator_traits<Alloc>::propagate_on_container_copy_assignment::value
+  > c;
+
+  deallocate_on_allocator_mismatch_dispatch(c, other);
+} // end contiguous_storage::deallocate_on_allocator_mismatch
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::destroy_on_allocator_mismatch(const contiguous_storage &other,
+        iterator first, iterator last)
+{
+  integral_constant<
+    bool,
+    allocator_traits<Alloc>::propagate_on_container_copy_assignment::value
+  > c;
+
+  destroy_on_allocator_mismatch_dispatch(c, other, first, last);
+} // end contiguous_storage::destroy_on_allocator_mismatch
+
+__thrust_exec_check_disable__
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::set_allocator(const Alloc &alloc)
+{
+  m_allocator = alloc;
+} // end contiguous_storage::set_allocator()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  bool contiguous_storage<T,Alloc>
+    ::is_allocator_not_equal(const Alloc &alloc) const
+{
+  return is_allocator_not_equal_dispatch(
+    integral_constant<
+      bool,
+      allocator_traits<Alloc>::is_always_equal::value
+    >(),
+    alloc);
+} // end contiguous_storage::is_allocator_not_equal()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  bool contiguous_storage<T,Alloc>
+    ::is_allocator_not_equal(const contiguous_storage<T,Alloc> &other) const
+{
+  return is_allocator_not_equal(m_allocator, other.m_allocator);
+} // end contiguous_storage::is_allocator_not_equal()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::propagate_allocator(const contiguous_storage &other)
+{
+  integral_constant<
+    bool,
+    allocator_traits<Alloc>::propagate_on_container_copy_assignment::value
+  > c;
+
+  propagate_allocator_dispatch(c, other);
+} // end contiguous_storage::propagate_allocator()
+
+#if THRUST_CPP_DIALECT >= 2011
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::propagate_allocator(contiguous_storage &other)
+{
+  integral_constant<
+    bool,
+    allocator_traits<Alloc>::propagate_on_container_move_assignment::value
+  > c;
+
+  propagate_allocator_dispatch(c, other);
+} // end contiguous_storage::propagate_allocator()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  contiguous_storage<T,Alloc> &contiguous_storage<T,Alloc>
+    ::operator=(contiguous_storage &&other)
+{
+  if (size() > 0)
+  {
+    deallocate();
+  }
+  propagate_allocator(other);
+  m_begin = std::move(other.m_begin);
+  m_size = std::move(other.m_size);
+
+  other.m_begin = pointer(static_cast<T*>(0));
+  other.m_size = 0;
+
+  return *this;
+} // end contiguous_storage::propagate_allocator()
+#endif
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::swap_allocators(true_type, const Alloc &)
+{
+} // end contiguous_storage::swap_allocators()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::swap_allocators(false_type, Alloc &other)
+{
+  NV_IF_TARGET(NV_IS_DEVICE, (
+    // allocators must be equal when swapping containers with allocators that propagate on swap
+    assert(!is_allocator_not_equal(other));
+  ), (
+    if (is_allocator_not_equal(other))
+    {
+      throw allocator_mismatch_on_swap();
+    }
+  ));
+
+  thrust::swap(m_allocator, other);
+} // end contiguous_storage::swap_allocators()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  bool contiguous_storage<T,Alloc>
+    ::is_allocator_not_equal_dispatch(true_type /*is_always_equal*/, const Alloc &) const
+{
+  return false;
+} // end contiguous_storage::is_allocator_not_equal_dispatch()
+
+__thrust_exec_check_disable__
+template<typename T, typename Alloc>
+__host__ __device__
+  bool contiguous_storage<T,Alloc>
+    ::is_allocator_not_equal_dispatch(false_type /*!is_always_equal*/, const Alloc& other) const
+{
+  return m_allocator != other;
+} // end contiguous_storage::is_allocator_not_equal_dispatch()
+
+__thrust_exec_check_disable__
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::deallocate_on_allocator_mismatch_dispatch(true_type, const contiguous_storage &other)
+{
+  if (m_allocator != other.m_allocator)
+  {
+    deallocate();
+  }
+} // end contiguous_storage::deallocate_on_allocator_mismatch()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::deallocate_on_allocator_mismatch_dispatch(false_type, const contiguous_storage &)
+{
+} // end contiguous_storage::deallocate_on_allocator_mismatch()
+
+__thrust_exec_check_disable__
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::destroy_on_allocator_mismatch_dispatch(true_type, const contiguous_storage &other,
+        iterator first, iterator last)
+{
+  if (m_allocator != other.m_allocator)
+  {
+    destroy(first, last);
+  }
+} // end contiguous_storage::destroy_on_allocator_mismatch()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::destroy_on_allocator_mismatch_dispatch(false_type, const contiguous_storage &,
+        iterator, iterator)
+{
+} // end contiguous_storage::destroy_on_allocator_mismatch()
+
+__thrust_exec_check_disable__
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::propagate_allocator_dispatch(true_type, const contiguous_storage &other)
+{
+  m_allocator = other.m_allocator;
+} // end contiguous_storage::propagate_allocator()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::propagate_allocator_dispatch(false_type, const contiguous_storage &)
+{
+} // end contiguous_storage::propagate_allocator()
+
+#if THRUST_CPP_DIALECT >= 2011
+__thrust_exec_check_disable__
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::propagate_allocator_dispatch(true_type, contiguous_storage &other)
+{
+  m_allocator = std::move(other.m_allocator);
+} // end contiguous_storage::propagate_allocator()
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void contiguous_storage<T,Alloc>
+    ::propagate_allocator_dispatch(false_type, contiguous_storage &)
+{
+} // end contiguous_storage::propagate_allocator()
+#endif
+
+} // end detail
+
+template<typename T, typename Alloc>
+__host__ __device__
+  void swap(detail::contiguous_storage<T,Alloc> &lhs, detail::contiguous_storage<T,Alloc> &rhs)
+{
+  lhs.swap(rhs);
+} // end swap()
+
+THRUST_NAMESPACE_END

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/copy.h

@@ -0,0 +1,90 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template<typename System,
+         typename InputIterator,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator copy(const thrust::detail::execution_policy_base<System> &system,
+                      InputIterator first,
+                      InputIterator last,
+                      OutputIterator result);
+
+template<typename System,
+         typename InputIterator,
+         typename Size,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator copy_n(const thrust::detail::execution_policy_base<System> &system,
+                        InputIterator first,
+                        Size n,
+                        OutputIterator result);
+
+template<typename InputIterator,
+         typename OutputIterator>
+  OutputIterator copy(InputIterator first,
+                      InputIterator last,
+                      OutputIterator result);
+
+template<typename InputIterator,
+         typename Size,
+         typename OutputIterator>
+  OutputIterator copy_n(InputIterator first,
+                        Size n,
+                        OutputIterator result);
+
+
+namespace detail
+{
+
+
+template<typename FromSystem,
+         typename ToSystem,
+         typename InputIterator,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator two_system_copy(const thrust::execution_policy<FromSystem> &from_system,
+                                 const thrust::execution_policy<ToSystem>   &two_system,
+                                 InputIterator first,
+                                 InputIterator last,
+                                 OutputIterator result);
+
+
+template<typename FromSystem,
+         typename ToSystem,
+         typename InputIterator,
+         typename Size,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator two_system_copy_n(const thrust::execution_policy<FromSystem> &from_system,
+                                   const thrust::execution_policy<ToSystem>   &two_system,
+                                   InputIterator first,
+                                   Size n,
+                                   OutputIterator result);
+
+
+} // end detail
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/copy.inl>

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/copy_if.h

@@ -0,0 +1,71 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename Predicate>
+__host__ __device__
+  OutputIterator copy_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                         InputIterator first,
+                         InputIterator last,
+                         OutputIterator result,
+                         Predicate pred);
+
+
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename Predicate>
+__host__ __device__
+  OutputIterator copy_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                         InputIterator1 first,
+                         InputIterator1 last,
+                         InputIterator2 stencil,
+                         OutputIterator result,
+                         Predicate pred);
+
+
+template<typename InputIterator,
+         typename OutputIterator,
+         typename Predicate>
+  OutputIterator copy_if(InputIterator first,
+                         InputIterator last,
+                         OutputIterator result,
+                         Predicate pred);
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename Predicate>
+  OutputIterator copy_if(InputIterator1 first,
+                         InputIterator1 last,
+                         InputIterator2 stencil,
+                         OutputIterator result,
+                         Predicate pred);
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/copy_if.inl>

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/copy_if.inl

@@ -0,0 +1,107 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/copy_if.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/copy_if.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/adl/copy_if.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename Predicate>
+__host__ __device__
+  OutputIterator copy_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                         InputIterator first,
+                         InputIterator last,
+                         OutputIterator result,
+                         Predicate pred)
+{
+  using thrust::system::detail::generic::copy_if;
+  return copy_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, result, pred);
+} // end copy_if()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename Predicate>
+__host__ __device__
+  OutputIterator copy_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                         InputIterator1 first,
+                         InputIterator1 last,
+                         InputIterator2 stencil,
+                         OutputIterator result,
+                         Predicate pred)
+{
+  using thrust::system::detail::generic::copy_if;
+  return copy_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, stencil, result, pred);
+} // end copy_if()
+
+
+template<typename InputIterator,
+         typename OutputIterator,
+         typename Predicate>
+  OutputIterator copy_if(InputIterator first,
+                         InputIterator last,
+                         OutputIterator result,
+                         Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type  System1;
+  typedef typename thrust::iterator_system<OutputIterator>::type System2;
+
+  System1 system1;
+  System2 system2;
+
+  return thrust::copy_if(select_system(system1,system2), first, last, result, pred);
+} // end copy_if()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename Predicate>
+  OutputIterator copy_if(InputIterator1 first,
+                         InputIterator1 last,
+                         InputIterator2 stencil,
+                         OutputIterator result,
+                         Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+  typedef typename thrust::iterator_system<OutputIterator>::type System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::copy_if(select_system(system1,system2,system3), first, last, stencil, result, pred);
+} // end copy_if()
+
+THRUST_NAMESPACE_END

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/count.h

@@ -0,0 +1,60 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename EqualityComparable>
+__host__ __device__
+  typename thrust::iterator_traits<InputIterator>::difference_type
+    count(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+          InputIterator first,
+          InputIterator last,
+          const EqualityComparable& value);
+
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename Predicate>
+__host__ __device__
+  typename thrust::iterator_traits<InputIterator>::difference_type
+    count_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+             InputIterator first,
+             InputIterator last,
+             Predicate pred);
+
+template <typename InputIterator,
+          typename EqualityComparable>
+  typename thrust::iterator_traits<InputIterator>::difference_type
+    count(InputIterator first,
+          InputIterator last,
+          const EqualityComparable& value);
+
+template <typename InputIterator,
+          typename Predicate>
+  typename thrust::iterator_traits<InputIterator>::difference_type
+    count_if(InputIterator first,
+             InputIterator last,
+             Predicate pred);
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/count.inl>

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/dependencies_aware_execution_policy.h

@@ -0,0 +1,106 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <tuple>
+
+#include <thrust/detail/execute_with_dependencies.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+template<template<typename> class ExecutionPolicyCRTPBase>
+struct dependencies_aware_execution_policy
+{
+    template<typename ...Dependencies>
+    __host__
+    thrust::detail::execute_with_dependencies<
+        ExecutionPolicyCRTPBase,
+        Dependencies...
+    >
+    after(Dependencies&& ...dependencies) const
+    {
+        return { capture_as_dependency(THRUST_FWD(dependencies))... };
+    }
+
+    template<typename ...Dependencies>
+    __host__
+    thrust::detail::execute_with_dependencies<
+        ExecutionPolicyCRTPBase,
+        Dependencies...
+    >
+    after(std::tuple<Dependencies...>& dependencies) const
+    {
+        return { capture_as_dependency(dependencies) };
+    }
+    template<typename ...Dependencies>
+    __host__
+    thrust::detail::execute_with_dependencies<
+        ExecutionPolicyCRTPBase,
+        Dependencies...
+    >
+    after(std::tuple<Dependencies...>&& dependencies) const
+    {
+        return { capture_as_dependency(std::move(dependencies)) };
+    }
+
+    template<typename ...Dependencies>
+    __host__
+    thrust::detail::execute_with_dependencies<
+        ExecutionPolicyCRTPBase,
+        Dependencies...
+    >
+    rebind_after(Dependencies&& ...dependencies) const
+    {
+        return { capture_as_dependency(THRUST_FWD(dependencies))... };
+    }
+
+    template<typename ...Dependencies>
+    __host__
+    thrust::detail::execute_with_dependencies<
+        ExecutionPolicyCRTPBase,
+        Dependencies...
+    >
+    rebind_after(std::tuple<Dependencies...>& dependencies) const
+    {
+        return { capture_as_dependency(dependencies) };
+    }
+    template<typename ...Dependencies>
+    __host__
+    thrust::detail::execute_with_dependencies<
+        ExecutionPolicyCRTPBase,
+        Dependencies...
+    >
+    rebind_after(std::tuple<Dependencies...>&& dependencies) const
+    {
+        return { capture_as_dependency(std::move(dependencies)) };
+    }
+};
+
+} // end detail
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_CPP_DIALECT >= 2011
+

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/device_malloc.inl

@@ -0,0 +1,53 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/device_malloc.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/detail/malloc_and_free.h>
+
+THRUST_NAMESPACE_BEGIN
+
+thrust::device_ptr<void> device_malloc(const std::size_t n)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef thrust::iterator_system< thrust::device_ptr<void> >::type system;
+
+  // XXX lower to select_system(system) here
+  system s;
+
+  return thrust::device_ptr<void>(thrust::malloc(s, n).get());
+} // end device_malloc()
+
+
+template<typename T>
+  thrust::device_ptr<T> device_malloc(const std::size_t n)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef thrust::iterator_system< thrust::device_ptr<void> >::type system;
+
+  // XXX lower to select_system(system) here
+  system s;
+
+  return thrust::device_ptr<T>(thrust::malloc<T>(s,n).get());
+} // end device_malloc()
+
+THRUST_NAMESPACE_END

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/device_ptr.inl

@@ -0,0 +1,64 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/device_ptr.h>
+#include <thrust/device_reference.h>
+#include <thrust/detail/config.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/iterator/iterator_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template<typename T>
+  __host__ __device__
+  device_ptr<T> device_pointer_cast(T *ptr)
+{
+  return device_ptr<T>(ptr);
+} // end device_pointer_cast()
+
+template<typename T>
+  __host__ __device__
+  device_ptr<T> device_pointer_cast(const device_ptr<T> &ptr)
+{
+  return ptr;
+} // end device_pointer_cast()
+
+
+namespace detail
+{
+
+template<typename T>
+  struct is_device_ptr< thrust::device_ptr<T> >
+    : public true_type
+{
+}; // end is_device_ptr
+
+#if (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC) && (_MSC_VER <= 1400)
+// XXX WAR MSVC 2005 problem with correctly implementing
+//     pointer_raw_pointer for device_ptr by specializing it here
+template<typename T>
+  struct pointer_raw_pointer< thrust::device_ptr<T> >
+{
+  typedef typename device_ptr<T>::raw_pointer type;
+}; // end pointer_raw_pointer
+#endif
+
+
+} // end namespace detail
+
+THRUST_NAMESPACE_END

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/distance.inl

@@ -0,0 +1,35 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/advance.h>
+#include <thrust/detail/config.h>
+#include <thrust/system/detail/generic/distance.h>
+#include <thrust/iterator/iterator_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template<typename InputIterator>
+inline __host__ __device__
+  typename thrust::iterator_traits<InputIterator>::difference_type
+    distance(InputIterator first, InputIterator last)
+{
+  return thrust::system::detail::generic::distance(first, last);
+} // end distance()
+
+THRUST_NAMESPACE_END

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/execute_with_allocator.h

@@ -0,0 +1,149 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/detail/execute_with_allocator_fwd.h>
+#include <thrust/pair.h>
+#include <thrust/detail/raw_pointer_cast.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/detail/allocator/allocator_traits.h>
+#include <thrust/detail/integer_math.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+template <
+    typename T
+  , typename Allocator
+  , template <typename> class BaseSystem
+>
+__host__
+thrust::pair<T*, std::ptrdiff_t>
+get_temporary_buffer(
+    thrust::detail::execute_with_allocator<Allocator, BaseSystem>& system
+  , std::ptrdiff_t n
+    )
+{
+  typedef typename thrust::detail::remove_reference<Allocator>::type naked_allocator;
+  typedef typename thrust::detail::allocator_traits<naked_allocator> alloc_traits;
+  typedef typename alloc_traits::void_pointer                        void_pointer;
+  typedef typename alloc_traits::size_type                           size_type;
+  typedef typename alloc_traits::value_type                          value_type;
+
+  // How many elements of type value_type do we need to accommodate n elements
+  // of type T?
+  size_type num_elements = divide_ri(sizeof(T) * n, sizeof(value_type));
+
+  void_pointer ptr = alloc_traits::allocate(system.get_allocator(), num_elements);
+
+  // Return the pointer and the number of elements of type T allocated.
+  return thrust::make_pair(thrust::reinterpret_pointer_cast<T*>(ptr),n);
+}
+
+template <
+    typename Pointer
+  , typename Allocator
+  , template <typename> class BaseSystem
+>
+__host__
+void
+return_temporary_buffer(
+    thrust::detail::execute_with_allocator<Allocator, BaseSystem>& system
+  , Pointer p
+  , std::ptrdiff_t n
+    )
+{
+  typedef typename thrust::detail::remove_reference<Allocator>::type naked_allocator;
+  typedef typename thrust::detail::allocator_traits<naked_allocator> alloc_traits;
+  typedef typename alloc_traits::pointer                             pointer;
+  typedef typename alloc_traits::size_type                           size_type;
+  typedef typename alloc_traits::value_type                          value_type;
+  typedef typename thrust::detail::pointer_traits<Pointer>::element_type T;
+
+  size_type num_elements = divide_ri(sizeof(T) * n, sizeof(value_type));
+
+  pointer to_ptr = thrust::reinterpret_pointer_cast<pointer>(p);
+  alloc_traits::deallocate(system.get_allocator(), to_ptr, num_elements);
+}
+
+#if THRUST_CPP_DIALECT >= 2011
+
+template <
+    typename T,
+    template <typename> class BaseSystem,
+    typename Allocator,
+    typename ...Dependencies
+>
+__host__
+thrust::pair<T*, std::ptrdiff_t>
+get_temporary_buffer(
+    thrust::detail::execute_with_allocator_and_dependencies<Allocator, BaseSystem, Dependencies...>& system,
+    std::ptrdiff_t n
+    )
+{
+  typedef typename thrust::detail::remove_reference<Allocator>::type naked_allocator;
+  typedef typename thrust::detail::allocator_traits<naked_allocator> alloc_traits;
+  typedef typename alloc_traits::void_pointer                        void_pointer;
+  typedef typename alloc_traits::size_type                           size_type;
+  typedef typename alloc_traits::value_type                          value_type;
+
+  // How many elements of type value_type do we need to accommodate n elements
+  // of type T?
+  size_type num_elements = divide_ri(sizeof(T) * n, sizeof(value_type));
+
+  void_pointer ptr = alloc_traits::allocate(system.get_allocator(), num_elements);
+
+  // Return the pointer and the number of elements of type T allocated.
+  return thrust::make_pair(thrust::reinterpret_pointer_cast<T*>(ptr),n);
+}
+
+template <
+    typename Pointer,
+    template <typename> class BaseSystem,
+    typename Allocator,
+    typename ...Dependencies
+>
+__host__
+void
+return_temporary_buffer(
+    thrust::detail::execute_with_allocator_and_dependencies<Allocator, BaseSystem, Dependencies...>& system,
+    Pointer p,
+    std::ptrdiff_t n
+    )
+{
+  typedef typename thrust::detail::remove_reference<Allocator>::type naked_allocator;
+  typedef typename thrust::detail::allocator_traits<naked_allocator> alloc_traits;
+  typedef typename alloc_traits::pointer                             pointer;
+  typedef typename alloc_traits::size_type                           size_type;
+  typedef typename alloc_traits::value_type                          value_type;
+  typedef typename thrust::detail::pointer_traits<Pointer>::element_type T;
+
+  size_type num_elements = divide_ri(sizeof(T) * n, sizeof(value_type));
+
+  pointer to_ptr = thrust::reinterpret_pointer_cast<pointer>(p);
+  alloc_traits::deallocate(system.get_allocator(), to_ptr, num_elements);
+}
+
+#endif
+
+} // namespace detail
+
+THRUST_NAMESPACE_END

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/execute_with_dependencies.h

@@ -0,0 +1,267 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <thrust/detail/type_deduction.h>
+#include <thrust/type_traits/remove_cvref.h>
+
+#include <tuple>
+#include <type_traits>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+struct capture_as_dependency_fn
+{
+  template<typename Dependency>
+  auto operator()(Dependency&& dependency) const
+  THRUST_DECLTYPE_RETURNS(capture_as_dependency(THRUST_FWD(dependency)))
+};
+
+// Default implementation: universal forwarding.
+template<typename Dependency>
+auto capture_as_dependency(Dependency&& dependency)
+THRUST_DECLTYPE_RETURNS(THRUST_FWD(dependency))
+
+template<typename... Dependencies>
+auto capture_as_dependency(std::tuple<Dependencies...>& dependencies)
+THRUST_DECLTYPE_RETURNS(
+  tuple_for_each(THRUST_FWD(dependencies), capture_as_dependency_fn{})
+)
+
+template<template<typename> class BaseSystem, typename... Dependencies>
+struct execute_with_dependencies
+    : BaseSystem<execute_with_dependencies<BaseSystem, Dependencies...>>
+{
+private:
+    using super_t = BaseSystem<execute_with_dependencies<BaseSystem, Dependencies...>>;
+
+    std::tuple<remove_cvref_t<Dependencies>...> dependencies;
+
+public:
+    __host__
+    execute_with_dependencies(super_t const &super, Dependencies && ...dependencies)
+        : super_t(super), dependencies(std::forward<Dependencies>(dependencies)...)
+    {
+    }
+
+    template <typename... UDependencies>
+    __host__
+    execute_with_dependencies(super_t const &super, UDependencies && ...deps)
+        : super_t(super), dependencies(THRUST_FWD(deps)...)
+    {
+    }
+
+    template <typename... UDependencies>
+    __host__
+    execute_with_dependencies(UDependencies && ...deps)
+        : dependencies(THRUST_FWD(deps)...)
+    {
+    }
+
+    template <typename... UDependencies>
+    __host__
+    execute_with_dependencies(super_t const &super, std::tuple<UDependencies...>&& deps)
+        : super_t(super), dependencies(std::move(deps))
+    {
+    }
+
+    template <typename... UDependencies>
+    __host__
+    execute_with_dependencies(std::tuple<UDependencies...>&& deps)
+        : dependencies(std::move(deps))
+    {
+    }
+
+    std::tuple<remove_cvref_t<Dependencies>...>
+    __host__
+    extract_dependencies() 
+    {
+        return std::move(dependencies);
+    }
+
+    // Rebinding.
+    template<typename ...UDependencies>
+    __host__
+    execute_with_dependencies<BaseSystem, UDependencies...>
+    rebind_after(UDependencies&& ...udependencies) const
+    {
+        return { capture_as_dependency(THRUST_FWD(udependencies))... };
+    }
+
+    // Rebinding.
+    template<typename ...UDependencies>
+    __host__
+    execute_with_dependencies<BaseSystem, UDependencies...>
+    rebind_after(std::tuple<UDependencies...>& udependencies) const
+    {
+        return { capture_as_dependency(udependencies) };
+    }
+    template<typename ...UDependencies>
+    __host__
+    execute_with_dependencies<BaseSystem, UDependencies...>
+    rebind_after(std::tuple<UDependencies...>&& udependencies) const
+    {
+        return { capture_as_dependency(std::move(udependencies)) };
+    }
+};
+
+template<
+    typename Allocator,
+    template<typename> class BaseSystem,
+    typename... Dependencies
+>
+struct execute_with_allocator_and_dependencies
+    : BaseSystem<
+        execute_with_allocator_and_dependencies<
+            Allocator,
+            BaseSystem,
+            Dependencies...
+        >
+    >
+{
+private:
+    using super_t = BaseSystem<
+        execute_with_allocator_and_dependencies<
+            Allocator,
+            BaseSystem,
+            Dependencies...
+        >
+    >;
+
+    std::tuple<remove_cvref_t<Dependencies>...> dependencies;
+    Allocator alloc;
+
+public:
+    template <typename... UDependencies>
+    __host__
+    execute_with_allocator_and_dependencies(super_t const &super, Allocator a, UDependencies && ...deps)
+        : super_t(super), dependencies(THRUST_FWD(deps)...), alloc(a)
+    {
+    }
+
+    template <typename... UDependencies>
+    __host__
+    execute_with_allocator_and_dependencies(Allocator a, UDependencies && ...deps)
+        : dependencies(THRUST_FWD(deps)...), alloc(a)
+    {
+    }
+
+    template <typename... UDependencies>
+    __host__
+    execute_with_allocator_and_dependencies(super_t const &super, Allocator a, std::tuple<UDependencies...>&& deps)
+        : super_t(super), dependencies(std::move(deps)), alloc(a)
+    {
+    }
+
+    template <typename... UDependencies>
+    __host__
+    execute_with_allocator_and_dependencies(Allocator a, std::tuple<UDependencies...>&& deps)
+        : dependencies(std::move(deps)), alloc(a)
+    {
+    }
+
+    std::tuple<remove_cvref_t<Dependencies>...>
+    __host__
+    extract_dependencies() 
+    {
+        return std::move(dependencies);
+    }
+
+    __host__
+    typename std::add_lvalue_reference<Allocator>::type
+    get_allocator()
+    {
+        return alloc;
+    }
+
+    // Rebinding.
+    template<typename ...UDependencies>
+    __host__
+    execute_with_allocator_and_dependencies<Allocator, BaseSystem, UDependencies...>
+    rebind_after(UDependencies&& ...udependencies) const
+    {
+        return { alloc, capture_as_dependency(THRUST_FWD(udependencies))... };
+    }
+
+    // Rebinding.
+    template<typename ...UDependencies>
+    __host__
+    execute_with_allocator_and_dependencies<Allocator, BaseSystem, UDependencies...>
+    rebind_after(std::tuple<UDependencies...>& udependencies) const
+    {
+        return { alloc, capture_as_dependency(udependencies) };
+    }
+    template<typename ...UDependencies>
+    __host__
+    execute_with_allocator_and_dependencies<Allocator, BaseSystem, UDependencies...>
+    rebind_after(std::tuple<UDependencies...>&& udependencies) const
+    {
+        return { alloc, capture_as_dependency(std::move(udependencies)) };
+    }
+};
+
+template<template<typename> class BaseSystem, typename ...Dependencies>
+__host__
+std::tuple<remove_cvref_t<Dependencies>...>
+extract_dependencies(thrust::detail::execute_with_dependencies<BaseSystem, Dependencies...>&& system)
+{
+    return std::move(system).extract_dependencies();
+}
+template<template<typename> class BaseSystem, typename ...Dependencies>
+__host__
+std::tuple<remove_cvref_t<Dependencies>...>
+extract_dependencies(thrust::detail::execute_with_dependencies<BaseSystem, Dependencies...>& system)
+{
+    return std::move(system).extract_dependencies();
+}
+
+template<typename Allocator, template<typename> class BaseSystem, typename ...Dependencies>
+__host__
+std::tuple<remove_cvref_t<Dependencies>...>
+extract_dependencies(thrust::detail::execute_with_allocator_and_dependencies<Allocator, BaseSystem, Dependencies...>&& system)
+{
+    return std::move(system).extract_dependencies();
+}
+template<typename Allocator, template<typename> class BaseSystem, typename ...Dependencies>
+__host__
+std::tuple<remove_cvref_t<Dependencies>...>
+extract_dependencies(thrust::detail::execute_with_allocator_and_dependencies<Allocator, BaseSystem, Dependencies...>& system)
+{
+    return std::move(system).extract_dependencies();
+}
+
+template<typename System>
+__host__
+std::tuple<>
+extract_dependencies(System &&)
+{
+    return std::tuple<>{};
+}
+
+} // end detail
+
+THRUST_NAMESPACE_END
+
+#endif // THRUST_CPP_DIALECT >= 2011

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/extrema.inl

@@ -0,0 +1,169 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/extrema.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/extrema.h>
+#include <thrust/system/detail/adl/extrema.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator>
+__host__ __device__
+ForwardIterator min_element(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, ForwardIterator first, ForwardIterator last)
+{
+  using thrust::system::detail::generic::min_element;
+  return min_element(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last);
+} // end min_element()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator, typename BinaryPredicate>
+__host__ __device__
+ForwardIterator min_element(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, ForwardIterator first, ForwardIterator last, BinaryPredicate comp)
+{
+  using thrust::system::detail::generic::min_element;
+  return min_element(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, comp);
+} // end min_element()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator>
+__host__ __device__
+ForwardIterator max_element(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, ForwardIterator first, ForwardIterator last)
+{
+  using thrust::system::detail::generic::max_element;
+  return max_element(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last);
+} // end max_element()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator, typename BinaryPredicate>
+__host__ __device__
+ForwardIterator max_element(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, ForwardIterator first, ForwardIterator last, BinaryPredicate comp)
+{
+  using thrust::system::detail::generic::max_element;
+  return max_element(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, comp);
+} // end max_element()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator>
+__host__ __device__
+thrust::pair<ForwardIterator,ForwardIterator> minmax_element(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, ForwardIterator first, ForwardIterator last)
+{
+  using thrust::system::detail::generic::minmax_element;
+  return minmax_element(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last);
+} // end minmax_element()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename ForwardIterator, typename BinaryPredicate>
+__host__ __device__
+thrust::pair<ForwardIterator,ForwardIterator> minmax_element(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, ForwardIterator first, ForwardIterator last, BinaryPredicate comp)
+{
+  using thrust::system::detail::generic::minmax_element;
+  return minmax_element(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, comp);
+} // end minmax_element()
+
+
+template <typename ForwardIterator>
+ForwardIterator min_element(ForwardIterator first, ForwardIterator last)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::min_element(select_system(system), first, last);
+} // end min_element()
+
+
+template <typename ForwardIterator, typename BinaryPredicate>
+ForwardIterator min_element(ForwardIterator first, ForwardIterator last,
+                            BinaryPredicate comp)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::min_element(select_system(system), first, last, comp);
+} // end min_element()
+
+
+template <typename ForwardIterator>
+ForwardIterator max_element(ForwardIterator first, ForwardIterator last)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::max_element(select_system(system), first, last);
+} // end max_element()
+
+
+template <typename ForwardIterator, typename BinaryPredicate>
+ForwardIterator max_element(ForwardIterator first, ForwardIterator last,
+                            BinaryPredicate comp)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::max_element(select_system(system), first, last, comp);
+} // end max_element()
+
+
+template <typename ForwardIterator>
+thrust::pair<ForwardIterator,ForwardIterator>
+minmax_element(ForwardIterator first, ForwardIterator last)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::minmax_element(select_system(system), first, last);
+} // end minmax_element()
+
+
+template <typename ForwardIterator, typename BinaryPredicate>
+thrust::pair<ForwardIterator,ForwardIterator>
+minmax_element(ForwardIterator first, ForwardIterator last, BinaryPredicate comp)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<ForwardIterator>::type System;
+
+  System system;
+
+  return thrust::minmax_element(select_system(system), first, last, comp);
+} // end minmax_element()
+
+THRUST_NAMESPACE_END

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/functional/operators/arithmetic_operators.h

@@ -0,0 +1,436 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/functional/actor.h>
+#include <thrust/detail/functional/composite.h>
+#include <thrust/detail/functional/operators/operator_adaptors.h>
+#include <thrust/functional.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace functional
+{
+
+template<typename Eval>
+__host__ __device__
+actor<
+  composite<
+    transparent_unary_operator<thrust::negate<>>,
+    actor<Eval>
+  >
+>
+__host__ __device__
+operator-(const actor<Eval> &_1)
+{
+  return compose(transparent_unary_operator<thrust::negate<>>(), _1);
+} // end operator-()
+
+// there's no standard unary_plus functional, so roll an ad hoc one here
+struct unary_plus
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1) const
+  noexcept(noexcept(+THRUST_FWD(t1)))
+  THRUST_TRAILING_RETURN(decltype(+THRUST_FWD(t1)))
+  {
+    return +THRUST_FWD(t1);
+  }
+};
+
+template<typename Eval>
+__host__ __device__
+actor<
+  composite<
+    transparent_unary_operator<unary_plus>,
+    actor<Eval>
+  >
+>
+operator+(const actor<Eval> &_1)
+{
+  return compose(transparent_unary_operator<unary_plus>(), _1);
+} // end operator+()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::plus<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator+(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<thrust::plus<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator+()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::plus<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator+(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::plus<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator+()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::plus<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator+(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::plus<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator+()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::minus<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator-(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::minus<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator-()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::minus<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator-(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<thrust::minus<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator-()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::minus<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator-(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::minus<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator-()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::multiplies<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator*(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::multiplies<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator*()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::multiplies<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator*(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<thrust::multiplies<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator*()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::multiplies<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator*(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::multiplies<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator*()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::divides<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator/(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<thrust::divides<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator/()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::divides<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator/(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::divides<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator/()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::divides<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator/(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::divides<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator/()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::modulus<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator%(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<thrust::modulus<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator%()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::modulus<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator%(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::modulus<void>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator%()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::modulus<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator%(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::modulus<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator%()
+
+// there's no standard prefix_increment functional, so roll an ad hoc one here
+struct prefix_increment
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1) const
+  noexcept(noexcept(++THRUST_FWD(t1)))
+  THRUST_TRAILING_RETURN(decltype(++THRUST_FWD(t1)))
+  {
+    return ++THRUST_FWD(t1);
+  }
+}; // end prefix_increment
+
+template<typename Eval>
+__host__ __device__
+actor<
+  composite<
+    transparent_unary_operator<prefix_increment>,
+    actor<Eval>
+  >
+>
+operator++(const actor<Eval> &_1)
+{
+  return compose(transparent_unary_operator<prefix_increment>(), _1);
+} // end operator++()
+
+
+// there's no standard postfix_increment functional, so roll an ad hoc one here
+struct postfix_increment
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1) const
+  noexcept(noexcept(THRUST_FWD(t1)++))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1)++))
+  {
+    return THRUST_FWD(t1)++;
+  }
+}; // end postfix_increment
+
+template<typename Eval>
+__host__ __device__
+actor<
+  composite<
+    transparent_unary_operator<postfix_increment>,
+    actor<Eval>
+  >
+>
+operator++(const actor<Eval> &_1, int)
+{
+  return compose(transparent_unary_operator<postfix_increment>(), _1);
+} // end operator++()
+
+
+// there's no standard prefix_decrement functional, so roll an ad hoc one here
+struct prefix_decrement
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1) const
+  noexcept(noexcept(--THRUST_FWD(t1)))
+  THRUST_TRAILING_RETURN(decltype(--THRUST_FWD(t1)))
+  {
+    return --THRUST_FWD(t1);
+  }
+}; // end prefix_decrement
+
+template<typename Eval>
+__host__ __device__
+actor<
+  composite<
+    transparent_unary_operator<prefix_decrement>,
+    actor<Eval>
+  >
+>
+operator--(const actor<Eval> &_1)
+{
+  return compose(transparent_unary_operator<prefix_decrement>(), _1);
+} // end operator--()
+
+
+// there's no standard postfix_decrement functional, so roll an ad hoc one here
+struct postfix_decrement
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1) const
+  noexcept(noexcept(THRUST_FWD(t1)--))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1)--))
+  {
+    return THRUST_FWD(t1)--;
+  }
+}; // end prefix_increment
+
+template<typename Eval>
+__host__ __device__
+actor<
+  composite<
+    transparent_unary_operator<postfix_decrement>,
+    actor<Eval>
+  >
+>
+operator--(const actor<Eval> &_1, int)
+{
+  return compose(transparent_unary_operator<postfix_decrement>(), _1);
+} // end operator--()
+
+} // end functional
+} // end detail
+THRUST_NAMESPACE_END
+

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/functional/operators/assignment_operator.h

@@ -0,0 +1,79 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/functional/actor.h>
+#include <thrust/detail/functional/composite.h>
+#include <thrust/detail/functional/operators/operator_adaptors.h>
+#include <thrust/functional.h>
+
+THRUST_NAMESPACE_BEGIN
+
+// XXX WAR circular inclusion with this forward declaration
+template<typename,typename,typename> struct binary_function;
+
+namespace detail
+{
+namespace functional
+{
+
+// XXX WAR circular inclusion with this forward declaration
+template<typename> struct as_actor;
+
+// there's no standard assign functional, so roll an ad hoc one here
+struct assign
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1, typename T2>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1, T2&& t2) const
+  noexcept(noexcept(THRUST_FWD(t1) = THRUST_FWD(t2)))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) = THRUST_FWD(t2)))
+  {
+    return THRUST_FWD(t1) = THRUST_FWD(t2);
+  }
+};
+
+template<typename Eval, typename T>
+  struct assign_result
+{
+  typedef actor<
+    composite<
+      transparent_binary_operator<assign>,
+      actor<Eval>,
+      typename as_actor<T>::type
+    >
+  > type;
+}; // end assign_result
+
+template<typename Eval, typename T>
+  __host__ __device__
+    typename assign_result<Eval,T>::type
+      do_assign(const actor<Eval> &_1, const T &_2)
+{
+  return compose(transparent_binary_operator<assign>(),
+                 _1,
+                 as_actor<T>::convert(_2));
+} // end do_assign()
+
+} // end functional
+} // end detail
+THRUST_NAMESPACE_END
+

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/functional/operators/bitwise_operators.h

@@ -0,0 +1,338 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/functional/actor.h>
+#include <thrust/detail/functional/composite.h>
+#include <thrust/detail/functional/operators/operator_adaptors.h>
+#include <thrust/functional.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace functional
+{
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_and<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator&(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<bit_and<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator&()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_and<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator&(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_and<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator&()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_and<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator&(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_and<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator&()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_or<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator|(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<bit_or<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator|()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_or<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator|(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_or<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator|()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_or<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator|(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_or<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator|()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_xor<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator^(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<bit_xor<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator^()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_xor<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator^(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_xor<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator^()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_xor<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator^(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_xor<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator^()
+
+
+// there's no standard bit_not functional, so roll an ad hoc one here
+struct bit_not
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1) const
+  noexcept(noexcept(~THRUST_FWD(t1)))
+  THRUST_TRAILING_RETURN(decltype(~THRUST_FWD(t1)))
+  {
+    return ~THRUST_FWD(t1);
+  }
+}; // end prefix_increment
+
+template<typename Eval>
+__host__ __device__
+actor<
+  composite<
+    transparent_unary_operator<bit_not>,
+    actor<Eval>
+  >
+>
+__host__ __device__
+operator~(const actor<Eval> &_1)
+{
+  return compose(transparent_unary_operator<bit_not>(), _1);
+} // end operator~()
+
+// there's no standard bit_lshift functional, so roll an ad hoc one here
+struct bit_lshift
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1, typename T2>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1, T2&& t2) const
+  noexcept(noexcept(THRUST_FWD(t1) << THRUST_FWD(t2)))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) << THRUST_FWD(t2)))
+  {
+    return THRUST_FWD(t1) << THRUST_FWD(t2);
+  }
+};
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_lshift>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator<<(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<bit_lshift>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator<<()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_lshift>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator<<(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_lshift>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator<<()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_lshift>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator<<(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_lshift>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator<<()
+
+// there's no standard bit_rshift functional, so roll an ad hoc one here
+struct bit_rshift
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1, typename T2>
+  __host__ __device__
+  constexpr auto operator()(T1& t1, T2&& t2) const
+  noexcept(noexcept(THRUST_FWD(t1) >> THRUST_FWD(t2)))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) >> THRUST_FWD(t2)))
+  {
+    return THRUST_FWD(t1) >> THRUST_FWD(t2);
+  }
+};
+
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_rshift>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator>>(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<bit_rshift>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator>>()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_rshift>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator>>(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_rshift>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator>>()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_rshift>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator>>(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_rshift>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator>>()
+
+} // end functional
+} // end detail
+THRUST_NAMESPACE_END
+

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/functional/operators/compound_assignment_operators.h

@@ -0,0 +1,512 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/functional/actor.h>
+#include <thrust/detail/functional/composite.h>
+#include <thrust/detail/functional/operators/operator_adaptors.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace functional
+{
+
+// there's no standard plus_equal functional, so roll an ad hoc one here
+struct plus_equal
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1, typename T2>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1, T2&& t2) const
+  noexcept(noexcept(THRUST_FWD(t1) += THRUST_FWD(t2)))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) += THRUST_FWD(t2)))
+  {
+    return THRUST_FWD(t1) += THRUST_FWD(t2);
+  }
+};
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<plus_equal>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator+=(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<plus_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator+=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<plus_equal>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator+=(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<plus_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator+=()
+
+// there's no standard minus_equal functional, so roll an ad hoc one here
+struct minus_equal
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1, typename T2>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1, T2&& t2) const
+  noexcept(noexcept(THRUST_FWD(t1) -= THRUST_FWD(t2)))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) -= THRUST_FWD(t2)))
+  {
+    return THRUST_FWD(t1) -= THRUST_FWD(t2);
+  }
+};
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<minus_equal>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator-=(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<minus_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator-=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<minus_equal>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator-=(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<minus_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator-=()
+
+// there's no standard multiplies_equal functional, so roll an ad hoc one here
+struct multiplies_equal
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1, typename T2>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1, T2&& t2) const
+  noexcept(noexcept(THRUST_FWD(t1) *= THRUST_FWD(t2)))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) *= THRUST_FWD(t2)))
+  {
+    return THRUST_FWD(t1) *= THRUST_FWD(t2);
+  }
+};
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<multiplies_equal>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator*=(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<multiplies_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator*=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<multiplies_equal>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator*=(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<multiplies_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator*=()
+
+// there's no standard divides_equal functional, so roll an ad hoc one here
+struct divides_equal
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1, typename T2>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1, T2&& t2) const
+  noexcept(noexcept(THRUST_FWD(t1) /= THRUST_FWD(t2)))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) /= THRUST_FWD(t2)))
+  {
+    return THRUST_FWD(t1) /= THRUST_FWD(t2);
+  }
+};
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<divides_equal>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator/=(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<divides_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator/=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<divides_equal>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator/=(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<divides_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator/=()
+
+// there's no standard modulus_equal functional, so roll an ad hoc one here
+struct modulus_equal
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1, typename T2>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1, T2&& t2) const
+  noexcept(noexcept(THRUST_FWD(t1) %= THRUST_FWD(t2)))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) %= THRUST_FWD(t2)))
+  {
+    return THRUST_FWD(t1) %= THRUST_FWD(t2);
+  }
+};
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<modulus_equal>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator%=(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<modulus_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator%=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<modulus_equal>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator%=(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<modulus_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator%=()
+
+// there's no standard bit_and_equal functional, so roll an ad hoc one here
+struct bit_and_equal
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1, typename T2>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1, T2&& t2) const
+  noexcept(noexcept(THRUST_FWD(t1) &= THRUST_FWD(t2)))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) &= THRUST_FWD(t2)))
+  {
+    return THRUST_FWD(t1) &= THRUST_FWD(t2);
+  }
+};
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_and_equal>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator&=(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<bit_and_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator&=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_and_equal>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator&=(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_and_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator&=()
+
+// there's no standard bit_or_equal functional, so roll an ad hoc one here
+struct bit_or_equal
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1, typename T2>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1, T2&& t2) const
+  noexcept(noexcept(THRUST_FWD(t1) |= THRUST_FWD(t2)))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) |= THRUST_FWD(t2)))
+  {
+    return THRUST_FWD(t1) |= THRUST_FWD(t2);
+  }
+};
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_or_equal>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator|=(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<bit_or_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator|=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_or_equal>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator|=(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_or_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator|=()
+
+// there's no standard bit_xor_equal functional, so roll an ad hoc one here
+struct bit_xor_equal
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1, typename T2>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1, T2&& t2) const
+  noexcept(noexcept(THRUST_FWD(t1) ^= THRUST_FWD(t2)))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) ^= THRUST_FWD(t2)))
+  {
+    return THRUST_FWD(t1) ^= THRUST_FWD(t2);
+  }
+};
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_xor_equal>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator^=(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<bit_xor_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator|=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_xor_equal>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator^=(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_xor_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator|=()
+
+// there's no standard bit_lshift_equal functional, so roll an ad hoc one here
+struct bit_lshift_equal
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1, typename T2>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1, T2&& t2) const
+  noexcept(noexcept(THRUST_FWD(t1) <<= THRUST_FWD(t2)))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) <<= THRUST_FWD(t2)))
+  {
+    return THRUST_FWD(t1) <<= THRUST_FWD(t2);
+  }
+};
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_lshift_equal>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator<<=(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<bit_lshift_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator<<=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_lshift_equal>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator<<=(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_lshift_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator<<=()
+
+// there's no standard bit_rshift_equal functional, so roll an ad hoc one here
+struct bit_rshift_equal
+{
+  using is_transparent = void;
+
+  __thrust_exec_check_disable__
+  template <typename T1, typename T2>
+  __host__ __device__
+  constexpr auto operator()(T1&& t1, T2&& t2) const
+  noexcept(noexcept(THRUST_FWD(t1) >>= THRUST_FWD(t2)))
+  THRUST_TRAILING_RETURN(decltype(THRUST_FWD(t1) >>= THRUST_FWD(t2)))
+  {
+    return THRUST_FWD(t1) >>= THRUST_FWD(t2);
+  }
+};
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_rshift_equal>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator>>=(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<bit_rshift_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator>>=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<bit_rshift_equal>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator>>=(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<bit_rshift_equal>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator>>=()
+
+} // end functional
+} // end detail
+THRUST_NAMESPACE_END
+

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/functional/operators/logical_operators.h

@@ -0,0 +1,143 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/functional/actor.h>
+#include <thrust/detail/functional/composite.h>
+#include <thrust/detail/functional/operators/operator_adaptors.h>
+#include <thrust/functional.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace functional
+{
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::logical_and<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator&&(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<thrust::logical_and<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator&&()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::logical_and<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator&&(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::logical_and<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator&&()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::logical_and<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator&&(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::logical_and<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator&&()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::logical_or<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator||(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<thrust::logical_or<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator&&()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::logical_or<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator||(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::logical_or<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator&&()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::logical_or<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator||(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::logical_or<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator&&()
+
+template<typename Eval>
+__host__ __device__
+actor<
+  composite<
+    transparent_unary_operator<thrust::logical_not<>>,
+    actor<Eval>
+  >
+>
+operator!(const actor<Eval> &_1)
+{
+  return compose(transparent_unary_operator<thrust::logical_not<>>(), _1);
+} // end operator!()
+
+} // end functional
+} // end detail
+THRUST_NAMESPACE_END
+

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/functional/operators/relational_operators.h

@@ -0,0 +1,322 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/functional/actor.h>
+#include <thrust/detail/functional/composite.h>
+#include <thrust/detail/functional/operators/operator_adaptors.h>
+#include <thrust/functional.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace functional
+{
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::equal_to<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator==(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<thrust::equal_to<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator==()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::equal_to<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator==(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::equal_to<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator==()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::equal_to<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator==(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::equal_to<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator==()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::not_equal_to<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator!=(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<thrust::not_equal_to<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator!=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::not_equal_to<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator!=(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::not_equal_to<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator!=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::not_equal_to<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator!=(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::not_equal_to<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator!=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::greater<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator>(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<thrust::greater<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator>()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::greater<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator>(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::greater<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator>()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::greater<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator>(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::greater<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator>()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::less<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator<(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<thrust::less<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator<()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::less<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator<(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::less<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator<()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::less<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator<(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::less<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator<()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::greater_equal<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator>=(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<thrust::greater_equal<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator>=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::greater_equal<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator>=(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::greater_equal<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator>=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::greater_equal<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator>=(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::greater_equal<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator>=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::less_equal<>>,
+    actor<T1>,
+    typename as_actor<T2>::type
+  >
+>
+operator<=(const actor<T1> &_1, const T2 &_2)
+{
+  return compose(transparent_binary_operator<thrust::less_equal<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator<=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::less_equal<>>,
+    typename as_actor<T1>::type,
+    actor<T2>
+  >
+>
+operator<=(const T1 &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::less_equal<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator<=()
+
+template<typename T1, typename T2>
+__host__ __device__
+actor<
+  composite<
+    transparent_binary_operator<thrust::less_equal<>>,
+    actor<T1>,
+    actor<T2>
+  >
+>
+operator<=(const actor<T1> &_1, const actor<T2> &_2)
+{
+  return compose(transparent_binary_operator<thrust::less_equal<>>(),
+                 make_actor(_1),
+                 make_actor(_2));
+} // end operator<=()
+
+} // end functional
+} // end detail
+THRUST_NAMESPACE_END
+

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/gather.inl

@@ -0,0 +1,161 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/gather.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/gather.h>
+#include <thrust/system/detail/adl/gather.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename RandomAccessIterator,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator gather(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                        InputIterator                                               map_first,
+                        InputIterator                                               map_last,
+                        RandomAccessIterator                                        input_first,
+                        OutputIterator                                              result)
+{
+  using thrust::system::detail::generic::gather;
+  return gather(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), map_first, map_last, input_first, result);
+} // end gather()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename RandomAccessIterator,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator gather_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           InputIterator1                                              map_first,
+                           InputIterator1                                              map_last,
+                           InputIterator2                                              stencil,
+                           RandomAccessIterator                                        input_first,
+                           OutputIterator                                              result)
+{
+  using thrust::system::detail::generic::gather_if;
+  return gather_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), map_first, map_last, stencil, input_first, result);
+} // end gather_if()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename RandomAccessIterator,
+         typename OutputIterator,
+         typename Predicate>
+__host__ __device__
+  OutputIterator gather_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                           InputIterator1                                              map_first,
+                           InputIterator1                                              map_last,
+                           InputIterator2                                              stencil,
+                           RandomAccessIterator                                        input_first,
+                           OutputIterator                                              result,
+                           Predicate                                                   pred)
+{
+  using thrust::system::detail::generic::gather_if;
+  return gather_if(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), map_first, map_last, stencil, input_first, result, pred);
+} // end gather_if()
+
+
+template<typename InputIterator,
+         typename RandomAccessIterator,
+         typename OutputIterator>
+  OutputIterator gather(InputIterator        map_first,
+                        InputIterator        map_last,
+                        RandomAccessIterator input_first,
+                        OutputIterator       result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type        System1;
+  typedef typename thrust::iterator_system<RandomAccessIterator>::type System2;
+  typedef typename thrust::iterator_system<OutputIterator>::type       System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::gather(select_system(system1,system2,system3), map_first, map_last, input_first, result);
+} // end gather()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename RandomAccessIterator,
+         typename OutputIterator>
+  OutputIterator gather_if(InputIterator1       map_first,
+                           InputIterator1       map_last,
+                           InputIterator2       stencil,
+                           RandomAccessIterator input_first,
+                           OutputIterator       result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type       System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type       System2;
+  typedef typename thrust::iterator_system<RandomAccessIterator>::type System3;
+  typedef typename thrust::iterator_system<OutputIterator>::type       System4;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+
+  return thrust::gather_if(select_system(system1,system2,system3,system4), map_first, map_last, stencil, input_first, result);
+} // end gather_if()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename RandomAccessIterator,
+         typename OutputIterator,
+         typename Predicate>
+  OutputIterator gather_if(InputIterator1       map_first,
+                           InputIterator1       map_last,
+                           InputIterator2       stencil,
+                           RandomAccessIterator input_first,
+                           OutputIterator       result,
+                           Predicate            pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type       System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type       System2;
+  typedef typename thrust::iterator_system<RandomAccessIterator>::type System3;
+  typedef typename thrust::iterator_system<OutputIterator>::type       System4;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+
+  return thrust::gather_if(select_system(system1,system2,system3,system4), map_first, map_last, stencil, input_first, result, pred);
+} // end gather_if()
+
+THRUST_NAMESPACE_END

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/integer_math.h

@@ -0,0 +1,152 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/type_deduction.h>
+
+#include <nv/target>
+
+#include <limits>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+template <typename Integer>
+__host__ __device__ __thrust_forceinline__
+Integer clz(Integer x)
+{
+  Integer result;
+
+  NV_IF_TARGET(NV_IS_DEVICE, (
+    result = ::__clz(x);
+  ), (
+    int num_bits = 8 * sizeof(Integer);
+    int num_bits_minus_one = num_bits - 1;
+    result = num_bits;
+    for (int i = num_bits_minus_one; i >= 0; --i)
+    {
+      if ((Integer(1) << i) & x)
+      {
+        result = num_bits_minus_one - i;
+        break;
+      }
+    }
+  ));
+
+  return result;
+}
+
+template <typename Integer>
+__host__ __device__ __thrust_forceinline__
+bool is_power_of_2(Integer x)
+{
+  return 0 == (x & (x - 1));
+}
+
+template <typename Integer>
+__host__ __device__ __thrust_forceinline__
+bool is_odd(Integer x)
+{
+  return 1 & x;
+}
+
+template <typename Integer>
+__host__ __device__ __thrust_forceinline__
+Integer log2(Integer x)
+{
+  Integer num_bits = 8 * sizeof(Integer);
+  Integer num_bits_minus_one = num_bits - 1;
+
+  return num_bits_minus_one - clz(x);
+}
+
+
+template <typename Integer>
+__host__ __device__ __thrust_forceinline__
+Integer log2_ri(Integer x)
+{
+  Integer result = log2(x);
+
+  // This is where we round up to the nearest log.
+  if (!is_power_of_2(x))
+    ++result;
+
+  return result;
+}
+
+// x/y rounding towards +infinity for integers
+// Used to determine # of blocks/warps etc.
+template <typename Integer0, typename Integer1>
+__host__ __device__ __thrust_forceinline__
+#if THRUST_CPP_DIALECT >= 2011
+// FIXME: Should use common_type.
+auto divide_ri(Integer0 const x, Integer1 const y)
+THRUST_DECLTYPE_RETURNS((x + (y - 1)) / y)
+#else
+// FIXME: Should use common_type.
+Integer0 divide_ri(Integer0 const x, Integer1 const y)
+{
+  return (x + (y - 1)) / y;
+}
+#endif
+
+// x/y rounding towards zero for integers.
+// Used to determine # of blocks/warps etc.
+template <typename Integer0, typename Integer1>
+__host__ __device__ __thrust_forceinline__
+#if THRUST_CPP_DIALECT >= 2011
+auto divide_rz(Integer0 const x, Integer1 const y)
+THRUST_DECLTYPE_RETURNS(x / y)
+#else
+// FIXME: Should use common_type.
+Integer0 divide_rz(Integer0 const x, Integer1 const y)
+{
+  return x / y;
+}
+#endif
+
+// Round x towards infinity to the next multiple of y.
+template <typename Integer0, typename Integer1>
+__host__ __device__ __thrust_forceinline__
+#if THRUST_CPP_DIALECT >= 2011
+auto round_i(Integer0 const x, Integer1 const y)
+THRUST_DECLTYPE_RETURNS(y * divide_ri(x, y))
+#else
+Integer0 round_i(Integer0 const x, Integer1 const y)
+{
+  return y * divide_ri(x, y);
+}
+#endif
+
+// Round x towards 0 to the next multiple of y.
+template <typename Integer0, typename Integer1>
+__host__ __device__ __thrust_forceinline__
+#if THRUST_CPP_DIALECT >= 2011
+auto round_z(Integer0 const x, Integer1 const y)
+THRUST_DECLTYPE_RETURNS(y * divide_rz(x, y))
+#else
+Integer0 round_z(Integer0 const x, Integer1 const y)
+{
+  return y * divide_rz(x, y);
+}
+#endif
+
+} // end detail
+
+THRUST_NAMESPACE_END

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/integer_traits.h

@@ -0,0 +1,130 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <limits>
+#include <limits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+template<typename T>
+  class integer_traits
+{
+  public:
+    static constexpr bool is_integral = false;
+};
+
+template<typename T, T min_val, T max_val>
+  class integer_traits_base
+{
+  public:
+    static constexpr bool is_integral = true;
+    static constexpr T const_min = min_val;
+    static constexpr T const_max = max_val;
+};
+
+
+template<>
+  class integer_traits<bool>
+    : public std::numeric_limits<bool>,
+      public integer_traits_base<bool, false, true>
+{};
+
+
+template<>
+  class integer_traits<char>
+    : public std::numeric_limits<char>,
+      public integer_traits_base<char, CHAR_MIN, CHAR_MAX>
+{};
+
+
+template<>
+  class integer_traits<signed char>
+    : public std::numeric_limits<signed char>,
+      public integer_traits_base<signed char, SCHAR_MIN, SCHAR_MAX>
+{};
+
+
+template<>
+  class integer_traits<unsigned char>
+    : public std::numeric_limits<unsigned char>,
+      public integer_traits_base<unsigned char, 0, UCHAR_MAX>
+{};
+
+
+template<>
+  class integer_traits<short>
+    : public std::numeric_limits<short>,
+      public integer_traits_base<short, SHRT_MIN, SHRT_MAX>
+{};
+
+
+template<>
+  class integer_traits<unsigned short>
+    : public std::numeric_limits<unsigned short>,
+      public integer_traits_base<unsigned short, 0, USHRT_MAX>
+{};
+
+
+template<>
+  class integer_traits<int>
+    : public std::numeric_limits<int>,
+      public integer_traits_base<int, INT_MIN, INT_MAX>
+{};
+
+
+template<>
+  class integer_traits<unsigned int>
+    : public std::numeric_limits<unsigned int>,
+      public integer_traits_base<unsigned int, 0, UINT_MAX>
+{};
+
+
+template<>
+  class integer_traits<long>
+    : public std::numeric_limits<long>,
+      public integer_traits_base<long, LONG_MIN, LONG_MAX>
+{};
+
+
+template<>
+  class integer_traits<unsigned long>
+    : public std::numeric_limits<unsigned long>,
+      public integer_traits_base<unsigned long, 0, ULONG_MAX>
+{};
+
+
+template<>
+  class integer_traits<long long>
+    : public std::numeric_limits<long long>,
+      public integer_traits_base<long long, LLONG_MIN, LLONG_MAX>
+{};
+
+
+template<>
+  class integer_traits<unsigned long long>
+    : public std::numeric_limits<unsigned long long>,
+      public integer_traits_base<unsigned long long, 0, ULLONG_MAX>
+{};
+
+} // end detail
+
+THRUST_NAMESPACE_END

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/logical.inl

@@ -0,0 +1,95 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/logical.h>
+#include <thrust/system/detail/adl/logical.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator, typename Predicate>
+__host__ __device__
+bool all_of(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, InputIterator first, InputIterator last, Predicate pred)
+{
+  using thrust::system::detail::generic::all_of;
+  return all_of(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, pred);
+} // end all_of()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator, typename Predicate>
+__host__ __device__
+bool any_of(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, InputIterator first, InputIterator last, Predicate pred)
+{
+  using thrust::system::detail::generic::any_of;
+  return any_of(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, pred);
+} // end any_of()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator, typename Predicate>
+__host__ __device__
+bool none_of(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, InputIterator first, InputIterator last, Predicate pred)
+{
+  using thrust::system::detail::generic::none_of;
+  return none_of(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first, last, pred);
+} // end none_of()
+
+
+template<typename InputIterator, typename Predicate>
+bool all_of(InputIterator first, InputIterator last, Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type System;
+
+  System system;
+
+  return thrust::all_of(select_system(system), first, last, pred);
+}
+
+
+template<typename InputIterator, typename Predicate>
+bool any_of(InputIterator first, InputIterator last, Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type System;
+
+  System system;
+
+  return thrust::any_of(select_system(system), first, last, pred);
+}
+
+
+template<typename InputIterator, typename Predicate>
+bool none_of(InputIterator first, InputIterator last, Predicate pred)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator>::type System;
+
+  System system;
+
+  return thrust::none_of(select_system(system), first, last, pred);
+}
+
+THRUST_NAMESPACE_END

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/memory_algorithms.h

@@ -0,0 +1,237 @@
+// Copyright (c) 2018 NVIDIA Corporation
+// Author: Bryce Adelstein Lelbach <brycelelbach@gmail.com>
+//
+// Distributed under the Boost Software License v1.0 (boost.org/LICENSE_1_0.txt)
+
+// TODO: These need to be turned into proper Thrust algorithms (dispatch layer,
+// backends, etc).
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/allocator/allocator_traits.h>
+#include <thrust/detail/memory_wrapper.h>
+#include <thrust/addressof.h>
+
+#include <nv/target>
+
+#include <utility>
+#include <new>
+
+
+THRUST_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+__host__ __device__
+void destroy_at(T* location)
+{
+  location->~T();
+}
+
+template <typename Allocator, typename T>
+__host__ __device__
+void destroy_at(Allocator const& alloc, T* location)
+{
+  typedef typename detail::allocator_traits<
+    typename detail::remove_cv<
+      typename detail::remove_reference<Allocator>::type
+    >::type
+  >::template rebind_traits<T>::other traits;
+
+  typename traits::allocator_type alloc_T(alloc);
+
+  traits::destroy(alloc_T, location);
+}
+
+template <typename ForwardIt>
+__host__ __device__
+ForwardIt destroy(ForwardIt first, ForwardIt last)
+{
+  for (; first != last; ++first)
+    destroy_at(addressof(*first));
+
+  return first;
+}
+
+template <typename Allocator, typename ForwardIt>
+__host__ __device__
+ForwardIt destroy(Allocator const& alloc, ForwardIt first, ForwardIt last)
+{
+  typedef typename iterator_traits<ForwardIt>::value_type T;
+  typedef typename detail::allocator_traits<
+    typename detail::remove_cv<
+      typename detail::remove_reference<Allocator>::type
+    >::type
+  >::template rebind_traits<T>::other traits;
+
+  typename traits::allocator_type alloc_T(alloc);
+
+  for (; first != last; ++first)
+    destroy_at(alloc_T, addressof(*first));
+
+  return first;
+}
+
+template <typename ForwardIt, typename Size>
+__host__ __device__
+ForwardIt destroy_n(ForwardIt first, Size n)
+{
+  for (; n > 0; (void) ++first, --n)
+    destroy_at(addressof(*first));
+
+  return first;
+}
+
+template <typename Allocator, typename ForwardIt, typename Size>
+__host__ __device__
+ForwardIt destroy_n(Allocator const& alloc, ForwardIt first, Size n)
+{
+  typedef typename iterator_traits<ForwardIt>::value_type T;
+  typedef typename detail::allocator_traits<
+    typename detail::remove_cv<
+      typename detail::remove_reference<Allocator>::type
+    >::type
+  >::template rebind_traits<T>::other traits;
+
+  typename traits::allocator_type alloc_T(alloc);
+
+  for (; n > 0; (void) ++first, --n)
+    destroy_at(alloc_T, addressof(*first));
+
+  return first;
+}
+
+template <typename ForwardIt, typename... Args>
+__host__ __device__
+void uninitialized_construct(
+  ForwardIt first, ForwardIt last, Args const&... args
+)
+{
+  using T = typename iterator_traits<ForwardIt>::value_type;
+
+  ForwardIt current = first;
+
+  // No exceptions in CUDA.
+  NV_IF_TARGET(NV_IS_HOST, (
+    try {
+      for (; current != last; ++current)
+      {
+        ::new (static_cast<void*>(addressof(*current))) T(args...);
+      }
+    } catch (...) {
+      destroy(first, current);
+      throw;
+    }
+  ), (
+    for (; current != last; ++current)
+    {
+      ::new (static_cast<void*>(addressof(*current))) T(args...);
+    }
+  ));
+}
+
+template <typename Allocator, typename ForwardIt, typename... Args>
+void uninitialized_construct_with_allocator(
+  Allocator const& alloc, ForwardIt first, ForwardIt last, Args const&... args
+)
+{
+  using T = typename iterator_traits<ForwardIt>::value_type;
+  using traits = typename detail::allocator_traits<
+    typename std::remove_cv<
+      typename std::remove_reference<Allocator>::type
+    >::type
+  >::template rebind_traits<T>;
+
+  typename traits::allocator_type alloc_T(alloc);
+
+  ForwardIt current = first;
+
+  // No exceptions in CUDA.
+  NV_IF_TARGET(NV_IS_HOST, (
+    try {
+      for (; current != last; ++current)
+      {
+        traits::construct(alloc_T, addressof(*current), args...);
+      }
+    } catch (...) {
+      destroy(alloc_T, first, current);
+      throw;
+    }
+  ), (
+    for (; current != last; ++current)
+    {
+      traits::construct(alloc_T, addressof(*current), args...);
+    }
+  ));
+}
+
+template <typename ForwardIt, typename Size, typename... Args>
+void uninitialized_construct_n(
+  ForwardIt first, Size n, Args const&... args
+)
+{
+  using T = typename iterator_traits<ForwardIt>::value_type;
+
+  ForwardIt current = first;
+
+  // No exceptions in CUDA.
+  NV_IF_TARGET(NV_IS_HOST, (
+    try {
+      for (; n > 0; ++current, --n)
+      {
+        ::new (static_cast<void*>(addressof(*current))) T(args...);
+      }
+    } catch (...) {
+      destroy(first, current);
+      throw;
+    }
+  ), (
+    for (; n > 0; ++current, --n)
+    {
+      ::new (static_cast<void*>(addressof(*current))) T(args...);
+    }
+  ));
+}
+
+template <typename Allocator, typename ForwardIt, typename Size, typename... Args>
+void uninitialized_construct_n_with_allocator(
+  Allocator const& alloc, ForwardIt first, Size n, Args const&... args
+)
+{
+  using T = typename iterator_traits<ForwardIt>::value_type;
+  using traits = typename detail::allocator_traits<
+    typename std::remove_cv<
+      typename std::remove_reference<Allocator>::type
+    >::type
+  >::template rebind_traits<T>;
+
+  typename traits::allocator_type alloc_T(alloc);
+
+  ForwardIt current = first;
+
+  // No exceptions in CUDA.
+  NV_IF_TARGET(NV_IS_HOST, (
+    try {
+      for (; n > 0; (void) ++current, --n)
+      {
+        traits::construct(alloc_T, addressof(*current), args...);
+      }
+    } catch (...) {
+      destroy(alloc_T, first, current);
+      throw;
+    }
+  ), (
+    for (; n > 0; (void) ++current, --n)
+    {
+      traits::construct(alloc_T, addressof(*current), args...);
+    }
+  ));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+THRUST_NAMESPACE_END

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/detail/memory_wrapper.h

@@ -0,0 +1,30 @@
+/*
+ *  Copyright 2020 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+// When a compiler uses Thrust as part of its implementation of Standard C++
+// algorithms, a cycle of included files may result when Thrust code tries to
+// use a standard algorithm.  Having a macro that is defined only when Thrust
+// is including an algorithms-related header gives the compiler a chance to
+// detect and break the cycle of includes.  (<memory> declares several standard
+// algorithms, including all of the uninitialized_* algorithms.  "_ALGORITHMS_"
+// in the macro name is meant generically, not as a specific reference to
+// the header <algorithms>.)
+
+#define THRUST_INCLUDING_ALGORITHMS_HEADER
+#include <memory>
+#undef  THRUST_INCLUDING_ALGORITHMS_HEADER