Add files using upload-large-folder tool

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

@@ -0,0 +1,250 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/iterator/constant_iterator.h
+ *  \brief An iterator which returns a constant value when
+ *         dereferenced
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/iterator/detail/constant_iterator_base.h>
+#include <thrust/iterator/iterator_facade.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p constant_iterator is an iterator which represents a pointer into a range
+ *  of constant values. This iterator is useful for creating a range filled with the same
+ *  value without explicitly storing it in memory. Using \p constant_iterator saves both
+ *  memory capacity and bandwidth.
+ *
+ *  The following code snippet demonstrates how to create a \p constant_iterator whose
+ *  \c value_type is \c int and whose value is \c 10.
+ *
+ *  \code
+ *  #include <thrust/iterator/constant_iterator.h>
+ *
+ *  thrust::constant_iterator<int> iter(10);
+ *
+ *  *iter;    // returns 10
+ *  iter[0];  // returns 10
+ *  iter[1];  // returns 10
+ *  iter[13]; // returns 10
+ *
+ *  // and so on...
+ *  \endcode
+ *
+ *  This next example demonstrates how to use a \p constant_iterator with the
+ *  \p thrust::transform function to increment all elements of a sequence by the
+ *  same value. We will create a temporary \p constant_iterator with the function
+ *  \p make_constant_iterator function in order to avoid explicitly specifying
+ *  its type:
+ *
+ *  \code
+ *  #include <thrust/iterator/constant_iterator.h>
+ *  #include <thrust/transform.h>
+ *  #include <thrust/functional.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  int main()
+ *  {
+ *    thrust::device_vector<int> data(4);
+ *    data[0] = 3;
+ *    data[1] = 7;
+ *    data[2] = 2;
+ *    data[3] = 5;
+ *    
+ *    // add 10 to all values in data
+ *    thrust::transform(data.begin(), data.end(),
+ *                      thrust::make_constant_iterator(10),
+ *                      data.begin(),
+ *                      thrust::plus<int>());
+ *    
+ *    // data is now [13, 17, 12, 15]
+ *    
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  \see make_constant_iterator
+ */
+template<typename Value,
+         typename Incrementable = use_default,
+         typename System = use_default>
+  class constant_iterator
+    : public detail::constant_iterator_base<Value, Incrementable, System>::type
+{
+    /*! \cond
+     */
+    friend class thrust::iterator_core_access;
+    typedef typename detail::constant_iterator_base<Value, Incrementable, System>::type          super_t;
+    typedef typename detail::constant_iterator_base<Value, Incrementable, System>::incrementable incrementable;
+    typedef typename detail::constant_iterator_base<Value, Incrementable, System>::base_iterator base_iterator;
+
+  public:
+    typedef typename super_t::reference  reference;
+    typedef typename super_t::value_type value_type;
+
+    /*! \endcond
+     */
+
+    /*! Null constructor initializes this \p constant_iterator's constant using its
+     *  null constructor.
+     */
+    __host__ __device__
+    constant_iterator()
+      : super_t(), m_value() {}
+
+    /*! Copy constructor copies the value of another \p constant_iterator into this
+     *  \p constant_iterator.
+     *
+     *  \p rhs The constant_iterator to copy.
+     */
+    __host__ __device__
+    constant_iterator(constant_iterator const &rhs)
+      : super_t(rhs.base()), m_value(rhs.m_value) {}
+
+    /*! Copy constructor copies the value of another \p constant_iterator with related
+     *  System type.
+     *
+     *  \param rhs The \p constant_iterator to copy.
+     */
+    template<typename OtherSystem>
+    __host__ __device__
+    constant_iterator(constant_iterator<Value,Incrementable,OtherSystem> const &rhs,
+                      typename thrust::detail::enable_if_convertible<
+                        typename thrust::iterator_system<constant_iterator<Value,Incrementable,OtherSystem> >::type,
+                        typename thrust::iterator_system<super_t>::type
+                      >::type * = 0)
+      : super_t(rhs.base()), m_value(rhs.value()) {}
+
+    /*! This constructor receives a value to use as the constant value of this
+     *  \p constant_iterator and an index specifying the location of this
+     *  \p constant_iterator in a sequence.
+     *  
+     *  \p v The value of this \p constant_iterator's constant value.
+     *  \p i The index of this \p constant_iterator in a sequence. Defaults to the
+     *       value returned by \c Incrementable's null constructor. For example,
+     *       when <tt>Incrementable == int</tt>, \c 0.
+     */
+    __host__ __device__
+    constant_iterator(value_type const& v, incrementable const &i = incrementable())
+      : super_t(base_iterator(i)), m_value(v) {}
+
+    /*! This constructor is templated to allow construction from a value type and
+     *  incrementable type related this this \p constant_iterator's respective types.
+     *
+     *  \p v The value of this \p constant_iterator's constant value.
+     *  \p i The index of this \p constant_iterator in a sequence. Defaults to the
+     *       value returned by \c Incrementable's null constructor. For example,
+     *       when <tt>Incrementable == int</tt>, \c 0.
+     */
+    template<typename OtherValue, typename OtherIncrementable>
+    __host__ __device__
+    constant_iterator(OtherValue const& v, OtherIncrementable const& i = incrementable())
+      : super_t(base_iterator(i)), m_value(v) {}
+
+    /*! This method returns the value of this \p constant_iterator's constant value.
+     *  \return A \c const reference to this \p constant_iterator's constant value.
+     */
+    __host__ __device__
+    Value const& value() const
+    { return m_value; }
+
+    /*! \cond
+     */
+
+  protected:
+    __host__ __device__
+    Value const& value_reference() const
+    { return m_value; }
+
+    __host__ __device__
+    Value & value_reference()
+    { return m_value; }
+  
+  private: // Core iterator interface
+    __host__ __device__
+    reference dereference() const
+    {
+      return m_value;
+    }
+
+  private:
+    Value m_value;
+
+    /*! \endcond
+     */
+}; // end constant_iterator
+
+
+/*! This version of \p make_constant_iterator creates a \p constant_iterator
+ *  from values given for both value and index. The type of \p constant_iterator
+ *  may be inferred by the compiler from the types of its parameters.
+ *
+ *  \param x The value of the returned \p constant_iterator's constant value.
+ *  \param i The index of the returned \p constant_iterator within a sequence.
+ *           The type of this parameter defaults to \c int. In the default case,
+ *           the value of this parameter is \c 0.
+ *
+ *  \return A new \p constant_iterator with constant value & index as given
+ *          by \p x & \p i.
+ *
+ *  \see constant_iterator
+ */
+template<typename ValueT, typename IndexT>
+inline __host__ __device__
+constant_iterator<ValueT, IndexT> make_constant_iterator(ValueT x, IndexT i = int())
+{
+  return constant_iterator<ValueT, IndexT>(x, i);
+} // end make_constant_iterator()
+
+
+/*! This version of \p make_constant_iterator creates a \p constant_iterator
+ *  using only a parameter for the desired constant value. The value of the
+ *  returned \p constant_iterator's index is set to \c 0.
+ *
+ *  \param x The value of the returned \p constant_iterator's constant value.
+ *  \return A new \p constant_iterator with constant value equal to \p x and
+ *          index equal to \c 0.
+ *  \see constant_iterator
+ */
+template<typename V>
+inline __host__ __device__
+constant_iterator<V> make_constant_iterator(V x)
+{
+  return constant_iterator<V>(x, 0);
+} // end make_constant_iterator()
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+

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

@@ -0,0 +1,30 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+// #include the device system's execution_policy header
+#define __THRUST_DEVICE_SYSTEM_TAG_HEADER <__THRUST_DEVICE_SYSTEM_ROOT/detail/execution_policy.h>
+#include __THRUST_DEVICE_SYSTEM_TAG_HEADER
+#undef __THRUST_DEVICE_SYSTEM_TAG_HEADER
+
+THRUST_NAMESPACE_BEGIN
+
+typedef thrust::system::__THRUST_DEVICE_SYSTEM_NAMESPACE::tag device_system_tag;
+
+THRUST_NAMESPACE_END

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

@@ -0,0 +1,130 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/iterator/iterator_categories.h>
+#include <thrust/iterator/detail/iterator_traversal_tags.h>
+#include <thrust/iterator/detail/iterator_category_to_system.h>
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+namespace detail
+{
+
+// forward declarations
+template <typename> struct is_iterator_system;
+template <typename> struct is_iterator_traversal;
+
+template <typename Category>
+  struct host_system_category_to_traversal
+    : eval_if<
+        is_convertible<Category, random_access_host_iterator_tag>::value,
+        detail::identity_<random_access_traversal_tag>,
+        eval_if<
+          is_convertible<Category, bidirectional_host_iterator_tag>::value,
+          detail::identity_<bidirectional_traversal_tag>,
+          eval_if<
+            is_convertible<Category, forward_host_iterator_tag>::value,
+            detail::identity_<forward_traversal_tag>,
+            eval_if<
+              is_convertible<Category, input_host_iterator_tag>::value,
+              detail::identity_<single_pass_traversal_tag>,
+              eval_if<
+                is_convertible<Category, output_host_iterator_tag>::value,
+                detail::identity_<incrementable_traversal_tag>,
+                detail::identity_<void>
+              >
+            >
+          >
+        >
+      >
+{
+}; // end host_system_category_to_traversal
+
+
+
+template <typename Category>
+  struct device_system_category_to_traversal
+    : eval_if<
+        is_convertible<Category, random_access_device_iterator_tag>::value,
+        detail::identity_<random_access_traversal_tag>,
+        eval_if<
+          is_convertible<Category, bidirectional_device_iterator_tag>::value,
+          detail::identity_<bidirectional_traversal_tag>,
+          eval_if<
+            is_convertible<Category, forward_device_iterator_tag>::value,
+            detail::identity_<forward_traversal_tag>,
+            eval_if<
+              is_convertible<Category, input_device_iterator_tag>::value,
+              detail::identity_<single_pass_traversal_tag>,
+              eval_if<
+                is_convertible<Category, output_device_iterator_tag>::value,
+                detail::identity_<incrementable_traversal_tag>,
+                detail::identity_<void>
+              >
+            >
+          >
+        >
+      >
+{
+}; // end device_system_category_to_traversal
+
+
+template<typename Category>
+  struct category_to_traversal
+      // check for host system
+    : eval_if<
+        or_<
+          is_convertible<Category, thrust::input_host_iterator_tag>,
+          is_convertible<Category, thrust::output_host_iterator_tag>
+        >::value,
+
+        host_system_category_to_traversal<Category>,
+
+        // check for device system
+        eval_if<
+          or_<
+            is_convertible<Category, thrust::input_device_iterator_tag>,
+            is_convertible<Category, thrust::output_device_iterator_tag>
+          >::value,
+
+          device_system_category_to_traversal<Category>,
+
+          // unknown category
+          detail::identity_<void>
+        >
+      >
+{};
+
+
+template <typename CategoryOrTraversal>
+  struct iterator_category_to_traversal
+    : eval_if<
+        is_iterator_traversal<CategoryOrTraversal>::value,
+        detail::identity_<CategoryOrTraversal>,
+        category_to_traversal<CategoryOrTraversal>
+      >
+{
+}; // end iterator_category_to_traversal
+
+
+} // end detail
+
+THRUST_NAMESPACE_END
+

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

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

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

@@ -0,0 +1,54 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/iterator/iterator_adaptor.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/iterator/detail/minimum_system.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template<typename,typename> class permutation_iterator;
+
+
+namespace detail
+{
+
+template<typename ElementIterator,
+         typename IndexIterator>
+  struct permutation_iterator_base
+{
+  typedef typename thrust::iterator_system<ElementIterator>::type System1;
+  typedef typename thrust::iterator_system<IndexIterator>::type System2;
+
+  typedef thrust::iterator_adaptor<
+    permutation_iterator<ElementIterator,IndexIterator>,
+    IndexIterator,
+    typename thrust::iterator_value<ElementIterator>::type,
+    typename detail::minimum_system<System1,System2>::type,
+    thrust::use_default,
+    typename thrust::iterator_reference<ElementIterator>::type
+  > type;
+}; // end permutation_iterator_base
+
+} // end detail
+
+THRUST_NAMESPACE_END
+

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

@@ -0,0 +1,147 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/iterator/detail/tagged_iterator.h>
+#include <thrust/detail/pointer.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace detail
+{
+
+
+// we can retag an iterator if FromTag converts to ToTag
+// or vice versa
+template<typename FromTag, typename ToTag>
+  struct is_retaggable
+    : integral_constant<
+        bool,
+        (is_convertible<FromTag,ToTag>::value || is_convertible<ToTag,FromTag>::value)
+      >
+{};
+
+
+template<typename FromTag, typename ToTag, typename Result>
+  struct enable_if_retaggable
+    : enable_if<
+        is_retaggable<FromTag,ToTag>::value,
+        Result
+      >
+{}; // end enable_if_retaggable
+
+
+} // end detail
+
+
+template<typename Tag, typename Iterator>
+__host__ __device__
+  thrust::detail::tagged_iterator<Iterator,Tag>
+    reinterpret_tag(Iterator iter)
+{
+  return thrust::detail::tagged_iterator<Iterator,Tag>(iter);
+} // end reinterpret_tag()
+
+
+// specialization for raw pointer
+template<typename Tag, typename T>
+__host__ __device__
+  thrust::pointer<T,Tag>
+    reinterpret_tag(T *ptr)
+{
+  return thrust::pointer<T,Tag>(ptr);
+} // end reinterpret_tag()
+
+
+// specialization for thrust::pointer
+template<typename Tag, typename T, typename OtherTag, typename Reference, typename Derived>
+__host__ __device__
+  thrust::pointer<T,Tag>
+    reinterpret_tag(thrust::pointer<T,OtherTag,Reference,Derived> ptr)
+{
+  return reinterpret_tag<Tag>(ptr.get());
+} // end reinterpret_tag()
+
+
+// avoid deeply-nested tagged_iterator
+template<typename Tag, typename BaseIterator, typename OtherTag>
+__host__ __device__
+  thrust::detail::tagged_iterator<BaseIterator,Tag>
+    reinterpret_tag(thrust::detail::tagged_iterator<BaseIterator,OtherTag> iter)
+{
+  return reinterpret_tag<Tag>(iter.base());
+} // end reinterpret_tag()
+
+
+template<typename Tag, typename Iterator>
+__host__ __device__
+  typename thrust::detail::enable_if_retaggable<
+    typename thrust::iterator_system<Iterator>::type,
+    Tag,
+    thrust::detail::tagged_iterator<Iterator,Tag>
+  >::type
+    retag(Iterator iter)
+{
+  return reinterpret_tag<Tag>(iter);
+} // end retag()
+
+
+// specialization for raw pointer
+template<typename Tag, typename T>
+__host__ __device__
+  typename thrust::detail::enable_if_retaggable<
+    typename thrust::iterator_system<T*>::type,
+    Tag,
+    thrust::pointer<T,Tag>
+  >::type
+    retag(T *ptr)
+{
+  return reinterpret_tag<Tag>(ptr);
+} // end retag()
+
+
+// specialization for thrust::pointer
+template<typename Tag, typename T, typename OtherTag>
+__host__ __device__
+  typename thrust::detail::enable_if_retaggable<
+    OtherTag,
+    Tag,
+    thrust::pointer<T,Tag>
+  >::type
+    retag(thrust::pointer<T,OtherTag> ptr)
+{
+  return reinterpret_tag<Tag>(ptr);
+} // end retag()
+
+
+// avoid deeply-nested tagged_iterator
+template<typename Tag, typename BaseIterator, typename OtherTag>
+__host__ __device__
+  typename thrust::detail::enable_if_retaggable<
+    OtherTag,
+    Tag,
+    thrust::detail::tagged_iterator<BaseIterator,Tag>
+  >::type
+    retag(thrust::detail::tagged_iterator<BaseIterator,OtherTag> iter)
+{
+  return reinterpret_tag<Tag>(iter);
+} // end retag()
+
+
+THRUST_NAMESPACE_END
+

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

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

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

@@ -0,0 +1,69 @@
+/*
+ *  Copyright 2008-2021 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/type_traits/result_of_adaptable_function.h>
+#include <thrust/iterator/iterator_adaptor.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/iterator/transform_iterator.h>
+#include <thrust/type_traits/remove_cvref.h>
+
+THRUST_NAMESPACE_BEGIN
+
+template <class UnaryFunction, class Iterator, class Reference, class Value>
+  class transform_iterator;
+
+namespace detail
+{
+
+// Compute the iterator_adaptor instantiation to be used for transform_iterator
+template <class UnaryFunc, class Iterator, class Reference, class Value>
+struct transform_iterator_base
+{
+ private:
+    // By default, dereferencing the iterator yields the same as the function.
+    typedef typename thrust::detail::ia_dflt_help<
+      Reference,
+      thrust::detail::result_of_adaptable_function<UnaryFunc(typename thrust::iterator_value<Iterator>::type)>
+    >::type reference;
+
+    // To get the default for Value: remove cvref on the result type.
+    using value_type =
+      typename thrust::detail::ia_dflt_help<Value, thrust::remove_cvref<reference>>::type;
+
+  public:
+    typedef thrust::iterator_adaptor
+    <
+        transform_iterator<UnaryFunc, Iterator, Reference, Value>
+      , Iterator
+      , value_type
+      , thrust::use_default   // Leave the system alone
+        //, thrust::use_default   // Leave the traversal alone
+        // use the Iterator's category to let any system iterators remain random access even though
+        // transform_iterator's reference type may not be a reference
+        // XXX figure out why only iterators whose reference types are true references are random access
+        , typename thrust::iterator_traits<Iterator>::iterator_category
+      , reference
+    > type;
+};
+
+
+} // end detail
+THRUST_NAMESPACE_END
+

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

@@ -0,0 +1,353 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#include <thrust/advance.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/iterator/iterator_facade.h>
+#include <thrust/iterator/iterator_categories.h>
+#include <thrust/iterator/detail/minimum_category.h>
+#include <thrust/iterator/detail/minimum_system.h>
+#include <thrust/type_traits/integer_sequence.h>
+#include <thrust/tuple.h>
+#include <thrust/detail/tuple_meta_transform.h>
+#include <thrust/detail/tuple_transform.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/iterator/detail/tuple_of_iterator_references.h>
+
+THRUST_NAMESPACE_BEGIN
+
+// forward declare zip_iterator for zip_iterator_base
+template<typename IteratorTuple> class zip_iterator;
+
+namespace detail
+{
+
+
+// Functors to be used with tuple algorithms
+//
+template<typename DiffType>
+class advance_iterator
+{
+public:
+  inline __host__ __device__
+  advance_iterator(DiffType step) : m_step(step) {}
+
+  __thrust_exec_check_disable__
+  template<typename Iterator>
+  inline __host__ __device__
+  void operator()(Iterator& it) const
+  { thrust::advance(it, m_step); }
+
+private:
+  DiffType m_step;
+}; // end advance_iterator
+
+
+struct increment_iterator
+{
+  __thrust_exec_check_disable__
+  template<typename Iterator>
+  inline __host__ __device__
+  void operator()(Iterator& it)
+  { ++it; }
+}; // end increment_iterator
+
+
+struct decrement_iterator
+{
+  __thrust_exec_check_disable__
+  template<typename Iterator>
+  inline __host__ __device__
+  void operator()(Iterator& it)
+  { --it; }
+}; // end decrement_iterator
+
+
+struct dereference_iterator
+{
+  template<typename Iterator>
+  struct apply
+  { 
+    typedef typename
+      iterator_traits<Iterator>::reference
+    type;
+  }; // end apply
+
+  // XXX silence warnings of the form "calling a __host__ function from a __host__ __device__ function is not allowed
+  __thrust_exec_check_disable__
+  template<typename Iterator>
+  __host__ __device__
+    typename apply<Iterator>::type operator()(Iterator const& it)
+  {
+    return *it;
+  }
+}; // end dereference_iterator
+
+
+// The namespace tuple_impl_specific provides two meta-
+// algorithms and two algorithms for tuples.
+namespace tuple_impl_specific
+{
+
+// define apply1 for tuple_meta_transform_impl
+template<typename UnaryMetaFunctionClass, class Arg>
+  struct apply1
+    : UnaryMetaFunctionClass::template apply<Arg>
+{
+}; // end apply1
+
+
+// define apply2 for tuple_meta_accumulate_impl
+template<typename UnaryMetaFunctionClass, class Arg1, class Arg2>
+  struct apply2
+    : UnaryMetaFunctionClass::template apply<Arg1,Arg2>
+{
+}; // end apply2
+
+
+// Meta-accumulate algorithm for tuples. Note: The template 
+// parameter StartType corresponds to the initial value in 
+// ordinary accumulation.
+//
+template<class Tuple, class BinaryMetaFun, class StartType>
+  struct tuple_meta_accumulate;
+
+template<
+    class BinaryMetaFun
+  , typename StartType
+>
+  struct tuple_meta_accumulate<thrust::tuple<>,BinaryMetaFun,StartType>
+{
+   typedef typename thrust::detail::identity_<StartType>::type type;
+};
+
+
+template<
+    class BinaryMetaFun
+  , typename StartType
+  , typename    T
+  , typename... Ts
+>
+  struct tuple_meta_accumulate<thrust::tuple<T,Ts...>,BinaryMetaFun,StartType>
+{
+   typedef typename apply2<
+       BinaryMetaFun
+     , T
+     , typename tuple_meta_accumulate<
+           thrust::tuple<Ts...>
+         , BinaryMetaFun
+         , StartType 
+       >::type
+   >::type type;
+};
+
+
+template<typename Fun>
+inline __host__ __device__
+Fun tuple_for_each_helper(Fun f)
+{
+  return f;
+}
+
+template<typename Fun, typename T, typename... Ts>
+inline __host__ __device__
+Fun tuple_for_each_helper(Fun f, T& t, Ts&... ts)
+{
+  f(t);
+  return tuple_for_each_helper(f, ts...);
+}
+
+// for_each algorithm for tuples.
+
+template<typename Fun, typename... Ts, size_t... Is>
+inline __host__ __device__
+Fun tuple_for_each(thrust::tuple<Ts...>& t, Fun f, thrust::index_sequence<Is...>)
+{
+  return tuple_for_each_helper(f, thrust::get<Is>(t)...);
+} // end tuple_for_each()
+
+// for_each algorithm for tuples.
+template<typename Fun, typename... Ts>
+inline __host__ __device__
+Fun tuple_for_each(thrust::tuple<Ts...>& t, Fun f)
+{ 
+  return tuple_for_each(t, f, thrust::make_index_sequence<thrust::tuple_size<thrust::tuple<Ts...>>::value>{});
+}
+
+
+} // end tuple_impl_specific
+
+
+// Metafunction to obtain the type of the tuple whose element types
+// are the value_types of an iterator tupel.
+//
+template<typename IteratorTuple>
+  struct tuple_of_value_types
+    : tuple_meta_transform<
+          IteratorTuple,
+          iterator_value
+        >
+{
+}; // end tuple_of_value_types
+
+
+struct minimum_category_lambda
+{
+  template<typename T1, typename T2>
+    struct apply : minimum_category<T1,T2>
+  {};
+};
+
+
+
+// Metafunction to obtain the minimal traversal tag in a tuple
+// of iterators.
+//
+template<typename IteratorTuple>
+struct minimum_traversal_category_in_iterator_tuple
+{
+  typedef typename tuple_meta_transform<
+      IteratorTuple
+    , thrust::iterator_traversal
+  >::type tuple_of_traversal_tags;
+      
+  typedef typename tuple_impl_specific::tuple_meta_accumulate<
+      tuple_of_traversal_tags
+    , minimum_category_lambda
+    , thrust::random_access_traversal_tag
+  >::type type;
+};
+
+
+struct minimum_system_lambda
+{
+  template<typename T1, typename T2>
+    struct apply : minimum_system<T1,T2>
+  {};
+};
+
+
+
+// Metafunction to obtain the minimal system tag in a tuple
+// of iterators.
+template<typename IteratorTuple>
+struct minimum_system_in_iterator_tuple
+{
+  typedef typename thrust::detail::tuple_meta_transform<
+    IteratorTuple,
+    thrust::iterator_system
+  >::type tuple_of_system_tags;
+
+  typedef typename tuple_impl_specific::tuple_meta_accumulate<
+    tuple_of_system_tags,
+    minimum_system_lambda,
+    thrust::any_system_tag
+  >::type type;
+};
+
+namespace zip_iterator_base_ns
+{
+
+
+template<typename Tuple, typename IndexSequence>
+  struct tuple_of_iterator_references_helper;
+
+
+template<typename Tuple, size_t... Is>
+  struct tuple_of_iterator_references_helper<Tuple, thrust::index_sequence<Is...>>
+{
+  typedef thrust::detail::tuple_of_iterator_references<
+    typename thrust::tuple_element<Is,Tuple>::type...
+  > type;
+};
+
+
+template<typename IteratorTuple>
+  struct tuple_of_iterator_references
+{
+  // get a thrust::tuple of the iterators' references
+  typedef typename tuple_meta_transform<
+    IteratorTuple,
+    iterator_reference
+  >::type tuple_of_references;
+
+  // map thrust::tuple<T...> to tuple_of_iterator_references<T...>
+  typedef typename tuple_of_iterator_references_helper<
+    tuple_of_references,
+    thrust::make_index_sequence<thrust::tuple_size<tuple_of_references>::value>
+  >::type type;
+};
+
+
+} // end zip_iterator_base_ns
+
+///////////////////////////////////////////////////////////////////
+//
+// Class zip_iterator_base
+//
+// Builds and exposes the iterator facade type from which the zip 
+// iterator will be derived.
+//
+template<typename IteratorTuple>
+  struct zip_iterator_base
+{
+ //private:
+    // reference type is the type of the tuple obtained from the
+    // iterators' reference types.
+    typedef typename zip_iterator_base_ns::tuple_of_iterator_references<IteratorTuple>::type reference;
+
+    // Boost's Value type is the same as reference type.
+    //typedef reference value_type;
+    typedef typename tuple_of_value_types<IteratorTuple>::type value_type;
+
+    // Difference type is the first iterator's difference type
+    typedef typename thrust::iterator_traits<
+      typename thrust::tuple_element<0, IteratorTuple>::type
+    >::difference_type difference_type;
+
+    // Iterator system is the minimum system tag in the
+    // iterator tuple
+    typedef typename
+    minimum_system_in_iterator_tuple<IteratorTuple>::type system;
+
+    // Traversal category is the minimum traversal category in the
+    // iterator tuple
+    typedef typename
+    minimum_traversal_category_in_iterator_tuple<IteratorTuple>::type traversal_category;
+  
+ public:
+  
+    // The iterator facade type from which the zip iterator will
+    // be derived.
+    typedef thrust::iterator_facade<
+        zip_iterator<IteratorTuple>,
+        value_type,  
+        system,
+        traversal_category,
+        reference,
+        difference_type
+    > type;
+}; // end zip_iterator_base
+
+} // end detail
+
+THRUST_NAMESPACE_END
+
+

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

@@ -0,0 +1,542 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/iterator/iterator_facade.h
+ *  \brief A class which exposes a public interface for iterators
+ */
+
+/*
+ * (C) Copyright David Abrahams 2002.
+ * (C) Copyright Jeremy Siek    2002.
+ * (C) Copyright Thomas Witt    2002.
+ * 
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/iterator/detail/iterator_facade_category.h>
+#include <thrust/iterator/detail/distance_from_result.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+
+// This forward declaration is required for the friend declaration
+// in iterator_core_access
+template<typename Derived, typename Value, typename System, typename Traversal, typename Reference, typename Difference> class iterator_facade;
+
+
+/*! \p iterator_core_access is the class which user iterator types derived from \p thrust::iterator_adaptor
+ *  or \p thrust::iterator_facade must befriend to allow it to access their private interface.
+ */
+class iterator_core_access
+{
+    /*! \cond
+     */
+
+    // declare our friends
+    template<typename Derived, typename Value, typename System, typename Traversal, typename Reference, typename Difference> friend class iterator_facade;
+
+    // iterator comparisons are our friends
+    template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+              typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+    inline __host__ __device__
+    friend bool
+    operator ==(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+                iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs);
+
+    template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+              typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+    inline __host__ __device__
+    friend bool
+    operator !=(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+                iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs);
+
+    template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+              typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+    inline __host__ __device__
+    friend bool
+    operator <(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+               iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs);
+
+    template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+              typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+    inline __host__ __device__
+    friend bool
+    operator >(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+               iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs);
+
+    template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+              typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+    inline __host__ __device__
+    friend bool
+    operator <=(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+                iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs);
+
+    template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+              typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+    inline __host__ __device__
+    friend bool
+    operator >=(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+                iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs);
+
+    // iterator difference is our friend
+    template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+              typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+    inline __host__ __device__
+    friend
+      typename thrust::detail::distance_from_result<
+        iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1>,
+        iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2>
+      >::type
+    operator-(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+              iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs);
+
+    template<typename Facade>
+    __host__ __device__
+    static typename Facade::reference dereference(Facade const& f)
+    {
+      return f.dereference();
+    }
+
+    template<typename Facade>
+    __host__ __device__
+    static void increment(Facade& f)
+    {
+      f.increment();
+    }
+
+    template<typename Facade>
+    __host__ __device__
+    static void decrement(Facade& f)
+    {
+      f.decrement();
+    }
+
+    template <class Facade1, class Facade2>
+    __host__ __device__
+    static bool equal(Facade1 const& f1, Facade2 const& f2)
+    {
+      return f1.equal(f2);
+    }
+
+    // XXX TODO: Investigate whether we need both of these cases
+    //template <class Facade1, class Facade2>
+    //__host__ __device__
+    //static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::true_)
+    //{
+    //  return f1.equal(f2);
+    //}
+
+    //template <class Facade1, class Facade2>
+    //__host__ __device__
+    //static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::false_)
+    //{
+    //  return f2.equal(f1);
+    //}
+
+    template <class Facade>
+    __host__ __device__
+    static void advance(Facade& f, typename Facade::difference_type n)
+    {
+      f.advance(n);
+    }
+
+    // Facade2 is convertible to Facade1,
+    // so return Facade1's difference_type
+    template <class Facade1, class Facade2>
+    __host__ __device__
+    static typename Facade1::difference_type
+      distance_from(Facade1 const& f1, Facade2 const& f2, thrust::detail::true_type)
+    {
+      return -f1.distance_to(f2);
+    }
+
+    // Facade2 is not convertible to Facade1,
+    // so return Facade2's difference_type
+    template <class Facade1, class Facade2>
+    __host__ __device__
+    static typename Facade2::difference_type
+      distance_from(Facade1 const& f1, Facade2 const& f2, thrust::detail::false_type)
+    {
+      return f2.distance_to(f1);
+    }
+    
+    template <class Facade1, class Facade2>
+    __host__ __device__
+    static typename thrust::detail::distance_from_result<Facade1,Facade2>::type
+      distance_from(Facade1 const& f1, Facade2 const& f2)
+    {
+      // dispatch the implementation of this method upon whether or not
+      // Facade2 is convertible to Facade1
+      return distance_from(f1, f2,
+        typename thrust::detail::is_convertible<Facade2,Facade1>::type());
+    }
+
+    //
+    // Curiously Recurring Template interface.
+    //
+    template <typename Derived, typename Value, typename System, typename Traversal, typename Reference, typename Difference>
+    __host__ __device__
+    static Derived& derived(iterator_facade<Derived,Value,System,Traversal,Reference,Difference>& facade)
+    {
+      return *static_cast<Derived*>(&facade);
+    }
+
+    template <typename Derived, typename Value, typename System, typename Traversal, typename Reference, typename Difference>
+    __host__ __device__
+    static Derived const& derived(iterator_facade<Derived,Value,System,Traversal,Reference,Difference> const& facade)
+    {
+      return *static_cast<Derived const*>(&facade);
+    }
+
+    /*! \endcond
+     */
+}; // end iterator_core_access
+
+
+/*! \p iterator_facade is a template which allows the programmer to define a novel iterator with a standards-conforming interface
+ *  which Thrust can use to reason about algorithm acceleration opportunities.
+ *
+ *  Because most of a standard iterator's interface is defined in terms of a small set of core primitives, \p iterator_facade
+ *  defines the non-primitive portion mechanically. In principle a novel iterator could explicitly provide the entire interface in
+ *  an ad hoc fashion but doing so might be tedious and prone to subtle errors.
+ *
+ *  Often \p iterator_facade is too primitive a tool to use for defining novel iterators. In these cases, \p iterator_adaptor
+ *  or a specific fancy iterator should be used instead.
+ *
+ *  \p iterator_facade's functionality is derived from and generally equivalent to \p boost::iterator_facade.
+ *  The exception is Thrust's addition of the template parameter \p System, which is necessary to allow Thrust
+ *  to dispatch an algorithm to one of several parallel backend systems. An additional exception is Thrust's omission
+ *  of the \c operator-> member function.
+ *
+ *  Interested users may refer to <tt>boost::iterator_facade</tt>'s documentation for usage examples.
+ *
+ *  \note \p iterator_facade's arithmetic operator free functions exist with the usual meanings but are omitted here for brevity.
+ */
+template<typename Derived,
+         typename Value,
+         typename System,
+         typename Traversal,
+         typename Reference,
+         typename Difference = std::ptrdiff_t>
+  class iterator_facade
+{
+  private:
+    /*! \cond
+     */
+
+    //
+    // Curiously Recurring Template interface.
+    //
+    __host__ __device__
+    Derived& derived()
+    {
+      return *static_cast<Derived*>(this);
+    }
+
+    __host__ __device__
+    Derived const& derived() const
+    {
+      return *static_cast<Derived const*>(this);
+    }
+    /*! \endcond
+     */
+
+  public:
+    /*! The type of element pointed to by \p iterator_facade.
+     */
+    typedef typename thrust::detail::remove_const<Value>::type value_type;
+
+    /*! The return type of \p iterator_facade::operator*().
+     */
+    typedef Reference                                          reference;
+
+    /*! The return type of \p iterator_facade's non-existent \c operator->()
+     *  member function. Unlike \c boost::iterator_facade, \p iterator_facade
+     *  disallows access to the \p value_type's members through expressions of the
+     *  form <tt>iter->member</tt>. \p pointer is defined to \c void to indicate
+     *  that these expressions are not allowed. This limitation may be relaxed in a
+     *  future version of Thrust.
+     */
+    typedef void                                               pointer;
+
+    /*! The type of expressions of the form <tt>x - y</tt> where <tt>x</tt> and <tt>y</tt>
+     *  are of type \p iterator_facade.
+     */
+    typedef Difference                                         difference_type;
+
+    /*! The type of iterator category of \p iterator_facade.
+     */
+    typedef typename thrust::detail::iterator_facade_category<
+      System, Traversal, Value, Reference
+    >::type                                                    iterator_category;
+
+    /*! \p operator*() dereferences this \p iterator_facade.
+     *  \return A reference to the element pointed to by this \p iterator_facade.
+     */
+    __host__ __device__
+    reference operator*() const
+    {
+      return iterator_core_access::dereference(this->derived());
+    }
+
+    // XXX unimplemented for now, consider implementing it later
+    //pointer operator->() const
+    //{
+    //  return;
+    //}
+
+    // XXX investigate whether or not we need to go to the lengths
+    //     boost does to determine the return type
+
+    /*! \p operator[] performs indexed dereference.
+     *  \return A reference to the element \p n distance away from this \p iterator_facade.
+     */
+    __host__ __device__
+    reference operator[](difference_type n) const
+    {
+      return *(this->derived() + n);
+    }
+
+    /*! \p operator++ pre-increments this \p iterator_facade to refer to the element in the next position.
+     *  \return <tt>*this</tt>
+     */
+    __host__ __device__
+    Derived& operator++()
+    {
+      iterator_core_access::increment(this->derived());
+      return this->derived();
+    }
+
+    /*! \p operator++ post-increments this \p iterator_facade and returns a new \p iterator_facade referring to the element in the next position.
+     *  \return A copy of <tt>*this</tt> before increment.
+     */
+    __host__ __device__
+    Derived  operator++(int)
+    {
+      Derived tmp(this->derived());
+      ++*this;
+      return tmp;
+    }
+
+    /*! \p operator-- pre-decrements this \p iterator_facade to refer to the element in the previous position.
+     *  \return <tt>*this</tt>
+     */
+    __host__ __device__
+    Derived& operator--()
+    {
+      iterator_core_access::decrement(this->derived());
+      return this->derived();
+    }
+
+    /*! \p operator-- post-decrements this \p iterator_facade and returns a new \p iterator_facade referring to the element in the previous position.
+     *  \return A copy of <tt>*this</tt> before decrement.
+     */
+    __host__ __device__
+    Derived  operator--(int)
+    {
+      Derived tmp(this->derived());
+      --*this;
+      return tmp;
+    }
+
+    /*! \p operator+= increments this \p iterator_facade to refer to an element a given distance after its current position.
+     *  \param n The quantity to increment.
+     *  \return <tt>*this</tt>
+     */
+    __host__ __device__
+    Derived& operator+=(difference_type n)
+    {
+      iterator_core_access::advance(this->derived(), n);
+      return this->derived();
+    }
+
+    /*! \p operator-= decrements this \p iterator_facade to refer to an element a given distance before its current postition.
+     *  \param n The quantity to decrement.
+     *  \return <tt>*this</tt>
+     */
+    __host__ __device__
+    Derived& operator-=(difference_type n)
+    {
+      iterator_core_access::advance(this->derived(), -n);
+      return this->derived();
+    }
+
+    /*! \p operator- subtracts a given quantity from this \p iterator_facade and returns a new \p iterator_facade referring to the element at the given position before this \p iterator_facade.
+     *  \param n The quantity to decrement
+     *  \return An \p iterator_facade pointing \p n elements before this \p iterator_facade.
+     */
+    __host__ __device__
+    Derived  operator-(difference_type n) const
+    {
+      Derived result(this->derived());
+      return result -= n;
+    }
+}; // end iterator_facade
+
+/*! \cond
+ */
+
+// Comparison operators
+template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+          typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+inline __host__ __device__
+// XXX it might be nice to implement this at some point
+//typename enable_if_interoperable<Dr1,Dr2,bool>::type // exposition
+bool
+operator ==(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+            iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs)
+{
+  return iterator_core_access
+    ::equal(*static_cast<Derived1 const*>(&lhs),
+            *static_cast<Derived2 const*>(&rhs));
+}
+
+template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+          typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+inline __host__ __device__
+// XXX it might be nice to implement this at some point
+//typename enable_if_interoperable<Dr1,Dr2,bool>::type // exposition
+bool
+operator !=(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+            iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs)
+{
+  return !iterator_core_access
+    ::equal(*static_cast<Derived1 const*>(&lhs),
+            *static_cast<Derived2 const*>(&rhs));
+}
+
+template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+          typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+inline __host__ __device__
+// XXX it might be nice to implement this at some point
+//typename enable_if_interoperable<Dr1,Dr2,bool>::type // exposition
+bool
+operator <(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+           iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs)
+{
+  return 0 > iterator_core_access
+    ::distance_from(*static_cast<Derived1 const*>(&lhs),
+                    *static_cast<Derived2 const*>(&rhs));
+}
+
+template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+          typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+inline __host__ __device__
+// XXX it might be nice to implement this at some point
+//typename enable_if_interoperable<Dr1,Dr2,bool>::type // exposition
+bool
+operator >(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+           iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs)
+{
+  return 0 < iterator_core_access
+    ::distance_from(*static_cast<Derived1 const*>(&lhs),
+                    *static_cast<Derived2 const*>(&rhs));
+}
+
+template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+          typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+inline __host__ __device__
+// XXX it might be nice to implement this at some point
+//typename enable_if_interoperable<Dr1,Dr2,bool>::type // exposition
+bool
+operator <=(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+            iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs)
+{
+  return 0 >= iterator_core_access
+    ::distance_from(*static_cast<Derived1 const*>(&lhs),
+                    *static_cast<Derived2 const*>(&rhs));
+}
+
+template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+          typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+inline __host__ __device__
+// XXX it might be nice to implement this at some point
+//typename enable_if_interoperable<Dr1,Dr2,bool>::type // exposition
+bool
+operator >=(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+            iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs)
+{
+  return 0 <= iterator_core_access
+    ::distance_from(*static_cast<Derived1 const*>(&lhs),
+                    *static_cast<Derived2 const*>(&rhs));
+}
+
+// Iterator difference
+template <typename Derived1, typename Value1, typename System1, typename Traversal1, typename Reference1, typename Difference1,
+          typename Derived2, typename Value2, typename System2, typename Traversal2, typename Reference2, typename Difference2>
+inline __host__ __device__
+
+// divine the type this operator returns
+typename thrust::detail::distance_from_result<
+  iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1>,
+  iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2>
+>::type
+
+operator-(iterator_facade<Derived1,Value1,System1,Traversal1,Reference1,Difference1> const& lhs,
+          iterator_facade<Derived2,Value2,System2,Traversal2,Reference2,Difference2> const& rhs)
+{
+  return iterator_core_access
+    ::distance_from(*static_cast<Derived1 const*>(&lhs),
+                    *static_cast<Derived2 const*>(&rhs));
+}
+
+// Iterator addition
+template <typename Derived, typename Value, typename System, typename Traversal, typename Reference, typename Difference>
+inline __host__ __device__
+Derived operator+ (iterator_facade<Derived,Value,System,Traversal,Reference,Difference> const& i,
+                   typename Derived::difference_type n)
+{
+  Derived tmp(static_cast<Derived const&>(i));
+  return tmp += n;
+}
+
+template <typename Derived, typename Value, typename System, typename Traversal, typename Reference, typename Difference>
+inline __host__ __device__
+Derived operator+ (typename Derived::difference_type n,
+                   iterator_facade<Derived,Value,System,Traversal,Reference,Difference> const& i)
+{
+  Derived tmp(static_cast<Derived const&>(i));
+  return tmp += n;
+}
+
+/*! \endcond
+ */
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+

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

@@ -0,0 +1,355 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file thrust/iterator/transform_iterator.h
+ *  \brief An iterator which adapts another iterator by applying a function to the result of its dereference
+ */
+
+/*
+ * (C) Copyright David Abrahams 2002.
+ * (C) Copyright Jeremy Siek    2002.
+ * (C) Copyright Thomas Witt    2002.
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying NOTICE file for the complete license)
+ *
+ * For more information, see http://www.boost.org
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+// #include the details first
+#include <thrust/iterator/detail/transform_iterator.inl>
+#include <thrust/iterator/iterator_facade.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p transform_iterator is an iterator which represents a pointer into a range
+ *  of values after transformation by a function. This iterator is useful for
+ *  creating a range filled with the result of applying an operation to another range
+ *  without either explicitly storing it in memory, or explicitly executing the transformation.
+ *  Using \p transform_iterator facilitates kernel fusion by deferring the execution
+ *  of a transformation until the value is needed while saving both memory capacity
+ *  and bandwidth.
+ *
+ *  The following code snippet demonstrates how to create a \p transform_iterator
+ *  which represents the result of \c sqrtf applied to the contents of a \p device_vector.
+ *
+ *  \code
+ *  #include <thrust/iterator/transform_iterator.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  // note: functor inherits from unary_function
+ *  struct square_root : public thrust::unary_function<float,float>
+ *  {
+ *    __host__ __device__
+ *    float operator()(float x) const
+ *    {
+ *      return sqrtf(x);
+ *    }
+ *  };
+ *
+ *  int main()
+ *  {
+ *    thrust::device_vector<float> v(4);
+ *    v[0] = 1.0f;
+ *    v[1] = 4.0f;
+ *    v[2] = 9.0f;
+ *    v[3] = 16.0f;
+ *
+ *    typedef thrust::device_vector<float>::iterator FloatIterator;
+ *
+ *    thrust::transform_iterator<square_root, FloatIterator> iter(v.begin(), square_root());
+ *
+ *    *iter;   // returns 1.0f
+ *    iter[0]; // returns 1.0f;
+ *    iter[1]; // returns 2.0f;
+ *    iter[2]; // returns 3.0f;
+ *    iter[3]; // returns 4.0f;
+ *
+ *    // iter[4] is an out-of-bounds error
+ *  }
+ *  \endcode
+ *
+ *  This next example demonstrates how to use a \p transform_iterator with the
+ *  \p thrust::reduce function to compute the sum of squares of a sequence.
+ *  We will create temporary \p transform_iterators with the
+ *  \p make_transform_iterator function in order to avoid explicitly specifying their type:
+ *
+ *  \code
+ *  #include <thrust/iterator/transform_iterator.h>
+ *  #include <thrust/device_vector.h>
+ *  #include <thrust/reduce.h>
+ *  #include <iostream>
+ *
+ *  // note: functor inherits from unary_function
+ *  struct square : public thrust::unary_function<float,float>
+ *  {
+ *    __host__ __device__
+ *    float operator()(float x) const
+ *    {
+ *      return x * x;
+ *    }
+ *  };
+ *
+ *  int main()
+ *  {
+ *    // initialize a device array
+ *    thrust::device_vector<float> v(4);
+ *    v[0] = 1.0f;
+ *    v[1] = 2.0f;
+ *    v[2] = 3.0f;
+ *    v[3] = 4.0f;
+ *
+ *    float sum_of_squares =
+ *     thrust::reduce(thrust::make_transform_iterator(v.begin(), square()),
+ *                    thrust::make_transform_iterator(v.end(),   square()));
+ *
+ *    std::cout << "sum of squares: " << sum_of_squares << std::endl;
+ *    return 0;
+ *  }
+ *  \endcode
+ *
+ *  Note that in the previous two examples the transform functor (namely \c square_root
+ *  and \c square) inherits from \c thrust::unary_function.  Inheriting from
+ *  \c thrust::unary_function ensures that a functor is a valid \c AdaptableUnaryFunction
+ *  and provides all the necessary \c typedef declarations.  The \p transform_iterator
+ *  can also be applied to a \c UnaryFunction that does not inherit from
+ *  \c thrust::unary_function using an optional template argument.  The following example
+ *  illustrates how to use the third template argument to specify the \c result_type of
+ *  the function.
+ *
+ *  \code
+ *  #include <thrust/iterator/transform_iterator.h>
+ *  #include <thrust/device_vector.h>
+ *
+ *  // note: functor *does not* inherit from unary_function
+ *  struct square_root
+ *  {
+ *    __host__ __device__
+ *    float operator()(float x) const
+ *    {
+ *      return sqrtf(x);
+ *    }
+ *  };
+ *
+ *  int main()
+ *  {
+ *    thrust::device_vector<float> v(4);
+ *    v[0] = 1.0f;
+ *    v[1] = 4.0f;
+ *    v[2] = 9.0f;
+ *    v[3] = 16.0f;
+ *
+ *    typedef thrust::device_vector<float>::iterator FloatIterator;
+ *
+ *    // note: float result_type is specified explicitly
+ *    thrust::transform_iterator<square_root, FloatIterator, float> iter(v.begin(), square_root());
+ *
+ *    *iter;   // returns 1.0f
+ *    iter[0]; // returns 1.0f;
+ *    iter[1]; // returns 2.0f;
+ *    iter[2]; // returns 3.0f;
+ *    iter[3]; // returns 4.0f;
+ *
+ *    // iter[4] is an out-of-bounds error
+ *  }
+ *  \endcode
+ *
+ *  \see make_transform_iterator
+ */
+template <class AdaptableUnaryFunction, class Iterator, class Reference = use_default, class Value = use_default>
+  class transform_iterator
+    : public detail::transform_iterator_base<AdaptableUnaryFunction, Iterator, Reference, Value>::type
+{
+  /*! \cond
+   */
+  public:
+    typedef typename
+    detail::transform_iterator_base<AdaptableUnaryFunction, Iterator, Reference, Value>::type
+    super_t;
+
+    friend class thrust::iterator_core_access;
+  /*! \endcond
+   */
+
+  public:
+    /*! Null constructor does nothing.
+     */
+    __host__ __device__
+    transform_iterator() {}
+
+#if THRUST_CPP_DIALECT >= 2011
+    transform_iterator(transform_iterator const&) = default;
+#endif
+
+    /*! This constructor takes as arguments an \c Iterator and an \c AdaptableUnaryFunction
+     *  and copies them to a new \p transform_iterator.
+     *
+     *  \param x An \c Iterator pointing to the input to this \p transform_iterator's \c AdaptableUnaryFunction.
+     *  \param f An \c AdaptableUnaryFunction used to transform the objects pointed to by \p x.
+     */
+    __host__ __device__
+    transform_iterator(Iterator const& x, AdaptableUnaryFunction f)
+      : super_t(x), m_f(f) {
+    }
+
+    /*! This explicit constructor copies the value of a given \c Iterator and creates
+     *  this \p transform_iterator's \c AdaptableUnaryFunction using its null constructor.
+     *
+     *  \param x An \c Iterator to copy.
+     */
+    __host__ __device__
+    explicit transform_iterator(Iterator const& x)
+      : super_t(x) { }
+
+    /*! This copy constructor creates a new \p transform_iterator from another
+     *  \p transform_iterator.
+     *
+     *  \param other The \p transform_iterator to copy.
+     */
+    template<typename OtherAdaptableUnaryFunction,
+             typename OtherIterator,
+             typename OtherReference,
+             typename OtherValue>
+    __host__ __device__
+    transform_iterator(const transform_iterator<OtherAdaptableUnaryFunction, OtherIterator, OtherReference, OtherValue> &other,
+                       typename thrust::detail::enable_if_convertible<OtherIterator, Iterator>::type* = 0,
+                       typename thrust::detail::enable_if_convertible<OtherAdaptableUnaryFunction, AdaptableUnaryFunction>::type* = 0)
+      : super_t(other.base()), m_f(other.functor()) {}
+
+    /*! Copy assignment operator copies from another \p transform_iterator.
+     *  \p other The other \p transform_iterator to copy
+     *  \return <tt>*this</tt>
+     *
+     *  \note If the type of this \p transform_iterator's functor is not copy assignable
+     *        (for example, if it is a lambda) it is not an error to call this function.
+     *        In this case, however, the functor will not be modified.
+     *
+     *        In any case, this \p transform_iterator's underlying iterator will be copy assigned.
+     */
+    __host__ __device__
+    transform_iterator &operator=(const transform_iterator &other)
+    {
+      return do_assign(other,
+      // XXX gcc 4.2.1 crashes on is_copy_assignable; just assume the functor is assignable as a WAR
+#if (THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_GCC) && (THRUST_GCC_VERSION <= 40201)
+          thrust::detail::true_type()
+#else
+          typename thrust::detail::is_copy_assignable<AdaptableUnaryFunction>::type()
+#endif // THRUST_HOST_COMPILER
+      );
+    }
+
+    /*! This method returns a copy of this \p transform_iterator's \c AdaptableUnaryFunction.
+     *  \return A copy of this \p transform_iterator's \c AdaptableUnaryFunction.
+     */
+    __host__ __device__
+    AdaptableUnaryFunction functor() const
+      { return m_f; }
+
+    /*! \cond
+     */
+  private:
+    __host__ __device__
+    transform_iterator &do_assign(const transform_iterator &other, thrust::detail::true_type)
+    {
+      super_t::operator=(other);
+
+      // do assign to m_f
+      m_f = other.functor();
+
+      return *this;
+    }
+
+    __host__ __device__
+    transform_iterator &do_assign(const transform_iterator &other, thrust::detail::false_type)
+    {
+      super_t::operator=(other);
+
+      // don't assign to m_f
+
+      return *this;
+    }
+
+    // MSVC 2013 and 2015 incorrectly warning about returning a reference to
+    // a local/temporary here.
+    // See goo.gl/LELTNp
+    THRUST_DISABLE_MSVC_WARNING_BEGIN(4172)
+
+    __thrust_exec_check_disable__
+    __host__ __device__
+    typename super_t::reference dereference() const
+    {
+      // Create a temporary to allow iterators with wrapped references to
+      // convert to their value type before calling m_f. Note that this
+      // disallows non-constant operations through m_f.
+      typename thrust::iterator_value<Iterator>::type const& x = *this->base();
+      return m_f(x);
+    }
+
+    THRUST_DISABLE_MSVC_WARNING_END(4172)
+
+    // tag this as mutable per Dave Abrahams in this thread:
+    // http://lists.boost.org/Archives/boost/2004/05/65332.php
+    mutable AdaptableUnaryFunction m_f;
+
+    /*! \endcond
+     */
+}; // end transform_iterator
+
+
+/*! \p make_transform_iterator creates a \p transform_iterator
+ *  from an \c Iterator and \c AdaptableUnaryFunction.
+ *
+ *  \param it The \c Iterator pointing to the input range of the
+ *            newly created \p transform_iterator.
+ *  \param fun The \c AdaptableUnaryFunction used to transform the range pointed
+ *             to by \p it in the newly created \p transform_iterator.
+ *  \return A new \p transform_iterator which transforms the range at
+ *          \p it by \p fun.
+ *  \see transform_iterator
+ */
+template <class AdaptableUnaryFunction, class Iterator>
+inline __host__ __device__
+transform_iterator<AdaptableUnaryFunction, Iterator>
+make_transform_iterator(Iterator it, AdaptableUnaryFunction fun)
+{
+  return transform_iterator<AdaptableUnaryFunction, Iterator>(it, fun);
+} // end make_transform_iterator
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+

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

@@ -0,0 +1,164 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file thrust/iterator/transform_output_iterator.h
+ *  \brief An output iterator which adapts another output iterator by applying a
+ *         function to the result of its dereference before writing it.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/iterator/detail/transform_output_iterator.inl>
+
+THRUST_NAMESPACE_BEGIN
+
+/*! \addtogroup iterators
+ *  \{
+ */
+
+/*! \addtogroup fancyiterator Fancy Iterators
+ *  \ingroup iterators
+ *  \{
+ */
+
+/*! \p transform_output_iterator is a special kind of output iterator which
+ * transforms a value written upon dereference. This iterator is useful
+ * for transforming an output from algorithms without explicitly storing the
+ * intermediate result in the memory and applying subsequent transformation, 
+ * thereby avoiding wasting memory capacity and bandwidth.
+ * Using \p transform_iterator facilitates kernel fusion by deferring execution
+ * of transformation until the value is written while saving both memory
+ * capacity and bandwidth.
+ *
+ * The following code snippet demonstrated how to create a
+ * \p transform_output_iterator which applies \c sqrtf to the assigning value.
+ *
+ * \code
+ * #include <thrust/iterator/transform_output_iterator.h>
+ * #include <thrust/device_vector.h>
+ *
+ * // note: functor inherits form unary function
+ *  // note: functor inherits from unary_function
+ *  struct square_root : public thrust::unary_function<float,float>
+ *  {
+ *    __host__ __device__
+ *    float operator()(float x) const
+ *    {
+ *      return sqrtf(x);
+ *    }
+ *  };
+ *  
+ *  int main()
+ *  {
+ *    thrust::device_vector<float> v(4);
+ *
+ *    typedef thrust::device_vector<float>::iterator FloatIterator;
+ *    thrust::transform_output_iterator<square_root, FloatIterator> iter(v.begin(), square_root());
+ *
+ *    iter[0] =  1.0f;    // stores sqrtf( 1.0f) 
+ *    iter[1] =  4.0f;    // stores sqrtf( 4.0f)
+ *    iter[2] =  9.0f;    // stores sqrtf( 9.0f)
+ *    iter[3] = 16.0f;    // stores sqrtf(16.0f)
+ *    // iter[4] is an out-of-bounds error
+ *                                                                                           
+ *    v[0]; // returns 1.0f;
+ *    v[1]; // returns 2.0f;
+ *    v[2]; // returns 3.0f;
+ *    v[3]; // returns 4.0f;
+ *                                                                                           
+ *  }
+ *  \endcode
+ *
+ *  \see make_transform_output_iterator
+ */
+
+template <typename UnaryFunction, typename OutputIterator>
+  class transform_output_iterator
+    : public detail::transform_output_iterator_base<UnaryFunction, OutputIterator>::type
+{
+
+  /*! \cond
+   */
+
+  public:
+
+    typedef typename
+    detail::transform_output_iterator_base<UnaryFunction, OutputIterator>::type
+    super_t;
+
+    friend class thrust::iterator_core_access;
+  /*! \endcond
+   */
+
+  transform_output_iterator() = default;
+
+  /*! This constructor takes as argument an \c OutputIterator and an \c
+   * UnaryFunction and copies them to a new \p transform_output_iterator
+   *
+   * \param out An \c OutputIterator pointing to the output range whereto the result of 
+   *            \p transform_output_iterator's \c UnaryFunction will be written.
+   * \param fun An \c UnaryFunction used to transform the objects assigned to
+   *            this \p transform_output_iterator.
+   */
+    __host__ __device__
+    transform_output_iterator(OutputIterator const& out, UnaryFunction fun) : super_t(out), fun(fun)
+    {
+    }
+
+    /*! \cond
+     */
+  private:
+
+    __host__ __device__
+    typename super_t::reference dereference() const
+    {
+      return detail::transform_output_iterator_proxy<
+        UnaryFunction, OutputIterator
+      >(this->base_reference(), fun);
+    }
+
+    UnaryFunction fun;
+
+    /*! \endcond
+     */
+}; // end transform_output_iterator
+
+/*! \p make_transform_output_iterator creates a \p transform_output_iterator from
+ *  an \c OutputIterator and \c UnaryFunction.
+ *
+ *  \param out The \c OutputIterator pointing to the output range of the newly
+ *            created \p transform_output_iterator
+ *  \param fun The \c UnaryFunction transform the object before assigning it to
+ *            \c out by the newly created \p transform_output_iterator
+ *  \see transform_output_iterator
+ */
+template <typename UnaryFunction, typename OutputIterator>
+transform_output_iterator<UnaryFunction, OutputIterator>
+__host__ __device__
+make_transform_output_iterator(OutputIterator out, UnaryFunction fun)
+{
+    return transform_output_iterator<UnaryFunction, OutputIterator>(out, fun);
+} // end make_transform_output_iterator
+
+/*! \} // end fancyiterators
+ */
+
+/*! \} // end iterators
+ */
+
+THRUST_NAMESPACE_END
+

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

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

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

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

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

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

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/system/detail/generic/partition.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.
+ */
+
+
+/*! \file partition.h
+ *  \brief Generic implementations of partition functions.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/system/detail/generic/tag.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace detail
+{
+namespace generic
+{
+
+
+template<typename ExecutionPolicy,
+         typename ForwardIterator,
+         typename Predicate>
+__host__ __device__
+  ForwardIterator stable_partition(thrust::execution_policy<ExecutionPolicy> &exec,
+                                   ForwardIterator first,
+                                   ForwardIterator last,
+                                   Predicate pred);
+
+template<typename ExecutionPolicy,
+         typename ForwardIterator,
+         typename InputIterator,
+         typename Predicate>
+__host__ __device__
+  ForwardIterator stable_partition(thrust::execution_policy<ExecutionPolicy> &exec,
+                                   ForwardIterator first,
+                                   ForwardIterator last,
+                                   InputIterator stencil,
+                                   Predicate pred);
+
+
+template<typename ExecutionPolicy,
+         typename InputIterator,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename Predicate>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+    stable_partition_copy(thrust::execution_policy<ExecutionPolicy> &exec,
+                          InputIterator first,
+                          InputIterator last,
+                          OutputIterator1 out_true,
+                          OutputIterator2 out_false,
+                          Predicate pred);
+
+
+template<typename ExecutionPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename Predicate>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+    stable_partition_copy(thrust::execution_policy<ExecutionPolicy> &exec,
+                          InputIterator1 first,
+                          InputIterator1 last,
+                          InputIterator2 stencil,
+                          OutputIterator1 out_true,
+                          OutputIterator2 out_false,
+                          Predicate pred);
+
+
+template<typename ExecutionPolicy,
+         typename ForwardIterator,
+         typename Predicate>
+__host__ __device__
+  ForwardIterator partition(thrust::execution_policy<ExecutionPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            Predicate pred);
+
+
+template<typename ExecutionPolicy,
+         typename ForwardIterator,
+         typename InputIterator,
+         typename Predicate>
+__host__ __device__
+  ForwardIterator partition(thrust::execution_policy<ExecutionPolicy> &exec,
+                            ForwardIterator first,
+                            ForwardIterator last,
+                            InputIterator stencil,
+                            Predicate pred);
+
+
+template<typename ExecutionPolicy,
+         typename InputIterator,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename Predicate>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+    partition_copy(thrust::execution_policy<ExecutionPolicy> &exec,
+                   InputIterator first,
+                   InputIterator last,
+                   OutputIterator1 out_true,
+                   OutputIterator2 out_false,
+                   Predicate pred);
+
+
+template<typename ExecutionPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename Predicate>
+__host__ __device__
+  thrust::pair<OutputIterator1,OutputIterator2>
+    partition_copy(thrust::execution_policy<ExecutionPolicy> &exec,
+                   InputIterator1 first,
+                   InputIterator1 last,
+                   InputIterator2 stencil,
+                   OutputIterator1 out_true,
+                   OutputIterator2 out_false,
+                   Predicate pred);
+
+
+template<typename ExecutionPolicy,
+         typename ForwardIterator,
+         typename Predicate>
+__host__ __device__
+  ForwardIterator partition_point(thrust::execution_policy<ExecutionPolicy> &exec,
+                                  ForwardIterator first,
+                                  ForwardIterator last,
+                                  Predicate pred);
+
+
+template<typename ExecutionPolicy,
+         typename InputIterator,
+         typename Predicate>
+__host__ __device__
+  bool is_partitioned(thrust::execution_policy<ExecutionPolicy> &exec,
+                      InputIterator first,
+                      InputIterator last,
+                      Predicate pred);
+
+
+} // end namespace generic
+} // end namespace detail
+} // end namespace system
+THRUST_NAMESPACE_END
+
+#include <thrust/system/detail/generic/partition.inl>
+

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

@@ -0,0 +1,127 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either 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/static_assert.h>
+#include <thrust/system/detail/generic/scan.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/scan.h>
+#include <thrust/detail/type_traits.h>
+#include <thrust/detail/type_traits/iterator/is_output_iterator.h>
+#include <thrust/functional.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace detail
+{
+namespace generic
+{
+
+
+template<typename ExecutionPolicy,
+         typename InputIterator,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator inclusive_scan(thrust::execution_policy<ExecutionPolicy> &exec,
+                                InputIterator first,
+                                InputIterator last,
+                                OutputIterator result)
+{
+  // assume plus as the associative operator
+  return thrust::inclusive_scan(exec, first, last, result, thrust::plus<>());
+} // end inclusive_scan()
+
+
+template<typename ExecutionPolicy,
+         typename InputIterator,
+         typename OutputIterator>
+__host__ __device__
+  OutputIterator exclusive_scan(thrust::execution_policy<ExecutionPolicy> &exec,
+                                InputIterator first,
+                                InputIterator last,
+                                OutputIterator result)
+{
+  // Use the input iterator's value type per https://wg21.link/P0571
+  using ValueType = typename thrust::iterator_value<InputIterator>::type;
+  return thrust::exclusive_scan(exec, first, last, result, ValueType{});
+} // end exclusive_scan()
+
+
+template<typename ExecutionPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename T>
+__host__ __device__
+  OutputIterator exclusive_scan(thrust::execution_policy<ExecutionPolicy> &exec,
+                                InputIterator first,
+                                InputIterator last,
+                                OutputIterator result,
+                                T init)
+{
+  // assume plus as the associative operator
+  return thrust::exclusive_scan(exec, first, last, result, init, thrust::plus<>());
+} // end exclusive_scan()
+
+
+template<typename ExecutionPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename BinaryFunction>
+__host__ __device__
+  OutputIterator inclusive_scan(thrust::execution_policy<ExecutionPolicy> &,
+                                InputIterator,
+                                InputIterator,
+                                OutputIterator result,
+                                BinaryFunction)
+{
+  THRUST_STATIC_ASSERT_MSG(
+    (thrust::detail::depend_on_instantiation<InputIterator, false>::value)
+  , "unimplemented for this system"
+  );
+  return result;
+} // end inclusive_scan
+
+
+template<typename ExecutionPolicy,
+         typename InputIterator,
+         typename OutputIterator,
+         typename T,
+         typename BinaryFunction>
+__host__ __device__
+  OutputIterator exclusive_scan(thrust::execution_policy<ExecutionPolicy> &,
+                                InputIterator,
+                                InputIterator,
+                                OutputIterator result,
+                                T,
+                                BinaryFunction)
+{
+  THRUST_STATIC_ASSERT_MSG(
+    (thrust::detail::depend_on_instantiation<InputIterator, false>::value)
+  , "unimplemented for this system"
+  );
+  return result;
+} // end exclusive_scan()
+
+
+} // end namespace generic
+} // end namespace detail
+} // end namespace system
+THRUST_NAMESPACE_END
+

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

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

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

@@ -0,0 +1,167 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file generic/type_traits.h
+ *  \brief Introspection for free functions defined in generic.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+THRUST_NAMESPACE_BEGIN
+
+// forward declaration of any_system_tag for any_conversion below
+struct any_system_tag;
+
+namespace system
+{
+namespace detail
+{
+
+// we must define these traits outside of generic's namespace
+namespace generic_type_traits_ns
+{
+
+typedef char yes;
+typedef char (&no)[2];
+
+struct any_conversion
+{
+  template<typename T> any_conversion(const T &);
+
+  // add this extra constructor to disambiguate conversion from any_system_tag
+  any_conversion(const any_system_tag &);
+};
+
+namespace select_system_exists_ns
+{
+  no select_system(const any_conversion &);
+  no select_system(const any_conversion &, const any_conversion &);
+  no select_system(const any_conversion &, const any_conversion &, const any_conversion &);
+  no select_system(const any_conversion &, const any_conversion &, const any_conversion &, const any_conversion &);
+  no select_system(const any_conversion &, const any_conversion &, const any_conversion &, const any_conversion &, const any_conversion &);
+  no select_system(const any_conversion &, const any_conversion &, const any_conversion &, const any_conversion &, const any_conversion &, const any_conversion &);
+
+  template<typename T> yes check(const T &);
+
+  no check(no);
+
+  template<typename Tag>
+    struct select_system1_exists
+  {
+    static Tag &tag;
+
+    static const bool value = sizeof(check(select_system(tag))) == sizeof(yes);
+  };
+
+  template<typename Tag1, typename Tag2>
+    struct select_system2_exists
+  {
+    static Tag1 &tag1;
+    static Tag2 &tag2;
+
+    static const bool value = sizeof(check(select_system(tag1,tag2))) == sizeof(yes);
+  };
+
+  template<typename Tag1, typename Tag2, typename Tag3>
+    struct select_system3_exists
+  {
+    static Tag1 &tag1;
+    static Tag2 &tag2;
+    static Tag3 &tag3;
+
+    static const bool value = sizeof(check(select_system(tag1,tag2,tag3))) == sizeof(yes);
+  };
+
+  template<typename Tag1, typename Tag2, typename Tag3, typename Tag4>
+    struct select_system4_exists
+  {
+    static Tag1 &tag1;
+    static Tag2 &tag2;
+    static Tag3 &tag3;
+    static Tag4 &tag4;
+
+    static const bool value = sizeof(check(select_system(tag1,tag2,tag3,tag4))) == sizeof(yes);
+  };
+
+  template<typename Tag1, typename Tag2, typename Tag3, typename Tag4, typename Tag5>
+    struct select_system5_exists
+  {
+    static Tag1 &tag1;
+    static Tag2 &tag2;
+    static Tag3 &tag3;
+    static Tag4 &tag4;
+    static Tag5 &tag5;
+
+    static const bool value = sizeof(check(select_system(tag1,tag2,tag3,tag4,tag5))) == sizeof(yes);
+  };
+
+  template<typename Tag1, typename Tag2, typename Tag3, typename Tag4, typename Tag5, typename Tag6>
+    struct select_system6_exists
+  {
+    static Tag1 &tag1;
+    static Tag2 &tag2;
+    static Tag3 &tag3;
+    static Tag4 &tag4;
+    static Tag5 &tag5;
+    static Tag6 &tag6;
+
+    static const bool value = sizeof(check(select_system(tag1,tag2,tag3,tag4,tag5,tag6))) == sizeof(yes);
+  };
+} // end select_system_exists_ns
+
+} // end generic_type_traits_ns
+
+namespace generic
+{
+
+template<typename Tag>
+  struct select_system1_exists
+    : generic_type_traits_ns::select_system_exists_ns::select_system1_exists<Tag>
+{};
+
+template<typename Tag1, typename Tag2>
+  struct select_system2_exists
+    : generic_type_traits_ns::select_system_exists_ns::select_system2_exists<Tag1,Tag2>
+{};
+
+template<typename Tag1, typename Tag2, typename Tag3>
+  struct select_system3_exists
+    : generic_type_traits_ns::select_system_exists_ns::select_system3_exists<Tag1,Tag2,Tag3>
+{};
+
+template<typename Tag1, typename Tag2, typename Tag3, typename Tag4>
+  struct select_system4_exists
+    : generic_type_traits_ns::select_system_exists_ns::select_system4_exists<Tag1,Tag2,Tag3,Tag4>
+{};
+
+template<typename Tag1, typename Tag2, typename Tag3, typename Tag4, typename Tag5>
+  struct select_system5_exists
+    : generic_type_traits_ns::select_system_exists_ns::select_system5_exists<Tag1,Tag2,Tag3,Tag4,Tag5>
+{};
+
+template<typename Tag1, typename Tag2, typename Tag3, typename Tag4, typename Tag5, typename Tag6>
+  struct select_system6_exists
+    : generic_type_traits_ns::select_system_exists_ns::select_system6_exists<Tag1,Tag2,Tag3,Tag4,Tag5,Tag6>
+{};
+
+} // end generic
+} // end detail
+} // end system
+THRUST_NAMESPACE_END
+

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

@@ -0,0 +1,54 @@
+/*
+ *  Copyright 2008-2020 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*! \file shuffle.h
+ *  \brief Generic implementations of shuffle functions.
+ */
+
+#pragma once
+
+
+#include <thrust/detail/config.h>
+#include <thrust/detail/cpp11_required.h>
+
+#if THRUST_CPP_DIALECT >= 2011
+
+#include <thrust/system/detail/generic/tag.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system {
+namespace detail {
+namespace generic {
+
+template <typename ExecutionPolicy, typename RandomIterator, typename URBG>
+__host__ __device__ void shuffle(
+    thrust::execution_policy<ExecutionPolicy>& exec, RandomIterator first,
+    RandomIterator last, URBG&& g);
+
+template <typename ExecutionPolicy, typename RandomIterator,
+          typename OutputIterator, typename URBG>
+__host__ __device__ void shuffle_copy(
+    thrust::execution_policy<ExecutionPolicy>& exec, RandomIterator first,
+    RandomIterator last, OutputIterator result, URBG&& g);
+
+}  // end namespace generic
+}  // end namespace detail
+}  // end namespace system
+THRUST_NAMESPACE_END
+
+#include <thrust/system/detail/generic/shuffle.inl>
+
+#endif

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

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

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

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

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

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

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

@@ -0,0 +1,72 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/system/omp/detail/execution_policy.h>
+#include <thrust/system/detail/generic/binary_search.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace omp
+{
+namespace detail
+{
+
+
+template <typename DerivedPolicy, typename ForwardIterator, typename T, typename StrictWeakOrdering>
+ForwardIterator lower_bound(execution_policy<DerivedPolicy> &exec,
+                            ForwardIterator begin,
+                            ForwardIterator end,
+                            const T& value, 
+                            StrictWeakOrdering comp)
+{
+    // omp prefers generic::lower_bound to cpp::lower_bound
+    return thrust::system::detail::generic::lower_bound(exec, begin, end, value, comp);
+}
+
+
+template <typename DerivedPolicy, typename ForwardIterator, typename T, typename StrictWeakOrdering, typename Backend>
+ForwardIterator upper_bound(execution_policy<DerivedPolicy> &exec,
+                            ForwardIterator begin,
+                            ForwardIterator end,
+                            const T& value, 
+                            StrictWeakOrdering comp)
+{
+    // omp prefers generic::upper_bound to cpp::upper_bound
+    return thrust::system::detail::generic::upper_bound(exec, begin, end, value, comp);
+}
+
+
+template <typename DerivedPolicy, typename ForwardIterator, typename T, typename StrictWeakOrdering>
+bool binary_search(execution_policy<DerivedPolicy> &exec,
+                   ForwardIterator begin,
+                   ForwardIterator end,
+                   const T& value, 
+                   StrictWeakOrdering comp)
+{
+    // omp prefers generic::binary_search to cpp::binary_search
+    return thrust::system::detail::generic::binary_search(exec, begin, end, value, comp);
+}
+
+
+} // end detail
+} // end omp
+} // end system
+THRUST_NAMESPACE_END
+

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

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

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

@@ -0,0 +1,136 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/system/omp/detail/copy.h>
+#include <thrust/system/detail/generic/copy.h>
+#include <thrust/system/detail/sequential/copy.h>
+#include <thrust/detail/type_traits/minimum_type.h>
+
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace omp
+{
+namespace detail
+{
+namespace dispatch
+{
+
+
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator>
+  OutputIterator copy(execution_policy<DerivedPolicy> &exec,
+                      InputIterator first,
+                      InputIterator last,
+                      OutputIterator result,
+                      thrust::incrementable_traversal_tag)
+{
+  return thrust::system::detail::sequential::copy(exec, first, last, result);
+} // end copy()
+
+
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator>
+  OutputIterator copy(execution_policy<DerivedPolicy> &exec,
+                      InputIterator first,
+                      InputIterator last,
+                      OutputIterator result,
+                      thrust::random_access_traversal_tag)
+{
+  return thrust::system::detail::generic::copy(exec, first, last, result);
+} // end copy()
+
+
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename Size,
+         typename OutputIterator>
+  OutputIterator copy_n(execution_policy<DerivedPolicy> &exec,
+                        InputIterator first,
+                        Size n,
+                        OutputIterator result,
+                        thrust::incrementable_traversal_tag)
+{
+  return thrust::system::detail::sequential::copy_n(exec, first, n, result);
+} // end copy_n()
+
+
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename Size,
+         typename OutputIterator>
+  OutputIterator copy_n(execution_policy<DerivedPolicy> &exec,
+                        InputIterator first,
+                        Size n,
+                        OutputIterator result,
+                        thrust::random_access_traversal_tag)
+{
+  return thrust::system::detail::generic::copy_n(exec, first, n, result);
+} // end copy_n()
+
+
+} // end dispatch
+
+
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator>
+OutputIterator copy(execution_policy<DerivedPolicy> &exec,
+                    InputIterator first,
+                    InputIterator last,
+                    OutputIterator result)
+{
+  typedef typename thrust::iterator_traversal<InputIterator>::type  traversal1;
+  typedef typename thrust::iterator_traversal<OutputIterator>::type traversal2;
+  
+  typedef typename thrust::detail::minimum_type<traversal1,traversal2>::type traversal;
+
+  // dispatch on minimum traversal
+  return thrust::system::omp::detail::dispatch::copy(exec, first, last, result, traversal());
+} // end copy()
+
+
+
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename Size,
+         typename OutputIterator>
+OutputIterator copy_n(execution_policy<DerivedPolicy> &exec,
+                      InputIterator first,
+                      Size n,
+                      OutputIterator result)
+{
+  typedef typename thrust::iterator_traversal<InputIterator>::type  traversal1;
+  typedef typename thrust::iterator_traversal<OutputIterator>::type traversal2;
+  
+  typedef typename thrust::detail::minimum_type<traversal1,traversal2>::type traversal;
+
+  // dispatch on minimum traversal
+  return thrust::system::omp::detail::dispatch::copy_n(exec, first, n, result, traversal());
+} // end copy_n()
+
+
+} // end namespace detail
+} // end namespace omp
+} // end namespace system
+THRUST_NAMESPACE_END
+

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

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

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

@@ -0,0 +1,44 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file default_decomposition.h
+ *  \brief Return a decomposition that is appropriate for the OpenMP backend.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/system/detail/internal/decompose.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace omp
+{
+namespace detail
+{
+
+template <typename IndexType>
+thrust::system::detail::internal::uniform_decomposition<IndexType> default_decomposition(IndexType n);
+
+} // end namespace detail
+} // end namespace omp
+} // end namespace system
+THRUST_NAMESPACE_END
+
+#include <thrust/system/omp/detail/default_decomposition.inl>
+

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

@@ -0,0 +1,61 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/system/omp/detail/default_decomposition.h>
+
+// don't attempt to #include this file without omp support
+#if (THRUST_DEVICE_COMPILER_IS_OMP_CAPABLE == THRUST_TRUE)
+#include <omp.h>
+#endif // omp support
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace omp
+{
+namespace detail
+{
+
+template <typename IndexType>
+thrust::system::detail::internal::uniform_decomposition<IndexType> default_decomposition(IndexType n)
+{
+  // we're attempting to launch an omp kernel, assert we're compiling with omp support
+  // ========================================================================
+  // X Note to the user: If you've found this line due to a compiler error, X
+  // X you need to OpenMP support in your compiler.                         X
+  // ========================================================================
+  THRUST_STATIC_ASSERT_MSG(
+    (thrust::detail::depend_on_instantiation<
+      IndexType, (THRUST_DEVICE_COMPILER_IS_OMP_CAPABLE == THRUST_TRUE)
+    >::value)
+  , "OpenMP compiler support is not enabled"
+  );
+
+#if (THRUST_DEVICE_COMPILER_IS_OMP_CAPABLE == THRUST_TRUE)
+  return thrust::system::detail::internal::uniform_decomposition<IndexType>(n, 1, omp_get_num_procs());
+#else
+  return thrust::system::detail::internal::uniform_decomposition<IndexType>(n, 1, 1);
+#endif
+}
+
+} // end namespace detail
+} // end namespace omp
+} // end namespace system
+THRUST_NAMESPACE_END
+

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

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

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

@@ -0,0 +1,106 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/system/cpp/detail/execution_policy.h>
+#include <thrust/system/tbb/detail/execution_policy.h>
+#include <thrust/iterator/detail/any_system_tag.h>
+#include <thrust/detail/type_traits.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+// put the canonical tag in the same ns as the backend's entry points
+namespace omp
+{
+namespace detail
+{
+
+// this awkward sequence of definitions arise
+// from the desire both for tag to derive
+// from execution_policy and for execution_policy
+// to convert to tag (when execution_policy is not
+// an ancestor of tag)
+
+// forward declaration of tag
+struct tag;
+
+// forward declaration of execution_policy
+template<typename> struct execution_policy;
+
+// specialize execution_policy for tag
+template<>
+  struct execution_policy<tag>
+    : thrust::system::cpp::detail::execution_policy<tag>
+{};
+
+// tag's definition comes before the
+// generic definition of execution_policy
+struct tag : execution_policy<tag> {};
+
+// allow conversion to tag when it is not a successor
+template<typename Derived>
+  struct execution_policy
+    : thrust::system::cpp::detail::execution_policy<Derived>
+{
+  typedef tag tag_type; 
+  operator tag() const { return tag(); }
+};
+
+
+// overloads of select_system
+
+// XXX select_system(tbb, omp) & select_system(omp, tbb) are ambiguous
+//     because both convert to cpp without these overloads, which we
+//     arbitrarily define in the omp backend
+
+template<typename System1, typename System2>
+inline __host__ __device__
+  System1 select_system(execution_policy<System1> s, thrust::system::tbb::detail::execution_policy<System2>)
+{
+  return thrust::detail::derived_cast(s);
+} // end select_system()
+
+
+template<typename System1, typename System2>
+inline __host__ __device__
+  System2 select_system(thrust::system::tbb::detail::execution_policy<System1>, execution_policy<System2> s)
+{
+  return thrust::detail::derived_cast(s);
+} // end select_system()
+
+
+} // end detail
+
+// alias execution_policy and tag here
+using thrust::system::omp::detail::execution_policy;
+using thrust::system::omp::detail::tag;
+
+} // end omp
+} // end system
+
+// alias items at top-level
+namespace omp
+{
+
+using thrust::system::omp::execution_policy;
+using thrust::system::omp::tag;
+
+} // end omp
+THRUST_NAMESPACE_END
+

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

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

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

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

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

@@ -0,0 +1,50 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file find.h
+ *  \brief OpenMP implementation of find_if. 
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/system/detail/generic/find.h>
+#include <thrust/system/omp/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace omp
+{
+namespace detail
+{
+
+template <typename DerivedPolicy, typename InputIterator, typename Predicate>
+InputIterator find_if(execution_policy<DerivedPolicy> &exec,
+                      InputIterator first,
+                      InputIterator last,
+                      Predicate pred)
+{
+  // omp prefers generic::find_if to cpp::find_if
+  return thrust::system::detail::generic::find_if(exec, first, last, pred);
+}
+
+} // end namespace detail
+} // end namespace omp
+} // end namespace system
+THRUST_NAMESPACE_END
+

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

@@ -0,0 +1,59 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file for_each.h
+ *  \brief Defines the interface for a function that executes a 
+ *  function or functional for each value in a given range.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/system/omp/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace omp
+{
+namespace detail
+{
+
+template<typename DerivedPolicy,
+         typename RandomAccessIterator,
+         typename UnaryFunction>
+  RandomAccessIterator for_each(execution_policy<DerivedPolicy> &exec,
+                                RandomAccessIterator first,
+                                RandomAccessIterator last,
+                                UnaryFunction f);
+
+template<typename DerivedPolicy,
+         typename RandomAccessIterator,
+         typename Size,
+         typename UnaryFunction>
+  RandomAccessIterator for_each_n(execution_policy<DerivedPolicy> &exec,
+                                  RandomAccessIterator first,
+                                  Size n,
+                                  UnaryFunction f);
+
+} // end namespace detail
+} // end namespace omp
+} // end namespace system
+THRUST_NAMESPACE_END
+
+#include <thrust/system/omp/detail/for_each.inl>
+

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/thrust/system/omp/detail/for_each.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/detail/function.h>
+#include <thrust/detail/static_assert.h>
+#include <thrust/distance.h>
+#include <thrust/for_each.h>
+#include <thrust/iterator/iterator_traits.h>
+#include <thrust/system/omp/detail/pragma_omp.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace omp
+{
+namespace detail
+{
+
+template<typename DerivedPolicy,
+         typename RandomAccessIterator,
+         typename Size,
+         typename UnaryFunction>
+RandomAccessIterator for_each_n(execution_policy<DerivedPolicy> &,
+                                RandomAccessIterator first,
+                                Size n,
+                                UnaryFunction f)
+{
+  // we're attempting to launch an omp kernel, assert we're compiling with omp support
+  // ========================================================================
+  // X Note to the user: If you've found this line due to a compiler error, X
+  // X you need to enable OpenMP support in your compiler.                  X
+  // ========================================================================
+  THRUST_STATIC_ASSERT_MSG(
+    (thrust::detail::depend_on_instantiation<
+      RandomAccessIterator, (THRUST_DEVICE_COMPILER_IS_OMP_CAPABLE == THRUST_TRUE)
+    >::value)
+  , "OpenMP compiler support is not enabled"
+  );
+
+  if (n <= 0) return first;  //empty range
+
+  // create a wrapped function for f
+  thrust::detail::wrapped_function<UnaryFunction,void> wrapped_f(f);
+
+  // use a signed type for the iteration variable or suffer the consequences of warnings
+  typedef typename thrust::iterator_difference<RandomAccessIterator>::type DifferenceType;
+  DifferenceType signed_n = n;
+
+  THRUST_PRAGMA_OMP(parallel for)
+  for(DifferenceType i = 0;
+      i < signed_n;
+      ++i)
+  {
+    RandomAccessIterator temp = first + i;
+    wrapped_f(*temp);
+  }
+
+  return first + n;
+} // end for_each_n()
+
+template<typename DerivedPolicy,
+         typename RandomAccessIterator,
+         typename UnaryFunction>
+  RandomAccessIterator for_each(execution_policy<DerivedPolicy> &s,
+                                RandomAccessIterator first,
+                                RandomAccessIterator last,
+                                UnaryFunction f)
+{
+  return omp::detail::for_each_n(s, first, thrust::distance(first,last), f);
+} // end for_each()
+
+} // end namespace detail
+} // end namespace omp
+} // end namespace system
+THRUST_NAMESPACE_END
+

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,86 @@
+/*
+ *  Copyright 2008-2018 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/system/cpp/detail/execution_policy.h>
+#include <thrust/system/omp/memory.h>
+#include <thrust/system/cpp/memory.h>
+
+#include <limits>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace omp
+{
+namespace detail
+{
+
+// XXX circular #inclusion problems cause the compiler to believe that cpp::malloc
+//     is not defined
+//     WAR the problem by using adl to call cpp::malloc, which requires it to depend
+//     on a template parameter
+template<typename Tag>
+  pointer<void> malloc_workaround(Tag t, std::size_t n)
+{
+  return pointer<void>(malloc(t, n));
+} // end malloc_workaround()
+
+// XXX circular #inclusion problems cause the compiler to believe that cpp::free
+//     is not defined
+//     WAR the problem by using adl to call cpp::free, which requires it to depend
+//     on a template parameter
+template<typename Tag>
+  void free_workaround(Tag t, pointer<void> ptr)
+{
+  free(t, ptr.get());
+} // end free_workaround()
+
+} // end detail
+
+inline pointer<void> malloc(std::size_t n)
+{
+  // XXX this is how we'd like to implement this function,
+  //     if not for circular #inclusion problems:
+  //
+  // return pointer<void>(thrust::system::cpp::malloc(n))
+  //
+  return detail::malloc_workaround(cpp::tag(), n);
+} // end malloc()
+
+template<typename T>
+pointer<T> malloc(std::size_t n)
+{
+  pointer<void> raw_ptr = thrust::system::omp::malloc(sizeof(T) * n);
+  return pointer<T>(reinterpret_cast<T*>(raw_ptr.get()));
+} // end malloc()
+
+inline void free(pointer<void> ptr)
+{
+  // XXX this is how we'd like to implement this function,
+  //     if not for circular #inclusion problems:
+  //
+  // thrust::system::cpp::free(ptr)
+  //
+  detail::free_workaround(cpp::tag(), ptr);
+} // end free()
+
+} // end omp
+} // end system
+THRUST_NAMESPACE_END
+

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

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

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

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

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

@@ -0,0 +1,90 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file reduce.h
+ *  \brief OpenMP implementation of reduce algorithms.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/system/omp/detail/execution_policy.h>
+#include <thrust/pair.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace omp
+{
+namespace detail
+{
+
+
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename Predicate>
+  ForwardIterator stable_partition(execution_policy<DerivedPolicy> &exec,
+                                   ForwardIterator first,
+                                   ForwardIterator last,
+                                   Predicate pred);
+
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename InputIterator,
+         typename Predicate>
+  ForwardIterator stable_partition(execution_policy<DerivedPolicy> &exec,
+                                   ForwardIterator first,
+                                   ForwardIterator last,
+                                   InputIterator stencil,
+                                   Predicate pred);
+
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename Predicate>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    stable_partition_copy(execution_policy<DerivedPolicy> &exec,
+                          InputIterator first,
+                          InputIterator last,
+                          OutputIterator1 out_true,
+                          OutputIterator2 out_false,
+                          Predicate pred);
+
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename Predicate>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    stable_partition_copy(execution_policy<DerivedPolicy> &exec,
+                          InputIterator1 first,
+                          InputIterator1 last,
+                          InputIterator2 stencil,
+                          OutputIterator1 out_true,
+                          OutputIterator2 out_false,
+                          Predicate pred);
+
+
+} // end namespace detail
+} // end namespace omp
+} // end namespace system
+THRUST_NAMESPACE_END
+
+#include <thrust/system/omp/detail/partition.inl>
+

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

@@ -0,0 +1,107 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file reduce.h
+ *  \brief OpenMP implementation of reduce algorithms.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/system/omp/detail/partition.h>
+#include <thrust/system/detail/generic/partition.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace omp
+{
+namespace detail
+{
+
+
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename Predicate>
+  ForwardIterator stable_partition(execution_policy<DerivedPolicy> &exec,
+                                   ForwardIterator first,
+                                   ForwardIterator last,
+                                   Predicate pred)
+{
+  // omp prefers generic::stable_partition to cpp::stable_partition
+  return thrust::system::detail::generic::stable_partition(exec, first, last, pred);
+} // end stable_partition()
+
+
+template<typename DerivedPolicy,
+         typename ForwardIterator,
+         typename InputIterator,
+         typename Predicate>
+  ForwardIterator stable_partition(execution_policy<DerivedPolicy> &exec,
+                                   ForwardIterator first,
+                                   ForwardIterator last,
+                                   InputIterator stencil,
+                                   Predicate pred)
+{
+  // omp prefers generic::stable_partition to cpp::stable_partition
+  return thrust::system::detail::generic::stable_partition(exec, first, last, stencil, pred);
+} // end stable_partition()
+
+
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename Predicate>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    stable_partition_copy(execution_policy<DerivedPolicy> &exec,
+                          InputIterator first,
+                          InputIterator last,
+                          OutputIterator1 out_true,
+                          OutputIterator2 out_false,
+                          Predicate pred)
+{
+  // omp prefers generic::stable_partition_copy to cpp::stable_partition_copy
+  return thrust::system::detail::generic::stable_partition_copy(exec, first, last, out_true, out_false, pred);
+} // end stable_partition_copy()
+
+
+template<typename DerivedPolicy,
+         typename InputIterator1,
+         typename InputIterator2,
+         typename OutputIterator1,
+         typename OutputIterator2,
+         typename Predicate>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    stable_partition_copy(execution_policy<DerivedPolicy> &exec,
+                          InputIterator1 first,
+                          InputIterator1 last,
+                          InputIterator2 stencil,
+                          OutputIterator1 out_true,
+                          OutputIterator2 out_false,
+                          Predicate pred)
+{
+  // omp prefers generic::stable_partition_copy to cpp::stable_partition_copy
+  return thrust::system::detail::generic::stable_partition_copy(exec, first, last, stencil, out_true, out_false, pred);
+} // end stable_partition_copy()
+
+
+} // end namespace detail
+} // end namespace omp
+} // end namespace system
+THRUST_NAMESPACE_END
+

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

@@ -0,0 +1,56 @@
+/******************************************************************************
+* Copyright (c) 2021, NVIDIA CORPORATION.  All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*     * Redistributions of source code must retain the above copyright
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above copyright
+*       notice, this list of conditions and the following disclaimer in the
+*       documentation and/or other materials provided with the distribution.
+*     * Neither the name of the NVIDIA CORPORATION nor the
+*       names of its contributors may be used to endorse or promote products
+*       derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+* ARE DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY
+* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*
+******************************************************************************/
+
+#pragma once
+
+#include <thrust/detail/config.h>
+
+#if THRUST_HOST_COMPILER == THRUST_HOST_COMPILER_MSVC
+// MSVC ICEs when using the standard C++11 `_Pragma` operator with OpenMP
+// directives.
+// WAR this by using the MSVC-extension `__pragma`. See this link for more info:
+// https://developercommunity.visualstudio.com/t/Using-C11s-_Pragma-with-OpenMP-dire/1590628
+#define THRUST_PRAGMA_OMP_IMPL(directive) __pragma(directive)
+#else // Not MSVC:
+#define THRUST_PRAGMA_OMP_IMPL(directive) _Pragma(#directive)
+#endif
+
+// For internal use only -- THRUST_PRAGMA_OMP is used to switch between
+// different flavors of openmp pragmas. Pragmas are not emitted when OpenMP is
+// not available.
+//
+// Usage:
+//   Replace: #pragma omp parallel for
+//   With   : THRUST_PRAGMA_OMP(parallel for)
+//
+#if defined(_NVHPC_STDPAR_OPENMP) && _NVHPC_STDPAR_OPENMP == 1
+#define THRUST_PRAGMA_OMP(directive) THRUST_PRAGMA_OMP_IMPL(omp_stdpar directive)
+#elif defined(_OPENMP)
+#define THRUST_PRAGMA_OMP(directive) THRUST_PRAGMA_OMP_IMPL(omp directive)
+#else
+#define THRUST_PRAGMA_OMP(directive)
+#endif

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

@@ -0,0 +1,73 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either 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/omp/detail/reduce.h>
+#include <thrust/system/omp/detail/default_decomposition.h>
+#include <thrust/system/omp/detail/reduce_intervals.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace omp
+{
+namespace detail
+{
+
+
+template<typename DerivedPolicy,
+         typename InputIterator,
+         typename OutputType,
+         typename BinaryFunction>
+  OutputType reduce(execution_policy<DerivedPolicy> &exec,
+                    InputIterator first,
+                    InputIterator last,
+                    OutputType init,
+                    BinaryFunction binary_op)
+{
+  typedef typename thrust::iterator_difference<InputIterator>::type difference_type;
+
+  const difference_type n = thrust::distance(first,last);
+
+  // determine first and second level decomposition
+  thrust::system::detail::internal::uniform_decomposition<difference_type> decomp1 = thrust::system::omp::detail::default_decomposition(n);
+  thrust::system::detail::internal::uniform_decomposition<difference_type> decomp2(decomp1.size() + 1, 1, 1);
+
+  // allocate storage for the initializer and partial sums
+  // XXX use select_system for Tag
+  thrust::detail::temporary_array<OutputType,DerivedPolicy> partial_sums(exec, decomp1.size() + 1);
+
+  // set first element of temp array to init
+  partial_sums[0] = init;
+
+  // accumulate partial sums (first level reduction)
+  thrust::system::omp::detail::reduce_intervals(exec, first, partial_sums.begin() + 1, binary_op, decomp1);
+
+  // reduce partial sums (second level reduction)
+  thrust::system::omp::detail::reduce_intervals(exec, partial_sums.begin(), partial_sums.begin(), binary_op, decomp2);
+
+  return partial_sums[0];
+} // end reduce()
+
+
+} // end detail
+} // end omp
+} // end system
+THRUST_NAMESPACE_END
+

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

@@ -0,0 +1,60 @@
+/*
+ *  Copyright 2008-2013 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+/*! \file reduce.h
+ *  \brief OpenMP implementation of reduce algorithms.
+ */
+
+#pragma once
+
+#include <thrust/detail/config.h>
+#include <thrust/system/omp/detail/execution_policy.h>
+
+THRUST_NAMESPACE_BEGIN
+namespace system
+{
+namespace omp
+{
+namespace detail
+{
+
+
+template <typename DerivedPolicy,
+          typename InputIterator1,
+          typename InputIterator2,
+          typename OutputIterator1,
+          typename OutputIterator2,
+          typename BinaryPredicate,
+          typename BinaryFunction>
+  thrust::pair<OutputIterator1,OutputIterator2>
+    reduce_by_key(execution_policy<DerivedPolicy> &exec,
+                  InputIterator1 keys_first, 
+                  InputIterator1 keys_last,
+                  InputIterator2 values_first,
+                  OutputIterator1 keys_output,
+                  OutputIterator2 values_output,
+                  BinaryPredicate binary_pred,
+                  BinaryFunction binary_op);
+
+
+} // end namespace detail
+} // end namespace omp
+} // end namespace system
+THRUST_NAMESPACE_END
+
+#include <thrust/system/omp/detail/reduce_by_key.inl>
+