Add files using upload-large-folder tool

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

@@ -0,0 +1,31 @@
+// Copyright (c) 2018 NVIDIA Corporation
+// Author: Bryce Adelstein Lelbach <brycelelbach@gmail.com>
+//
+// Distributed under the Boost Software License v1.0 (boost.org/LICENSE_1_0.txt)
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+#  include <thrust/detail/memory_wrapper.h>
+#endif
+
+THRUST_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+
+/*! Obtains the actual address of the object or function arg, even in presence of overloaded operator&.
+ */
+template <typename T>
+__host__ __device__
+T* addressof(T& arg) 
+{
+  return reinterpret_cast<T*>(
+    &const_cast<char&>(reinterpret_cast<const volatile char&>(arg))
+  );
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+THRUST_NAMESPACE_END

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

@@ -0,0 +1,140 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file advance.h
+ *  \brief Advance an iterator by a given distance.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \p advance(i, n) increments the iterator \p i by the distance \p n.
+ *  If <tt>n > 0</tt> it is equivalent to executing <tt>++i</tt> \p n
+ *  times, and if <tt>n < 0</tt> it is equivalent to executing <tt>--i</tt>
+ *  \p n times. If <tt>n == 0</tt>, the call has no effect.
+ *
+ *  \param i The iterator to be advanced.
+ *  \param n The distance by which to advance the iterator.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *  \tparam Distance is an integral type that is convertible to \p InputIterator's distance type.
+ *
+ *  \pre \p n shall be negative only for bidirectional and random access iterators.
+ *
+ *  The following code snippet demonstrates how to use \p advance to increment
+ *  an iterator a given number of times.
+ *
+ *  \code
+ *  #include <thrust/advance.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> vec(13);
+ *  thrust::device_vector<int>::iterator iter = vec.begin();
+ *
+ *  thrust::advance(iter, 7);
+ *
+ *  // iter - vec.begin() == 7
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/advance
+ */
+template <typename InputIterator, typename Distance>
+__host__ __device__
+void advance(InputIterator& i, Distance n);
+
+/*! \p next(i, n) returns the \p n th successor of the iterator \p i.
+ *
+ *  \param i An iterator.
+ *  \param n The number of elements to advance.
+ *
+ *  \tparam InputIterator must meet the <a href="https://en.cppreference.com/w/cpp/named_req/InputIterator">InputIterator</a>.
+ *
+ *  \pre \p n shall be negative only for bidirectional and random access iterators.
+ *
+ *  The following code snippet demonstrates how to use \p next.
+ *
+ *  \code
+ *  #include <thrust/advance.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> vec(13);
+ *  thrust::device_vector<int>::iterator i0 = vec.begin();
+ *
+ *  auto i1 = thrust::next(i0);
+ *
+ *  // i0 - vec.begin() == 0
+ *  // i1 - vec.begin() == 1
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/next
+ */
+#if 0 // Doxygen only
+template <typename InputIterator, typename Distance>
+__host__ __device__
+InputIterator next(
+  InputIterator i
+, typename iterator_traits<InputIterator>::difference_type n = 1
+);
+#endif
+
+/*! \p prev(i, n) returns the \p n th predecessor of the iterator \p i.
+ *
+ *  \param i An iterator.
+ *  \param n The number of elements to descend.
+ *
+ *  \tparam BidirectionalIterator must meet the <a href="https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator">BidirectionalIterator</a>.
+ *
+ *  The following code snippet demonstrates how to use \p prev.
+ *
+ *  \code
+ *  #include <thrust/advance.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  thrust::device_vector<int> vec(13);
+ *  thrust::device_vector<int>::iterator i0 = vec.end();
+ *
+ *  auto i1 = thrust::prev(i0);
+ *
+ *  // vec.end() - i0 == 0
+ *  // vec.end() - i1 == 1
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/iterator/prev
+ */
+#if 0 // Doxygen only
+template <typename BidirectionalIterator, typename Distance>
+__host__ __device__
+BidirectionalIterator prev(
+  BidirectionalIterator i
+, typename iterator_traits<BidirectionalIterator>::difference_type n = 1
+);
+#endif
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/advance.inl>
+

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

@@ -0,0 +1,512 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/copy.h
+ *  \brief Copies elements from one range to another
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup algorithms
+ */
+
+/*! \addtogroup copying
+ *  \ingroup algorithms
+ *  \{
+ */
+
+
+/*! \p copy copies elements from the range [\p first, \p last) to the range
+ *  [\p result, \p result + (\p last - \p first)). That is, it performs
+ *  the assignments *\p result = *\p first, *(\p result + \c 1) = *(\p first + \c 1),
+ *  and so on. Generally, for every integer \c n from \c 0 to \p last - \p first, \p copy
+ *  performs the assignment *(\p result + \c n) = *(\p first + \c n). Unlike
+ *  \c std::copy, \p copy offers no guarantee on order of operation.  As a result,
+ *  calling \p copy with overlapping source and destination ranges has undefined
+ *  behavior.
+ *
+ *  The return value is \p result + (\p last - \p first).
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence to copy.
+ *  \param last The end of the sequence to copy.
+ *  \param result The destination sequence.
+ *  \return The end of the destination sequence.
+ *  \see https://en.cppreference.com/w/cpp/algorithm/copy
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator's \c value_type must be convertible to \c OutputIterator's \c value_type.
+ *  \tparam OutputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre \p result may be equal to \p first, but \p result shall not be in the range <tt>[first, last)</tt> otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p copy
+ *  to copy from one range to another using the \p thrust::device parallelization policy:
+ *
+ *  \code
+ *  #include <thrust/copy.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *
+ *  thrust::device_vector<int> vec0(100);
+ *  thrust::device_vector<int> vec1(100);
+ *  ...
+ *
+ *  thrust::copy(thrust::device, vec0.begin(), vec0.end(), vec1.begin());
+ *
+ *  // vec1 is now a copy of vec0
+ *  \endcode
+ */
+template<typename DerivedPolicy, typename InputIterator, typename OutputIterator>
+__host__ __device__
+  OutputIterator copy(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                      InputIterator first,
+                      InputIterator last,
+                      OutputIterator result);
+
+
+/*! \p copy_n copies elements from the range <tt>[first, first + n)</tt> to the range
+ *  <tt>[result, result + n)</tt>. That is, it performs the assignments <tt>*result = *first, *(result + 1) = *(first + 1)</tt>,
+ *  and so on. Generally, for every integer \c i from \c 0 to \c n, \p copy
+ *  performs the assignment *(\p result + \c i) = *(\p first + \c i). Unlike
+ *  \c std::copy_n, \p copy_n offers no guarantee on order of operation. As a result,
+ *  calling \p copy_n with overlapping source and destination ranges has undefined
+ *  behavior.
+ *
+ *  The return value is \p result + \p n.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the range to copy.
+ *  \param n The number of elements to copy.
+ *  \param result The beginning destination range.
+ *  \return The end of the destination range.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator's \c value_type must be convertible to \c OutputIterator's \c value_type.
+ *  \tparam Size is an integral type.
+ *  \tparam OutputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre \p result may be equal to \p first, but \p result shall not be in the range <tt>[first, first + n)</tt> otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p copy
+ *  to copy from one range to another using the \p thrust::device parallelization policy:
+ *
+ *  \code
+ *  #include <thrust/copy.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  size_t n = 100;
+ *  thrust::device_vector<int> vec0(n);
+ *  thrust::device_vector<int> vec1(n);
+ *  ...
+ *  thrust::copy_n(thrust::device, vec0.begin(), n, vec1.begin());
+ *
+ *  // vec1 is now a copy of vec0
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/copy_n
+ *  \see thrust::copy
+ */
+template<typename DerivedPolicy, typename InputIterator, typename Size, typename OutputIterator>
+__host__ __device__
+  OutputIterator copy_n(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                        InputIterator first,
+                        Size n,
+                        OutputIterator result);
+
+
+	
+/*! \p copy copies elements from the range [\p first, \p last) to the range
+ *  [\p result, \p result + (\p last - \p first)). That is, it performs
+ *  the assignments *\p result = *\p first, *(\p result + \c 1) = *(\p first + \c 1),
+ *  and so on. Generally, for every integer \c n from \c 0 to \p last - \p first, \p copy
+ *  performs the assignment *(\p result + \c n) = *(\p first + \c n). Unlike
+ *  \c std::copy, \p copy offers no guarantee on order of operation.  As a result,
+ *  calling \p copy with overlapping source and destination ranges has undefined
+ *  behavior.
+ *
+ *  The return value is \p result + (\p last - \p first).
+ *
+ *  \param first The beginning of the sequence to copy.
+ *  \param last The end of the sequence to copy.
+ *  \param result The destination sequence.
+ *  \return The end of the destination sequence.
+ *  \see https://en.cppreference.com/w/cpp/algorithm/copy
+ *
+ *  \tparam InputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator's \c value_type must be convertible to \c OutputIterator's \c value_type.
+ *  \tparam OutputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre \p result may be equal to \p first, but \p result shall not be in the range <tt>[first, last)</tt> otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p copy
+ *  to copy from one range to another.
+ *
+ *  \code
+ *  #include <thrust/copy.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *
+ *  thrust::device_vector<int> vec0(100);
+ *  thrust::device_vector<int> vec1(100);
+ *  ...
+ *
+ *  thrust::copy(vec0.begin(), vec0.end(),
+ *               vec1.begin());
+ *
+ *  // vec1 is now a copy of vec0
+ *  \endcode
+ */
+template<typename InputIterator, typename OutputIterator>
+  OutputIterator copy(InputIterator first,
+                      InputIterator last,
+                      OutputIterator result);
+
+/*! \p copy_n copies elements from the range <tt>[first, first + n)</tt> to the range
+ *  <tt>[result, result + n)</tt>. That is, it performs the assignments <tt>*result = *first, *(result + 1) = *(first + 1)</tt>,
+ *  and so on. Generally, for every integer \c i from \c 0 to \c n, \p copy
+ *  performs the assignment *(\p result + \c i) = *(\p first + \c i). Unlike
+ *  \c std::copy_n, \p copy_n offers no guarantee on order of operation. As a result,
+ *  calling \p copy_n with overlapping source and destination ranges has undefined
+ *  behavior.
+ *
+ *  The return value is \p result + \p n.
+ *
+ *  \param first The beginning of the range to copy.
+ *  \param n The number of elements to copy.
+ *  \param result The beginning destination range.
+ *  \return The end of the destination range.
+ *
+ *  \tparam InputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a> and \c InputIterator's \c value_type must be convertible to \c OutputIterator's \c value_type.
+ *  \tparam Size is an integral type.
+ *  \tparam OutputIterator must be a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *
+ *  \pre \p result may be equal to \p first, but \p result shall not be in the range <tt>[first, first + n)</tt> otherwise.
+ *
+ *  The following code snippet demonstrates how to use \p copy
+ *  to copy from one range to another.
+ *
+ *  \code
+ *  #include <thrust/copy.h>
+ *  #include <thrust/device_vector.h>
+ *  ...
+ *  size_t n = 100;
+ *  thrust::device_vector<int> vec0(n);
+ *  thrust::device_vector<int> vec1(n);
+ *  ...
+ *  thrust::copy_n(vec0.begin(), n, vec1.begin());
+ *
+ *  // vec1 is now a copy of vec0
+ *  \endcode
+ *
+ *  \see https://en.cppreference.com/w/cpp/algorithm/copy_n
+ *  \see thrust::copy
+ */
+template<typename InputIterator, typename Size, typename OutputIterator>
+  OutputIterator copy_n(InputIterator first,
+                        Size n,
+                        OutputIterator result);
+
+/*! \} // end copying
+ */
+
+/*! \addtogroup stream_compaction
+ *  \{
+ */
+
+
+/*! This version of \p copy_if copies elements from the range <tt>[first,last)</tt>
+ *  to a range beginning at \p result, except that any element which causes \p pred
+ *  to be \c false is not copied. \p copy_if is stable, meaning that the relative
+ *  order of elements that are copied is unchanged.
+ *
+ *  More precisely, for every integer \c n such that <tt>0 <= n < last-first</tt>,
+ *  \p copy_if performs the assignment <tt>*result = *(first+n)</tt> and \p result
+ *  is advanced one position if <tt>pred(*(first+n))</tt>. Otherwise, no assignment
+ *  occurs and \p result is not advanced.
+ *
+ *  The algorithm's execution is parallelized as determined by \p system.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence from which to copy.
+ *  \param last The end of the sequence from which to copy.
+ *  \param result The beginning of the sequence into which to copy.
+ *  \param pred The predicate to test on every value of the range <tt>[first, last)</tt>.
+ *  \return <tt>result + n</tt>, where \c n is equal to the number of times \p pred
+ *          evaluated to \c true in the range <tt>[first, last)</tt>.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *                        and \p InputIterator's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The ranges <tt>[first, last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p copy_if to perform stream compaction
+ *  to copy even numbers to an output range using the \p thrust::host parallelization policy:
+ *
+ *  \code
+ *  #include <thrust/copy.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  ...
+ *  const int N = 6;
+ *  int V[N] = {-2, 0, -1, 0, 1, 2};
+ *  int result[4];
+ *
+ *  thrust::copy_if(thrust::host, V, V + N, result, is_even());
+ *
+ *  // V remains {-2, 0, -1, 0, 1, 2}
+ *  // result is now {-2, 0, 0, 2}
+ *  \endcode
+ *
+ *  \see \c remove_copy_if
+ */
+template<typename DerivedPolicy, typename InputIterator, typename OutputIterator, typename Predicate>
+__host__ __device__
+  OutputIterator copy_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                         InputIterator first,
+                         InputIterator last,
+                         OutputIterator result,
+                         Predicate pred);
+
+
+
+/*! This version of \p copy_if copies elements from the range <tt>[first,last)</tt>
+ *  to a range beginning at \p result, except that any element which causes \p pred
+ *  to \c false is not copied. \p copy_if is stable, meaning that the relative
+ *  order of elements that are copied is unchanged.
+ *
+ *  More precisely, for every integer \c n such that <tt>0 <= n < last-first</tt>,
+ *  \p copy_if performs the assignment <tt>*result = *(first+n)</tt> and \p result
+ *  is advanced one position if <tt>pred(*(first+n))</tt>. Otherwise, no assignment
+ *  occurs and \p result is not advanced.
+ *
+ *  \param first The beginning of the sequence from which to copy.
+ *  \param last The end of the sequence from which to copy.
+ *  \param result The beginning of the sequence into which to copy.
+ *  \param pred The predicate to test on every value of the range <tt>[first, last)</tt>.
+ *  \return <tt>result + n</tt>, where \c n is equal to the number of times \p pred
+ *          evaluated to \c true in the range <tt>[first, last)</tt>.
+ *
+ *  \tparam InputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *                        and \p InputIterator's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/iterator/output_iterator">Output Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The ranges <tt>[first, last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p copy_if to perform stream compaction
+ *  to copy even numbers to an output range.
+ *
+ *  \code
+ *  #include <thrust/copy.h>
+ *  ...
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  ...
+ *  const int N = 6;
+ *  int V[N] = {-2, 0, -1, 0, 1, 2};
+ *  int result[4];
+ *
+ *  thrust::copy_if(V, V + N, result, is_even());
+ *
+ *  // V remains {-2, 0, -1, 0, 1, 2}
+ *  // result is now {-2, 0, 0, 2}
+ *  \endcode
+ *
+ *  \see \c remove_copy_if
+ */
+template<typename InputIterator,
+         typename OutputIterator,
+         typename Predicate>
+  OutputIterator copy_if(InputIterator first,
+                         InputIterator last,
+                         OutputIterator result,
+                         Predicate pred);
+
+
+/*! This version of \p copy_if copies elements from the range <tt>[first,last)</tt>
+ *  to a range beginning at \p result, except that any element whose corresponding stencil
+ *  element causes \p pred to be \c false is not copied. \p copy_if is stable, meaning
+ *  that the relative order of elements that are copied is unchanged.
+ *
+ *  More precisely, for every integer \c n such that <tt>0 <= n < last-first</tt>,
+ *  \p copy_if performs the assignment <tt>*result = *(first+n)</tt> and \p result
+ *  is advanced one position if <tt>pred(*(stencil+n))</tt>. Otherwise, no assignment
+ *  occurs and \p result is not advanced.
+ *
+ *  The algorithm's execution is parallelized as determined by \p exec.
+ *
+ *  \param exec The execution policy to use for parallelization.
+ *  \param first The beginning of the sequence from which to copy.
+ *  \param last The end of the sequence from which to copy.
+ *  \param stencil The beginning of the stencil sequence.
+ *  \param result The beginning of the sequence into which to copy.
+ *  \param pred The predicate to test on every value of the range <tt>[stencil, stencil + (last-first))</tt>.
+ *  \return <tt>result + n</tt>, where \c n is equal to the number of times \p pred
+ *          evaluated to \c true in the range <tt>[stencil, stencil + (last-first))</tt>.
+ *
+ *  \tparam DerivedPolicy The name of the derived execution policy.
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *                         and \p InputIterator2's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/named_req/OutputIterator">Output Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The ranges <tt>[first, last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *  \pre The ranges <tt>[stencil, stencil + (last - first))</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p copy_if to perform stream compaction
+ *  to copy numbers to an output range when corresponding stencil elements are even using the \p thrust::host execution policy:
+ *
+ *  \code
+ *  #include <thrust/copy.h>
+ *  #include <thrust/execution_policy.h>
+ *  ...
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  ...
+ *  int N = 6;
+ *  int data[N]    = { 0, 1,  2, 3, 4, 5};
+ *  int stencil[N] = {-2, 0, -1, 0, 1, 2};
+ *  int result[4];
+ *
+ *  thrust::copy_if(thrust::host, data, data + N, stencil, result, is_even());
+ *
+ *  // data remains    = { 0, 1,  2, 3, 4, 5};
+ *  // stencil remains = {-2, 0, -1, 0, 1, 2};
+ *  // result is now     { 0, 1,  3, 5}
+ *  \endcode
+ *
+ *  \see \c remove_copy_if
+ */
+template<typename DerivedPolicy, typename InputIterator1, typename InputIterator2, typename OutputIterator, typename Predicate>
+__host__ __device__
+  OutputIterator copy_if(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                         InputIterator1 first,
+                         InputIterator1 last,
+                         InputIterator2 stencil,
+                         OutputIterator result,
+                         Predicate pred);
+
+
+/*! This version of \p copy_if copies elements from the range <tt>[first,last)</tt>
+ *  to a range beginning at \p result, except that any element whose corresponding stencil
+ *  element causes \p pred to be \c false is not copied. \p copy_if is stable, meaning
+ *  that the relative order of elements that are copied is unchanged.
+ *
+ *  More precisely, for every integer \c n such that <tt>0 <= n < last-first</tt>,
+ *  \p copy_if performs the assignment <tt>*result = *(first+n)</tt> and \p result
+ *  is advanced one position if <tt>pred(*(stencil+n))</tt>. Otherwise, no assignment
+ *  occurs and \p result is not advanced.
+ *
+ *  \param first The beginning of the sequence from which to copy.
+ *  \param last The end of the sequence from which to copy.
+ *  \param stencil The beginning of the stencil sequence.
+ *  \param result The beginning of the sequence into which to copy.
+ *  \param pred The predicate to test on every value of the range <tt>[stencil, stencil + (last-first))</tt>.
+ *  \return <tt>result + n</tt>, where \c n is equal to the number of times \p pred
+ *          evaluated to \c true in the range <tt>[stencil, stencil + (last-first))</tt>.
+ *
+ *  \tparam InputIterator1 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>.
+ *  \tparam InputIterator2 is a model of <a href="https://en.cppreference.com/w/cpp/iterator/input_iterator">Input Iterator</a>,
+ *                         and \p InputIterator2's \c value_type is convertible to \p Predicate's \c argument_type.
+ *  \tparam OutputIterator is a model of <a href="https://en.cppreference.com/w/cpp/named_req/OutputIterator">Output Iterator</a>.
+ *  \tparam Predicate is a model of <a href="https://en.cppreference.com/w/cpp/concepts/predicate">Predicate</a>.
+ *
+ *  \pre The ranges <tt>[first, last)</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *  \pre The ranges <tt>[stencil, stencil + (last - first))</tt> and <tt>[result, result + (last - first))</tt> shall not overlap.
+ *
+ *  The following code snippet demonstrates how to use \p copy_if to perform stream compaction
+ *  to copy numbers to an output range when corresponding stencil elements are even:
+ *
+ *  \code
+ *  #include <thrust/copy.h>
+ *  ...
+ *  struct is_even
+ *  {
+ *    __host__ __device__
+ *    bool operator()(const int x)
+ *    {
+ *      return (x % 2) == 0;
+ *    }
+ *  };
+ *  ...
+ *  int N = 6;
+ *  int data[N]    = { 0, 1,  2, 3, 4, 5};
+ *  int stencil[N] = {-2, 0, -1, 0, 1, 2};
+ *  int result[4];
+ *
+ *  thrust::copy_if(data, data + N, stencil, result, is_even());
+ *
+ *  // data remains    = { 0, 1,  2, 3, 4, 5};
+ *  // stencil remains = {-2, 0, -1, 0, 1, 2};
+ *  // result is now     { 0, 1,  3, 5}
+ *  \endcode
+ *
+ *  \see \c remove_copy_if
+ */
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename Predicate>
+  OutputIterator copy_if(InputIterator1 first,
+                         InputIterator1 last,
+                         InputIterator2 stencil,
+                         OutputIterator result,
+                         Predicate pred);
+
+/*! \} // end stream_compaction
+ */
+
+THRUST_NAMESPACE_END
+
+#include <thrust/detail/copy.h>
+#include <thrust/detail/copy_if.h>
+

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

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

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

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

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

@@ -0,0 +1,204 @@
+/*
+ *  Copyright 2017 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file alignment.h
+ *  \brief Type-alignment utilities.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/type_traits.h> // For `integral_constant`.
+
+#include <cstddef> // For `std::size_t` and `std::max_align_t`.
+
+#if THRUST_CPP_DIALECT >= 2011
+    #include <type_traits> // For `std::alignment_of`. 
+#endif
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+/// \p THRUST_ALIGNOF is a macro that takes a single type-id as a parameter,
+/// and returns the alignment requirement of the type in bytes.
+/// 
+/// It is an approximation of C++11's `alignof` operator.
+///
+/// Note: MSVC does not allow the builtin used to implement this to be placed
+/// inside of a `__declspec(align(#))` attribute. As a workaround, you can
+/// assign the result of \p THRUST_ALIGNOF to a variable and pass the variable
+/// as the argument to `__declspec(align(#))`.
+#if THRUST_CPP_DIALECT >= 2011
+    #define THRUST_ALIGNOF(x) alignof(x) 
+#else
+    #define THRUST_ALIGNOF(x) __alignof(x)
+#endif
+
+/// \p alignment_of provides the member constant `value` which is equal to the
+/// alignment requirement of the type `T`, as if obtained by a C++11 `alignof`
+/// expression.
+/// 
+/// It is an implementation of C++11's \p std::alignment_of.
+#if THRUST_CPP_DIALECT >= 2011
+    template <typename T>
+    using alignment_of = std::alignment_of<T>;
+#else
+    template <typename T>
+    struct alignment_of;
+
+    template <typename T, std::size_t size_diff>
+    struct alignment_of_helper
+    {
+        static const std::size_t value =
+            integral_constant<std::size_t, size_diff>::value;
+    };
+
+    template <typename T>
+    struct alignment_of_helper<T, 0>
+    {
+        static const std::size_t value = alignment_of<T>::value;
+    };
+
+    template <typename T>
+    struct alignment_of
+    {
+      private:
+        struct impl
+        {
+            T    x;
+            char c;
+        };
+
+      public:
+        static const std::size_t value =
+            alignment_of_helper<impl, sizeof(impl) - sizeof(T)>::value;
+    };
+#endif
+
+/// \p aligned_type provides the nested type `type`, which is a trivial
+/// type whose alignment requirement is a divisor of `Align`.
+///
+/// The behavior is undefined if `Align` is not a power of 2.
+template <std::size_t Align>
+struct aligned_type;
+
+#if THRUST_CPP_DIALECT >= 2011                                                     \
+  && (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC)                        \
+  && (THRUST_GCC_VERSION >= 40800)
+    // C++11 implementation, excluding GCC 4.7, which doesn't have `alignas`.
+    template <std::size_t Align>
+    struct aligned_type
+    {
+        struct alignas(Align) type {};
+    };
+#elif  (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC)                    \
+    || (   (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC)                 \
+        && (THRUST_GCC_VERSION < 40600))
+    // C++03 implementation for MSVC and GCC <= 4.5.
+    // 
+    // We have to implement `aligned_type` with specializations for MSVC
+    // and GCC 4.2.x and older because they require literals as arguments to 
+    // their alignment attribute.
+
+    #if (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC)
+        // MSVC implementation.
+        #define THRUST_DEFINE_ALIGNED_TYPE_SPECIALIZATION(X)                  \
+            template <>                                                       \
+            struct aligned_type<X>                                            \
+            {                                                                 \
+                __declspec(align(X)) struct type {};                          \
+            };                                                                \
+            /**/
+    #else
+        // GCC <= 4.2 implementation.
+        #define THRUST_DEFINE_ALIGNED_TYPE_SPECIALIZATION(X)                  \
+            template <>                                                       \
+            struct aligned_type<X>                                            \
+            {                                                                 \
+                struct type {} __attribute__((aligned(X)));                   \
+            };                                                                \
+            /**/
+    #endif
+    
+    THRUST_DEFINE_ALIGNED_TYPE_SPECIALIZATION(1);
+    THRUST_DEFINE_ALIGNED_TYPE_SPECIALIZATION(2);
+    THRUST_DEFINE_ALIGNED_TYPE_SPECIALIZATION(4);
+    THRUST_DEFINE_ALIGNED_TYPE_SPECIALIZATION(8);
+    THRUST_DEFINE_ALIGNED_TYPE_SPECIALIZATION(16);
+    THRUST_DEFINE_ALIGNED_TYPE_SPECIALIZATION(32);
+    THRUST_DEFINE_ALIGNED_TYPE_SPECIALIZATION(64);
+    THRUST_DEFINE_ALIGNED_TYPE_SPECIALIZATION(128);
+
+    #undef THRUST_DEFINE_ALIGNED_TYPE_SPECIALIZATION
+#else
+    // C++03 implementation for GCC > 4.5, Clang, PGI, ICPC, and xlC.
+    template <std::size_t Align>
+    struct aligned_type
+    {
+        struct type {} __attribute__((aligned(Align)));
+    };
+#endif
+
+/// \p max_align_t is a trivial type whose alignment requirement is at least as
+/// strict (as large) as that of every scalar type.
+///
+/// It is an implementation of C++11's \p std::max_align_t.
+#if THRUST_CPP_DIALECT >= 2011                                                     \
+  && (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC)                        \
+  && (THRUST_GCC_VERSION >= 40900)
+    // GCC 4.7 and 4.8 don't have `std::max_align_t`.
+    using max_align_t = std::max_align_t;
+#else
+    union max_align_t
+    {
+        // These cannot be private because C++03 POD types cannot have private
+        // data members.
+        char c;
+        short s;
+        int i;
+        long l;
+        float f;
+        double d;
+        long long ll;
+        long double ld;
+        void* p;
+    };
+#endif
+
+/// \p aligned_reinterpret_cast `reinterpret_cast`s \p u of type \p U to `void*`
+/// and then `reinterpret_cast`s the result to \p T. The indirection through
+/// `void*` suppresses compiler warnings when the alignment requirement of \p *u
+/// is less than the alignment requirement of \p *t. The caller of
+/// \p aligned_reinterpret_cast is responsible for ensuring that the alignment
+/// requirements are actually satisified.
+template <typename T, typename U>
+__host__ __device__
+T aligned_reinterpret_cast(U u)
+{
+  return reinterpret_cast<T>(reinterpret_cast<void*>(u));
+}
+
+__host__ __device__
+inline std::size_t aligned_storage_size(std::size_t n, std::size_t align)
+{
+  return ((n + align - 1) / align) * align;
+}
+
+} // end namespace detail
+
+THRUST_NAMESPACE_END

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

@@ -0,0 +1,101 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execute_with_allocator_fwd.h>
+#include <thrust/detail/alignment.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+  #include <type_traits>
+#endif
+
+THRUST_NAMESPACE_BEGIN
+
+namespace mr
+{
+
+template<typename T, class MR>
+class allocator;
+
+}
+
+namespace detail
+{
+
+template<template <typename> class ExecutionPolicyCRTPBase>
+struct allocator_aware_execution_policy
+{
+  template<typename MemoryResource>
+  struct execute_with_memory_resource_type
+  {
+    typedef thrust::detail::execute_with_allocator<
+      thrust::mr::allocator<
+        thrust::detail::max_align_t,
+        MemoryResource
+      >,
+      ExecutionPolicyCRTPBase
+    > type;
+  };
+
+  template<typename Allocator>
+  struct execute_with_allocator_type
+  {
+      typedef thrust::detail::execute_with_allocator<
+        Allocator,
+        ExecutionPolicyCRTPBase
+      > type;
+  };
+
+  template<typename MemoryResource>
+    typename execute_with_memory_resource_type<MemoryResource>::type
+      operator()(MemoryResource * mem_res) const
+  {
+    return typename execute_with_memory_resource_type<MemoryResource>::type(mem_res);
+  }
+
+  template<typename Allocator>
+    typename execute_with_allocator_type<Allocator&>::type
+      operator()(Allocator &alloc) const
+  {
+    return typename execute_with_allocator_type<Allocator&>::type(alloc);
+  }
+
+  template<typename Allocator>
+    typename execute_with_allocator_type<Allocator>::type
+      operator()(const Allocator &alloc) const
+  {
+    return typename execute_with_allocator_type<Allocator>::type(alloc);
+  }
+
+#if THRUST_CPP_DIALECT >= 2011
+  // just the rvalue overload
+  // perfect forwarding doesn't help, because a const reference has to be turned
+  // into a value by copying for the purpose of storing it in execute_with_allocator
+  template<typename Allocator,
+      typename std::enable_if<!std::is_lvalue_reference<Allocator>::value>::type * = nullptr>
+    typename execute_with_allocator_type<Allocator>::type
+      operator()(Allocator &&alloc) const
+  {
+    return typename execute_with_allocator_type<Allocator>::type(std::move(alloc));
+  }
+#endif
+};
+
+} // end namespace detail
+
+THRUST_NAMESPACE_END

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

@@ -0,0 +1,47 @@
+/*
+ *  Copyright 2020 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/mr/allocator.h>
+#include <thrust/mr/disjoint_tls_pool.h>
+#include <thrust/mr/new.h>
+#include <thrust/mr/device_memory_resource.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+inline
+thrust::mr::allocator<
+    char,
+    thrust::mr::disjoint_unsynchronized_pool_resource<
+        thrust::device_memory_resource,
+        thrust::mr::new_delete_resource
+    >
+> single_device_tls_caching_allocator()
+{
+    return {
+        &thrust::mr::tls_disjoint_pool(
+            thrust::mr::get_global_resource<thrust::device_memory_resource>(),
+            thrust::mr::get_global_resource<thrust::mr::new_delete_resource>()
+        )
+    };
+}
+}
+
+THRUST_NAMESPACE_END

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

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

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

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

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

@@ -0,0 +1,26 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config/cpp_dialect.h>
+
+#ifndef THRUST_CPP11_REQUIRED_NO_ERROR
+#  if THRUST_CPP_DIALECT < 2011 
+#    error C++11 is required for this Thrust feature; please upgrade your compiler or pass the appropriate -std=c++XX flag to it.
+#  endif
+#endif
+

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

@@ -0,0 +1,26 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config/cpp_dialect.h>
+
+#ifndef THRUST_CPP14_REQUIRED_NO_ERROR
+#  if THRUST_CPP_DIALECT < 2014
+#    error C++14 is required for this Thrust feature; please upgrade your compiler or pass the appropriate -std=c++14 flag to it.
+#  endif
+#endif
+

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

@@ -0,0 +1,83 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC) || \
+    (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_CLANG) || \
+    (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_INTEL)
+#include <stdint.h>
+#endif
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+#if (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC)
+
+#if (_MSC_VER < 1300)
+   typedef signed   char     int8_t;
+   typedef signed   short    int16_t;
+   typedef signed   int      int32_t;
+   typedef unsigned char     uint8_t;
+   typedef unsigned short    uint16_t;
+   typedef unsigned int      uint32_t;
+#else
+   typedef signed   __int8   int8_t;
+   typedef signed   __int16  int16_t;
+   typedef signed   __int32  int32_t;
+   typedef unsigned __int8   uint8_t;
+   typedef unsigned __int16  uint16_t;
+   typedef unsigned __int32  uint32_t;
+#endif
+typedef signed   __int64     int64_t;
+typedef unsigned __int64     uint64_t;
+
+#else
+
+typedef ::int8_t   int8_t;
+typedef ::int16_t  int16_t;
+typedef ::int32_t  int32_t;
+typedef ::int64_t  int64_t;
+typedef ::uint8_t  uint8_t;
+typedef ::uint16_t uint16_t;
+typedef ::uint32_t uint32_t;
+typedef ::uint64_t uint64_t;
+
+#endif
+
+
+// an oracle to tell us how to define intptr_t
+template<int word_size = sizeof(void*)> struct divine_intptr_t;
+template<int word_size = sizeof(void*)> struct divine_uintptr_t;
+
+// 32b platforms
+template<>  struct divine_intptr_t<4>  {  typedef thrust::detail::int32_t  type; };
+template<>  struct divine_uintptr_t<4> {  typedef thrust::detail::uint32_t type; };
+
+// 64b platforms
+template<>  struct divine_intptr_t<8>  { typedef thrust::detail::int64_t  type; };
+template<>  struct divine_uintptr_t<8> { typedef thrust::detail::uint64_t type; };
+
+typedef divine_intptr_t<>::type   intptr_t;
+typedef divine_uintptr_t<>::type  uintptr_t;
+
+} // end detail
+
+THRUST_NAMESPACE_END

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

@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/device_delete.h>
+#include <thrust/device_free.h>
+#include <thrust/detail/allocator/destroy_range.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+// define an empty allocator class to use below
+struct device_delete_allocator {};
+
+}
+
+template<typename T>
+  void device_delete(device_ptr<T> ptr,
+                     const size_t n)
+{
+  // we can use device_allocator to destroy the range
+  thrust::detail::device_delete_allocator a;
+  thrust::detail::destroy_range(a, ptr, n);
+  thrust::device_free(ptr);
+} // end device_delete()
+
+THRUST_NAMESPACE_END

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

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

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

@@ -0,0 +1,56 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/device_new.h>
+#include <thrust/device_malloc.h>
+#include <thrust/uninitialized_fill.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template<typename T>
+  device_ptr<T> device_new(device_ptr<void> p,
+                           const size_t n)
+{
+  // XXX TODO dispatch n null device constructors at p here
+  // in the meantime, dispatch 1 null host constructor here
+  // and dispatch n copy constructors
+  return device_new<T>(p, T(), n);
+} // end device_new()
+
+template<typename T>
+  device_ptr<T> device_new(device_ptr<void> p,
+                           const T &exemplar,
+                           const size_t n)
+{
+  device_ptr<T> result(reinterpret_cast<T*>(p.get()));
+
+  // run copy constructors at p here
+  thrust::uninitialized_fill(result, result + n, exemplar);
+
+  return result;
+} // end device_new()
+
+template<typename T>
+  device_ptr<T> device_new(const size_t n)
+{
+  // call placement new
+  return device_new<T>(thrust::device_malloc<T>(n));
+} // end device_new()
+
+THRUST_NAMESPACE_END

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

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

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

@@ -0,0 +1,164 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/// \file thrust/detail/event_error.h
+/// \brief \c thrust::future and thrust::future error handling types and codes.
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp14_required.h>
+
+#if THRUST_CPP_DIALECT >= 2014
+
+#include <thrust/detail/type_traits.h>
+#include <thrust/system/error_code.h>
+
+#include <stdexcept>
+
+THRUST_NAMESPACE_BEGIN
+
+enum class event_errc
+{
+  unknown_event_error
+, no_state
+, no_content
+, last_event_error
+};
+
+/// \return <tt>error_code(static_cast<int>(e), event_category())</tt>
+inline error_code make_error_code(event_errc e);
+
+/// \return <tt>error_condition(static_cast<int>(e), event_category())</tt>.
+inline error_condition make_error_condition(event_errc e);
+
+struct event_error_category : error_category
+{
+  event_error_category() = default;
+
+  virtual char const* name() const
+  {
+    return "event";
+  }
+
+  virtual std::string message(int ev) const
+  {
+    switch (static_cast<event_errc>(ev))
+    {
+      case event_errc::no_state:
+      {
+        return "no_state: an operation that requires an event or future to have "
+               "a stream or content has been performed on a event or future "
+               "without either, e.g. a moved-from or default constructed event "
+               "or future (an event or future may have been consumed more than "
+               "once)";
+      }
+      case event_errc::no_content:
+      {
+        return "no_content: an operation that requires a future to have content "
+               "has been performed on future without any, e.g. a moved-from, "
+               "default constructed, or `thrust::new_stream` constructed future "
+               "(a future may have been consumed more than once)";
+      }
+      default:
+      {
+        return "unknown_event_error: an unknown error with a future "
+               "object has occurred";
+      }
+    };
+  }
+
+  virtual error_condition default_error_condition(int ev) const
+  {
+    if (
+         event_errc::last_event_error
+         >
+         static_cast<event_errc>(ev)
+       )
+      return make_error_condition(static_cast<event_errc>(ev));
+
+    return system_category().default_error_condition(ev);
+  }
+};
+
+/// Obtains a reference to the static error category object for the errors
+/// related to futures and promises. The object is required to override the
+/// virtual function error_category::name() to return a pointer to the string
+/// "event". It is used to identify error codes provided in the
+/// exceptions of type event_error.
+inline error_category const& event_category()
+{
+  static const event_error_category result;
+  return result;
+}
+
+namespace system
+{
+/// Specialization of \p is_error_code_enum for \p event_errc.
+template<> struct is_error_code_enum<event_errc> : true_type {};
+} // end system
+
+/// \return <tt>error_code(static_cast<int>(e), event_category())</tt>
+inline error_code make_error_code(event_errc e)
+{
+  return error_code(static_cast<int>(e), event_category());
+}
+
+/// \return <tt>error_condition(static_cast<int>(e), event_category())</tt>.
+inline error_condition make_error_condition(event_errc e)
+{
+  return error_condition(static_cast<int>(e), event_category());
+}
+
+struct event_error : std::logic_error
+{
+  __host__
+  explicit event_error(error_code ec)
+    : std::logic_error(ec.message()), ec_(ec)
+  {}
+
+  __host__
+  explicit event_error(event_errc e)
+    : event_error(make_error_code(e))
+  {}
+
+  __host__
+  error_code const& code() const noexcept
+  {
+    return ec_;
+  }
+
+  __host__
+  virtual ~event_error() noexcept {}
+
+private:
+  error_code ec_;
+};
+
+inline bool operator==(event_error const& lhs, event_error const& rhs) noexcept
+{
+  return lhs.code() == rhs.code();
+}
+
+inline bool operator<(event_error const& lhs, event_error const& rhs) noexcept
+{
+  return lhs.code() < rhs.code();
+}
+
+THRUST_NAMESPACE_END
+
+#endif // C++14
+

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

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

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

@@ -0,0 +1,76 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+struct execution_policy_marker {};
+
+// execution_policy_base serves as a guard against
+// inifinite recursion in thrust entry points:
+//
+// template<typename DerivedPolicy>
+// void foo(const thrust::detail::execution_policy_base<DerivedPolicy> &s)
+// {
+//   using thrust::system::detail::generic::foo;
+//
+//   foo(thrust::detail::derived_cast(thrust::detail::strip_const(s));
+// }
+//
+// foo is not recursive when
+// 1. DerivedPolicy is derived from thrust::execution_policy below
+// 2. generic::foo takes thrust::execution_policy as a parameter
+template<typename DerivedPolicy>
+struct execution_policy_base : execution_policy_marker {};
+
+
+template<typename DerivedPolicy>
+constexpr __host__ __device__
+execution_policy_base<DerivedPolicy> &strip_const(const execution_policy_base<DerivedPolicy> &x)
+{
+  return const_cast<execution_policy_base<DerivedPolicy>&>(x);
+}
+
+
+template<typename DerivedPolicy>
+constexpr __host__ __device__
+DerivedPolicy &derived_cast(execution_policy_base<DerivedPolicy> &x)
+{
+  return static_cast<DerivedPolicy&>(x);
+}
+
+
+template<typename DerivedPolicy>
+constexpr __host__ __device__
+const DerivedPolicy &derived_cast(const execution_policy_base<DerivedPolicy> &x)
+{
+  return static_cast<const DerivedPolicy&>(x);
+}
+
+} // end detail
+
+template<typename DerivedPolicy>
+  struct execution_policy
+    : thrust::detail::execution_policy_base<DerivedPolicy>
+{};
+
+THRUST_NAMESPACE_END

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

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

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

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

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

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

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

@@ -0,0 +1,161 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/raw_reference_cast.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+template <typename Function, typename Result>
+struct wrapped_function
+{
+  // mutable because Function::operator() might be const
+  mutable Function m_f;
+
+  inline __host__ __device__
+  wrapped_function()
+      : m_f()
+  {}
+
+  inline __host__ __device__
+  wrapped_function(const Function& f)
+      : m_f(f)
+  {}
+
+  __thrust_exec_check_disable__
+  template <typename Argument>
+  __thrust_forceinline__ __host__ __device__
+  Result operator()(Argument& x) const
+  {
+    return static_cast<Result>(m_f(thrust::raw_reference_cast(x)));
+  }
+
+  __thrust_exec_check_disable__
+  template <typename Argument>
+  __thrust_forceinline__ __host__ __device__
+  Result operator()(const Argument& x) const
+  {
+    return static_cast<Result>(m_f(thrust::raw_reference_cast(x)));
+  }
+
+  __thrust_exec_check_disable__
+  template <typename Argument1, typename Argument2>
+  __thrust_forceinline__ __host__ __device__
+  Result operator()(Argument1& x, Argument2& y) const
+  {
+    return static_cast<Result>(m_f(thrust::raw_reference_cast(x),
+                                   thrust::raw_reference_cast(y)));
+  }
+
+  __thrust_exec_check_disable__
+  template <typename Argument1, typename Argument2>
+  __thrust_forceinline__ __host__ __device__
+  Result operator()(const Argument1& x, Argument2& y) const
+  {
+    return static_cast<Result>(m_f(thrust::raw_reference_cast(x),
+                                   thrust::raw_reference_cast(y)));
+  }
+
+  __thrust_exec_check_disable__
+  template <typename Argument1, typename Argument2>
+  __thrust_forceinline__ __host__ __device__
+  Result operator()(const Argument1& x, const Argument2& y) const
+  {
+    return static_cast<Result>(m_f(thrust::raw_reference_cast(x),
+                                   thrust::raw_reference_cast(y)));
+  }
+
+  __thrust_exec_check_disable__
+  template <typename Argument1, typename Argument2>
+  __thrust_forceinline__ __host__ __device__
+  Result operator()(Argument1& x, const Argument2& y) const
+  {
+    return static_cast<Result>(m_f(thrust::raw_reference_cast(x),
+                                   thrust::raw_reference_cast(y)));
+  }
+}; // end wrapped_function
+
+// Specialize for void return types:
+template <typename Function>
+struct wrapped_function<Function, void>
+{
+  // mutable because Function::operator() might be const
+  mutable Function m_f;
+  inline __host__ __device__
+  wrapped_function()
+    : m_f()
+  {}
+
+  inline __host__ __device__
+  wrapped_function(const Function& f)
+    : m_f(f)
+  {}
+
+  __thrust_exec_check_disable__
+  template <typename Argument>
+  __thrust_forceinline__ __host__ __device__
+  void operator()(Argument& x) const
+  {
+    m_f(thrust::raw_reference_cast(x));
+  }
+
+  __thrust_exec_check_disable__
+  template <typename Argument>
+  __thrust_forceinline__ __host__ __device__
+  void operator()(const Argument& x) const
+  {
+    m_f(thrust::raw_reference_cast(x));
+  }
+
+  __thrust_exec_check_disable__
+  template <typename Argument1, typename Argument2>
+  __thrust_forceinline__ __host__ __device__
+  void operator()(Argument1& x, Argument2& y) const
+  {
+    m_f(thrust::raw_reference_cast(x), thrust::raw_reference_cast(y));
+  }
+
+  __thrust_exec_check_disable__
+  template <typename Argument1, typename Argument2>
+  __thrust_forceinline__ __host__ __device__
+  void operator()(const Argument1& x, Argument2& y) const
+  {
+    m_f(thrust::raw_reference_cast(x), thrust::raw_reference_cast(y));
+  }
+  __thrust_exec_check_disable__
+  template <typename Argument1, typename Argument2>
+  __thrust_forceinline__ __host__ __device__
+  void operator()(const Argument1& x, const Argument2& y) const
+  {
+    m_f(thrust::raw_reference_cast(x), thrust::raw_reference_cast(y));
+  }
+  __thrust_exec_check_disable__
+  template <typename Argument1, typename Argument2>
+  __thrust_forceinline__ __host__ __device__
+  void operator()(Argument1& x, const Argument2& y) const
+  {
+    m_f(thrust::raw_reference_cast(x), thrust::raw_reference_cast(y));
+  }
+}; // end wrapped_function
+
+} // namespace detail
+
+THRUST_NAMESPACE_END

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

@@ -0,0 +1,126 @@
+/*
+ *  Copyright 2008-2021 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/functional.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+template<typename Operation>
+  struct unary_traits_imp;
+
+template<typename Operation>
+  struct unary_traits_imp<Operation*>
+{
+  typedef Operation                         function_type;
+  typedef const function_type &             param_type;
+  typedef typename Operation::result_type   result_type;
+  typedef typename Operation::argument_type argument_type;
+}; // end unary_traits_imp
+
+template<typename Result, typename Argument>
+  struct unary_traits_imp<Result(*)(Argument)>
+{
+  typedef Result   (*function_type)(Argument);
+  typedef Result   (*param_type)(Argument);
+  typedef Result   result_type;
+  typedef Argument argument_type;
+}; // end unary_traits_imp
+
+template<typename Operation>
+  struct binary_traits_imp;
+
+template<typename Operation>
+  struct binary_traits_imp<Operation*>
+{
+  typedef Operation                                function_type;
+  typedef const function_type &                    param_type;
+  typedef typename Operation::result_type          result_type;
+  typedef typename Operation::first_argument_type  first_argument_type;
+  typedef typename Operation::second_argument_type second_argument_type;
+}; // end binary_traits_imp
+
+template<typename Result, typename Argument1, typename Argument2>
+  struct binary_traits_imp<Result(*)(Argument1, Argument2)>
+{
+  typedef Result (*function_type)(Argument1, Argument2);
+  typedef Result (*param_type)(Argument1, Argument2);
+  typedef Result result_type;
+  typedef Argument1 first_argument_type;
+  typedef Argument2 second_argument_type;
+}; // end binary_traits_imp
+
+} // end detail
+
+template<typename Operation>
+  struct unary_traits
+{
+  typedef typename detail::unary_traits_imp<Operation*>::function_type function_type;
+  typedef typename detail::unary_traits_imp<Operation*>::param_type    param_type;
+  typedef typename detail::unary_traits_imp<Operation*>::result_type   result_type;
+  typedef typename detail::unary_traits_imp<Operation*>::argument_type argument_type;
+}; // end unary_traits
+
+template<typename Result, typename Argument>
+  struct unary_traits<Result(*)(Argument)>
+{
+  typedef Result   (*function_type)(Argument);
+  typedef Result   (*param_type)(Argument);
+  typedef Result   result_type;
+  typedef Argument argument_type;
+}; // end unary_traits
+
+template<typename Operation>
+  struct binary_traits
+{
+  typedef typename detail::binary_traits_imp<Operation*>::function_type        function_type;
+  typedef typename detail::binary_traits_imp<Operation*>::param_type           param_type;
+  typedef typename detail::binary_traits_imp<Operation*>::result_type          result_type;
+  typedef typename detail::binary_traits_imp<Operation*>::first_argument_type  first_argument_type;
+  typedef typename detail::binary_traits_imp<Operation*>::second_argument_type second_argument_type;
+}; // end binary_traits
+
+template<typename Result, typename Argument1, typename Argument2>
+  struct binary_traits<Result(*)(Argument1, Argument2)>
+{
+  typedef Result (*function_type)(Argument1, Argument2);
+  typedef Result (*param_type)(Argument1, Argument2);
+  typedef Result result_type;
+  typedef Argument1 first_argument_type;
+  typedef Argument2 second_argument_type;
+}; // end binary_traits
+
+template<typename Predicate>
+  __host__ __device__
+  unary_negate<Predicate> not1(const Predicate &pred)
+{
+  return unary_negate<Predicate>(pred);
+} // end not1()
+
+template<typename BinaryPredicate>
+  __host__ __device__
+  binary_negate<BinaryPredicate> not2(const BinaryPredicate &pred)
+{
+  return binary_negate<BinaryPredicate>(pred);
+} // end not2()
+
+THRUST_NAMESPACE_END

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

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

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

@@ -0,0 +1,55 @@
+#pragma once
+/*
+ *  Copyright 2008-2016 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <thrust/detail/config.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/execution_policy.h>
+#include <thrust/detail/type_traits/pointer_traits.h>
+#include <thrust/system/detail/generic/memory.h> // for get_value()
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail {
+
+// get_iterator_value specialization on iterators
+// --------------------------------------------------
+// it is okay to dereference iterator in the usual way
+template<typename DerivedPolicy, typename Iterator>
+__host__ __device__
+typename thrust::iterator_traits<Iterator>::value_type
+get_iterator_value(thrust::execution_policy<DerivedPolicy> &, Iterator it)
+{
+  return *it;
+} // get_iterator_value(exec,Iterator);
+
+// get_iterator_value specialization on pointer
+// ----------------------------------------------
+// we can't just dereference a pointer in the usual way, because
+// it may point to a location in the device memory. 
+// we use get_value(exec,pointer*) function
+// to perform a dereferencing consistent with the execution policy
+template<typename DerivedPolicy, typename Pointer>
+__host__ __device__
+typename thrust::detail::pointer_traits<Pointer*>::element_type 
+get_iterator_value(thrust::execution_policy<DerivedPolicy> &exec, Pointer* ptr)
+{
+  return get_value(derived_cast(exec),ptr);
+} // get_iterator_value(exec,Pointer*)
+
+} // namespace detail
+
+THRUST_NAMESPACE_END

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

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

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

@@ -0,0 +1,558 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file internal_functional.inl
+ *  \brief Non-public functionals used to implement algorithm internals.
+ */
+
+#pragma once
+
+#include <thrust/tuple.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/config.h>
+#include <thrust/detail/static_assert.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/iterator/detail/tuple_of_iterator_references.h>
+#include <thrust/detail/raw_reference_cast.h>
+#include <thrust/detail/memory_wrapper.h> // for ::new
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+// unary_negate does not need to know argument_type
+template<typename Predicate>
+struct unary_negate
+{
+  typedef bool result_type;
+
+  Predicate pred;
+
+  __host__ __device__
+  explicit unary_negate(const Predicate& pred) : pred(pred) {}
+
+  template <typename T>
+  __host__ __device__
+  bool operator()(const T& x)
+  {
+    return !bool(pred(x));
+  }
+};
+
+// binary_negate does not need to know first_argument_type or second_argument_type
+template<typename Predicate>
+struct binary_negate
+{
+  typedef bool result_type;
+
+  Predicate pred;
+
+  __host__ __device__
+  explicit binary_negate(const Predicate& pred) : pred(pred) {}
+
+  template <typename T1, typename T2>
+  __host__ __device__
+  bool operator()(const T1& x, const T2& y)
+  {
+    return !bool(pred(x,y));
+  }
+};
+
+template<typename Predicate>
+__host__ __device__
+thrust::detail::unary_negate<Predicate> not1(const Predicate &pred)
+{
+  return thrust::detail::unary_negate<Predicate>(pred);
+}
+
+template<typename Predicate>
+__host__ __device__
+thrust::detail::binary_negate<Predicate> not2(const Predicate &pred)
+{
+  return thrust::detail::binary_negate<Predicate>(pred);
+}
+
+
+// convert a predicate to a 0 or 1 integral value
+template<typename Predicate, typename IntegralType>
+struct predicate_to_integral
+{
+  Predicate pred;
+
+  __host__ __device__
+  explicit predicate_to_integral(const Predicate& pred) : pred(pred) {}
+
+  template <typename T>
+  __host__ __device__
+  IntegralType operator()(const T& x)
+  {
+    return pred(x) ? IntegralType(1) : IntegralType(0);
+  }
+};
+
+
+// note that detail::equal_to does not force conversion from T2 -> T1 as equal_to does
+template<typename T1>
+struct equal_to
+{
+  typedef bool result_type;
+
+  template <typename T2>
+  __host__ __device__
+  bool operator()(const T1& lhs, const T2& rhs) const
+  {
+    return lhs == rhs;
+  }
+};
+
+// note that equal_to_value does not force conversion from T2 -> T1 as equal_to does
+template<typename T2>
+struct equal_to_value
+{
+  T2 rhs;
+
+  __host__ __device__
+  equal_to_value(const T2& rhs) : rhs(rhs) {}
+
+  template <typename T1>
+  __host__ __device__
+  bool operator()(const T1& lhs) const
+  {
+    return lhs == rhs;
+  }
+};
+
+template<typename Predicate>
+struct tuple_binary_predicate
+{
+  typedef bool result_type;
+
+  __host__ __device__
+  tuple_binary_predicate(const Predicate& p) : pred(p) {}
+
+  template<typename Tuple>
+  __host__ __device__
+  bool operator()(const Tuple& t) const
+  {
+    return pred(thrust::get<0>(t), thrust::get<1>(t));
+  }
+
+  mutable Predicate pred;
+};
+
+template<typename Predicate>
+struct tuple_not_binary_predicate
+{
+  typedef bool result_type;
+
+  __host__ __device__
+  tuple_not_binary_predicate(const Predicate& p) : pred(p) {}
+
+  template<typename Tuple>
+  __host__ __device__
+  bool operator()(const Tuple& t) const
+  {
+    return !pred(thrust::get<0>(t), thrust::get<1>(t));
+  }
+
+  mutable Predicate pred;
+};
+
+template<typename Generator>
+  struct host_generate_functor
+{
+  typedef void result_type;
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  host_generate_functor(Generator g)
+    : gen(g) {}
+
+  // operator() does not take an lvalue reference because some iterators
+  // produce temporary proxy references when dereferenced. for example,
+  // consider the temporary tuple of references produced by zip_iterator.
+  // such temporaries cannot bind to an lvalue reference.
+  //
+  // to WAR this, accept a const reference (which is bindable to a temporary),
+  // and const_cast in the implementation.
+  //
+  // XXX change to an rvalue reference upon c++0x (which either a named variable
+  //     or temporary can bind to)
+  template<typename T>
+  __host__
+  void operator()(const T &x)
+  {
+    // we have to be naughty and const_cast this to get it to work
+    T &lvalue = const_cast<T&>(x);
+
+    // this assigns correctly whether x is a true reference or proxy
+    lvalue = gen();
+  }
+
+  Generator gen;
+};
+
+template<typename Generator>
+  struct device_generate_functor
+{
+  typedef void result_type;
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  device_generate_functor(Generator g)
+    : gen(g) {}
+
+  // operator() does not take an lvalue reference because some iterators
+  // produce temporary proxy references when dereferenced. for example,
+  // consider the temporary tuple of references produced by zip_iterator.
+  // such temporaries cannot bind to an lvalue reference.
+  //
+  // to WAR this, accept a const reference (which is bindable to a temporary),
+  // and const_cast in the implementation.
+  //
+  // XXX change to an rvalue reference upon c++0x (which either a named variable
+  //     or temporary can bind to)
+  template<typename T>
+  __host__ __device__
+  void operator()(const T &x)
+  {
+    // we have to be naughty and const_cast this to get it to work
+    T &lvalue = const_cast<T&>(x);
+
+    // this assigns correctly whether x is a true reference or proxy
+    lvalue = gen();
+  }
+
+  Generator gen;
+};
+
+template<typename System, typename Generator>
+  struct generate_functor
+    : thrust::detail::eval_if<
+        thrust::detail::is_convertible<System, thrust::host_system_tag>::value,
+        thrust::detail::identity_<host_generate_functor<Generator> >,
+        thrust::detail::identity_<device_generate_functor<Generator> >
+      >
+{};
+
+
+template<typename ResultType, typename BinaryFunction>
+  struct zipped_binary_op
+{
+  typedef ResultType result_type;
+
+  __host__ __device__
+  zipped_binary_op(BinaryFunction binary_op)
+    : m_binary_op(binary_op) {}
+
+  template<typename Tuple>
+  __host__ __device__
+  inline result_type operator()(Tuple t)
+  {
+    return m_binary_op(thrust::get<0>(t), thrust::get<1>(t));
+  }
+
+  BinaryFunction m_binary_op;
+};
+
+
+template<typename T>
+  struct is_non_const_reference
+    : thrust::detail::and_<
+        thrust::detail::not_<thrust::detail::is_const<T> >,
+        thrust::detail::or_<thrust::detail::is_reference<T>,
+                            thrust::detail::is_proxy_reference<T> >
+      >
+{};
+
+template<typename T> struct is_tuple_of_iterator_references : thrust::detail::false_type {};
+
+template<typename... Ts>
+  struct is_tuple_of_iterator_references<
+    thrust::detail::tuple_of_iterator_references<
+      Ts...
+    >
+  >
+    : thrust::detail::true_type
+{};
+
+// use this enable_if to avoid assigning to temporaries in the transform functors below
+// XXX revisit this problem with c++11 perfect forwarding
+template<typename T>
+  struct enable_if_non_const_reference_or_tuple_of_iterator_references
+    : thrust::detail::enable_if<
+        is_non_const_reference<T>::value || is_tuple_of_iterator_references<T>::value
+      >
+{};
+
+
+template<typename UnaryFunction>
+  struct unary_transform_functor
+{
+  typedef void result_type;
+
+  UnaryFunction f;
+
+  __host__ __device__
+  unary_transform_functor(UnaryFunction f)
+    : f(f)
+  {}
+
+  __thrust_exec_check_disable__
+  template<typename Tuple>
+  inline __host__ __device__
+  typename enable_if_non_const_reference_or_tuple_of_iterator_references<
+    typename thrust::tuple_element<1,Tuple>::type
+  >::type
+    operator()(Tuple t)
+  {
+    thrust::get<1>(t) = f(thrust::get<0>(t));
+  }
+};
+
+
+template<typename BinaryFunction>
+  struct binary_transform_functor
+{
+  BinaryFunction f;
+
+  __host__ __device__
+  binary_transform_functor(BinaryFunction f)
+    : f(f)
+  {}
+
+  __thrust_exec_check_disable__
+  template<typename Tuple>
+  inline __host__ __device__
+  typename enable_if_non_const_reference_or_tuple_of_iterator_references<
+    typename thrust::tuple_element<2,Tuple>::type
+  >::type
+    operator()(Tuple t)
+  {
+    thrust::get<2>(t) = f(thrust::get<0>(t), thrust::get<1>(t));
+  }
+};
+
+
+template<typename UnaryFunction, typename Predicate>
+struct unary_transform_if_functor
+{
+  UnaryFunction unary_op;
+  Predicate pred;
+
+  __host__ __device__
+  unary_transform_if_functor(UnaryFunction unary_op, Predicate pred)
+    : unary_op(unary_op), pred(pred)
+  {}
+
+  __thrust_exec_check_disable__
+  template<typename Tuple>
+  inline __host__ __device__
+  typename enable_if_non_const_reference_or_tuple_of_iterator_references<
+    typename thrust::tuple_element<1,Tuple>::type
+  >::type
+    operator()(Tuple t)
+  {
+    if(pred(thrust::get<0>(t)))
+    {
+      thrust::get<1>(t) = unary_op(thrust::get<0>(t));
+    }
+  }
+}; // end unary_transform_if_functor
+
+
+template<typename UnaryFunction, typename Predicate>
+struct unary_transform_if_with_stencil_functor
+{
+  UnaryFunction unary_op;
+  Predicate pred;
+
+  __host__ __device__
+  unary_transform_if_with_stencil_functor(UnaryFunction unary_op, Predicate pred)
+    : unary_op(unary_op), pred(pred)
+  {}
+
+  __thrust_exec_check_disable__
+  template<typename Tuple>
+  inline __host__ __device__
+  typename enable_if_non_const_reference_or_tuple_of_iterator_references<
+    typename thrust::tuple_element<2,Tuple>::type
+  >::type
+    operator()(Tuple t)
+  {
+    if(pred(thrust::get<1>(t)))
+      thrust::get<2>(t) = unary_op(thrust::get<0>(t));
+  }
+}; // end unary_transform_if_with_stencil_functor
+
+
+template<typename BinaryFunction, typename Predicate>
+struct binary_transform_if_functor
+{
+  BinaryFunction binary_op;
+  Predicate pred;
+
+  __host__ __device__
+  binary_transform_if_functor(BinaryFunction binary_op, Predicate pred)
+    : binary_op(binary_op), pred(pred) {}
+
+  __thrust_exec_check_disable__
+  template<typename Tuple>
+  inline __host__ __device__
+  typename enable_if_non_const_reference_or_tuple_of_iterator_references<
+    typename thrust::tuple_element<3,Tuple>::type
+  >::type
+    operator()(Tuple t)
+  {
+    if(pred(thrust::get<2>(t)))
+      thrust::get<3>(t) = binary_op(thrust::get<0>(t), thrust::get<1>(t));
+  }
+}; // end binary_transform_if_functor
+
+
+template<typename T>
+  struct host_destroy_functor
+{
+  __host__
+  void operator()(T &x) const
+  {
+    x.~T();
+  } // end operator()()
+}; // end host_destroy_functor
+
+
+template<typename T>
+  struct device_destroy_functor
+{
+  // add __host__ to allow the omp backend to compile with nvcc
+  __host__ __device__
+  void operator()(T &x) const
+  {
+    x.~T();
+  } // end operator()()
+}; // end device_destroy_functor
+
+
+template<typename System, typename T>
+  struct destroy_functor
+    : thrust::detail::eval_if<
+        thrust::detail::is_convertible<System, thrust::host_system_tag>::value,
+        thrust::detail::identity_<host_destroy_functor<T> >,
+        thrust::detail::identity_<device_destroy_functor<T> >
+      >
+{};
+
+
+template <typename T>
+struct fill_functor
+{
+  T exemplar;
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  fill_functor(const T& _exemplar)
+    : exemplar(_exemplar) {}
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  fill_functor(const fill_functor & other)
+    :exemplar(other.exemplar){}
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  ~fill_functor() {}
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  T operator()(void) const
+  {
+    return exemplar;
+  }
+};
+
+
+template<typename T>
+  struct uninitialized_fill_functor
+{
+  T exemplar;
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  uninitialized_fill_functor(const T & x):exemplar(x){}
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  uninitialized_fill_functor(const uninitialized_fill_functor & other)
+    :exemplar(other.exemplar){}
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  ~uninitialized_fill_functor() {}
+
+  __thrust_exec_check_disable__
+  __host__ __device__
+  void operator()(T &x)
+  {
+    ::new(static_cast<void*>(&x)) T(exemplar);
+  } // end operator()()
+}; // end uninitialized_fill_functor
+
+
+// this predicate tests two two-element tuples
+// we first use a Compare for the first element
+// if the first elements are equivalent, we use
+// < for the second elements
+template<typename Compare>
+  struct compare_first_less_second
+{
+  compare_first_less_second(Compare c)
+    : comp(c) {}
+
+  template<typename T1, typename T2>
+  __host__ __device__
+  bool operator()(T1 lhs, T2 rhs)
+  {
+    return comp(thrust::get<0>(lhs), thrust::get<0>(rhs)) || (!comp(thrust::get<0>(rhs), thrust::get<0>(lhs)) && thrust::get<1>(lhs) < thrust::get<1>(rhs));
+  }
+
+  Compare comp;
+}; // end compare_first_less_second
+
+
+template<typename Compare>
+  struct compare_first
+{
+  Compare comp;
+
+  __host__ __device__
+  compare_first(Compare comp)
+    : comp(comp)
+  {}
+
+  template<typename Tuple1, typename Tuple2>
+  __host__ __device__
+  bool operator()(const Tuple1 &x, const Tuple2 &y)
+  {
+    return comp(thrust::raw_reference_cast(thrust::get<0>(x)), thrust::raw_reference_cast(thrust::get<0>(y)));
+  }
+}; // end compare_first
+
+
+} // end namespace detail
+
+THRUST_NAMESPACE_END

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

@@ -0,0 +1,83 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/execution_policy.h>
+#include <thrust/detail/pointer.h>
+#include <thrust/detail/raw_pointer_cast.h>
+#include <thrust/system/detail/generic/memory.h>
+#include <thrust/system/detail/adl/malloc_and_free.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy>
+__host__ __device__
+pointer<void,DerivedPolicy> malloc(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, std::size_t n)
+{
+  using thrust::system::detail::generic::malloc;
+
+  // XXX should use a hypothetical thrust::static_pointer_cast here
+  void *raw_ptr = static_cast<void*>(thrust::raw_pointer_cast(malloc(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), n)));
+
+  return pointer<void,DerivedPolicy>(raw_ptr);
+}
+
+__thrust_exec_check_disable__
+template<typename T, typename DerivedPolicy>
+__host__ __device__
+pointer<T,DerivedPolicy> malloc(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, std::size_t n)
+{
+  using thrust::system::detail::generic::malloc;
+
+  T *raw_ptr = static_cast<T*>(thrust::raw_pointer_cast(malloc<T>(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), n)));
+
+  return pointer<T,DerivedPolicy>(raw_ptr);
+}
+
+
+// XXX WAR nvbug 992955
+#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
+#if CUDART_VERSION < 5000
+
+// cudafe generates unqualified calls to free(int *volatile)
+// which get confused with thrust::free
+// spoof a thrust::free which simply maps to ::free
+inline __host__ __device__
+void free(int *volatile ptr)
+{
+  ::free(ptr);
+}
+
+#endif // CUDART_VERSION
+#endif // THRUST_DEVICE_COMPILER
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename Pointer>
+__host__ __device__
+void free(const thrust::detail::execution_policy_base<DerivedPolicy> &exec, Pointer ptr)
+{
+  using thrust::system::detail::generic::free;
+
+  free(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), ptr);
+}
+
+// XXX consider another form of free which does not take a system argument and
+// instead infers the system from the pointer
+
+THRUST_NAMESPACE_END

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

@@ -0,0 +1,221 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/merge.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/system/detail/generic/merge.h>
+#include <thrust/system/detail/adl/merge.h>
+
+THRUST_NAMESPACE_BEGIN
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator merge(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                       InputIterator1 first1,
+                       InputIterator1 last1,
+                       InputIterator2 first2,
+                       InputIterator2 last2,
+                       OutputIterator result)
+{
+  using thrust::system::detail::generic::merge;
+  return merge(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, last2, result);
+} // end merge()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename StrictWeakCompare>
+__host__ __device__
+  OutputIterator merge(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                       InputIterator1 first1,
+                       InputIterator1 last1,
+                       InputIterator2 first2,
+                       InputIterator2 last2,
+                       OutputIterator result,
+                       StrictWeakCompare comp)
+{
+  using thrust::system::detail::generic::merge;
+  return merge(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), first1, last1, first2, last2, result, comp);
+} // end merge()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator1, typename InputIterator2, typename InputIterator3, typename InputIterator4, typename OutputIterator1, typename OutputIterator2>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+    merge_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                 InputIterator1 keys_first1, InputIterator1 keys_last1,
+                 InputIterator2 keys_first2, InputIterator2 keys_last2,
+                 InputIterator3 values_first1, InputIterator4 values_first2,
+                 OutputIterator1 keys_result,
+                 OutputIterator2 values_result)
+{
+  using thrust::system::detail::generic::merge_by_key;
+  return merge_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result);
+} // end merge_by_key()
+
+
+__thrust_exec_check_disable__
+template<typename DerivedPolicy, typename InputIterator1, typename InputIterator2, typename InputIterator3, typename InputIterator4, typename OutputIterator1, typename OutputIterator2, typename Compare>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+    merge_by_key(const thrust::detail::execution_policy_base<DerivedPolicy> &exec,
+                 InputIterator1 keys_first1, InputIterator1 keys_last1,
+                 InputIterator2 keys_first2, InputIterator2 keys_last2,
+                 InputIterator3 values_first1, InputIterator4 values_first2,
+                 OutputIterator1 keys_result,
+                 OutputIterator2 values_result,
+                 Compare comp)
+{
+  using thrust::system::detail::generic::merge_by_key;
+  return merge_by_key(thrust::detail::derived_cast(thrust::detail::strip_const(exec)), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result, comp);
+} // end merge_by_key()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator,
+         typename StrictWeakOrdering>
+  OutputIterator merge(InputIterator1 first1,
+                       InputIterator1 last1,
+                       InputIterator2 first2,
+                       InputIterator2 last2,
+                       OutputIterator result,
+                       StrictWeakOrdering comp)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+  typedef typename thrust::iterator_system<OutputIterator>::type System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::merge(select_system(system1,system2,system3), first1, last1, first2, last2, result, comp);
+} // end merge()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator>
+  OutputIterator merge(InputIterator1 first1,
+                       InputIterator1 last1,
+                       InputIterator2 first2,
+                       InputIterator2 last2,
+                       OutputIterator result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type System2;
+  typedef typename thrust::iterator_system<OutputIterator>::type System3;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+
+  return thrust::merge(select_system(system1,system2,system3), first1, last1, first2, last2, result);
+} // end merge()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename StrictWeakOrdering>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    merge_by_key(InputIterator1 keys_first1,
+                 InputIterator1 keys_last1,
+                 InputIterator2 keys_first2,
+                 InputIterator2 keys_last2,
+                 InputIterator3 values_first1,
+                 InputIterator4 values_first2,
+                 OutputIterator1 keys_result,
+                 OutputIterator2 values_result,
+                 StrictWeakOrdering comp)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type  System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type  System2;
+  typedef typename thrust::iterator_system<InputIterator3>::type  System3;
+  typedef typename thrust::iterator_system<InputIterator4>::type  System4;
+  typedef typename thrust::iterator_system<OutputIterator1>::type System5;
+  typedef typename thrust::iterator_system<OutputIterator2>::type System6;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+  System5 system5;
+  System6 system6;
+
+  return thrust::merge_by_key(select_system(system1,system2,system3,system4,system5,system6), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result, comp);
+} // end merge_by_key()
+
+
+template<typename InputIterator1,
+         typename InputIterator2,
+         typename InputIterator3,
+         typename InputIterator4,
+         typename OutputIterator1,
+         typename OutputIterator2>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    merge_by_key(InputIterator1 keys_first1,
+                 InputIterator1 keys_last1,
+                 InputIterator2 keys_first2,
+                 InputIterator2 keys_last2,
+                 InputIterator3 values_first1,
+                 InputIterator4 values_first2,
+                 OutputIterator1 keys_result,
+                 OutputIterator2 values_result)
+{
+  using thrust::system::detail::generic::select_system;
+
+  typedef typename thrust::iterator_system<InputIterator1>::type  System1;
+  typedef typename thrust::iterator_system<InputIterator2>::type  System2;
+  typedef typename thrust::iterator_system<InputIterator3>::type  System3;
+  typedef typename thrust::iterator_system<InputIterator4>::type  System4;
+  typedef typename thrust::iterator_system<OutputIterator1>::type System5;
+  typedef typename thrust::iterator_system<OutputIterator2>::type System6;
+
+  System1 system1;
+  System2 system2;
+  System3 system3;
+  System4 system4;
+  System5 system5;
+  System6 system6;
+
+  return thrust::merge_by_key(select_system(system1,system2,system3,system4,system5,system6), keys_first1, keys_last1, keys_first2, keys_last2, values_first1, values_first2, keys_result, values_result);
+} // end merge_by_key()
+
+THRUST_NAMESPACE_END

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

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

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

@@ -0,0 +1,26 @@
+/*
+ *  Copyright 2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config/cpp_dialect.h>
+
+#ifndef THRUST_MODERN_GCC_REQUIRED_NO_ERROR
+#  if defined(THRUST_GCC_VERSION) && !defined(THRUST_MODERN_GCC)
+#    error GCC 5 or later is required for this Thrust feature; please upgrade your compiler.
+#  endif
+#endif
+

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

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

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

@@ -0,0 +1,131 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/iterator/detail/minimum_system.h>
+#include <thrust/detail/copy.h>
+#include <thrust/detail/temporary_array.h>
+#include <thrust/system/cpp/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+
+template<typename InputIterator,
+         typename OutputIterator>
+  OutputIterator sequential_copy(InputIterator first,
+                                 InputIterator last,
+                                 OutputIterator result)
+{
+  for(; first != last; ++first, ++result)
+  {
+    *result = *first;
+  } // end for
+
+  return result;
+} // end sequential_copy()
+
+
+template<typename BidirectionalIterator1,
+         typename BidirectionalIterator2>
+  BidirectionalIterator2 sequential_copy_backward(BidirectionalIterator1 first,
+                                                  BidirectionalIterator1 last,
+                                                  BidirectionalIterator2 result)
+{
+  // yes, we preincrement
+  // the ranges are open on the right, i.e. [first, last)
+  while(first != last)
+  {
+    *--result = *--last;
+  } // end while
+
+  return result;
+} // end sequential_copy_backward()
+
+
+namespace dispatch
+{
+
+
+template<typename DerivedPolicy,
+         typename RandomAccessIterator1,
+         typename RandomAccessIterator2>
+  RandomAccessIterator2 overlapped_copy(thrust::system::cpp::detail::execution_policy<DerivedPolicy> &,
+                                        RandomAccessIterator1 first,
+                                        RandomAccessIterator1 last,
+                                        RandomAccessIterator2 result)
+{
+  if(first < last && first <= result && result < last)
+  {
+    // result lies in [first, last)
+    // it's safe to use std::copy_backward here
+    thrust::detail::sequential_copy_backward(first, last, result + (last - first));
+    result += (last - first);
+  } // end if
+  else
+  {
+    // result + (last - first) lies in [first, last)
+    // it's safe to use sequential_copy here
+    result = thrust::detail::sequential_copy(first, last, result);
+  } // end else
+
+  return result;
+} // end overlapped_copy()
+
+
+template<typename DerivedPolicy,
+         typename RandomAccessIterator1,
+         typename RandomAccessIterator2>
+  RandomAccessIterator2 overlapped_copy(thrust::execution_policy<DerivedPolicy> &exec,
+                                        RandomAccessIterator1 first,
+                                        RandomAccessIterator1 last,
+                                        RandomAccessIterator2 result)
+{
+  typedef typename thrust::iterator_value<RandomAccessIterator1>::type value_type;
+
+  // make a temporary copy of [first,last), and copy into it first
+  thrust::detail::temporary_array<value_type, DerivedPolicy> temp(exec, first, last);
+  return thrust::copy(exec, temp.begin(), temp.end(), result);
+} // end overlapped_copy()
+
+} // end dispatch
+
+
+template<typename RandomAccessIterator1,
+         typename RandomAccessIterator2>
+  RandomAccessIterator2 overlapped_copy(RandomAccessIterator1 first,
+                                        RandomAccessIterator1 last,
+                                        RandomAccessIterator2 result)
+{
+  typedef typename thrust::iterator_system<RandomAccessIterator2>::type System1;
+  typedef typename thrust::iterator_system<RandomAccessIterator2>::type System2;
+
+  typedef typename thrust::detail::minimum_system<System1, System2>::type System;
+
+  // XXX presumes System is default constructible
+  System system;
+
+  return thrust::detail::dispatch::overlapped_copy(system, first, last, result);
+} // end overlapped_copy()
+
+} // end detail
+
+THRUST_NAMESPACE_END

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

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

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

@@ -0,0 +1,332 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/raw_pointer_cast.h>
+#include <thrust/detail/type_traits/has_nested_type.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/tuple_transform.h>
+#include <thrust/iterator/detail/tuple_of_iterator_references.h>
+
+
+// the order of declarations and definitions in this file is totally goofy
+// this header defines raw_reference_cast, which has a few overloads towards the bottom of the file
+// raw_reference_cast depends on metafunctions such as is_unwrappable and raw_reference
+// we need to be sure that these metafunctions are completely defined (including specializations) before they are instantiated by raw_reference_cast
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+
+__THRUST_DEFINE_HAS_NESTED_TYPE(is_wrapped_reference, wrapped_reference_hint)
+
+
+// wrapped reference-like things which aren't strictly wrapped references
+// (e.g. tuples of wrapped references) are considered unwrappable
+template<typename T>
+  struct is_unwrappable
+    : is_wrapped_reference<T>
+{};
+
+
+// specialize is_unwrappable
+// a tuple is_unwrappable if any of its elements is_unwrappable
+template<typename... Ts>
+  struct is_unwrappable<
+    thrust::tuple<Ts...>
+  >
+    : or_<
+        is_unwrappable<Ts>...
+      >
+{};
+
+
+// specialize is_unwrappable
+// a tuple_of_iterator_references is_unwrappable if any of its elements is_unwrappable
+template<
+  typename... Ts
+>
+  struct is_unwrappable<
+    thrust::detail::tuple_of_iterator_references<Ts...>
+  >
+    : or_<
+        is_unwrappable<Ts>...
+      >
+{};
+
+
+template<typename T, typename Result = void>
+  struct enable_if_unwrappable
+    : enable_if<
+        is_unwrappable<T>::value,
+        Result
+      >
+{};
+
+
+namespace raw_reference_detail
+{
+
+
+template<typename T, typename Enable = void>
+  struct raw_reference_impl
+    : add_reference<T>
+{};
+
+
+template<typename T>
+  struct raw_reference_impl<
+    T,
+    typename thrust::detail::enable_if<
+      is_wrapped_reference<
+        typename remove_cv<T>::type
+      >::value
+    >::type
+  >
+{
+  typedef typename add_reference<
+    typename pointer_element<typename T::pointer>::type
+  >::type type;
+};
+
+
+} // end raw_reference_detail
+
+
+template<typename T>
+  struct raw_reference :
+    raw_reference_detail::raw_reference_impl<T>
+{};
+
+
+namespace raw_reference_detail
+{
+
+// unlike raw_reference,
+// raw_reference_tuple_helper needs to return a value
+// when it encounters one, rather than a reference
+// upon encountering tuple, recurse
+//
+// we want the following behavior:
+//  1. T                                -> T
+//  2. T&                               -> T&
+//  3. null_type                        -> null_type
+//  4. reference<T>                     -> T&
+//  5. tuple_of_iterator_references<T>  -> tuple_of_iterator_references<raw_reference_tuple_helper<T>::type>
+
+
+// wrapped references are unwrapped using raw_reference, otherwise, return T
+template<typename T>
+  struct raw_reference_tuple_helper
+    : eval_if<
+        is_unwrappable<
+          typename remove_cv<T>::type
+        >::value,
+        raw_reference<T>,
+        identity_<T>
+      >
+{};
+
+
+// recurse on tuples
+template <
+  typename... Ts
+>
+  struct raw_reference_tuple_helper<
+    thrust::tuple<Ts...>
+  >
+{
+  typedef thrust::tuple<
+    typename raw_reference_tuple_helper<Ts>::type...
+  > type;
+};
+
+
+template <
+  typename... Ts
+>
+  struct raw_reference_tuple_helper<
+    thrust::detail::tuple_of_iterator_references<Ts...>
+  >
+{
+  typedef thrust::detail::tuple_of_iterator_references<
+    typename raw_reference_tuple_helper<Ts>::type...
+  > type;
+};
+
+
+} // end raw_reference_detail
+
+
+// a couple of specializations of raw_reference for tuples follow
+
+
+// if a tuple "tuple_type" is_unwrappable,
+//   then the raw_reference of tuple_type is a tuple of its members' raw_references
+//   else the raw_reference of tuple_type is tuple_type &
+template <
+  typename... Ts
+>
+  struct raw_reference<
+    thrust::tuple<Ts...>
+  >
+{
+  private:
+    typedef thrust::tuple<Ts...> tuple_type;
+
+  public:
+    typedef typename eval_if<
+      is_unwrappable<tuple_type>::value,
+      raw_reference_detail::raw_reference_tuple_helper<tuple_type>,
+      add_reference<tuple_type>
+    >::type type;
+};
+
+
+template <
+  typename... Ts
+>
+  struct raw_reference<
+    thrust::detail::tuple_of_iterator_references<Ts...>
+  >
+{
+  private:
+    typedef detail::tuple_of_iterator_references<Ts...> tuple_type;
+
+  public:
+    typedef typename raw_reference_detail::raw_reference_tuple_helper<tuple_type>::type type;
+
+    // XXX figure out why is_unwrappable seems to be broken for tuple_of_iterator_references
+    //typedef typename eval_if<
+    //  is_unwrappable<tuple_type>::value,
+    //  raw_reference_detail::raw_reference_tuple_helper<tuple_type>,
+    //  add_reference<tuple_type>
+    //>::type type;
+};
+
+
+} // end detail
+
+
+// provide declarations of raw_reference_cast's overloads for raw_reference_caster below
+template<typename T>
+__host__ __device__
+typename detail::raw_reference<T>::type
+  raw_reference_cast(T &ref);
+
+
+template<typename T>
+__host__ __device__
+typename detail::raw_reference<const T>::type
+  raw_reference_cast(const T &ref);
+
+
+template<
+  typename... Ts
+>
+__host__ __device__
+typename detail::enable_if_unwrappable<
+  thrust::detail::tuple_of_iterator_references<Ts...>,
+  typename detail::raw_reference<
+    thrust::detail::tuple_of_iterator_references<Ts...>
+  >::type
+>::type
+raw_reference_cast(thrust::detail::tuple_of_iterator_references<Ts...> t);
+
+
+namespace detail
+{
+
+
+struct raw_reference_caster
+{
+  template<typename T>
+  __host__ __device__
+  typename detail::raw_reference<T>::type operator()(T &ref)
+  {
+    return thrust::raw_reference_cast(ref);
+  }
+
+  template<typename T>
+  __host__ __device__
+  typename detail::raw_reference<const T>::type operator()(const T &ref)
+  {
+    return thrust::raw_reference_cast(ref);
+  }
+
+  template<
+    typename... Ts
+  >
+  __host__ __device__
+  typename detail::raw_reference<
+    thrust::detail::tuple_of_iterator_references<Ts...>
+  >::type
+  operator()(thrust::detail::tuple_of_iterator_references<Ts...> t,
+             typename enable_if<
+               is_unwrappable<thrust::detail::tuple_of_iterator_references<Ts...> >::value
+             >::type * = 0)
+  {
+    return thrust::raw_reference_cast(t);
+  }
+}; // end raw_reference_caster
+
+
+} // end detail
+
+
+template<typename T>
+__host__ __device__
+typename detail::raw_reference<T>::type
+  raw_reference_cast(T &ref)
+{
+  return *thrust::raw_pointer_cast(&ref);
+} // end raw_reference_cast
+
+
+template<typename T>
+__host__ __device__
+typename detail::raw_reference<const T>::type
+  raw_reference_cast(const T &ref)
+{
+  return *thrust::raw_pointer_cast(&ref);
+} // end raw_reference_cast
+
+
+template<
+  typename... Ts
+>
+__host__ __device__
+typename detail::enable_if_unwrappable<
+  thrust::detail::tuple_of_iterator_references<Ts...>,
+  typename detail::raw_reference<
+    thrust::detail::tuple_of_iterator_references<Ts...>
+  >::type
+>::type
+raw_reference_cast(thrust::detail::tuple_of_iterator_references<Ts...> t)
+{
+  thrust::detail::raw_reference_caster f;
+
+  // note that we pass raw_reference_tuple_helper, not raw_reference as the unary metafunction
+  // the different way that raw_reference_tuple_helper unwraps tuples is important
+  return thrust::detail::tuple_host_device_transform<detail::raw_reference_detail::raw_reference_tuple_helper>(t, f);
+} // end raw_reference_cast
+
+
+THRUST_NAMESPACE_END
+

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,52 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/allocator_aware_execution_policy.h>
+#include <thrust/system/detail/sequential/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+
+struct seq_t : thrust::system::detail::sequential::execution_policy<seq_t>,
+  thrust::detail::allocator_aware_execution_policy<
+    thrust::system::detail::sequential::execution_policy>
+{
+  __host__ __device__
+  constexpr seq_t() : thrust::system::detail::sequential::execution_policy<seq_t>() {}
+
+  // allow any execution_policy to convert to seq_t
+  template<typename DerivedPolicy>
+  __host__ __device__
+  seq_t(const thrust::execution_policy<DerivedPolicy> &)
+    : thrust::system::detail::sequential::execution_policy<seq_t>()
+  {}
+};
+
+
+} // end detail
+
+
+THRUST_INLINE_CONSTANT detail::seq_t seq;
+
+
+THRUST_NAMESPACE_END
+
+

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

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

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

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

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

@@ -0,0 +1,91 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*
+ * (C) Copyright John Maddock 2000.
+ * 
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/preprocessor.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+template <typename, bool x>
+struct depend_on_instantiation
+{
+  THRUST_INLINE_INTEGRAL_MEMBER_CONSTANT bool value = x;
+};
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#  if THRUST_CPP_DIALECT >= 2017
+#    define THRUST_STATIC_ASSERT(B)        static_assert(B)
+#  else
+#    define THRUST_STATIC_ASSERT(B)        static_assert(B, "static assertion failed")
+#  endif
+#  define THRUST_STATIC_ASSERT_MSG(B, msg) static_assert(B, msg)
+
+#else // Older than C++11.
+
+// HP aCC cannot deal with missing names for template value parameters.
+template <bool x> struct STATIC_ASSERTION_FAILURE;
+
+template <> struct STATIC_ASSERTION_FAILURE<true> {};
+
+// HP aCC cannot deal with missing names for template value parameters.
+template <int x> struct static_assert_test {};
+
+#if    (  (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC)                  \
+       && (THRUST_GCC_VERSION >= 40800))                                      \
+    || (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_CLANG)
+  // Clang and GCC 4.8+ will complain about this typedef being unused unless we
+  // annotate it as such.
+#  define THRUST_STATIC_ASSERT(B)                                             \
+    typedef THRUST_NS_QUALIFIER::detail::static_assert_test<                  \
+      sizeof(THRUST_NS_QUALIFIER::detail::STATIC_ASSERTION_FAILURE<(bool)(B)>)\
+    >                                                                         \
+      THRUST_PP_CAT2(thrust_static_assert_typedef_, __LINE__)                 \
+      __attribute__((unused))                                                 \
+    /**/      
+#else
+#  define THRUST_STATIC_ASSERT(B)                                             \
+    typedef THRUST_NS_QUALIFIER::detail::static_assert_test<                  \
+      sizeof(THRUST_NS_QUALIFIER::detail::STATIC_ASSERTION_FAILURE<(bool)(B)>)\
+    >                                                                         \
+      THRUST_PP_CAT2(thrust_static_assert_typedef_, __LINE__)                 \
+    /**/      
+#endif
+
+#define THRUST_STATIC_ASSERT_MSG(B, msg) THRUST_STATIC_ASSERT(B)
+
+#endif // THRUST_CPP_DIALECT >= 2011
+
+} // namespace detail
+
+THRUST_NAMESPACE_END
+
+

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

@@ -0,0 +1,169 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+
+#include <thrust/detail/config.h>
+
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+namespace static_map_detail
+{
+
+
+template<unsigned int k, unsigned int v>
+struct key_value
+{
+  static const unsigned int key = k;
+  static const unsigned int value = v;
+};
+
+
+template<typename Head, typename Tail = void>
+struct cons
+{
+  template<unsigned int key, unsigned int default_value>
+  struct static_get
+  {
+    static const unsigned int value = (key == Head::key) ? (Head::value) : Tail::template static_get<key,default_value>::value;
+  };
+
+
+  template<unsigned int default_value>
+  __host__ __device__
+  static unsigned int get(unsigned int key)
+  {
+    return (key == Head::key) ? (Head::value) : Tail::template get<default_value>(key);
+  }
+};
+
+
+template<typename Head>
+struct cons<Head,void>
+{
+  template<unsigned int key, unsigned int default_value>
+  struct static_get
+  {
+    static const unsigned int value = (key == Head::key) ? (Head::value) : default_value;
+  };
+
+  template<unsigned int default_value>
+  __host__ __device__
+  static unsigned int get(unsigned int key)
+  {
+    return (key == Head::key) ? (Head::value) : default_value;
+  }
+};
+
+
+template<unsigned int default_value,
+         unsigned int key0 = 0, unsigned int value0 = default_value,
+         unsigned int key1 = 0, unsigned int value1 = default_value,
+         unsigned int key2 = 0, unsigned int value2 = default_value,
+         unsigned int key3 = 0, unsigned int value3 = default_value,
+         unsigned int key4 = 0, unsigned int value4 = default_value,
+         unsigned int key5 = 0, unsigned int value5 = default_value,
+         unsigned int key6 = 0, unsigned int value6 = default_value,
+         unsigned int key7 = 0, unsigned int value7 = default_value>
+struct static_map
+{
+  typedef cons<
+    key_value<key0,value0>,
+    cons<
+      key_value<key1,value1>,
+      cons<
+        key_value<key2,value2>,
+        cons<
+          key_value<key3,value3>,
+          cons<
+            key_value<key4,value4>,
+            cons<
+              key_value<key5,value5>,
+              cons<
+                key_value<key6,value6>,
+                cons<
+                  key_value<key7,value7>
+                >
+              >
+            >
+          >
+        >
+      >
+    >
+  > impl;
+
+  template<unsigned int key>
+  struct static_get
+  {
+    static const unsigned int value = impl::template static_get<key,default_value>::value;
+  };
+
+  __host__ __device__
+  static unsigned int get(unsigned int key)
+  {
+    return impl::template get<default_value>(key);
+  }
+};
+
+
+} // end namespace static_map_detail
+
+
+template<unsigned int default_value,
+         unsigned int key0 = 0, unsigned int value0 = default_value,
+         unsigned int key1 = 0, unsigned int value1 = default_value,
+         unsigned int key2 = 0, unsigned int value2 = default_value,
+         unsigned int key3 = 0, unsigned int value3 = default_value,
+         unsigned int key4 = 0, unsigned int value4 = default_value,
+         unsigned int key5 = 0, unsigned int value5 = default_value,
+         unsigned int key6 = 0, unsigned int value6 = default_value,
+         unsigned int key7 = 0, unsigned int value7 = default_value>
+struct static_map
+  : static_map_detail::static_map<
+      default_value,
+      key0, value0,
+      key1, value1,
+      key2, value2,
+      key3, value3,
+      key4, value4,
+      key5, value5,
+      key6, value6,
+      key7, value7
+    >
+{};
+
+
+template<unsigned int key, typename StaticMap>
+struct static_lookup
+{
+  static const unsigned int value = StaticMap::template static_get<key>::value;
+};
+
+
+template<typename StaticMap>
+__host__ __device__
+unsigned int lookup(unsigned int key)
+{
+  return StaticMap::get(key);
+}
+
+
+} // end namespace detail
+THRUST_NAMESPACE_END
+

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

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

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

@@ -0,0 +1,168 @@
+/*
+ *  Copyright 2008-2021 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/detail/temporary_array.h>
+#include <thrust/distance.h>
+#include <thrust/system/detail/generic/select_system.h>
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+namespace temporary_array_detail
+{
+
+
+template<typename T> struct avoid_initialization : thrust::detail::has_trivial_copy_constructor<T> {};
+
+
+template<typename T, typename TemporaryArray, typename Size>
+__host__ __device__
+typename thrust::detail::enable_if<
+  avoid_initialization<T>::value
+>::type
+  construct_values(TemporaryArray &,
+                   Size)
+{
+  // avoid the overhead of initialization
+} // end construct_values()
+
+
+template<typename T, typename TemporaryArray, typename Size>
+__host__ __device__
+typename thrust::detail::disable_if<
+  avoid_initialization<T>::value
+>::type
+  construct_values(TemporaryArray &a,
+                   Size n)
+{
+  a.default_construct_n(a.begin(), n);
+} // end construct_values()
+
+
+} // end temporary_array_detail
+
+
+template<typename T, typename System>
+__host__ __device__
+  temporary_array<T,System>
+    ::temporary_array(thrust::execution_policy<System> &system)
+      :super_t(alloc_type(temporary_allocator<T,System>(system)))
+{
+} // end temporary_array::temporary_array()
+
+
+template<typename T, typename System>
+__host__ __device__
+  temporary_array<T,System>
+    ::temporary_array(thrust::execution_policy<System> &system, size_type n)
+      :super_t(n, alloc_type(temporary_allocator<T,System>(system)))
+{
+  temporary_array_detail::construct_values<T>(*this, n);
+} // end temporary_array::temporary_array()
+
+
+template<typename T, typename System>
+__host__ __device__
+  temporary_array<T,System>
+    ::temporary_array(int, thrust::execution_policy<System> &system, size_type n)
+      :super_t(n, alloc_type(temporary_allocator<T,System>(system)))
+{
+  // avoid initialization
+  ;
+} // end temporary_array::temporary_array()
+
+
+template<typename T, typename System>
+  template<typename InputIterator>
+  __host__ __device__
+    temporary_array<T,System>
+      ::temporary_array(thrust::execution_policy<System> &system,
+                        InputIterator first,
+                        size_type n)
+        : super_t(alloc_type(temporary_allocator<T,System>(system)))
+{
+  super_t::allocate(n);
+
+  super_t::uninitialized_copy_n(system, first, n, super_t::begin());
+} // end temporary_array::temporary_array()
+
+
+template<typename T, typename System>
+  template<typename InputIterator, typename InputSystem>
+  __host__ __device__
+    temporary_array<T,System>
+      ::temporary_array(thrust::execution_policy<System> &system,
+                        thrust::execution_policy<InputSystem> &input_system,
+                        InputIterator first,
+                        size_type n)
+        : super_t(alloc_type(temporary_allocator<T,System>(system)))
+{
+  super_t::allocate(n);
+
+  super_t::uninitialized_copy_n(input_system, first, n, super_t::begin());
+} // end temporary_array::temporary_array()
+
+
+template<typename T, typename System>
+  template<typename InputIterator>
+  __host__ __device__
+    temporary_array<T,System>
+      ::temporary_array(thrust::execution_policy<System> &system,
+                        InputIterator first,
+                        InputIterator last)
+        : super_t(alloc_type(temporary_allocator<T,System>(system)))
+{
+  super_t::allocate(thrust::distance(first,last));
+
+  super_t::uninitialized_copy(system, first, last, super_t::begin());
+} // end temporary_array::temporary_array()
+
+
+template<typename T, typename System>
+  template<typename InputSystem, typename InputIterator>
+  __host__ __device__
+    temporary_array<T,System>
+      ::temporary_array(thrust::execution_policy<System> &system,
+                        thrust::execution_policy<InputSystem> &input_system,
+                        InputIterator first,
+                        InputIterator last)
+        : super_t(alloc_type(temporary_allocator<T,System>(system)))
+{
+  super_t::allocate(thrust::distance(first,last));
+
+  super_t::uninitialized_copy(input_system, first, last, super_t::begin());
+} // end temporary_array::temporary_array()
+
+
+template<typename T, typename System>
+__host__ __device__
+  temporary_array<T,System>
+    ::~temporary_array()
+{
+  // note that super_t::destroy will ignore trivial destructors automatically
+  super_t::destroy(super_t::begin(), super_t::end());
+} // end temporary_array::~temporary_array()
+
+} // end detail
+
+THRUST_NAMESPACE_END
+

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

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