Add files using upload-large-folder tool

.gitattributes

@@ -903,3 +903,4 @@ videochat2/lib/python3.10/site-packages/tensorflow/compiler/mlir/quantization/te
 videochat2/lib/python3.10/site-packages/tensorflow/compiler/mlir/quantization/tensorflow/python/pywrap_quantize_model.so filter=lfs diff=lfs merge=lfs -text
 videochat2/lib/python3.10/site-packages/torchvision/_C.so filter=lfs diff=lfs merge=lfs -text
 videochat2/lib/python3.10/site-packages/tensorflow/compiler/mlir/quantization/tensorflow/calibrator/pywrap_calibration.so filter=lfs diff=lfs merge=lfs -text
+videochat2/lib/python3.10/site-packages/tensorflow/python/client/_pywrap_tf_session.so filter=lfs diff=lfs merge=lfs -text

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__algorithm/swap_ranges.h

@@ -0,0 +1,36 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___ALGORITHM_SWAP_RANGES_H
+#define _LIBCUDACXX___ALGORITHM_SWAP_RANGES_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__utility/swap.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _ForwardIterator1, class _ForwardIterator2>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+_ForwardIterator2 swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2)
+{
+    for(; __first1 != __last1; ++__first1, (void) ++__first2)
+        swap(*__first1, *__first2);
+    return __first2;
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___ALGORITHM_SWAP_RANGES_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__concepts/different_from.h

@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___CONCEPTS_DIFFERENT_FROM_H
+#define _LIBCUDACXX___CONCEPTS_DIFFERENT_FROM_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__concepts/same_as.h"
+#include "../__type_traits/remove_cvref.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT __different_from = !same_as<remove_cvref_t<_Tp>, remove_cvref_t<_Up>>;
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_DIFFERENT_FROM_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__concepts/regular.h

@@ -0,0 +1,53 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___CONCEPTS_REGULAR_H
+#define _LIBCUDACXX___CONCEPTS_REGULAR_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__concepts/equality_comparable.h"
+#include "../__concepts/semiregular.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+// [concept.object]
+
+template<class _Tp>
+concept regular = semiregular<_Tp> && equality_comparable<_Tp>;
+
+#elif _LIBCUDACXX_STD_VER > 11
+
+// [concept.object]
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __regular_,
+  requires()(
+    requires(semiregular<_Tp>),
+    requires(equality_comparable<_Tp>)
+  ));
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT regular = _LIBCUDACXX_FRAGMENT(__regular_, _Tp);
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_REGULAR_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__concepts/same_as.h

@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___CONCEPTS_SAME_AS_H
+#define _LIBCUDACXX___CONCEPTS_SAME_AS_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__type_traits/is_same.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+// [concept.same]
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT __same_as_impl = _IsSame<_Tp, _Up>::value;
+
+template<class _Tp, class _Up>
+_LIBCUDACXX_CONCEPT same_as = __same_as_impl<_Tp, _Up> && __same_as_impl<_Up, _Tp>;
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_SAME_AS_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__concepts/semiregular.h

@@ -0,0 +1,53 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___CONCEPTS_SEMIREGULAR_H
+#define _LIBCUDACXX___CONCEPTS_SEMIREGULAR_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__concepts/constructible.h"
+#include "../__concepts/copyable.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 17
+
+// [concept.object]
+
+template<class _Tp>
+concept semiregular = copyable<_Tp> && default_initializable<_Tp>;
+
+#elif _LIBCUDACXX_STD_VER > 11
+
+// [concept.object]
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT_FRAGMENT(
+  __semiregular_,
+  requires()(
+    requires(copyable<_Tp>),
+    requires(default_initializable<_Tp>)
+  ));
+
+template<class _Tp>
+_LIBCUDACXX_CONCEPT semiregular = _LIBCUDACXX_FRAGMENT(__semiregular_, _Tp);
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___CONCEPTS_SEMIREGULAR_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/binary_function.h

@@ -0,0 +1,56 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___FUNCTIONAL_BINARY_FUNCTION_H
+#define _LIBCUDACXX___FUNCTIONAL_BINARY_FUNCTION_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER <= 14 || defined(_LIBCUDACXX_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION)
+
+template <class _Arg1, class _Arg2, class _Result>
+struct _LIBCUDACXX_TEMPLATE_VIS _LIBCUDACXX_DEPRECATED_IN_CXX11 binary_function
+{
+    typedef _Arg1   first_argument_type;
+    typedef _Arg2   second_argument_type;
+    typedef _Result result_type;
+};
+
+#endif // _LIBCUDACXX_STD_VER <= 14 || defined(_LIBCUDACXX_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION)
+
+template <class _Arg1, class _Arg2, class _Result> struct __binary_function_keep_layout_base {
+#if _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
+  using first_argument_type _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Arg1;
+  using second_argument_type _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Arg2;
+  using result_type _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Result;
+#endif
+};
+
+#if _LIBCUDACXX_STD_VER <= 14 || defined(_LIBCUDACXX_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION)
+_LIBCUDACXX_DIAGNOSTIC_PUSH
+_LIBCUDACXX_CLANG_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations")
+template <class _Arg1, class _Arg2, class _Result>
+using __binary_function = binary_function<_Arg1, _Arg2, _Result>;
+_LIBCUDACXX_DIAGNOSTIC_POP
+#else
+template <class _Arg1, class _Arg2, class _Result>
+using __binary_function = __binary_function_keep_layout_base<_Arg1, _Arg2, _Result>;
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___FUNCTIONAL_BINARY_FUNCTION_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/bind_back.h

@@ -0,0 +1,75 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___FUNCTIONAL_BIND_BACK_H
+#define _LIBCUDACXX___FUNCTIONAL_BIND_BACK_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__functional/invoke.h"
+#include "../__functional/perfect_forward.h"
+#include "../__fwd/get.h"
+#include "../__tuple_dir/tuple_size.h"
+#include "../__type_traits/decay.h"
+#include "../__type_traits/enable_if.h"
+#include "../__type_traits/is_constructible.h"
+#include "../__type_traits/is_move_constructible.h"
+#include "../__utility/forward.h"
+#include "../__utility/integer_sequence.h"
+
+#include "../tuple"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 14
+
+template <size_t _NBound, class = make_index_sequence<_NBound>>
+struct __bind_back_op;
+
+template <size_t _NBound, size_t ..._Ip>
+struct __bind_back_op<_NBound, index_sequence<_Ip...>> {
+    template <class _Fn, class _BoundArgs, class... _Args>
+    _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY
+    constexpr auto operator()(_Fn&& __f, _BoundArgs&& __bound_args, _Args&&... __args) const
+        noexcept(noexcept(_CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fn>(__f), _CUDA_VSTD::forward<_Args>(__args)..., _CUDA_VSTD::get<_Ip>(_CUDA_VSTD::forward<_BoundArgs>(__bound_args))...)))
+        -> decltype(      _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fn>(__f), _CUDA_VSTD::forward<_Args>(__args)..., _CUDA_VSTD::get<_Ip>(_CUDA_VSTD::forward<_BoundArgs>(__bound_args))...))
+        { return          _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fn>(__f), _CUDA_VSTD::forward<_Args>(__args)..., _CUDA_VSTD::get<_Ip>(_CUDA_VSTD::forward<_BoundArgs>(__bound_args))...); }
+};
+
+template <class _Fn, class _BoundArgs>
+struct __bind_back_t : __perfect_forward<__bind_back_op<tuple_size_v<_BoundArgs>>, _Fn, _BoundArgs> {
+    using __perfect_forward<__bind_back_op<tuple_size_v<_BoundArgs>>, _Fn, _BoundArgs>::__perfect_forward;
+};
+
+template <class _Fn, class ..._Args, class = enable_if_t<
+    _And<
+        is_constructible<decay_t<_Fn>, _Fn>,
+        is_move_constructible<decay_t<_Fn>>,
+        is_constructible<decay_t<_Args>, _Args>...,
+        is_move_constructible<decay_t<_Args>>...
+    >::value
+>>
+_LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY
+constexpr auto __bind_back(_Fn&& __f, _Args&&... __args)
+    noexcept(noexcept(__bind_back_t<decay_t<_Fn>, tuple<decay_t<_Args>...>>(_CUDA_VSTD::forward<_Fn>(__f), _CUDA_VSTD::forward_as_tuple(_CUDA_VSTD::forward<_Args>(__args)...))))
+    -> decltype(      __bind_back_t<decay_t<_Fn>, tuple<decay_t<_Args>...>>(_CUDA_VSTD::forward<_Fn>(__f), _CUDA_VSTD::forward_as_tuple(_CUDA_VSTD::forward<_Args>(__args)...)))
+    { return          __bind_back_t<decay_t<_Fn>, tuple<decay_t<_Args>...>>(_CUDA_VSTD::forward<_Fn>(__f), _CUDA_VSTD::forward_as_tuple(_CUDA_VSTD::forward<_Args>(__args)...)); }
+
+#endif // _LIBCUDACXX_STD_VER > 14
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___FUNCTIONAL_BIND_BACK_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/bind_front.h

@@ -0,0 +1,78 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___FUNCTIONAL_BIND_FRONT_H
+#define _LIBCUDACXX___FUNCTIONAL_BIND_FRONT_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__functional/invoke.h"
+#include "../__functional/perfect_forward.h"
+#include "../__type_traits/decay.h"
+#include "../__type_traits/enable_if.h"
+#include "../__type_traits/is_constructible.h"
+#include "../__type_traits/is_move_constructible.h"
+#include "../__type_traits/is_nothrow_constructible.h"
+#include "../__utility/forward.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 14
+
+struct __bind_front_op {
+    template <class ..._Args>
+    _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY
+    constexpr auto operator()(_Args&& ...__args) const
+        noexcept(noexcept(_CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Args>(__args)...)))
+        -> decltype(      _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Args>(__args)...))
+        { return          _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Args>(__args)...); }
+};
+
+template <class _Fn, class ..._BoundArgs>
+struct __bind_front_t : __perfect_forward<__bind_front_op, _Fn, _BoundArgs...> {
+    using __base = __perfect_forward<__bind_front_op, _Fn, _BoundArgs...>;
+#if defined(_LIBCUDACXX_COMPILER_NVRTC)
+    constexpr __bind_front_t() noexcept = default;
+
+    template<class... _Args>
+    _LIBCUDACXX_INLINE_VISIBILITY constexpr
+    __bind_front_t(_Args&&... __args) noexcept(noexcept(__base(_CUDA_VSTD::declval<_Args>()...)))
+        : __base(_CUDA_VSTD::forward<_Args>(__args)...)
+    {}
+#else
+    using __base::__base;
+#endif
+};
+
+template<class _Fn, class... _Args>
+_LIBCUDACXX_CONCEPT __can_bind_front = is_constructible_v<decay_t<_Fn>, _Fn> &&
+                                       is_move_constructible_v<decay_t<_Fn>> &&
+                                       (is_constructible_v<decay_t<_Args>, _Args> && ...) &&
+                                       (is_move_constructible_v<decay_t<_Args>> && ... );
+
+_LIBCUDACXX_TEMPLATE(class _Fn, class... _Args)
+  (requires __can_bind_front<_Fn, _Args...>)
+_LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY
+constexpr auto bind_front(_Fn&& __f, _Args&&... __args) noexcept(is_nothrow_constructible_v<tuple<decay_t<_Args>...>, _Args&&...>) {
+    return __bind_front_t<decay_t<_Fn>, decay_t<_Args>...>(_CUDA_VSTD::forward<_Fn>(__f), _CUDA_VSTD::forward<_Args>(__args)...);
+}
+
+#endif // _LIBCUDACXX_STD_VER > 14
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___FUNCTIONAL_BIND_FRONT_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/binder1st.h

@@ -0,0 +1,59 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___FUNCTIONAL_BINDER1ST_H
+#define _LIBCUDACXX___FUNCTIONAL_BINDER1ST_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__functional/unary_function.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER <= 14 || defined(_LIBCUDACXX_ENABLE_CXX17_REMOVED_BINDERS)
+
+template <class __Operation>
+class _LIBCUDACXX_TEMPLATE_VIS _LIBCUDACXX_DEPRECATED_IN_CXX11 binder1st
+    : public __unary_function<typename __Operation::second_argument_type, typename __Operation::result_type>
+{
+protected:
+    __Operation                               op;
+    typename __Operation::first_argument_type value;
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY binder1st(const __Operation& __x,
+                               const typename __Operation::first_argument_type __y)
+        : op(__x), value(__y) {}
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    _LIBCUDACXX_INLINE_VISIBILITY typename __Operation::result_type operator()
+        (typename __Operation::second_argument_type& __x) const
+            {return op(value, __x);}
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    _LIBCUDACXX_INLINE_VISIBILITY typename __Operation::result_type operator()
+        (const typename __Operation::second_argument_type& __x) const
+            {return op(value, __x);}
+};
+
+template <class __Operation, class _Tp>
+_LIBCUDACXX_DEPRECATED_IN_CXX11 inline _LIBCUDACXX_INLINE_VISIBILITY
+binder1st<__Operation>
+bind1st(const __Operation& __op, const _Tp& __x)
+    {return binder1st<__Operation>(__op, __x);}
+
+#endif // _LIBCUDACXX_STD_VER <= 14 || defined(_LIBCUDACXX_ENABLE_CXX17_REMOVED_BINDERS)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___FUNCTIONAL_BINDER1ST_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/binder2nd.h

@@ -0,0 +1,59 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___FUNCTIONAL_BINDER2ND_H
+#define _LIBCUDACXX___FUNCTIONAL_BINDER2ND_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__functional/unary_function.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER <= 14 || defined(_LIBCUDACXX_ENABLE_CXX17_REMOVED_BINDERS)
+
+template <class __Operation>
+class _LIBCUDACXX_TEMPLATE_VIS _LIBCUDACXX_DEPRECATED_IN_CXX11 binder2nd
+    : public __unary_function<typename __Operation::first_argument_type, typename __Operation::result_type>
+{
+protected:
+    __Operation                                op;
+    typename __Operation::second_argument_type value;
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    binder2nd(const __Operation& __x, const typename __Operation::second_argument_type __y)
+        : op(__x), value(__y) {}
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    _LIBCUDACXX_INLINE_VISIBILITY typename __Operation::result_type operator()
+        (      typename __Operation::first_argument_type& __x) const
+            {return op(__x, value);}
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    _LIBCUDACXX_INLINE_VISIBILITY typename __Operation::result_type operator()
+        (const typename __Operation::first_argument_type& __x) const
+            {return op(__x, value);}
+};
+
+template <class __Operation, class _Tp>
+_LIBCUDACXX_DEPRECATED_IN_CXX11 inline _LIBCUDACXX_INLINE_VISIBILITY
+binder2nd<__Operation>
+bind2nd(const __Operation& __op, const _Tp& __x)
+    {return binder2nd<__Operation>(__op, __x);}
+
+#endif // _LIBCUDACXX_STD_VER <= 14 || defined(_LIBCUDACXX_ENABLE_CXX17_REMOVED_BINDERS)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___FUNCTIONAL_BINDER2ND_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/compose.h

@@ -0,0 +1,56 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___FUNCTIONAL_COMPOSE_H
+#define _LIBCUDACXX___FUNCTIONAL_COMPOSE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__functional/invoke.h"
+#include "../__functional/perfect_forward.h"
+#include "../__type_traits/decay.h"
+#include "../__utility/forward.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 14
+
+struct __compose_op {
+    template<class _Fn1, class _Fn2, class ..._Args>
+    _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY
+    constexpr auto operator()(_Fn1&& __f1, _Fn2&& __f2, _Args&&... __args) const
+        noexcept(noexcept(_CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fn1>(__f1), _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fn2>(__f2), _CUDA_VSTD::forward<_Args>(__args)...))))
+        -> decltype(      _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fn1>(__f1), _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fn2>(__f2), _CUDA_VSTD::forward<_Args>(__args)...)))
+        { return          _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fn1>(__f1), _CUDA_VSTD::invoke(_CUDA_VSTD::forward<_Fn2>(__f2), _CUDA_VSTD::forward<_Args>(__args)...)); }
+};
+
+template <class _Fn1, class _Fn2>
+struct __compose_t : __perfect_forward<__compose_op, _Fn1, _Fn2> {
+    using __perfect_forward<__compose_op, _Fn1, _Fn2>::__perfect_forward;
+};
+
+template <class _Fn1, class _Fn2>
+_LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY
+constexpr auto __compose(_Fn1&& __f1, _Fn2&& __f2)
+    noexcept(noexcept(__compose_t<decay_t<_Fn1>, decay_t<_Fn2>>(_CUDA_VSTD::forward<_Fn1>(__f1), _CUDA_VSTD::forward<_Fn2>(__f2))))
+    -> decltype(      __compose_t<decay_t<_Fn1>, decay_t<_Fn2>>(_CUDA_VSTD::forward<_Fn1>(__f1), _CUDA_VSTD::forward<_Fn2>(__f2)))
+    { return          __compose_t<decay_t<_Fn1>, decay_t<_Fn2>>(_CUDA_VSTD::forward<_Fn1>(__f1), _CUDA_VSTD::forward<_Fn2>(__f2)); }
+
+#endif // _LIBCUDACXX_STD_VER > 14
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___FUNCTIONAL_COMPOSE_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/default_searcher.h

@@ -0,0 +1,148 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___FUNCTIONAL_DEFAULT_SEARCHER_H
+#define _LIBCUDACXX___FUNCTIONAL_DEFAULT_SEARCHER_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+// #include "../__algorithm/search.h"
+#include "../__functional/identity.h"
+#include "../__functional/operations.h"
+#include "../__iterator/iterator_traits.h"
+#include "../__utility/pair.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _BinaryPredicate, class _ForwardIterator1, class _ForwardIterator2>
+_LIBCUDACXX_HOST_DEVICE _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+pair<_ForwardIterator1, _ForwardIterator1>
+__search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+         _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred,
+         forward_iterator_tag, forward_iterator_tag)
+{
+    if (__first2 == __last2)
+        return _CUDA_VSTD::make_pair(__first1, __first1);  // Everything matches an empty sequence
+    while (true)
+    {
+        // Find first element in sequence 1 that matchs *__first2, with a mininum of loop checks
+        while (true)
+        {
+            if (__first1 == __last1)  // return __last1 if no element matches *__first2
+                return _CUDA_VSTD::make_pair(__last1, __last1);
+            if (__pred(*__first1, *__first2))
+                break;
+            ++__first1;
+        }
+        // *__first1 matches *__first2, now match elements after here
+        _ForwardIterator1 __m1 = __first1;
+        _ForwardIterator2 __m2 = __first2;
+        while (true)
+        {
+            if (++__m2 == __last2)  // If pattern exhausted, __first1 is the answer (works for 1 element pattern)
+                return _CUDA_VSTD::make_pair(__first1, __m1);
+            if (++__m1 == __last1)  // Otherwise if source exhaused, pattern not found
+                return _CUDA_VSTD::make_pair(__last1, __last1);
+            if (!__pred(*__m1, *__m2))  // if there is a mismatch, restart with a new __first1
+            {
+                ++__first1;
+                break;
+            }  // else there is a match, check next elements
+        }
+    }
+}
+
+template <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2>
+_LIBCUDACXX_HOST_DEVICE _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+pair<_RandomAccessIterator1, _RandomAccessIterator1>
+__search(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
+         _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred,
+           random_access_iterator_tag, random_access_iterator_tag)
+{
+    typedef typename iterator_traits<_RandomAccessIterator1>::difference_type _Diff1;
+    typedef typename iterator_traits<_RandomAccessIterator2>::difference_type _Diff2;
+    // Take advantage of knowing source and pattern lengths.  Stop short when source is smaller than pattern
+    const _Diff2 __len2 = __last2 - __first2;
+    if (__len2 == 0)
+        return _CUDA_VSTD::make_pair(__first1, __first1);
+    const _Diff1 __len1 = __last1 - __first1;
+    if (__len1 < __len2)
+        return _CUDA_VSTD::make_pair(__last1, __last1);
+    const _RandomAccessIterator1 __s = __last1 - (__len2 - 1);  // Start of pattern match can't go beyond here
+
+    while (true)
+    {
+        while (true)
+        {
+            if (__first1 == __s)
+                return _CUDA_VSTD::make_pair(__last1, __last1);
+            if (__pred(*__first1, *__first2))
+                break;
+            ++__first1;
+        }
+
+        _RandomAccessIterator1 __m1 = __first1;
+        _RandomAccessIterator2 __m2 = __first2;
+         while (true)
+         {
+             if (++__m2 == __last2)
+                 return _CUDA_VSTD::make_pair(__first1, __first1 + __len2);
+             ++__m1;          // no need to check range on __m1 because __s guarantees we have enough source
+             if (!__pred(*__m1, *__m2))
+             {
+                 ++__first1;
+                 break;
+             }
+         }
+    }
+}
+
+#ifndef __cuda_std__
+
+#if _LIBCUDACXX_STD_VER > 14
+
+// default searcher
+template<class _ForwardIterator, class _BinaryPredicate = equal_to<>>
+class _LIBCUDACXX_TEMPLATE_VIS default_searcher {
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+    default_searcher(_ForwardIterator __f, _ForwardIterator __l,
+                       _BinaryPredicate __p = _BinaryPredicate())
+        : __first_(__f), __last_(__l), __pred_(__p) {}
+
+    template <typename _ForwardIterator2>
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+    pair<_ForwardIterator2, _ForwardIterator2>
+    operator () (_ForwardIterator2 __f, _ForwardIterator2 __l) const
+    {
+        return _CUDA_VSTD::__search(__f, __l, __first_, __last_, __pred_,
+            typename _CUDA_VSTD::iterator_traits<_ForwardIterator>::iterator_category(),
+            typename _CUDA_VSTD::iterator_traits<_ForwardIterator2>::iterator_category());
+    }
+
+private:
+    _ForwardIterator __first_;
+    _ForwardIterator __last_;
+    _BinaryPredicate __pred_;
+};
+_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(default_searcher);
+
+#endif // _LIBCUDACXX_STD_VER > 14
+#endif // __cuda_std__
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___FUNCTIONAL_DEFAULT_SEARCHER_H

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

@@ -0,0 +1,1261 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___FUNCTIONAL_FUNCTION_H
+#define _LIBCUDACXX___FUNCTIONAL_FUNCTION_H
+
+#ifndef __cuda_std__
+
+#ifndef __cuda_std__
+#include <__config>
+#include <exception>
+#include <memory>
+#include <new>
+#include <typeinfo>
+#endif // __cuda_std__
+
+#include "__assert"
+#include "../__debug"
+#include "../__functional_base"
+#include "../__functional/binary_function.h"
+#include "../__functional/invoke.h"
+#include "../__functional/unary_function.h"
+#include "../__iterator/iterator_traits.h"
+#include "../__type_traits/conditional.h"
+#include "../__type_traits/decay.h"
+#include "../__type_traits/enable_if.h"
+#include "../__type_traits/is_nothrow_copy_constructible.h"
+#include "../__type_traits/is_same.h"
+#include "../__type_traits/is_scalar.h"
+#include "../__type_traits/is_trivially_copy_constructible.h"
+#include "../__type_traits/is_trivially_destructible.h"
+#include "../__type_traits/is_void.h"
+#include "../__type_traits/remove_cvref.h"
+#include "../__utility/forward.h"
+#include "../__utility/move.h"
+#include "../__utility/piecewise_construct.h"
+#include "../__utility/swap.h"
+#include "../tuple"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+#ifndef _LIBCUDACXX_CXX03_LANG
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// bad_function_call
+
+class _LIBCUDACXX_EXCEPTION_ABI bad_function_call
+    : public exception
+{
+#ifdef _LIBCUDACXX_ABI_BAD_FUNCTION_CALL_KEY_FUNCTION
+public:
+    virtual ~bad_function_call() _NOEXCEPT;
+
+    virtual const char* what() const _NOEXCEPT;
+#endif
+};
+
+_LIBCUDACXX_NORETURN inline _LIBCUDACXX_INLINE_VISIBILITY
+void __throw_bad_function_call()
+{
+#ifndef _LIBCUDACXX_NO_EXCEPTIONS
+    throw bad_function_call();
+#else
+    _CUDA_VSTD::abort();
+#endif
+}
+
+template<class _Fp> class _LIBCUDACXX_TEMPLATE_VIS function; // undefined
+
+namespace __function
+{
+
+template<class _Rp>
+struct __maybe_derive_from_unary_function
+{
+};
+
+template<class _Rp, class _A1>
+struct __maybe_derive_from_unary_function<_Rp(_A1)>
+    : public __unary_function<_A1, _Rp>
+{
+};
+
+template<class _Rp>
+struct __maybe_derive_from_binary_function
+{
+};
+
+template<class _Rp, class _A1, class _A2>
+struct __maybe_derive_from_binary_function<_Rp(_A1, _A2)>
+    : public __binary_function<_A1, _A2, _Rp>
+{
+};
+
+template <class _Fp>
+_LIBCUDACXX_INLINE_VISIBILITY
+bool __not_null(_Fp const&) { return true; }
+
+template <class _Fp>
+_LIBCUDACXX_INLINE_VISIBILITY
+bool __not_null(_Fp* __ptr) { return __ptr; }
+
+template <class _Ret, class _Class>
+_LIBCUDACXX_INLINE_VISIBILITY
+bool __not_null(_Ret _Class::*__ptr) { return __ptr; }
+
+template <class _Fp>
+_LIBCUDACXX_INLINE_VISIBILITY
+bool __not_null(function<_Fp> const& __f) { return !!__f; }
+
+#ifdef _LIBCUDACXX_HAS_EXTENSION_BLOCKS
+template <class _Rp, class ..._Args>
+_LIBCUDACXX_INLINE_VISIBILITY
+bool __not_null(_Rp (^__p)(_Args...)) { return __p; }
+#endif
+
+} // namespace __function
+
+#ifndef _LIBCUDACXX_CXX03_LANG
+
+namespace __function {
+
+// __alloc_func holds a functor and an allocator.
+
+template <class _Fp, class _Ap, class _FB> class __alloc_func;
+template <class _Fp, class _FB>
+class __default_alloc_func;
+
+template <class _Fp, class _Ap, class _Rp, class... _ArgTypes>
+class __alloc_func<_Fp, _Ap, _Rp(_ArgTypes...)>
+{
+    __compressed_pair<_Fp, _Ap> __f_;
+
+  public:
+    typedef _LIBCUDACXX_NODEBUG_TYPE _Fp _Target;
+    typedef _LIBCUDACXX_NODEBUG_TYPE _Ap _Alloc;
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const _Target& __target() const { return __f_.first(); }
+
+    // WIN32 APIs may define __allocator, so use __get_allocator instead.
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const _Alloc& __get_allocator() const { return __f_.second(); }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit __alloc_func(_Target&& __f)
+        : __f_(piecewise_construct, _CUDA_VSTD::forward_as_tuple(_CUDA_VSTD::move(__f)),
+               _CUDA_VSTD::forward_as_tuple())
+    {
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit __alloc_func(const _Target& __f, const _Alloc& __a)
+        : __f_(piecewise_construct, _CUDA_VSTD::forward_as_tuple(__f),
+               _CUDA_VSTD::forward_as_tuple(__a))
+    {
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit __alloc_func(const _Target& __f, _Alloc&& __a)
+        : __f_(piecewise_construct, _CUDA_VSTD::forward_as_tuple(__f),
+               _CUDA_VSTD::forward_as_tuple(_CUDA_VSTD::move(__a)))
+    {
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit __alloc_func(_Target&& __f, _Alloc&& __a)
+        : __f_(piecewise_construct, _CUDA_VSTD::forward_as_tuple(_CUDA_VSTD::move(__f)),
+               _CUDA_VSTD::forward_as_tuple(_CUDA_VSTD::move(__a)))
+    {
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    _Rp operator()(_ArgTypes&&... __arg)
+    {
+        typedef __invoke_void_return_wrapper<_Rp> _Invoker;
+        return _Invoker::__call(__f_.first(),
+                                _CUDA_VSTD::forward<_ArgTypes>(__arg)...);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __alloc_func* __clone() const
+    {
+        typedef allocator_traits<_Alloc> __alloc_traits;
+        typedef typename __rebind_alloc_helper<__alloc_traits, __alloc_func>::type _AA;
+        _AA __a(__f_.second());
+        typedef __allocator_destructor<_AA> _Dp;
+        unique_ptr<__alloc_func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
+        ::new ((void*)__hold.get()) __alloc_func(__f_.first(), _Alloc(__a));
+        return __hold.release();
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void destroy() _NOEXCEPT { __f_.~__compressed_pair<_Target, _Alloc>(); }
+
+    static void __destroy_and_delete(__alloc_func* __f) {
+      typedef allocator_traits<_Alloc> __alloc_traits;
+      typedef typename __rebind_alloc_helper<__alloc_traits, __alloc_func>::type _FunAlloc;
+      _FunAlloc __a(__f->__get_allocator());
+      __f->destroy();
+      __a.deallocate(__f, 1);
+    }
+};
+
+template <class _Fp, class _Rp, class... _ArgTypes>
+class __default_alloc_func<_Fp, _Rp(_ArgTypes...)> {
+  _Fp __f_;
+
+public:
+  typedef _LIBCUDACXX_NODEBUG_TYPE _Fp _Target;
+
+  _LIBCUDACXX_INLINE_VISIBILITY
+  const _Target& __target() const { return __f_; }
+
+  _LIBCUDACXX_INLINE_VISIBILITY
+  explicit __default_alloc_func(_Target&& __f) : __f_(_CUDA_VSTD::move(__f)) {}
+
+  _LIBCUDACXX_INLINE_VISIBILITY
+  explicit __default_alloc_func(const _Target& __f) : __f_(__f) {}
+
+  _LIBCUDACXX_INLINE_VISIBILITY
+  _Rp operator()(_ArgTypes&&... __arg) {
+    typedef __invoke_void_return_wrapper<_Rp> _Invoker;
+    return _Invoker::__call(__f_, _CUDA_VSTD::forward<_ArgTypes>(__arg)...);
+  }
+
+  _LIBCUDACXX_INLINE_VISIBILITY
+  __default_alloc_func* __clone() const {
+      __builtin_new_allocator::__holder_t __hold =
+        __builtin_new_allocator::__allocate_type<__default_alloc_func>(1);
+    __default_alloc_func* __res =
+        ::new ((void*)__hold.get()) __default_alloc_func(__f_);
+    (void)__hold.release();
+    return __res;
+  }
+
+  _LIBCUDACXX_INLINE_VISIBILITY
+  void destroy() _NOEXCEPT { __f_.~_Target(); }
+
+  static void __destroy_and_delete(__default_alloc_func* __f) {
+    __f->destroy();
+      __builtin_new_allocator::__deallocate_type<__default_alloc_func>(__f, 1);
+  }
+};
+
+// __base provides an abstract interface for copyable functors.
+
+template<class _Fp> class _LIBCUDACXX_TEMPLATE_VIS __base;
+
+template<class _Rp, class ..._ArgTypes>
+class __base<_Rp(_ArgTypes...)>
+{
+    __base(const __base&);
+    __base& operator=(const __base&);
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY __base() {}
+    _LIBCUDACXX_INLINE_VISIBILITY virtual ~__base() {}
+    virtual __base* __clone() const = 0;
+    virtual void __clone(__base*) const = 0;
+    virtual void destroy() _NOEXCEPT = 0;
+    virtual void destroy_deallocate() _NOEXCEPT = 0;
+    virtual _Rp operator()(_ArgTypes&& ...) = 0;
+#ifndef _LIBCUDACXX_NO_RTTI
+    virtual const void* target(const type_info&) const _NOEXCEPT = 0;
+    virtual const type_info& target_type() const _NOEXCEPT = 0;
+#endif // _LIBCUDACXX_NO_RTTI
+};
+
+// __func implements __base for a given functor type.
+
+template<class _FD, class _Alloc, class _FB> class __func;
+
+template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
+class __func<_Fp, _Alloc, _Rp(_ArgTypes...)>
+    : public  __base<_Rp(_ArgTypes...)>
+{
+    __alloc_func<_Fp, _Alloc, _Rp(_ArgTypes...)> __f_;
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit __func(_Fp&& __f)
+        : __f_(_CUDA_VSTD::move(__f)) {}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit __func(const _Fp& __f, const _Alloc& __a)
+        : __f_(__f, __a) {}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit __func(const _Fp& __f, _Alloc&& __a)
+        : __f_(__f, _CUDA_VSTD::move(__a)) {}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit __func(_Fp&& __f, _Alloc&& __a)
+        : __f_(_CUDA_VSTD::move(__f), _CUDA_VSTD::move(__a)) {}
+
+    virtual __base<_Rp(_ArgTypes...)>* __clone() const;
+    virtual void __clone(__base<_Rp(_ArgTypes...)>*) const;
+    virtual void destroy() _NOEXCEPT;
+    virtual void destroy_deallocate() _NOEXCEPT;
+    virtual _Rp operator()(_ArgTypes&&... __arg);
+#ifndef _LIBCUDACXX_NO_RTTI
+    virtual const void* target(const type_info&) const _NOEXCEPT;
+    virtual const type_info& target_type() const _NOEXCEPT;
+#endif // _LIBCUDACXX_NO_RTTI
+};
+
+template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
+__base<_Rp(_ArgTypes...)>*
+__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone() const
+{
+    typedef allocator_traits<_Alloc> __alloc_traits;
+    typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap;
+    _Ap __a(__f_.__get_allocator());
+    typedef __allocator_destructor<_Ap> _Dp;
+    unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
+    ::new ((void*)__hold.get()) __func(__f_.__target(), _Alloc(__a));
+    return __hold.release();
+}
+
+template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
+void
+__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone(__base<_Rp(_ArgTypes...)>* __p) const
+{
+    ::new ((void*)__p) __func(__f_.__target(), __f_.__get_allocator());
+}
+
+template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
+void
+__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy() _NOEXCEPT
+{
+    __f_.destroy();
+}
+
+template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
+void
+__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate() _NOEXCEPT
+{
+    typedef allocator_traits<_Alloc> __alloc_traits;
+    typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap;
+    _Ap __a(__f_.__get_allocator());
+    __f_.destroy();
+    __a.deallocate(this, 1);
+}
+
+template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
+_Rp
+__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
+{
+    return __f_(_CUDA_VSTD::forward<_ArgTypes>(__arg)...);
+}
+
+#ifndef _LIBCUDACXX_NO_RTTI
+
+template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
+const void*
+__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target(const type_info& __ti) const _NOEXCEPT
+{
+    if (__ti == typeid(_Fp))
+        return _CUDA_VSTD::addressof(__f_.__target());
+    return nullptr;
+}
+
+template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
+const type_info&
+__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target_type() const _NOEXCEPT
+{
+    return typeid(_Fp);
+}
+
+#endif // _LIBCUDACXX_NO_RTTI
+
+// __value_func creates a value-type from a __func.
+
+template <class _Fp> class __value_func;
+
+template <class _Rp, class... _ArgTypes> class __value_func<_Rp(_ArgTypes...)>
+{
+    typename aligned_storage<3 * sizeof(void*)>::type __buf_;
+
+    typedef __base<_Rp(_ArgTypes...)> __func;
+    __func* __f_;
+
+    _LIBCUDACXX_NO_CFI static __func* __as_base(void* __p)
+    {
+        return reinterpret_cast<__func*>(__p);
+    }
+
+  public:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __value_func() _NOEXCEPT : __f_(nullptr) {}
+
+    template <class _Fp, class _Alloc>
+    _LIBCUDACXX_INLINE_VISIBILITY __value_func(_Fp&& __f, const _Alloc& __a)
+        : __f_(nullptr)
+    {
+        typedef allocator_traits<_Alloc> __alloc_traits;
+        typedef __function::__func<_Fp, _Alloc, _Rp(_ArgTypes...)> _Fun;
+        typedef typename __rebind_alloc_helper<__alloc_traits, _Fun>::type _FunAlloc;
+
+        if (__function::__not_null(__f))
+        {
+            _FunAlloc __af(__a);
+            if (sizeof(_Fun) <= sizeof(__buf_) &&
+                is_nothrow_copy_constructible<_Fp>::value &&
+                is_nothrow_copy_constructible<_FunAlloc>::value)
+            {
+                __f_ =
+                    ::new ((void*)&__buf_) _Fun(_CUDA_VSTD::move(__f), _Alloc(__af));
+            }
+            else
+            {
+                typedef __allocator_destructor<_FunAlloc> _Dp;
+                unique_ptr<__func, _Dp> __hold(__af.allocate(1), _Dp(__af, 1));
+                ::new ((void*)__hold.get()) _Fun(_CUDA_VSTD::move(__f), _Alloc(__a));
+                __f_ = __hold.release();
+            }
+        }
+    }
+
+    template <class _Fp,
+        class = __enable_if_t<!is_same<__decay_t<_Fp>, __value_func>::value>>
+    _LIBCUDACXX_INLINE_VISIBILITY explicit __value_func(_Fp&& __f)
+        : __value_func(_CUDA_VSTD::forward<_Fp>(__f), allocator<_Fp>()) {}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __value_func(const __value_func& __f)
+    {
+        if (__f.__f_ == nullptr)
+            __f_ = nullptr;
+        else if ((void*)__f.__f_ == &__f.__buf_)
+        {
+            __f_ = __as_base(&__buf_);
+            __f.__f_->__clone(__f_);
+        }
+        else
+            __f_ = __f.__f_->__clone();
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __value_func(__value_func&& __f) _NOEXCEPT
+    {
+        if (__f.__f_ == nullptr)
+            __f_ = nullptr;
+        else if ((void*)__f.__f_ == &__f.__buf_)
+        {
+            __f_ = __as_base(&__buf_);
+            __f.__f_->__clone(__f_);
+        }
+        else
+        {
+            __f_ = __f.__f_;
+            __f.__f_ = nullptr;
+        }
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    ~__value_func()
+    {
+        if ((void*)__f_ == &__buf_)
+            __f_->destroy();
+        else if (__f_)
+            __f_->destroy_deallocate();
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __value_func& operator=(__value_func&& __f)
+    {
+        *this = nullptr;
+        if (__f.__f_ == nullptr)
+            __f_ = nullptr;
+        else if ((void*)__f.__f_ == &__f.__buf_)
+        {
+            __f_ = __as_base(&__buf_);
+            __f.__f_->__clone(__f_);
+        }
+        else
+        {
+            __f_ = __f.__f_;
+            __f.__f_ = nullptr;
+        }
+        return *this;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __value_func& operator=(nullptr_t)
+    {
+        __func* __f = __f_;
+        __f_ = nullptr;
+        if ((void*)__f == &__buf_)
+            __f->destroy();
+        else if (__f)
+            __f->destroy_deallocate();
+        return *this;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    _Rp operator()(_ArgTypes&&... __args) const
+    {
+        if (__f_ == nullptr)
+            __throw_bad_function_call();
+        return (*__f_)(_CUDA_VSTD::forward<_ArgTypes>(__args)...);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void swap(__value_func& __f) _NOEXCEPT
+    {
+        if (&__f == this)
+            return;
+        if ((void*)__f_ == &__buf_ && (void*)__f.__f_ == &__f.__buf_)
+        {
+            typename aligned_storage<sizeof(__buf_)>::type __tempbuf;
+            __func* __t = __as_base(&__tempbuf);
+            __f_->__clone(__t);
+            __f_->destroy();
+            __f_ = nullptr;
+            __f.__f_->__clone(__as_base(&__buf_));
+            __f.__f_->destroy();
+            __f.__f_ = nullptr;
+            __f_ = __as_base(&__buf_);
+            __t->__clone(__as_base(&__f.__buf_));
+            __t->destroy();
+            __f.__f_ = __as_base(&__f.__buf_);
+        }
+        else if ((void*)__f_ == &__buf_)
+        {
+            __f_->__clone(__as_base(&__f.__buf_));
+            __f_->destroy();
+            __f_ = __f.__f_;
+            __f.__f_ = __as_base(&__f.__buf_);
+        }
+        else if ((void*)__f.__f_ == &__f.__buf_)
+        {
+            __f.__f_->__clone(__as_base(&__buf_));
+            __f.__f_->destroy();
+            __f.__f_ = __f_;
+            __f_ = __as_base(&__buf_);
+        }
+        else
+            _CUDA_VSTD::swap(__f_, __f.__f_);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    _LIBCUDACXX_EXPLICIT operator bool() const _NOEXCEPT { return __f_ != nullptr; }
+
+#ifndef _LIBCUDACXX_NO_RTTI
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const type_info& target_type() const _NOEXCEPT
+    {
+        if (__f_ == nullptr)
+            return typeid(void);
+        return __f_->target_type();
+    }
+
+    template <typename _Tp>
+    _LIBCUDACXX_INLINE_VISIBILITY const _Tp* target() const _NOEXCEPT
+    {
+        if (__f_ == nullptr)
+            return nullptr;
+        return (const _Tp*)__f_->target(typeid(_Tp));
+    }
+#endif // _LIBCUDACXX_NO_RTTI
+};
+
+// Storage for a functor object, to be used with __policy to manage copy and
+// destruction.
+union __policy_storage
+{
+    mutable char __small[sizeof(void*) * 2];
+    void* __large;
+};
+
+// True if _Fun can safely be held in __policy_storage.__small.
+template <typename _Fun>
+struct __use_small_storage
+    : public integral_constant<
+          bool, sizeof(_Fun) <= sizeof(__policy_storage) &&
+                    _LIBCUDACXX_ALIGNOF(_Fun) <= _LIBCUDACXX_ALIGNOF(__policy_storage) &&
+                    is_trivially_copy_constructible<_Fun>::value &&
+                    is_trivially_destructible<_Fun>::value> {};
+
+// Policy contains information about how to copy, destroy, and move the
+// underlying functor. You can think of it as a vtable of sorts.
+struct __policy
+{
+    // Used to copy or destroy __large values. null for trivial objects.
+    void* (*const __clone)(const void*);
+    void (*const __destroy)(void*);
+
+    // True if this is the null policy (no value).
+    const bool __is_null;
+
+    // The target type. May be null if RTTI is disabled.
+    const type_info* const __type_info;
+
+    // Returns a pointer to a static policy object suitable for the functor
+    // type.
+    template <typename _Fun>
+    _LIBCUDACXX_INLINE_VISIBILITY static const __policy* __create()
+    {
+        return __choose_policy<_Fun>(__use_small_storage<_Fun>());
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    static const __policy* __create_empty()
+    {
+        static const _LIBCUDACXX_CONSTEXPR __policy __policy_ = {nullptr, nullptr,
+                                                             true,
+#ifndef _LIBCUDACXX_NO_RTTI
+                                                             &typeid(void)
+#else
+                                                             nullptr
+#endif
+        };
+        return &__policy_;
+    }
+
+  private:
+    template <typename _Fun> static void* __large_clone(const void* __s)
+    {
+        const _Fun* __f = static_cast<const _Fun*>(__s);
+        return __f->__clone();
+    }
+
+    template <typename _Fun>
+    static void __large_destroy(void* __s) {
+      _Fun::__destroy_and_delete(static_cast<_Fun*>(__s));
+    }
+
+    template <typename _Fun>
+    _LIBCUDACXX_INLINE_VISIBILITY static const __policy*
+    __choose_policy(/* is_small = */ false_type) {
+      static const _LIBCUDACXX_CONSTEXPR __policy __policy_ = {
+          &__large_clone<_Fun>, &__large_destroy<_Fun>, false,
+#ifndef _LIBCUDACXX_NO_RTTI
+          &typeid(typename _Fun::_Target)
+#else
+          nullptr
+#endif
+      };
+        return &__policy_;
+    }
+
+    template <typename _Fun>
+    _LIBCUDACXX_INLINE_VISIBILITY static const __policy*
+        __choose_policy(/* is_small = */ true_type)
+    {
+        static const _LIBCUDACXX_CONSTEXPR __policy __policy_ = {
+            nullptr, nullptr, false,
+#ifndef _LIBCUDACXX_NO_RTTI
+            &typeid(typename _Fun::_Target)
+#else
+            nullptr
+#endif
+        };
+        return &__policy_;
+    }
+};
+
+// Used to choose between perfect forwarding or pass-by-value. Pass-by-value is
+// faster for types that can be passed in registers.
+template <typename _Tp>
+using __fast_forward = __conditional_t<is_scalar<_Tp>::value, _Tp, _Tp&&>;
+
+// __policy_invoker calls an instance of __alloc_func held in __policy_storage.
+
+template <class _Fp> struct __policy_invoker;
+
+template <class _Rp, class... _ArgTypes>
+struct __policy_invoker<_Rp(_ArgTypes...)>
+{
+    typedef _Rp (*__Call)(const __policy_storage*,
+                          __fast_forward<_ArgTypes>...);
+
+    __Call __call_;
+
+    // Creates an invoker that throws bad_function_call.
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __policy_invoker() : __call_(&__call_empty) {}
+
+    // Creates an invoker that calls the given instance of __func.
+    template <typename _Fun>
+    _LIBCUDACXX_INLINE_VISIBILITY static __policy_invoker __create()
+    {
+        return __policy_invoker(&__call_impl<_Fun>);
+    }
+
+  private:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit __policy_invoker(__Call __c) : __call_(__c) {}
+
+    static _Rp __call_empty(const __policy_storage*,
+                            __fast_forward<_ArgTypes>...)
+    {
+        __throw_bad_function_call();
+    }
+
+    template <typename _Fun>
+    static _Rp __call_impl(const __policy_storage* __buf,
+                           __fast_forward<_ArgTypes>... __args)
+    {
+        _Fun* __f = reinterpret_cast<_Fun*>(__use_small_storage<_Fun>::value
+                                                ? &__buf->__small
+                                                : __buf->__large);
+        return (*__f)(_CUDA_VSTD::forward<_ArgTypes>(__args)...);
+    }
+};
+
+// __policy_func uses a __policy and __policy_invoker to create a type-erased,
+// copyable functor.
+
+template <class _Fp> class __policy_func;
+
+template <class _Rp, class... _ArgTypes> class __policy_func<_Rp(_ArgTypes...)>
+{
+    // Inline storage for small objects.
+    __policy_storage __buf_;
+
+    // Calls the value stored in __buf_. This could technically be part of
+    // policy, but storing it here eliminates a level of indirection inside
+    // operator().
+    typedef __function::__policy_invoker<_Rp(_ArgTypes...)> __invoker;
+    __invoker __invoker_;
+
+    // The policy that describes how to move / copy / destroy __buf_. Never
+    // null, even if the function is empty.
+    const __policy* __policy_;
+
+  public:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __policy_func() : __policy_(__policy::__create_empty()) {}
+
+    template <class _Fp, class _Alloc>
+    _LIBCUDACXX_INLINE_VISIBILITY __policy_func(_Fp&& __f, const _Alloc& __a)
+        : __policy_(__policy::__create_empty())
+    {
+        typedef __alloc_func<_Fp, _Alloc, _Rp(_ArgTypes...)> _Fun;
+        typedef allocator_traits<_Alloc> __alloc_traits;
+        typedef typename __rebind_alloc_helper<__alloc_traits, _Fun>::type _FunAlloc;
+
+        if (__function::__not_null(__f))
+        {
+            __invoker_ = __invoker::template __create<_Fun>();
+            __policy_ = __policy::__create<_Fun>();
+
+            _FunAlloc __af(__a);
+            if (__use_small_storage<_Fun>())
+            {
+                ::new ((void*)&__buf_.__small)
+                    _Fun(_CUDA_VSTD::move(__f), _Alloc(__af));
+            }
+            else
+            {
+                typedef __allocator_destructor<_FunAlloc> _Dp;
+                unique_ptr<_Fun, _Dp> __hold(__af.allocate(1), _Dp(__af, 1));
+                ::new ((void*)__hold.get())
+                    _Fun(_CUDA_VSTD::move(__f), _Alloc(__af));
+                __buf_.__large = __hold.release();
+            }
+        }
+    }
+
+    template <class _Fp, class = __enable_if_t<!is_same<__decay_t<_Fp>, __policy_func>::value>>
+    _LIBCUDACXX_INLINE_VISIBILITY explicit __policy_func(_Fp&& __f)
+        : __policy_(__policy::__create_empty()) {
+      typedef __default_alloc_func<_Fp, _Rp(_ArgTypes...)> _Fun;
+
+      if (__function::__not_null(__f)) {
+        __invoker_ = __invoker::template __create<_Fun>();
+        __policy_ = __policy::__create<_Fun>();
+        if (__use_small_storage<_Fun>()) {
+          ::new ((void*)&__buf_.__small) _Fun(_CUDA_VSTD::move(__f));
+        } else {
+          __builtin_new_allocator::__holder_t __hold =
+              __builtin_new_allocator::__allocate_type<_Fun>(1);
+          __buf_.__large = ::new ((void*)__hold.get()) _Fun(_CUDA_VSTD::move(__f));
+          (void)__hold.release();
+        }
+      }
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __policy_func(const __policy_func& __f)
+        : __buf_(__f.__buf_), __invoker_(__f.__invoker_),
+          __policy_(__f.__policy_)
+    {
+        if (__policy_->__clone)
+            __buf_.__large = __policy_->__clone(__f.__buf_.__large);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __policy_func(__policy_func&& __f)
+        : __buf_(__f.__buf_), __invoker_(__f.__invoker_),
+          __policy_(__f.__policy_)
+    {
+        if (__policy_->__destroy)
+        {
+            __f.__policy_ = __policy::__create_empty();
+            __f.__invoker_ = __invoker();
+        }
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    ~__policy_func()
+    {
+        if (__policy_->__destroy)
+            __policy_->__destroy(__buf_.__large);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __policy_func& operator=(__policy_func&& __f)
+    {
+        *this = nullptr;
+        __buf_ = __f.__buf_;
+        __invoker_ = __f.__invoker_;
+        __policy_ = __f.__policy_;
+        __f.__policy_ = __policy::__create_empty();
+        __f.__invoker_ = __invoker();
+        return *this;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __policy_func& operator=(nullptr_t)
+    {
+        const __policy* __p = __policy_;
+        __policy_ = __policy::__create_empty();
+        __invoker_ = __invoker();
+        if (__p->__destroy)
+            __p->__destroy(__buf_.__large);
+        return *this;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    _Rp operator()(_ArgTypes&&... __args) const
+    {
+        return __invoker_.__call_(_CUDA_VSTD::addressof(__buf_),
+                                  _CUDA_VSTD::forward<_ArgTypes>(__args)...);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void swap(__policy_func& __f)
+    {
+        _CUDA_VSTD::swap(__invoker_, __f.__invoker_);
+        _CUDA_VSTD::swap(__policy_, __f.__policy_);
+        _CUDA_VSTD::swap(__buf_, __f.__buf_);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit operator bool() const _NOEXCEPT
+    {
+        return !__policy_->__is_null;
+    }
+
+#ifndef _LIBCUDACXX_NO_RTTI
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const type_info& target_type() const _NOEXCEPT
+    {
+        return *__policy_->__type_info;
+    }
+
+    template <typename _Tp>
+    _LIBCUDACXX_INLINE_VISIBILITY const _Tp* target() const _NOEXCEPT
+    {
+        if (__policy_->__is_null || typeid(_Tp) != *__policy_->__type_info)
+            return nullptr;
+        if (__policy_->__clone) // Out of line storage.
+            return reinterpret_cast<const _Tp*>(__buf_.__large);
+        else
+            return reinterpret_cast<const _Tp*>(&__buf_.__small);
+    }
+#endif // _LIBCUDACXX_NO_RTTI
+};
+
+#if defined(_LIBCUDACXX_HAS_BLOCKS_RUNTIME)
+
+extern "C" void *_Block_copy(const void *);
+extern "C" void _Block_release(const void *);
+
+template<class _Rp1, class ..._ArgTypes1, class _Alloc, class _Rp, class ..._ArgTypes>
+class __func<_Rp1(^)(_ArgTypes1...), _Alloc, _Rp(_ArgTypes...)>
+    : public  __base<_Rp(_ArgTypes...)>
+{
+    typedef _Rp1(^__block_type)(_ArgTypes1...);
+    __block_type __f_;
+
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit __func(__block_type const& __f)
+#ifdef _LIBCUDACXX_HAS_OBJC_ARC
+        : __f_(__f)
+#else
+        : __f_(reinterpret_cast<__block_type>(__f ? _Block_copy(__f) : nullptr))
+#endif
+    { }
+
+    // [TODO] add && to save on a retain
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit __func(__block_type __f, const _Alloc& /* unused */)
+#ifdef _LIBCUDACXX_HAS_OBJC_ARC
+        : __f_(__f)
+#else
+        : __f_(reinterpret_cast<__block_type>(__f ? _Block_copy(__f) : nullptr))
+#endif
+    { }
+
+    virtual __base<_Rp(_ArgTypes...)>* __clone() const {
+        _LIBCUDACXX_ASSERT(false,
+            "Block pointers are just pointers, so they should always fit into "
+            "std::function's small buffer optimization. This function should "
+            "never be invoked.");
+        return nullptr;
+    }
+
+    virtual void __clone(__base<_Rp(_ArgTypes...)>* __p) const {
+        ::new ((void*)__p) __func(__f_);
+    }
+
+    virtual void destroy() _NOEXCEPT {
+#ifndef _LIBCUDACXX_HAS_OBJC_ARC
+        if (__f_)
+            _Block_release(__f_);
+#endif
+        __f_ = 0;
+    }
+
+    virtual void destroy_deallocate() _NOEXCEPT {
+        _LIBCUDACXX_ASSERT(false,
+            "Block pointers are just pointers, so they should always fit into "
+            "std::function's small buffer optimization. This function should "
+            "never be invoked.");
+    }
+
+    virtual _Rp operator()(_ArgTypes&& ... __arg) {
+        return _CUDA_VSTD::__invoke(__f_, _CUDA_VSTD::forward<_ArgTypes>(__arg)...);
+    }
+
+#ifndef _LIBCUDACXX_NO_RTTI
+    virtual const void* target(type_info const& __ti) const _NOEXCEPT {
+        if (__ti == typeid(__func::__block_type))
+            return &__f_;
+        return (const void*)nullptr;
+    }
+
+    virtual const type_info& target_type() const _NOEXCEPT {
+        return typeid(__func::__block_type);
+    }
+#endif // _LIBCUDACXX_NO_RTTI
+};
+
+#endif // _LIBCUDACXX_HAS_EXTENSION_BLOCKS
+
+} // namespace __function
+
+template<class _Rp, class ..._ArgTypes>
+class _LIBCUDACXX_TEMPLATE_VIS function<_Rp(_ArgTypes...)>
+    : public __function::__maybe_derive_from_unary_function<_Rp(_ArgTypes...)>,
+      public __function::__maybe_derive_from_binary_function<_Rp(_ArgTypes...)>
+{
+#ifndef _LIBCUDACXX_ABI_OPTIMIZED_FUNCTION
+    typedef __function::__value_func<_Rp(_ArgTypes...)> __func;
+#else
+    typedef __function::__policy_func<_Rp(_ArgTypes...)> __func;
+#endif
+
+    __func __f_;
+
+    template <class _Fp, bool = _And<
+        _IsNotSame<__remove_cvref_t<_Fp>, function>,
+        __invokable<_Fp, _ArgTypes...>
+    >::value>
+    struct __callable;
+    template <class _Fp>
+        struct __callable<_Fp, true>
+        {
+            static const bool value = is_void<_Rp>::value ||
+                __is_core_convertible<typename __invoke_of<_Fp, _ArgTypes...>::type,
+                                      _Rp>::value;
+        };
+    template <class _Fp>
+        struct __callable<_Fp, false>
+        {
+            static const bool value = false;
+        };
+
+  template <class _Fp>
+  using _EnableIfLValueCallable = __enable_if_t<__callable<_Fp&>::value>;
+public:
+    typedef _Rp result_type;
+
+    // construct/copy/destroy:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    function() _NOEXCEPT { }
+    _LIBCUDACXX_INLINE_VISIBILITY
+    function(nullptr_t) _NOEXCEPT {}
+    function(const function&);
+    function(function&&) _NOEXCEPT;
+    template<class _Fp, class = _EnableIfLValueCallable<_Fp>>
+    function(_Fp);
+
+#if _LIBCUDACXX_STD_VER <= 14
+    template<class _Alloc>
+      _LIBCUDACXX_INLINE_VISIBILITY
+      function(allocator_arg_t, const _Alloc&) _NOEXCEPT {}
+    template<class _Alloc>
+      _LIBCUDACXX_INLINE_VISIBILITY
+      function(allocator_arg_t, const _Alloc&, nullptr_t) _NOEXCEPT {}
+    template<class _Alloc>
+      function(allocator_arg_t, const _Alloc&, const function&);
+    template<class _Alloc>
+      function(allocator_arg_t, const _Alloc&, function&&);
+    template<class _Fp, class _Alloc, class = _EnableIfLValueCallable<_Fp>>
+      function(allocator_arg_t, const _Alloc& __a, _Fp __f);
+#endif
+
+    function& operator=(const function&);
+    function& operator=(function&&) _NOEXCEPT;
+    function& operator=(nullptr_t) _NOEXCEPT;
+    template<class _Fp, class = _EnableIfLValueCallable<__decay_t<_Fp>>>
+    function& operator=(_Fp&&);
+
+    ~function();
+
+    // function modifiers:
+    void swap(function&) _NOEXCEPT;
+
+#if _LIBCUDACXX_STD_VER <= 14
+    template<class _Fp, class _Alloc>
+      _LIBCUDACXX_INLINE_VISIBILITY
+      void assign(_Fp&& __f, const _Alloc& __a)
+        {function(allocator_arg, __a, _CUDA_VSTD::forward<_Fp>(__f)).swap(*this);}
+#endif
+
+    // function capacity:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    _LIBCUDACXX_EXPLICIT operator bool() const _NOEXCEPT {
+      return static_cast<bool>(__f_);
+    }
+
+    // deleted overloads close possible hole in the type system
+    template<class _R2, class... _ArgTypes2>
+      bool operator==(const function<_R2(_ArgTypes2...)>&) const = delete;
+    template<class _R2, class... _ArgTypes2>
+      bool operator!=(const function<_R2(_ArgTypes2...)>&) const = delete;
+public:
+    // function invocation:
+    _Rp operator()(_ArgTypes...) const;
+
+#ifndef _LIBCUDACXX_NO_RTTI
+    // function target access:
+    const type_info& target_type() const _NOEXCEPT;
+    template <typename _Tp> _Tp* target() _NOEXCEPT;
+    template <typename _Tp> const _Tp* target() const _NOEXCEPT;
+#endif // _LIBCUDACXX_NO_RTTI
+};
+
+#if _LIBCUDACXX_STD_VER > 14
+template<class _Rp, class ..._Ap>
+function(_Rp(*)(_Ap...)) -> function<_Rp(_Ap...)>;
+
+template<class _Fp>
+struct __strip_signature;
+
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...)> { using type = _Rp(_Ap...); };
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) const> { using type = _Rp(_Ap...); };
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) volatile> { using type = _Rp(_Ap...); };
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) const volatile> { using type = _Rp(_Ap...); };
+
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) &> { using type = _Rp(_Ap...); };
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) const &> { using type = _Rp(_Ap...); };
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) volatile &> { using type = _Rp(_Ap...); };
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) const volatile &> { using type = _Rp(_Ap...); };
+
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) noexcept> { using type = _Rp(_Ap...); };
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) const noexcept> { using type = _Rp(_Ap...); };
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) volatile noexcept> { using type = _Rp(_Ap...); };
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) const volatile noexcept> { using type = _Rp(_Ap...); };
+
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) & noexcept> { using type = _Rp(_Ap...); };
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) const & noexcept> { using type = _Rp(_Ap...); };
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) volatile & noexcept> { using type = _Rp(_Ap...); };
+template<class _Rp, class _Gp, class ..._Ap>
+struct __strip_signature<_Rp (_Gp::*) (_Ap...) const volatile & noexcept> { using type = _Rp(_Ap...); };
+
+template<class _Fp, class _Stripped = typename __strip_signature<decltype(&_Fp::operator())>::type>
+function(_Fp) -> function<_Stripped>;
+#endif // _LIBCUDACXX_STD_VER > 14
+
+template<class _Rp, class ..._ArgTypes>
+function<_Rp(_ArgTypes...)>::function(const function& __f) : __f_(__f.__f_) {}
+
+#if _LIBCUDACXX_STD_VER <= 14
+template<class _Rp, class ..._ArgTypes>
+template <class _Alloc>
+function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
+                                     const function& __f) : __f_(__f.__f_) {}
+#endif
+
+template <class _Rp, class... _ArgTypes>
+function<_Rp(_ArgTypes...)>::function(function&& __f) _NOEXCEPT
+    : __f_(_CUDA_VSTD::move(__f.__f_)) {}
+
+#if _LIBCUDACXX_STD_VER <= 14
+template<class _Rp, class ..._ArgTypes>
+template <class _Alloc>
+function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
+                                      function&& __f)
+    : __f_(_CUDA_VSTD::move(__f.__f_)) {}
+#endif
+
+template <class _Rp, class... _ArgTypes>
+template <class _Fp, class>
+function<_Rp(_ArgTypes...)>::function(_Fp __f) : __f_(_CUDA_VSTD::move(__f)) {}
+
+#if _LIBCUDACXX_STD_VER <= 14
+template <class _Rp, class... _ArgTypes>
+template <class _Fp, class _Alloc, class>
+function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a,
+                                      _Fp __f)
+    : __f_(_CUDA_VSTD::move(__f), __a) {}
+#endif
+
+template<class _Rp, class ..._ArgTypes>
+function<_Rp(_ArgTypes...)>&
+function<_Rp(_ArgTypes...)>::operator=(const function& __f)
+{
+    function(__f).swap(*this);
+    return *this;
+}
+
+template<class _Rp, class ..._ArgTypes>
+function<_Rp(_ArgTypes...)>&
+function<_Rp(_ArgTypes...)>::operator=(function&& __f) _NOEXCEPT
+{
+    __f_ = _CUDA_VSTD::move(__f.__f_);
+    return *this;
+}
+
+template<class _Rp, class ..._ArgTypes>
+function<_Rp(_ArgTypes...)>&
+function<_Rp(_ArgTypes...)>::operator=(nullptr_t) _NOEXCEPT
+{
+    __f_ = nullptr;
+    return *this;
+}
+
+template<class _Rp, class ..._ArgTypes>
+template <class _Fp, class>
+function<_Rp(_ArgTypes...)>&
+function<_Rp(_ArgTypes...)>::operator=(_Fp&& __f)
+{
+    function(_CUDA_VSTD::forward<_Fp>(__f)).swap(*this);
+    return *this;
+}
+
+template<class _Rp, class ..._ArgTypes>
+function<_Rp(_ArgTypes...)>::~function() {}
+
+template<class _Rp, class ..._ArgTypes>
+void
+function<_Rp(_ArgTypes...)>::swap(function& __f) _NOEXCEPT
+{
+    __f_.swap(__f.__f_);
+}
+
+template<class _Rp, class ..._ArgTypes>
+_Rp
+function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
+{
+    return __f_(_CUDA_VSTD::forward<_ArgTypes>(__arg)...);
+}
+
+#ifndef _LIBCUDACXX_NO_RTTI
+
+template<class _Rp, class ..._ArgTypes>
+const type_info&
+function<_Rp(_ArgTypes...)>::target_type() const _NOEXCEPT
+{
+    return __f_.target_type();
+}
+
+template<class _Rp, class ..._ArgTypes>
+template <typename _Tp>
+_Tp*
+function<_Rp(_ArgTypes...)>::target() _NOEXCEPT
+{
+    return (_Tp*)(__f_.template target<_Tp>());
+}
+
+template<class _Rp, class ..._ArgTypes>
+template <typename _Tp>
+const _Tp*
+function<_Rp(_ArgTypes...)>::target() const _NOEXCEPT
+{
+    return __f_.template target<_Tp>();
+}
+
+#endif // _LIBCUDACXX_NO_RTTI
+
+template <class _Rp, class... _ArgTypes>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool
+operator==(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return !__f;}
+
+template <class _Rp, class... _ArgTypes>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool
+operator==(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return !__f;}
+
+template <class _Rp, class... _ArgTypes>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool
+operator!=(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return (bool)__f;}
+
+template <class _Rp, class... _ArgTypes>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool
+operator!=(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return (bool)__f;}
+
+template <class _Rp, class... _ArgTypes>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+void
+swap(function<_Rp(_ArgTypes...)>& __x, function<_Rp(_ArgTypes...)>& __y) _NOEXCEPT
+{return __x.swap(__y);}
+
+#else // _LIBCUDACXX_CXX03_LANG
+
+#include <__functional_03>
+
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX_CXX03_LANG
+
+#endif // __cuda_std__
+
+#endif // _LIBCUDACXX___FUNCTIONAL_FUNCTION_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/hash.h

@@ -0,0 +1,692 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___FUNCTIONAL_HASH_H
+#define _LIBCUDACXX___FUNCTIONAL_HASH_H
+
+#ifndef __cuda_std__
+#include <__config>
+#include <cstring>
+#endif // __cuda_std__
+
+#include "../__functional/invoke.h"
+#include "../__functional/unary_function.h"
+#include "../__fwd/hash.h"
+#include "../__type_traits/enable_if.h"
+#include "../__type_traits/integral_constant.h"
+#include "../__type_traits/is_enum.h"
+#include "../__type_traits/is_copy_constructible.h"
+#include "../__type_traits/is_default_constructible.h"
+#include "../__type_traits/is_move_constructible.h"
+#include "../__type_traits/underlying_type.h"
+#include "../__utility/forward.h"
+#include "../__utility/move.h"
+#include "../__utility/pair.h"
+#include "../__utility/swap.h"
+#include "../cstdint"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+#ifndef __cuda_std__
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Size>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+_Size
+__loadword(const void* __p)
+{
+    _Size __r;
+    std::memcpy(&__r, __p, sizeof(__r));
+    return __r;
+}
+
+// We use murmur2 when size_t is 32 bits, and cityhash64 when size_t
+// is 64 bits.  This is because cityhash64 uses 64bit x 64bit
+// multiplication, which can be very slow on 32-bit systems.
+template <class _Size, size_t = sizeof(_Size)*__CHAR_BIT__>
+struct __murmur2_or_cityhash;
+
+template <class _Size>
+struct __murmur2_or_cityhash<_Size, 32>
+{
+    inline _Size operator()(const void* __key, _Size __len)
+         _LIBCUDACXX_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK;
+};
+
+// murmur2
+template <class _Size>
+_Size
+__murmur2_or_cityhash<_Size, 32>::operator()(const void* __key, _Size __len)
+{
+    const _Size __m = 0x5bd1e995;
+    const _Size __r = 24;
+    _Size __h = __len;
+    const unsigned char* __data = static_cast<const unsigned char*>(__key);
+    for (; __len >= 4; __data += 4, __len -= 4)
+    {
+        _Size __k = __loadword<_Size>(__data);
+        __k *= __m;
+        __k ^= __k >> __r;
+        __k *= __m;
+        __h *= __m;
+        __h ^= __k;
+    }
+    switch (__len)
+    {
+    case 3:
+        __h ^= static_cast<_Size>(__data[2] << 16);
+        _LIBCUDACXX_FALLTHROUGH();
+    case 2:
+        __h ^= static_cast<_Size>(__data[1] << 8);
+        _LIBCUDACXX_FALLTHROUGH();
+    case 1:
+        __h ^= __data[0];
+        __h *= __m;
+    }
+    __h ^= __h >> 13;
+    __h *= __m;
+    __h ^= __h >> 15;
+    return __h;
+}
+
+template <class _Size>
+struct __murmur2_or_cityhash<_Size, 64>
+{
+    inline _Size operator()(const void* __key, _Size __len)  _LIBCUDACXX_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK;
+
+ private:
+  // Some primes between 2^63 and 2^64.
+  static const _Size __k0 = 0xc3a5c85c97cb3127ULL;
+  static const _Size __k1 = 0xb492b66fbe98f273ULL;
+  static const _Size __k2 = 0x9ae16a3b2f90404fULL;
+  static const _Size __k3 = 0xc949d7c7509e6557ULL;
+
+  static _Size __rotate(_Size __val, int __shift) {
+    return __shift == 0 ? __val : ((__val >> __shift) | (__val << (64 - __shift)));
+  }
+
+  static _Size __rotate_by_at_least_1(_Size __val, int __shift) {
+    return (__val >> __shift) | (__val << (64 - __shift));
+  }
+
+  static _Size __shift_mix(_Size __val) {
+    return __val ^ (__val >> 47);
+  }
+
+  static _Size __hash_len_16(_Size __u, _Size __v)
+     _LIBCUDACXX_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
+  {
+    const _Size __mul = 0x9ddfea08eb382d69ULL;
+    _Size __a = (__u ^ __v) * __mul;
+    __a ^= (__a >> 47);
+    _Size __b = (__v ^ __a) * __mul;
+    __b ^= (__b >> 47);
+    __b *= __mul;
+    return __b;
+  }
+
+  static _Size __hash_len_0_to_16(const char* __s, _Size __len)
+     _LIBCUDACXX_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
+  {
+    if (__len > 8) {
+      const _Size __a = __loadword<_Size>(__s);
+      const _Size __b = __loadword<_Size>(__s + __len - 8);
+      return __hash_len_16(__a, __rotate_by_at_least_1(__b + __len, __len)) ^ __b;
+    }
+    if (__len >= 4) {
+      const uint32_t __a = __loadword<uint32_t>(__s);
+      const uint32_t __b = __loadword<uint32_t>(__s + __len - 4);
+      return __hash_len_16(__len + (static_cast<_Size>(__a) << 3), __b);
+    }
+    if (__len > 0) {
+      const unsigned char __a = static_cast<unsigned char>(__s[0]);
+      const unsigned char __b = static_cast<unsigned char>(__s[__len >> 1]);
+      const unsigned char __c = static_cast<unsigned char>(__s[__len - 1]);
+      const uint32_t __y = static_cast<uint32_t>(__a) +
+                           (static_cast<uint32_t>(__b) << 8);
+      const uint32_t __z = __len + (static_cast<uint32_t>(__c) << 2);
+      return __shift_mix(__y * __k2 ^ __z * __k3) * __k2;
+    }
+    return __k2;
+  }
+
+  static _Size __hash_len_17_to_32(const char *__s, _Size __len)
+     _LIBCUDACXX_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
+  {
+    const _Size __a = __loadword<_Size>(__s) * __k1;
+    const _Size __b = __loadword<_Size>(__s + 8);
+    const _Size __c = __loadword<_Size>(__s + __len - 8) * __k2;
+    const _Size __d = __loadword<_Size>(__s + __len - 16) * __k0;
+    return __hash_len_16(__rotate(__a - __b, 43) + __rotate(__c, 30) + __d,
+                         __a + __rotate(__b ^ __k3, 20) - __c + __len);
+  }
+
+  // Return a 16-byte hash for 48 bytes.  Quick and dirty.
+  // Callers do best to use "random-looking" values for a and b.
+  static pair<_Size, _Size> __weak_hash_len_32_with_seeds(
+      _Size __w, _Size __x, _Size __y, _Size __z, _Size __a, _Size __b)
+        _LIBCUDACXX_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
+  {
+    __a += __w;
+    __b = __rotate(__b + __a + __z, 21);
+    const _Size __c = __a;
+    __a += __x;
+    __a += __y;
+    __b += __rotate(__a, 44);
+    return pair<_Size, _Size>(__a + __z, __b + __c);
+  }
+
+  // Return a 16-byte hash for s[0] ... s[31], a, and b.  Quick and dirty.
+  static pair<_Size, _Size> __weak_hash_len_32_with_seeds(
+      const char* __s, _Size __a, _Size __b)
+    _LIBCUDACXX_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
+  {
+    return __weak_hash_len_32_with_seeds(__loadword<_Size>(__s),
+                                         __loadword<_Size>(__s + 8),
+                                         __loadword<_Size>(__s + 16),
+                                         __loadword<_Size>(__s + 24),
+                                         __a,
+                                         __b);
+  }
+
+  // Return an 8-byte hash for 33 to 64 bytes.
+  static _Size __hash_len_33_to_64(const char *__s, size_t __len)
+    _LIBCUDACXX_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
+  {
+    _Size __z = __loadword<_Size>(__s + 24);
+    _Size __a = __loadword<_Size>(__s) +
+                (__len + __loadword<_Size>(__s + __len - 16)) * __k0;
+    _Size __b = __rotate(__a + __z, 52);
+    _Size __c = __rotate(__a, 37);
+    __a += __loadword<_Size>(__s + 8);
+    __c += __rotate(__a, 7);
+    __a += __loadword<_Size>(__s + 16);
+    _Size __vf = __a + __z;
+    _Size __vs = __b + __rotate(__a, 31) + __c;
+    __a = __loadword<_Size>(__s + 16) + __loadword<_Size>(__s + __len - 32);
+    __z += __loadword<_Size>(__s + __len - 8);
+    __b = __rotate(__a + __z, 52);
+    __c = __rotate(__a, 37);
+    __a += __loadword<_Size>(__s + __len - 24);
+    __c += __rotate(__a, 7);
+    __a += __loadword<_Size>(__s + __len - 16);
+    _Size __wf = __a + __z;
+    _Size __ws = __b + __rotate(__a, 31) + __c;
+    _Size __r = __shift_mix((__vf + __ws) * __k2 + (__wf + __vs) * __k0);
+    return __shift_mix(__r * __k0 + __vs) * __k2;
+  }
+};
+
+// cityhash64
+template <class _Size>
+_Size
+__murmur2_or_cityhash<_Size, 64>::operator()(const void* __key, _Size __len)
+{
+  const char* __s = static_cast<const char*>(__key);
+  if (__len <= 32) {
+    if (__len <= 16) {
+      return __hash_len_0_to_16(__s, __len);
+    } else {
+      return __hash_len_17_to_32(__s, __len);
+    }
+  } else if (__len <= 64) {
+    return __hash_len_33_to_64(__s, __len);
+  }
+
+  // For strings over 64 bytes we hash the end first, and then as we
+  // loop we keep 56 bytes of state: v, w, x, y, and z.
+  _Size __x = __loadword<_Size>(__s + __len - 40);
+  _Size __y = __loadword<_Size>(__s + __len - 16) +
+              __loadword<_Size>(__s + __len - 56);
+  _Size __z = __hash_len_16(__loadword<_Size>(__s + __len - 48) + __len,
+                          __loadword<_Size>(__s + __len - 24));
+  pair<_Size, _Size> __v = __weak_hash_len_32_with_seeds(__s + __len - 64, __len, __z);
+  pair<_Size, _Size> __w = __weak_hash_len_32_with_seeds(__s + __len - 32, __y + __k1, __x);
+  __x = __x * __k1 + __loadword<_Size>(__s);
+
+  // Decrease len to the nearest multiple of 64, and operate on 64-byte chunks.
+  __len = (__len - 1) & ~static_cast<_Size>(63);
+  do {
+    __x = __rotate(__x + __y + __v.first + __loadword<_Size>(__s + 8), 37) * __k1;
+    __y = __rotate(__y + __v.second + __loadword<_Size>(__s + 48), 42) * __k1;
+    __x ^= __w.second;
+    __y += __v.first + __loadword<_Size>(__s + 40);
+    __z = __rotate(__z + __w.first, 33) * __k1;
+    __v = __weak_hash_len_32_with_seeds(__s, __v.second * __k1, __x + __w.first);
+    __w = __weak_hash_len_32_with_seeds(__s + 32, __z + __w.second,
+                                        __y + __loadword<_Size>(__s + 16));
+    _CUDA_VSTD::swap(__z, __x);
+    __s += 64;
+    __len -= 64;
+  } while (__len != 0);
+  return __hash_len_16(
+      __hash_len_16(__v.first, __w.first) + __shift_mix(__y) * __k1 + __z,
+      __hash_len_16(__v.second, __w.second) + __x);
+}
+
+template <class _Tp, size_t = sizeof(_Tp) / sizeof(size_t)>
+struct __scalar_hash;
+
+template <class _Tp>
+struct __scalar_hash<_Tp, 0>
+    : public __unary_function<_Tp, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(_Tp __v) const _NOEXCEPT
+    {
+        union
+        {
+            _Tp    __t;
+            size_t __a;
+        } __u;
+        __u.__a = 0;
+        __u.__t = __v;
+        return __u.__a;
+    }
+};
+
+template <class _Tp>
+struct __scalar_hash<_Tp, 1>
+    : public __unary_function<_Tp, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(_Tp __v) const _NOEXCEPT
+    {
+        union
+        {
+            _Tp    __t;
+            size_t __a;
+        } __u;
+        __u.__t = __v;
+        return __u.__a;
+    }
+};
+
+template <class _Tp>
+struct __scalar_hash<_Tp, 2>
+    : public __unary_function<_Tp, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(_Tp __v) const _NOEXCEPT
+    {
+        union
+        {
+            _Tp __t;
+            struct
+            {
+                size_t __a;
+                size_t __b;
+            } __s;
+        } __u;
+        __u.__t = __v;
+        return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u));
+    }
+};
+
+template <class _Tp>
+struct __scalar_hash<_Tp, 3>
+    : public __unary_function<_Tp, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(_Tp __v) const _NOEXCEPT
+    {
+        union
+        {
+            _Tp __t;
+            struct
+            {
+                size_t __a;
+                size_t __b;
+                size_t __c;
+            } __s;
+        } __u;
+        __u.__t = __v;
+        return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u));
+    }
+};
+
+template <class _Tp>
+struct __scalar_hash<_Tp, 4>
+    : public __unary_function<_Tp, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(_Tp __v) const _NOEXCEPT
+    {
+        union
+        {
+            _Tp __t;
+            struct
+            {
+                size_t __a;
+                size_t __b;
+                size_t __c;
+                size_t __d;
+            } __s;
+        } __u;
+        __u.__t = __v;
+        return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u));
+    }
+};
+
+struct _PairT {
+  size_t first;
+  size_t second;
+};
+
+_LIBCUDACXX_INLINE_VISIBILITY
+inline size_t __hash_combine(size_t __lhs, size_t __rhs) _NOEXCEPT {
+    typedef __scalar_hash<_PairT> _HashT;
+    const _PairT __p = {__lhs, __rhs};
+    return _HashT()(__p);
+}
+
+template<class _Tp>
+struct _LIBCUDACXX_TEMPLATE_VIS hash<_Tp*>
+    : public __unary_function<_Tp*, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(_Tp* __v) const _NOEXCEPT
+    {
+        union
+        {
+            _Tp* __t;
+            size_t __a;
+        } __u;
+        __u.__t = __v;
+        return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u));
+    }
+};
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS hash<bool>
+    : public __unary_function<bool, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(bool __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+};
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS hash<char>
+    : public __unary_function<char, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+};
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS hash<signed char>
+    : public __unary_function<signed char, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(signed char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+};
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS hash<unsigned char>
+    : public __unary_function<unsigned char, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(unsigned char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+};
+
+#ifndef _LIBCUDACXX_HAS_NO_UNICODE_CHARS
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS hash<char16_t>
+    : public __unary_function<char16_t, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(char16_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+};
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS hash<char32_t>
+    : public __unary_function<char32_t, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(char32_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+};
+#endif  // _LIBCUDACXX_HAS_NO_UNICODE_CHARS
+
+#ifndef _LIBCUDACXX_HAS_NO_WIDE_CHARACTERS
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS hash<wchar_t>
+    : public __unary_function<wchar_t, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(wchar_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+};
+#endif // _LIBCUDACXX_HAS_NO_WIDE_CHARACTERS
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS hash<short>
+    : public __unary_function<short, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(short __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+};
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS hash<unsigned short>
+    : public __unary_function<unsigned short, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(unsigned short __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+};
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS hash<int>
+    : public __unary_function<int, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(int __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+};
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS hash<unsigned int>
+    : public __unary_function<unsigned int, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(unsigned int __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+};
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS hash<long>
+    : public __unary_function<long, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(long __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+};
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS hash<unsigned long>
+    : public __unary_function<unsigned long, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(unsigned long __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+};
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS hash<long long>
+    : public __scalar_hash<long long>
+{
+};
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS hash<unsigned long long>
+    : public __scalar_hash<unsigned long long>
+{
+};
+
+#ifndef _LIBCUDACXX_HAS_NO_INT128
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS hash<__int128_t>
+    : public __scalar_hash<__int128_t>
+{
+};
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS hash<__uint128_t>
+    : public __scalar_hash<__uint128_t>
+{
+};
+
+#endif
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS hash<float>
+    : public __scalar_hash<float>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(float __v) const _NOEXCEPT
+    {
+        // -0.0 and 0.0 should return same hash
+       if (__v == 0.0f)
+           return 0;
+        return __scalar_hash<float>::operator()(__v);
+    }
+};
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS hash<double>
+    : public __scalar_hash<double>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(double __v) const _NOEXCEPT
+    {
+        // -0.0 and 0.0 should return same hash
+       if (__v == 0.0)
+           return 0;
+        return __scalar_hash<double>::operator()(__v);
+    }
+};
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS hash<long double>
+    : public __scalar_hash<long double>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(long double __v) const _NOEXCEPT
+    {
+        // -0.0 and 0.0 should return same hash
+        if (__v == 0.0L)
+            return 0;
+#if defined(__i386__) || (defined(__x86_64__) && defined(__ILP32__))
+        // Zero out padding bits
+        union
+        {
+            long double __t;
+            struct
+            {
+                size_t __a;
+                size_t __b;
+                size_t __c;
+                size_t __d;
+            } __s;
+        } __u;
+        __u.__s.__a = 0;
+        __u.__s.__b = 0;
+        __u.__s.__c = 0;
+        __u.__s.__d = 0;
+        __u.__t = __v;
+        return __u.__s.__a ^ __u.__s.__b ^ __u.__s.__c ^ __u.__s.__d;
+#elif defined(__x86_64__)
+        // Zero out padding bits
+        union
+        {
+            long double __t;
+            struct
+            {
+                size_t __a;
+                size_t __b;
+            } __s;
+        } __u;
+        __u.__s.__a = 0;
+        __u.__s.__b = 0;
+        __u.__t = __v;
+        return __u.__s.__a ^ __u.__s.__b;
+#else
+        return __scalar_hash<long double>::operator()(__v);
+#endif
+    }
+};
+
+template <class _Tp, bool = is_enum<_Tp>::value>
+struct _LIBCUDACXX_TEMPLATE_VIS __enum_hash
+    : public __unary_function<_Tp, size_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    size_t operator()(_Tp __v) const _NOEXCEPT
+    {
+        typedef typename underlying_type<_Tp>::type type;
+        return hash<type>()(static_cast<type>(__v));
+    }
+};
+template <class _Tp>
+struct _LIBCUDACXX_TEMPLATE_VIS __enum_hash<_Tp, false> {
+    __enum_hash() = delete;
+    __enum_hash(__enum_hash const&) = delete;
+    __enum_hash& operator=(__enum_hash const&) = delete;
+};
+
+template <class _Tp>
+struct _LIBCUDACXX_TEMPLATE_VIS hash : public __enum_hash<_Tp>
+{
+};
+
+#if _LIBCUDACXX_STD_VER > 14
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS hash<nullptr_t>
+  : public __unary_function<nullptr_t, size_t>
+{
+  _LIBCUDACXX_INLINE_VISIBILITY
+  size_t operator()(nullptr_t) const _NOEXCEPT {
+    return 662607004ull;
+  }
+};
+#endif
+
+#ifndef _LIBCUDACXX_CXX03_LANG
+template <class _Key, class _Hash>
+using __check_hash_requirements _LIBCUDACXX_NODEBUG_TYPE = integral_constant<bool,
+    is_copy_constructible<_Hash>::value &&
+    is_move_constructible<_Hash>::value &&
+    __invokable_r<size_t, _Hash, _Key const&>::value
+>;
+
+template <class _Key, class _Hash = hash<_Key> >
+using __has_enabled_hash _LIBCUDACXX_NODEBUG_TYPE = integral_constant<bool,
+    __check_hash_requirements<_Key, _Hash>::value &&
+    is_default_constructible<_Hash>::value
+>;
+
+#if _LIBCUDACXX_STD_VER > 14
+template <class _Type, class>
+using __enable_hash_helper_imp _LIBCUDACXX_NODEBUG_TYPE = _Type;
+
+template <class _Type, class ..._Keys>
+using __enable_hash_helper _LIBCUDACXX_NODEBUG_TYPE = __enable_hash_helper_imp<_Type,
+  __enable_if_t<__all<__has_enabled_hash<_Keys>::value...>::value>
+>;
+#else
+template <class _Type, class ...>
+using __enable_hash_helper _LIBCUDACXX_NODEBUG_TYPE = _Type;
+#endif
+
+#endif // !_LIBCUDACXX_CXX03_LANG
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // __cuda_std__
+
+#endif // _LIBCUDACXX___FUNCTIONAL_HASH_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/identity.h

@@ -0,0 +1,50 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___FUNCTIONAL_IDENTITY_H
+#define _LIBCUDACXX___FUNCTIONAL_IDENTITY_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__utility/forward.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+struct __identity {
+  template <class _Tp>
+  _LIBCUDACXX_NODISCARD_EXT _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR _Tp&& operator()(_Tp&& __t) const _NOEXCEPT {
+    return _CUDA_VSTD::forward<_Tp>(__t);
+  }
+
+  using is_transparent = void;
+};
+
+#if _LIBCUDACXX_STD_VER > 11
+
+struct identity {
+    template<class _Tp>
+    _LIBCUDACXX_NODISCARD_EXT _LIBCUDACXX_INLINE_VISIBILITY constexpr _Tp&& operator()(_Tp&& __t) const noexcept
+    {
+        return _CUDA_VSTD::forward<_Tp>(__t);
+    }
+
+    using is_transparent = void;
+};
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___FUNCTIONAL_IDENTITY_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/is_transparent.h

@@ -0,0 +1,40 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___FUNCTIONAL_IS_TRANSPARENT
+#define _LIBCUDACXX___FUNCTIONAL_IS_TRANSPARENT
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__type_traits/integral_constant.h"
+#include "../__type_traits/void_t.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+template <class _Tp, class, class = void>
+struct __is_transparent : false_type {};
+
+template <class _Tp, class _Up>
+struct __is_transparent<_Tp, _Up, __void_t<typename _Tp::is_transparent> >
+   : true_type {};
+
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___FUNCTIONAL_IS_TRANSPARENT

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/mem_fn.h

@@ -0,0 +1,61 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___FUNCTIONAL_MEM_FN_H
+#define _LIBCUDACXX___FUNCTIONAL_MEM_FN_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__functional/binary_function.h"
+#include "../__functional/invoke.h"
+#include "../__functional/weak_result_type.h"
+#include "../__utility/forward.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+class __mem_fn : public __weak_result_type<_Tp>
+{
+public:
+    // types
+    typedef _Tp type;
+private:
+    type __f_;
+
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+    __mem_fn(type __f) _NOEXCEPT : __f_(__f) {}
+
+    // invoke
+    template <class... _ArgTypes>
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+    typename __invoke_return<type, _ArgTypes...>::type
+    operator() (_ArgTypes&&... __args) const {
+        return _CUDA_VSTD::__invoke(__f_, _CUDA_VSTD::forward<_ArgTypes>(__args)...);
+    }
+};
+
+template<class _Rp, class _Tp>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+__mem_fn<_Rp _Tp::*>
+mem_fn(_Rp _Tp::* __pm) _NOEXCEPT
+{
+    return __mem_fn<_Rp _Tp::*>(__pm);
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___FUNCTIONAL_MEM_FN_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/operations.h

@@ -0,0 +1,622 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___FUNCTIONAL_OPERATIONS_H
+#define _LIBCUDACXX___FUNCTIONAL_OPERATIONS_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__functional/binary_function.h"
+#include "../__functional/unary_function.h"
+#include "../__utility/forward.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// Arithmetic operations
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp = void>
+#else
+template <class _Tp>
+#endif
+struct _LIBCUDACXX_TEMPLATE_VIS plus
+    : __binary_function<_Tp, _Tp, _Tp>
+{
+    typedef _Tp __result_type;  // used by valarray
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    _Tp operator()(const _Tp& __x, const _Tp& __y) const
+        {return __x + __y;}
+};
+_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(plus);
+
+#if _LIBCUDACXX_STD_VER > 11
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS plus<void>
+{
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    template <class _T1, class _T2>
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    auto operator()(_T1&& __t, _T2&& __u) const
+        noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) + _CUDA_VSTD::forward<_T2>(__u)))
+        -> decltype(      _CUDA_VSTD::forward<_T1>(__t) + _CUDA_VSTD::forward<_T2>(__u))
+        { return          _CUDA_VSTD::forward<_T1>(__t) + _CUDA_VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
+};
+#endif
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp = void>
+#else
+template <class _Tp>
+#endif
+struct _LIBCUDACXX_TEMPLATE_VIS minus
+    : __binary_function<_Tp, _Tp, _Tp>
+{
+    typedef _Tp __result_type;  // used by valarray
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    _Tp operator()(const _Tp& __x, const _Tp& __y) const
+        {return __x - __y;}
+};
+_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(minus);
+
+#if _LIBCUDACXX_STD_VER > 11
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS minus<void>
+{
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    template <class _T1, class _T2>
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    auto operator()(_T1&& __t, _T2&& __u) const
+        noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) - _CUDA_VSTD::forward<_T2>(__u)))
+        -> decltype(      _CUDA_VSTD::forward<_T1>(__t) - _CUDA_VSTD::forward<_T2>(__u))
+        { return          _CUDA_VSTD::forward<_T1>(__t) - _CUDA_VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
+};
+#endif
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp = void>
+#else
+template <class _Tp>
+#endif
+struct _LIBCUDACXX_TEMPLATE_VIS multiplies
+    : __binary_function<_Tp, _Tp, _Tp>
+{
+    typedef _Tp __result_type;  // used by valarray
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    _Tp operator()(const _Tp& __x, const _Tp& __y) const
+        {return __x * __y;}
+};
+_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(multiplies);
+
+#if _LIBCUDACXX_STD_VER > 11
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS multiplies<void>
+{
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    template <class _T1, class _T2>
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    auto operator()(_T1&& __t, _T2&& __u) const
+        noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) * _CUDA_VSTD::forward<_T2>(__u)))
+        -> decltype(      _CUDA_VSTD::forward<_T1>(__t) * _CUDA_VSTD::forward<_T2>(__u))
+        { return          _CUDA_VSTD::forward<_T1>(__t) * _CUDA_VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
+};
+#endif
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp = void>
+#else
+template <class _Tp>
+#endif
+struct _LIBCUDACXX_TEMPLATE_VIS divides
+    : __binary_function<_Tp, _Tp, _Tp>
+{
+    typedef _Tp __result_type;  // used by valarray
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    _Tp operator()(const _Tp& __x, const _Tp& __y) const
+        {return __x / __y;}
+};
+_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(divides);
+
+#if _LIBCUDACXX_STD_VER > 11
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS divides<void>
+{
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    template <class _T1, class _T2>
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    auto operator()(_T1&& __t, _T2&& __u) const
+        noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) / _CUDA_VSTD::forward<_T2>(__u)))
+        -> decltype(      _CUDA_VSTD::forward<_T1>(__t) / _CUDA_VSTD::forward<_T2>(__u))
+        { return          _CUDA_VSTD::forward<_T1>(__t) / _CUDA_VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
+};
+#endif
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp = void>
+#else
+template <class _Tp>
+#endif
+struct _LIBCUDACXX_TEMPLATE_VIS modulus
+    : __binary_function<_Tp, _Tp, _Tp>
+{
+    typedef _Tp __result_type;  // used by valarray
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    _Tp operator()(const _Tp& __x, const _Tp& __y) const
+        {return __x % __y;}
+};
+_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(modulus);
+
+#if _LIBCUDACXX_STD_VER > 11
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS modulus<void>
+{
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    template <class _T1, class _T2>
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    auto operator()(_T1&& __t, _T2&& __u) const
+        noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) % _CUDA_VSTD::forward<_T2>(__u)))
+        -> decltype(      _CUDA_VSTD::forward<_T1>(__t) % _CUDA_VSTD::forward<_T2>(__u))
+        { return          _CUDA_VSTD::forward<_T1>(__t) % _CUDA_VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
+};
+#endif
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp = void>
+#else
+template <class _Tp>
+#endif
+struct _LIBCUDACXX_TEMPLATE_VIS negate
+    : __unary_function<_Tp, _Tp>
+{
+    typedef _Tp __result_type;  // used by valarray
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    _Tp operator()(const _Tp& __x) const
+        {return -__x;}
+};
+_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(negate);
+
+#if _LIBCUDACXX_STD_VER > 11
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS negate<void>
+{
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    template <class _Tp>
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    auto operator()(_Tp&& __x) const
+        noexcept(noexcept(- _CUDA_VSTD::forward<_Tp>(__x)))
+        -> decltype(      - _CUDA_VSTD::forward<_Tp>(__x))
+        { return          - _CUDA_VSTD::forward<_Tp>(__x); }
+    typedef void is_transparent;
+};
+#endif
+
+// Bitwise operations
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp = void>
+#else
+template <class _Tp>
+#endif
+struct _LIBCUDACXX_TEMPLATE_VIS bit_and
+    : __binary_function<_Tp, _Tp, _Tp>
+{
+    typedef _Tp __result_type;  // used by valarray
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    _Tp operator()(const _Tp& __x, const _Tp& __y) const
+        {return __x & __y;}
+};
+_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(bit_and);
+
+#if _LIBCUDACXX_STD_VER > 11
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS bit_and<void>
+{
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    template <class _T1, class _T2>
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    auto operator()(_T1&& __t, _T2&& __u) const
+        noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) & _CUDA_VSTD::forward<_T2>(__u)))
+        -> decltype(      _CUDA_VSTD::forward<_T1>(__t) & _CUDA_VSTD::forward<_T2>(__u))
+        { return          _CUDA_VSTD::forward<_T1>(__t) & _CUDA_VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
+};
+#endif
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp = void>
+struct _LIBCUDACXX_TEMPLATE_VIS bit_not
+    : __unary_function<_Tp, _Tp>
+{
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    _Tp operator()(const _Tp& __x) const
+        {return ~__x;}
+};
+_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(bit_not);
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS bit_not<void>
+{
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    template <class _Tp>
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    auto operator()(_Tp&& __x) const
+        noexcept(noexcept(~_CUDA_VSTD::forward<_Tp>(__x)))
+        -> decltype(      ~_CUDA_VSTD::forward<_Tp>(__x))
+        { return          ~_CUDA_VSTD::forward<_Tp>(__x); }
+    typedef void is_transparent;
+};
+#endif
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp = void>
+#else
+template <class _Tp>
+#endif
+struct _LIBCUDACXX_TEMPLATE_VIS bit_or
+    : __binary_function<_Tp, _Tp, _Tp>
+{
+    typedef _Tp __result_type;  // used by valarray
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    _Tp operator()(const _Tp& __x, const _Tp& __y) const
+        {return __x | __y;}
+};
+_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(bit_or);
+
+#if _LIBCUDACXX_STD_VER > 11
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS bit_or<void>
+{
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    template <class _T1, class _T2>
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    auto operator()(_T1&& __t, _T2&& __u) const
+        noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) | _CUDA_VSTD::forward<_T2>(__u)))
+        -> decltype(      _CUDA_VSTD::forward<_T1>(__t) | _CUDA_VSTD::forward<_T2>(__u))
+        { return          _CUDA_VSTD::forward<_T1>(__t) | _CUDA_VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
+};
+#endif
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp = void>
+#else
+template <class _Tp>
+#endif
+struct _LIBCUDACXX_TEMPLATE_VIS bit_xor
+    : __binary_function<_Tp, _Tp, _Tp>
+{
+    typedef _Tp __result_type;  // used by valarray
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    _Tp operator()(const _Tp& __x, const _Tp& __y) const
+        {return __x ^ __y;}
+};
+_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(bit_xor);
+
+#if _LIBCUDACXX_STD_VER > 11
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS bit_xor<void>
+{
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    template <class _T1, class _T2>
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    auto operator()(_T1&& __t, _T2&& __u) const
+        noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) ^ _CUDA_VSTD::forward<_T2>(__u)))
+        -> decltype(      _CUDA_VSTD::forward<_T1>(__t) ^ _CUDA_VSTD::forward<_T2>(__u))
+        { return          _CUDA_VSTD::forward<_T1>(__t) ^ _CUDA_VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
+};
+#endif
+
+// Comparison operations
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp = void>
+#else
+template <class _Tp>
+#endif
+struct _LIBCUDACXX_TEMPLATE_VIS equal_to
+    : __binary_function<_Tp, _Tp, bool>
+{
+    typedef bool __result_type;  // used by valarray
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    bool operator()(const _Tp& __x, const _Tp& __y) const
+        {return __x == __y;}
+};
+_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(equal_to);
+
+#if _LIBCUDACXX_STD_VER > 11
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS equal_to<void>
+{
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    template <class _T1, class _T2>
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    auto operator()(_T1&& __t, _T2&& __u) const
+        noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) == _CUDA_VSTD::forward<_T2>(__u)))
+        -> decltype(      _CUDA_VSTD::forward<_T1>(__t) == _CUDA_VSTD::forward<_T2>(__u))
+        { return          _CUDA_VSTD::forward<_T1>(__t) == _CUDA_VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
+};
+#endif
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp = void>
+#else
+template <class _Tp>
+#endif
+struct _LIBCUDACXX_TEMPLATE_VIS not_equal_to
+    : __binary_function<_Tp, _Tp, bool>
+{
+    typedef bool __result_type;  // used by valarray
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    bool operator()(const _Tp& __x, const _Tp& __y) const
+        {return __x != __y;}
+};
+_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(not_equal_to);
+
+#if _LIBCUDACXX_STD_VER > 11
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS not_equal_to<void>
+{
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    template <class _T1, class _T2>
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    auto operator()(_T1&& __t, _T2&& __u) const
+        noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) != _CUDA_VSTD::forward<_T2>(__u)))
+        -> decltype(      _CUDA_VSTD::forward<_T1>(__t) != _CUDA_VSTD::forward<_T2>(__u))
+        { return          _CUDA_VSTD::forward<_T1>(__t) != _CUDA_VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
+};
+#endif
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp = void>
+#else
+template <class _Tp>
+#endif
+struct _LIBCUDACXX_TEMPLATE_VIS less
+    : __binary_function<_Tp, _Tp, bool>
+{
+    typedef bool __result_type;  // used by valarray
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    bool operator()(const _Tp& __x, const _Tp& __y) const
+        {return __x < __y;}
+};
+_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(less);
+
+#if _LIBCUDACXX_STD_VER > 11
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS less<void>
+{
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    template <class _T1, class _T2>
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    auto operator()(_T1&& __t, _T2&& __u) const
+        noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) < _CUDA_VSTD::forward<_T2>(__u)))
+        -> decltype(      _CUDA_VSTD::forward<_T1>(__t) < _CUDA_VSTD::forward<_T2>(__u))
+        { return          _CUDA_VSTD::forward<_T1>(__t) < _CUDA_VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
+};
+#endif
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp = void>
+#else
+template <class _Tp>
+#endif
+struct _LIBCUDACXX_TEMPLATE_VIS less_equal
+    : __binary_function<_Tp, _Tp, bool>
+{
+    typedef bool __result_type;  // used by valarray
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    bool operator()(const _Tp& __x, const _Tp& __y) const
+        {return __x <= __y;}
+};
+_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(less_equal);
+
+#if _LIBCUDACXX_STD_VER > 11
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS less_equal<void>
+{
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    template <class _T1, class _T2>
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    auto operator()(_T1&& __t, _T2&& __u) const
+        noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) <= _CUDA_VSTD::forward<_T2>(__u)))
+        -> decltype(      _CUDA_VSTD::forward<_T1>(__t) <= _CUDA_VSTD::forward<_T2>(__u))
+        { return          _CUDA_VSTD::forward<_T1>(__t) <= _CUDA_VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
+};
+#endif
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp = void>
+#else
+template <class _Tp>
+#endif
+struct _LIBCUDACXX_TEMPLATE_VIS greater_equal
+    : __binary_function<_Tp, _Tp, bool>
+{
+    typedef bool __result_type;  // used by valarray
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    bool operator()(const _Tp& __x, const _Tp& __y) const
+        {return __x >= __y;}
+};
+_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(greater_equal);
+
+#if _LIBCUDACXX_STD_VER > 11
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS greater_equal<void>
+{
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    template <class _T1, class _T2>
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    auto operator()(_T1&& __t, _T2&& __u) const
+        noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) >= _CUDA_VSTD::forward<_T2>(__u)))
+        -> decltype(      _CUDA_VSTD::forward<_T1>(__t) >= _CUDA_VSTD::forward<_T2>(__u))
+        { return          _CUDA_VSTD::forward<_T1>(__t) >= _CUDA_VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
+};
+#endif
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp = void>
+#else
+template <class _Tp>
+#endif
+struct _LIBCUDACXX_TEMPLATE_VIS greater
+    : __binary_function<_Tp, _Tp, bool>
+{
+    typedef bool __result_type;  // used by valarray
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    bool operator()(const _Tp& __x, const _Tp& __y) const
+        {return __x > __y;}
+};
+_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(greater);
+
+#if _LIBCUDACXX_STD_VER > 11
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS greater<void>
+{
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    template <class _T1, class _T2>
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    auto operator()(_T1&& __t, _T2&& __u) const
+        noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) > _CUDA_VSTD::forward<_T2>(__u)))
+        -> decltype(      _CUDA_VSTD::forward<_T1>(__t) > _CUDA_VSTD::forward<_T2>(__u))
+        { return          _CUDA_VSTD::forward<_T1>(__t) > _CUDA_VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
+};
+#endif
+
+// Logical operations
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp = void>
+#else
+template <class _Tp>
+#endif
+struct _LIBCUDACXX_TEMPLATE_VIS logical_and
+    : __binary_function<_Tp, _Tp, bool>
+{
+    typedef bool __result_type;  // used by valarray
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    bool operator()(const _Tp& __x, const _Tp& __y) const
+        {return __x && __y;}
+};
+_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(logical_and);
+
+#if _LIBCUDACXX_STD_VER > 11
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS logical_and<void>
+{
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    template <class _T1, class _T2>
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    auto operator()(_T1&& __t, _T2&& __u) const
+        noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) && _CUDA_VSTD::forward<_T2>(__u)))
+        -> decltype(      _CUDA_VSTD::forward<_T1>(__t) && _CUDA_VSTD::forward<_T2>(__u))
+        { return          _CUDA_VSTD::forward<_T1>(__t) && _CUDA_VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
+};
+#endif
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp = void>
+#else
+template <class _Tp>
+#endif
+struct _LIBCUDACXX_TEMPLATE_VIS logical_not
+    : __unary_function<_Tp, bool>
+{
+    typedef bool __result_type;  // used by valarray
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    bool operator()(const _Tp& __x) const
+        {return !__x;}
+};
+_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(logical_not);
+
+#if _LIBCUDACXX_STD_VER > 11
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS logical_not<void>
+{
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    template <class _Tp>
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    auto operator()(_Tp&& __x) const
+        noexcept(noexcept(!_CUDA_VSTD::forward<_Tp>(__x)))
+        -> decltype(      !_CUDA_VSTD::forward<_Tp>(__x))
+        { return          !_CUDA_VSTD::forward<_Tp>(__x); }
+    typedef void is_transparent;
+};
+#endif
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Tp = void>
+#else
+template <class _Tp>
+#endif
+struct _LIBCUDACXX_TEMPLATE_VIS logical_or
+    : __binary_function<_Tp, _Tp, bool>
+{
+    typedef bool __result_type;  // used by valarray
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    bool operator()(const _Tp& __x, const _Tp& __y) const
+        {return __x || __y;}
+};
+_LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(logical_or);
+
+#if _LIBCUDACXX_STD_VER > 11
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS logical_or<void>
+{
+    _LIBCUDACXX_DISABLE_EXEC_CHECK
+    template <class _T1, class _T2>
+    _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+    auto operator()(_T1&& __t, _T2&& __u) const
+        noexcept(noexcept(_CUDA_VSTD::forward<_T1>(__t) || _CUDA_VSTD::forward<_T2>(__u)))
+        -> decltype(      _CUDA_VSTD::forward<_T1>(__t) || _CUDA_VSTD::forward<_T2>(__u))
+        { return          _CUDA_VSTD::forward<_T1>(__t) || _CUDA_VSTD::forward<_T2>(__u); }
+    typedef void is_transparent;
+};
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___FUNCTIONAL_OPERATIONS_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/perfect_forward.h

@@ -0,0 +1,113 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___FUNCTIONAL_PERFECT_FORWARD_H
+#define _LIBCUDACXX___FUNCTIONAL_PERFECT_FORWARD_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__concepts/__concept_macros.h"
+#include "../__functional/invoke.h"
+#include "../__type_traits/enable_if.h"
+#include "../__type_traits/is_constructible.h"
+#include "../__type_traits/is_nothrow_constructible.h"
+#include "../__utility/declval.h"
+#include "../__utility/forward.h"
+#include "../__utility/integer_sequence.h"
+#include "../__utility/move.h"
+
+#include "../tuple"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 14
+
+template <class _Op, class _Indices, class... _BoundArgs>
+struct __perfect_forward_impl;
+
+template <class _Op, size_t... _Idx, class... _BoundArgs>
+struct __perfect_forward_impl<_Op, index_sequence<_Idx...>, _BoundArgs...> {
+private:
+  tuple<_BoundArgs...> __bound_args_;
+
+public:
+  _LIBCUDACXX_TEMPLATE(class... _Args)
+    (requires is_constructible_v<tuple<_BoundArgs...>, _Args&&...>)
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY
+  explicit constexpr __perfect_forward_impl(_Args&&... __bound_args)
+    noexcept(is_nothrow_constructible_v<tuple<_BoundArgs...>, _Args&&...>)
+    : __bound_args_(_CUDA_VSTD::forward<_Args>(__bound_args)...) {}
+
+  __perfect_forward_impl(__perfect_forward_impl const&) = default;
+  __perfect_forward_impl(__perfect_forward_impl&&) = default;
+
+  __perfect_forward_impl& operator=(__perfect_forward_impl const&) = default;
+  __perfect_forward_impl& operator=(__perfect_forward_impl&&) = default;
+
+  _LIBCUDACXX_TEMPLATE(class... _Args)
+    (requires is_invocable_v<_Op, _BoundArgs&..., _Args...>)
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr auto operator()(_Args&&... __args) &
+    noexcept(noexcept(_Op()(_CUDA_VSTD::get<_Idx>(__bound_args_)..., _CUDA_VSTD::forward<_Args>(__args)...)))
+    -> decltype(      _Op()(_CUDA_VSTD::get<_Idx>(__bound_args_)..., _CUDA_VSTD::forward<_Args>(__args)...))
+    { return          _Op()(_CUDA_VSTD::get<_Idx>(__bound_args_)..., _CUDA_VSTD::forward<_Args>(__args)...); }
+
+  _LIBCUDACXX_TEMPLATE(class... _Args)
+    (requires (!is_invocable_v<_Op, _BoundArgs&..., _Args...>))
+  _LIBCUDACXX_INLINE_VISIBILITY auto operator()(_Args&&...) & = delete;
+
+  _LIBCUDACXX_TEMPLATE(class... _Args)
+    (requires is_invocable_v<_Op, _BoundArgs const&..., _Args...>)
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr auto operator()(_Args&&... __args) const&
+    noexcept(noexcept(_Op()(_CUDA_VSTD::get<_Idx>(__bound_args_)..., _CUDA_VSTD::forward<_Args>(__args)...)))
+    -> decltype(      _Op()(_CUDA_VSTD::get<_Idx>(__bound_args_)..., _CUDA_VSTD::forward<_Args>(__args)...))
+    { return          _Op()(_CUDA_VSTD::get<_Idx>(__bound_args_)..., _CUDA_VSTD::forward<_Args>(__args)...); }
+
+  _LIBCUDACXX_TEMPLATE(class... _Args)
+    (requires (!is_invocable_v<_Op, _BoundArgs const&..., _Args...>))
+  _LIBCUDACXX_INLINE_VISIBILITY auto operator()(_Args&&...) const& = delete;
+
+  _LIBCUDACXX_TEMPLATE(class... _Args)
+    (requires is_invocable_v<_Op, _BoundArgs..., _Args...>)
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr auto operator()(_Args&&... __args) &&
+    noexcept(noexcept(_Op()(_CUDA_VSTD::get<_Idx>(_CUDA_VSTD::move(__bound_args_))..., _CUDA_VSTD::forward<_Args>(__args)...)))
+    -> decltype(      _Op()(_CUDA_VSTD::get<_Idx>(_CUDA_VSTD::move(__bound_args_))..., _CUDA_VSTD::forward<_Args>(__args)...))
+    { return          _Op()(_CUDA_VSTD::get<_Idx>(_CUDA_VSTD::move(__bound_args_))..., _CUDA_VSTD::forward<_Args>(__args)...); }
+
+  _LIBCUDACXX_TEMPLATE(class... _Args)
+    (requires (!is_invocable_v<_Op, _BoundArgs..., _Args...>))
+  _LIBCUDACXX_INLINE_VISIBILITY auto operator()(_Args&&...) && = delete;
+
+  _LIBCUDACXX_TEMPLATE(class... _Args)
+    (requires is_invocable_v<_Op, _BoundArgs const..., _Args...>)
+  _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_INLINE_VISIBILITY constexpr auto operator()(_Args&&... __args) const&&
+    noexcept(noexcept(_Op()(_CUDA_VSTD::get<_Idx>(_CUDA_VSTD::move(__bound_args_))..., _CUDA_VSTD::forward<_Args>(__args)...)))
+    -> decltype(      _Op()(_CUDA_VSTD::get<_Idx>(_CUDA_VSTD::move(__bound_args_))..., _CUDA_VSTD::forward<_Args>(__args)...))
+    { return          _Op()(_CUDA_VSTD::get<_Idx>(_CUDA_VSTD::move(__bound_args_))..., _CUDA_VSTD::forward<_Args>(__args)...); }
+
+  _LIBCUDACXX_TEMPLATE(class... _Args)
+    (requires (!is_invocable_v<_Op, _BoundArgs const..., _Args...>))
+  _LIBCUDACXX_INLINE_VISIBILITY auto operator()(_Args&&...) const&& = delete;
+};
+
+// __perfect_forward implements a perfect-forwarding call wrapper as explained in [func.require].
+template <class _Op, class ..._Args>
+using __perfect_forward = __perfect_forward_impl<_Op, index_sequence_for<_Args...>, _Args...>;
+
+#endif // _LIBCUDACXX_STD_VER > 14
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___FUNCTIONAL_PERFECT_FORWARD_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/reference_wrapper.h

@@ -0,0 +1,103 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___FUNCTIONAL_REFERENCE_WRAPPER_H
+#define _LIBCUDACXX___FUNCTIONAL_REFERENCE_WRAPPER_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__functional/weak_result_type.h"
+#include "../__memory/addressof.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+class _LIBCUDACXX_TEMPLATE_VIS reference_wrapper : public __weak_result_type<_Tp>
+{
+public:
+    // types
+    typedef _Tp type;
+private:
+    type* __f_;
+
+    static _LIBCUDACXX_INLINE_VISIBILITY void __fun(_Tp&) _NOEXCEPT;
+    static void __fun(_Tp&&) = delete;
+
+public:
+    template <class _Up, class = __enable_if_t<!__is_same_uncvref<_Up, reference_wrapper>::value, decltype(__fun(declval<_Up>())) > >
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+    reference_wrapper(_Up&& __u) _NOEXCEPT_(noexcept(__fun(declval<_Up>()))) {
+        type& __f = static_cast<_Up&&>(__u);
+        __f_ = _CUDA_VSTD::addressof(__f);
+    }
+
+    // access
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+    operator type&() const _NOEXCEPT {return *__f_;}
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+    type& get() const _NOEXCEPT {return *__f_;}
+
+    // invoke
+    template <class... _ArgTypes>
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+    typename __invoke_of<type&, _ArgTypes...>::type
+    operator() (_ArgTypes&&... __args) const {
+        return _CUDA_VSTD::__invoke(get(), _CUDA_VSTD::forward<_ArgTypes>(__args)...);
+    }
+};
+
+#if _LIBCUDACXX_STD_VER > 14 && !defined(_LIBCUDACXX_HAS_NO_DEDUCTION_GUIDES)
+template <class _Tp>
+reference_wrapper(_Tp&) -> reference_wrapper<_Tp>;
+#endif
+
+template <class _Tp>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+reference_wrapper<_Tp>
+ref(_Tp& __t) _NOEXCEPT
+{
+    return reference_wrapper<_Tp>(__t);
+}
+
+template <class _Tp>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+reference_wrapper<_Tp>
+ref(reference_wrapper<_Tp> __t) _NOEXCEPT
+{
+    return __t;
+}
+
+template <class _Tp>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+reference_wrapper<const _Tp>
+cref(const _Tp& __t) _NOEXCEPT
+{
+    return reference_wrapper<const _Tp>(__t);
+}
+
+template <class _Tp>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+reference_wrapper<const _Tp>
+cref(reference_wrapper<_Tp> __t) _NOEXCEPT
+{
+    return __t;
+}
+
+template <class _Tp> void ref(const _Tp&&) = delete;
+template <class _Tp> void cref(const _Tp&&) = delete;
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___FUNCTIONAL_REFERENCE_WRAPPER_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__functional/weak_result_type.h

@@ -0,0 +1,297 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___FUNCTIONAL_WEAK_RESULT_TYPE_H
+#define _LIBCUDACXX___FUNCTIONAL_WEAK_RESULT_TYPE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__functional/binary_function.h"
+#include "../__functional/invoke.h"
+#include "../__functional/unary_function.h"
+#include "../__type_traits/integral_constant.h"
+#include "../__type_traits/is_same.h"
+#include "../__utility/declval.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct __has_result_type
+{
+private:
+    template <class _Up> _LIBCUDACXX_INLINE_VISIBILITY static false_type __test(...);
+    template <class _Up> _LIBCUDACXX_INLINE_VISIBILITY static true_type __test(typename _Up::result_type* = 0);
+public:
+    static const bool value = decltype(__test<_Tp>(0))::value;
+};
+
+// __weak_result_type
+
+template <class _Tp>
+struct __derives_from_unary_function
+{
+private:
+    struct __two {char __lx; char __lxx;};
+    static _LIBCUDACXX_INLINE_VISIBILITY __two __test(...);
+    template <class _Ap, class _Rp>
+        static _LIBCUDACXX_INLINE_VISIBILITY __unary_function<_Ap, _Rp>
+        __test(const volatile __unary_function<_Ap, _Rp>*);
+
+public:
+    static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value;
+    typedef decltype(__test((_Tp*)0)) type;
+};
+
+template <class _Tp>
+struct __derives_from_binary_function
+{
+private:
+    struct __two {char __lx; char __lxx;};
+    static __two _LIBCUDACXX_INLINE_VISIBILITY __test(...);
+    template <class _A1, class _A2, class _Rp>
+        static _LIBCUDACXX_INLINE_VISIBILITY __binary_function<_A1, _A2, _Rp>
+        __test(const volatile __binary_function<_A1, _A2, _Rp>*);
+
+public:
+    static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value;
+    typedef decltype(__test((_Tp*)0)) type;
+};
+
+template <class _Tp, bool = __derives_from_unary_function<_Tp>::value>
+struct __maybe_derive_from_unary_function  // bool is true
+    : public __derives_from_unary_function<_Tp>::type
+{
+};
+
+template <class _Tp>
+struct __maybe_derive_from_unary_function<_Tp, false>
+{
+};
+
+template <class _Tp, bool = __derives_from_binary_function<_Tp>::value>
+struct __maybe_derive_from_binary_function  // bool is true
+    : public __derives_from_binary_function<_Tp>::type
+{
+};
+
+template <class _Tp>
+struct __maybe_derive_from_binary_function<_Tp, false>
+{
+};
+
+template <class _Tp, bool = __has_result_type<_Tp>::value>
+struct __weak_result_type_imp // bool is true
+    : public __maybe_derive_from_unary_function<_Tp>,
+      public __maybe_derive_from_binary_function<_Tp>
+{
+#if _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
+    using result_type _LIBCUDACXX_NODEBUG_TYPE _LIBCUDACXX_DEPRECATED_IN_CXX17 = typename _Tp::result_type;
+#endif
+};
+
+template <class _Tp>
+struct __weak_result_type_imp<_Tp, false>
+    : public __maybe_derive_from_unary_function<_Tp>,
+      public __maybe_derive_from_binary_function<_Tp>
+{
+};
+
+template <class _Tp>
+struct __weak_result_type
+    : public __weak_result_type_imp<_Tp>
+{
+};
+
+// 0 argument case
+
+template <class _Rp>
+struct __weak_result_type<_Rp ()>
+{
+#if _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
+    using result_type _LIBCUDACXX_NODEBUG_TYPE _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Rp;
+#endif
+};
+
+template <class _Rp>
+struct __weak_result_type<_Rp (&)()>
+{
+#if _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
+    using result_type _LIBCUDACXX_NODEBUG_TYPE _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Rp;
+#endif
+};
+
+template <class _Rp>
+struct __weak_result_type<_Rp (*)()>
+{
+#if _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
+    using result_type _LIBCUDACXX_NODEBUG_TYPE _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Rp;
+#endif
+};
+
+// 1 argument case
+
+template <class _Rp, class _A1>
+struct __weak_result_type<_Rp (_A1)>
+    : public __unary_function<_A1, _Rp>
+{
+};
+
+template <class _Rp, class _A1>
+struct __weak_result_type<_Rp (&)(_A1)>
+    : public __unary_function<_A1, _Rp>
+{
+};
+
+template <class _Rp, class _A1>
+struct __weak_result_type<_Rp (*)(_A1)>
+    : public __unary_function<_A1, _Rp>
+{
+};
+
+template <class _Rp, class _Cp>
+struct __weak_result_type<_Rp (_Cp::*)()>
+    : public __unary_function<_Cp*, _Rp>
+{
+};
+
+template <class _Rp, class _Cp>
+struct __weak_result_type<_Rp (_Cp::*)() const>
+    : public __unary_function<const _Cp*, _Rp>
+{
+};
+
+template <class _Rp, class _Cp>
+struct __weak_result_type<_Rp (_Cp::*)() volatile>
+    : public __unary_function<volatile _Cp*, _Rp>
+{
+};
+
+template <class _Rp, class _Cp>
+struct __weak_result_type<_Rp (_Cp::*)() const volatile>
+    : public __unary_function<const volatile _Cp*, _Rp>
+{
+};
+
+// 2 argument case
+
+template <class _Rp, class _A1, class _A2>
+struct __weak_result_type<_Rp (_A1, _A2)>
+    : public __binary_function<_A1, _A2, _Rp>
+{
+};
+
+template <class _Rp, class _A1, class _A2>
+struct __weak_result_type<_Rp (*)(_A1, _A2)>
+    : public __binary_function<_A1, _A2, _Rp>
+{
+};
+
+template <class _Rp, class _A1, class _A2>
+struct __weak_result_type<_Rp (&)(_A1, _A2)>
+    : public __binary_function<_A1, _A2, _Rp>
+{
+};
+
+template <class _Rp, class _Cp, class _A1>
+struct __weak_result_type<_Rp (_Cp::*)(_A1)>
+    : public __binary_function<_Cp*, _A1, _Rp>
+{
+};
+
+template <class _Rp, class _Cp, class _A1>
+struct __weak_result_type<_Rp (_Cp::*)(_A1) const>
+    : public __binary_function<const _Cp*, _A1, _Rp>
+{
+};
+
+template <class _Rp, class _Cp, class _A1>
+struct __weak_result_type<_Rp (_Cp::*)(_A1) volatile>
+    : public __binary_function<volatile _Cp*, _A1, _Rp>
+{
+};
+
+template <class _Rp, class _Cp, class _A1>
+struct __weak_result_type<_Rp (_Cp::*)(_A1) const volatile>
+    : public __binary_function<const volatile _Cp*, _A1, _Rp>
+{
+};
+
+// 3 or more arguments
+
+template <class _Rp, class _A1, class _A2, class _A3, class ..._A4>
+struct __weak_result_type<_Rp (_A1, _A2, _A3, _A4...)>
+{
+#if _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
+    using result_type _LIBCUDACXX_NODEBUG_TYPE _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Rp;
+#endif
+};
+
+template <class _Rp, class _A1, class _A2, class _A3, class ..._A4>
+struct __weak_result_type<_Rp (&)(_A1, _A2, _A3, _A4...)>
+{
+#if _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
+    using result_type _LIBCUDACXX_NODEBUG_TYPE _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Rp;
+#endif
+};
+
+template <class _Rp, class _A1, class _A2, class _A3, class ..._A4>
+struct __weak_result_type<_Rp (*)(_A1, _A2, _A3, _A4...)>
+{
+#if _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
+    using result_type _LIBCUDACXX_NODEBUG_TYPE _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Rp;
+#endif
+};
+
+template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
+struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...)>
+{
+#if _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
+    using result_type _LIBCUDACXX_NODEBUG_TYPE _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Rp;
+#endif
+};
+
+template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
+struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) const>
+{
+#if _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
+    using result_type _LIBCUDACXX_NODEBUG_TYPE _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Rp;
+#endif
+};
+
+template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
+struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) volatile>
+{
+#if _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
+    using result_type _LIBCUDACXX_NODEBUG_TYPE _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Rp;
+#endif
+};
+
+template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
+struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) const volatile>
+{
+#if _LIBCUDACXX_STD_VER <= 17 || defined(_LIBCUDACXX_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
+    using result_type _LIBCUDACXX_NODEBUG_TYPE _LIBCUDACXX_DEPRECATED_IN_CXX17 = _Rp;
+#endif
+};
+
+template <class _Tp, class ..._Args>
+struct __invoke_return
+{
+    typedef decltype(_CUDA_VSTD::__invoke(declval<_Tp>(), declval<_Args>()...)) type;
+};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___FUNCTIONAL_WEAK_RESULT_TYPE_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/array.h

@@ -0,0 +1,30 @@
+//===---------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___FWD_ARRAY_H
+#define _LIBCUDACXX___FWD_ARRAY_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../cstddef"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp, size_t _Size>
+struct _LIBCUDACXX_TEMPLATE_VIS array;
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___FWD_ARRAY_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/get.h

@@ -0,0 +1,99 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___FWD_GET_H
+#define _LIBCUDACXX___FWD_GET_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__fwd/array.h"
+#include "../__fwd/pair.h"
+#include "../__fwd/tuple.h"
+#include "../__tuple_dir/tuple_element.h"
+#include "../cstddef"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#ifndef _LIBCUDACXX_CXX03_LANG
+
+template <size_t _Ip, class ..._Tp>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+typename tuple_element<_Ip, tuple<_Tp...> >::type&
+get(tuple<_Tp...>&) _NOEXCEPT;
+
+template <size_t _Ip, class ..._Tp>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+const typename tuple_element<_Ip, tuple<_Tp...> >::type&
+get(const tuple<_Tp...>&) _NOEXCEPT;
+
+template <size_t _Ip, class ..._Tp>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+typename tuple_element<_Ip, tuple<_Tp...> >::type&&
+get(tuple<_Tp...>&&) _NOEXCEPT;
+
+template <size_t _Ip, class ..._Tp>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+const typename tuple_element<_Ip, tuple<_Tp...> >::type&&
+get(const tuple<_Tp...>&&) _NOEXCEPT;
+
+#endif // _LIBCUDACXX_CXX03_LANG
+
+template <size_t _Ip, class _T1, class _T2>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+typename tuple_element<_Ip, pair<_T1, _T2> >::type&
+get(pair<_T1, _T2>&) _NOEXCEPT;
+
+template <size_t _Ip, class _T1, class _T2>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
+get(const pair<_T1, _T2>&) _NOEXCEPT;
+
+#ifndef _LIBCUDACXX_CXX03_LANG
+template <size_t _Ip, class _T1, class _T2>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
+get(pair<_T1, _T2>&&) _NOEXCEPT;
+
+template <size_t _Ip, class _T1, class _T2>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+const typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
+get(const pair<_T1, _T2>&&) _NOEXCEPT;
+#endif // _LIBCUDACXX_CXX03_LANG
+
+template <size_t _Ip, class _Tp, size_t _Size>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+_Tp&
+get(array<_Tp, _Size>&) _NOEXCEPT;
+
+template <size_t _Ip, class _Tp, size_t _Size>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+const _Tp&
+get(const array<_Tp, _Size>&) _NOEXCEPT;
+
+#ifndef _LIBCUDACXX_CXX03_LANG
+template <size_t _Ip, class _Tp, size_t _Size>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+_Tp&&
+get(array<_Tp, _Size>&&) _NOEXCEPT;
+
+template <size_t _Ip, class _Tp, size_t _Size>
+_LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+const _Tp&&
+get(const array<_Tp, _Size>&&) _NOEXCEPT;
+#endif // _LIBCUDACXX_CXX03_LANG
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___FWD_GET_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/hash.h

@@ -0,0 +1,28 @@
+//===---------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___FWD_HASH_H
+#define _LIBCUDACXX___FWD_HASH_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class>
+struct _LIBCUDACXX_TEMPLATE_VIS hash;
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___FWD_HASH_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/memory_resource.h

@@ -0,0 +1,30 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___FWD_MEMORY_RESOURCE_H
+#define _LIBCUDACXX___FWD_MEMORY_RESOURCE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+namespace pmr {
+template <class _ValueType>
+class _LIBCUDACXX_TEMPLATE_VIS polymorphic_allocator;
+} // namespace pmr
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___FWD_MEMORY_RESOURCE_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/pair.h

@@ -0,0 +1,28 @@
+//===---------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___FWD_PAIR_H
+#define _LIBCUDACXX___FWD_PAIR_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class, class>
+struct _LIBCUDACXX_TEMPLATE_VIS pair;
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___FWD_PAIR_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/span.h

@@ -0,0 +1,36 @@
+// -*- C++ -*-
+//===---------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___FWD_SPAN_H
+#define _LIBCUDACXX___FWD_SPAN_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../cstddef"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_INLINE_VAR constexpr size_t dynamic_extent = static_cast<size_t>(-1);
+template <typename _Tp, size_t _Extent = dynamic_extent> class span;
+
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+
+#endif // _LIBCUDACXX___FWD_SPAN_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/string.h

@@ -0,0 +1,114 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___FWD_STRING_H
+#define _LIBCUDACXX___FWD_STRING_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__fwd/memory_resource.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _CharT>
+struct _LIBCUDACXX_TEMPLATE_VIS char_traits;
+template <>
+struct char_traits<char>;
+
+#ifndef _LIBCUDACXX_NO_HAS_CHAR8_T
+template <>
+struct char_traits<char8_t>;
+#endif
+
+template <>
+struct char_traits<char16_t>;
+template <>
+struct char_traits<char32_t>;
+
+#ifndef _LIBCUDACXX_HAS_NO_WIDE_CHARACTERS
+template <>
+struct char_traits<wchar_t>;
+#endif
+
+template <class _Tp>
+class _LIBCUDACXX_TEMPLATE_VIS allocator;
+
+template <class _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT> >
+class _LIBCUDACXX_TEMPLATE_VIS basic_string;
+
+using string = basic_string<char>;
+
+#ifndef _LIBCUDACXX_HAS_NO_WIDE_CHARACTERS
+using wstring = basic_string<wchar_t>;
+#endif
+
+#ifndef _LIBCUDACXX_NO_HAS_CHAR8_T
+using u8string = basic_string<char8_t>;
+#endif
+
+using u16string = basic_string<char16_t>;
+using u32string = basic_string<char32_t>;
+
+#if _LIBCUDACXX_STD_VER >= 17
+
+namespace pmr {
+template <class _CharT, class _Traits = char_traits<_CharT>>
+using basic_string = std::basic_string<_CharT, _Traits, polymorphic_allocator<_CharT>>;
+
+using string = basic_string<char>;
+
+#  ifndef _LIBCUDACXX_HAS_NO_WIDE_CHARACTERS
+using wstring = basic_string<wchar_t>;
+#  endif
+
+#  ifndef _LIBCUDACXX_NO_HAS_CHAR8_T
+using u8string = basic_string<char8_t>;
+#  endif
+
+using u16string = basic_string<char16_t>;
+using u32string = basic_string<char32_t>;
+
+} // namespace pmr
+
+#endif // _LIBCUDACXX_STD_VER >= 17
+
+// clang-format off
+template <class _CharT, class _Traits, class _Allocator>
+class _LIBCUDACXX_PREFERRED_NAME(string)
+#ifndef _LIBCUDACXX_HAS_NO_WIDE_CHARACTERS
+      _LIBCUDACXX_PREFERRED_NAME(wstring)
+#endif
+#ifndef _LIBCUDACXX_NO_HAS_CHAR8_T
+      _LIBCUDACXX_PREFERRED_NAME(u8string)
+#endif
+      _LIBCUDACXX_PREFERRED_NAME(u16string)
+      _LIBCUDACXX_PREFERRED_NAME(u32string)
+#if _LIBCUDACXX_STD_VER >= 17
+      _LIBCUDACXX_PREFERRED_NAME(pmr::string)
+#  ifndef _LIBCUDACXX_HAS_NO_WIDE_CHARACTERS
+      _LIBCUDACXX_PREFERRED_NAME(pmr::wstring)
+#  endif
+#  ifndef _LIBCUDACXX_NO_HAS_CHAR8_T
+      _LIBCUDACXX_PREFERRED_NAME(pmr::u8string)
+#  endif
+      _LIBCUDACXX_PREFERRED_NAME(pmr::u16string)
+      _LIBCUDACXX_PREFERRED_NAME(pmr::u32string)
+#endif
+      basic_string;
+// clang-format on
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___FWD_STRING_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/string_view.h

@@ -0,0 +1,54 @@
+// -*- C++ -*-
+//===---------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___FWD_STRING_VIEW_H
+#define _LIBCUDACXX___FWD_STRING_VIEW_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__fwd/string.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template<class _CharT, class _Traits = char_traits<_CharT> >
+class _LIBCUDACXX_TEMPLATE_VIS basic_string_view;
+
+typedef basic_string_view<char>     string_view;
+#ifndef _LIBCUDACXX_NO_HAS_CHAR8_T
+typedef basic_string_view<char8_t>  u8string_view;
+#endif
+typedef basic_string_view<char16_t> u16string_view;
+typedef basic_string_view<char32_t> u32string_view;
+#ifndef _LIBCUDACXX_HAS_NO_WIDE_CHARACTERS
+typedef basic_string_view<wchar_t>  wstring_view;
+#endif
+
+// clang-format off
+template <class _CharT, class _Traits>
+class _LIBCUDACXX_PREFERRED_NAME(string_view)
+#ifndef _LIBCUDACXX_HAS_NO_WIDE_CHARACTERS
+      _LIBCUDACXX_PREFERRED_NAME(wstring_view)
+#endif
+#ifndef _LIBCUDACXX_NO_HAS_CHAR8_T
+      _LIBCUDACXX_PREFERRED_NAME(u8string_view)
+#endif
+      _LIBCUDACXX_PREFERRED_NAME(u16string_view)
+      _LIBCUDACXX_PREFERRED_NAME(u32string_view)
+      basic_string_view;
+// clang-format on
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___FWD_STRING_VIEW_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__fwd/tuple.h

@@ -0,0 +1,32 @@
+//===---------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___FWD_TUPLE_H
+#define _LIBCUDACXX___FWD_TUPLE_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#ifndef _LIBCUDACXX_CXX03_LANG
+
+template <class...>
+class _LIBCUDACXX_TEMPLATE_VIS tuple;
+
+#endif // _LIBCUDACXX_CXX03_LANG
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___FWD_TUPLE_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/data.h

@@ -0,0 +1,55 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___ITERATOR_DATA_H
+#define _LIBCUDACXX___ITERATOR_DATA_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../cstddef"
+#include "../initializer_list"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+template <class _Cont> constexpr
+_LIBCUDACXX_INLINE_VISIBILITY
+auto data(_Cont& __c)
+_NOEXCEPT_(noexcept(__c.data()))
+-> decltype        (__c.data())
+{ return            __c.data(); }
+
+template <class _Cont> constexpr
+_LIBCUDACXX_INLINE_VISIBILITY
+auto data(const _Cont& __c)
+_NOEXCEPT_(noexcept(__c.data()))
+-> decltype        (__c.data())
+{ return            __c.data(); }
+
+template <class _Tp, size_t _Sz>
+_LIBCUDACXX_INLINE_VISIBILITY
+constexpr _Tp* data(_Tp (&__array)[_Sz]) noexcept { return __array; }
+
+template <class _Ep>
+_LIBCUDACXX_INLINE_VISIBILITY
+constexpr const _Ep* data(initializer_list<_Ep> __il) noexcept { return __il.begin(); }
+
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___ITERATOR_DATA_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/empty.h

@@ -0,0 +1,48 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___ITERATOR_EMPTY_H
+#define _LIBCUDACXX___ITERATOR_EMPTY_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../cstddef"
+#include "../initializer_list"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+template <class _Cont>
+_LIBCUDACXX_NODISCARD_AFTER_CXX17 _LIBCUDACXX_INLINE_VISIBILITY
+constexpr auto empty(const _Cont& __c)
+_NOEXCEPT_(noexcept(__c.empty()))
+-> decltype        (__c.empty())
+{ return            __c.empty(); }
+
+template <class _Tp, size_t _Sz>
+_LIBCUDACXX_NODISCARD_AFTER_CXX17 _LIBCUDACXX_INLINE_VISIBILITY
+constexpr bool empty(const _Tp (&)[_Sz]) noexcept { return false; }
+
+template <class _Ep>
+_LIBCUDACXX_NODISCARD_AFTER_CXX17 _LIBCUDACXX_INLINE_VISIBILITY
+constexpr bool empty(initializer_list<_Ep> __il) noexcept { return __il.size() == 0; }
+
+#endif // _LIBCUDACXX_STD_VER > 17
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___ITERATOR_EMPTY_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/erase_if_container.h

@@ -0,0 +1,43 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___ITERATOR_ERASE_IF_CONTAINER_H
+#define _LIBCUDACXX___ITERATOR_ERASE_IF_CONTAINER_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Container, class _Predicate>
+_LIBCUDACXX_INLINE_VISIBILITY
+typename _Container::size_type
+__libcpp_erase_if_container(_Container& __c, _Predicate& __pred) {
+  typename _Container::size_type __old_size = __c.size();
+
+  const typename _Container::iterator __last = __c.end();
+  for (typename _Container::iterator __iter = __c.begin(); __iter != __last;) {
+    if (__pred(*__iter))
+      __iter = __c.erase(__iter);
+    else
+      ++__iter;
+  }
+
+  return __old_size - __c.size();
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___ITERATOR_ERASE_IF_CONTAINER_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/front_insert_iterator.h

@@ -0,0 +1,69 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___ITERATOR_FRONT_INSERT_ITERATOR_H
+#define _LIBCUDACXX___ITERATOR_FRONT_INSERT_ITERATOR_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__iterator/iterator.h"
+#include "../__iterator/iterator_traits.h"
+#include "../__memory/addressof.h"
+#include "../__utility/move.h"
+#include "../cstddef"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+_LIBCUDACXX_SUPPRESS_DEPRECATED_PUSH
+template <class _Container>
+class _LIBCUDACXX_TEMPLATE_VIS front_insert_iterator
+#if _LIBCUDACXX_STD_VER <= 14 || !defined(_LIBCUDACXX_ABI_NO_ITERATOR_BASES)
+    : public iterator<output_iterator_tag,
+                      void,
+                      void,
+                      void,
+                      void>
+#endif
+{
+_LIBCUDACXX_SUPPRESS_DEPRECATED_POP
+protected:
+    _Container* container;
+public:
+    typedef _Container container_type;
+
+    _LIBCUDACXX_INLINE_VISIBILITY explicit front_insert_iterator(_Container& __x) : container(_CUDA_VSTD::addressof(__x)) {}
+    _LIBCUDACXX_INLINE_VISIBILITY front_insert_iterator& operator=(const typename _Container::value_type& __value_)
+        {container->push_front(__value_); return *this;}
+#ifndef _LIBCUDACXX_CXX03_LANG
+    _LIBCUDACXX_INLINE_VISIBILITY front_insert_iterator& operator=(typename _Container::value_type&& __value_)
+        {container->push_front(_CUDA_VSTD::move(__value_)); return *this;}
+#endif  // _LIBCUDACXX_CXX03_LANG
+    _LIBCUDACXX_INLINE_VISIBILITY front_insert_iterator& operator*()     {return *this;}
+    _LIBCUDACXX_INLINE_VISIBILITY front_insert_iterator& operator++()    {return *this;}
+    _LIBCUDACXX_INLINE_VISIBILITY front_insert_iterator  operator++(int) {return *this;}
+};
+
+template <class _Container>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+front_insert_iterator<_Container>
+front_inserter(_Container& __x)
+{
+    return front_insert_iterator<_Container>(__x);
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___ITERATOR_FRONT_INSERT_ITERATOR_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/insert_iterator.h

@@ -0,0 +1,71 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___ITERATOR_INSERT_ITERATOR_H
+#define _LIBCUDACXX___ITERATOR_INSERT_ITERATOR_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__iterator/iterator_traits.h"
+#include "../__iterator/iterator.h"
+#include "../__memory/addressof.h"
+#include "../__utility/move.h"
+#include "../cstddef"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+_LIBCUDACXX_SUPPRESS_DEPRECATED_PUSH
+template <class _Container>
+class _LIBCUDACXX_TEMPLATE_VIS insert_iterator
+#if _LIBCUDACXX_STD_VER <= 14 || !defined(_LIBCUDACXX_ABI_NO_ITERATOR_BASES)
+    : public iterator<output_iterator_tag,
+                      void,
+                      void,
+                      void,
+                      void>
+#endif
+{
+_LIBCUDACXX_SUPPRESS_DEPRECATED_POP
+protected:
+    _Container* container;
+    typename _Container::iterator iter;
+public:
+    typedef _Container container_type;
+
+    _LIBCUDACXX_INLINE_VISIBILITY insert_iterator(_Container& __x, typename _Container::iterator __i)
+        : container(_CUDA_VSTD::addressof(__x)), iter(__i) {}
+    _LIBCUDACXX_INLINE_VISIBILITY insert_iterator& operator=(const typename _Container::value_type& __value_)
+        {iter = container->insert(iter, __value_); ++iter; return *this;}
+#ifndef _LIBCUDACXX_CXX03_LANG
+    _LIBCUDACXX_INLINE_VISIBILITY insert_iterator& operator=(typename _Container::value_type&& __value_)
+        {iter = container->insert(iter, _CUDA_VSTD::move(__value_)); ++iter; return *this;}
+#endif  // _LIBCUDACXX_CXX03_LANG
+    _LIBCUDACXX_INLINE_VISIBILITY insert_iterator& operator*()        {return *this;}
+    _LIBCUDACXX_INLINE_VISIBILITY insert_iterator& operator++()       {return *this;}
+    _LIBCUDACXX_INLINE_VISIBILITY insert_iterator& operator++(int)    {return *this;}
+};
+
+template <class _Container>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+insert_iterator<_Container>
+inserter(_Container& __x, typename _Container::iterator __i)
+{
+    return insert_iterator<_Container>(__x, __i);
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___ITERATOR_INSERT_ITERATOR_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/next.h

@@ -0,0 +1,48 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___ITERATOR_NEXT_H
+#define _LIBCUDACXX___ITERATOR_NEXT_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__assert"
+#include "../__iterator/advance.h"
+#include "../__iterator/iterator_traits.h"
+#include "../__type_traits/enable_if.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _InputIter>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+__enable_if_t
+<
+    __is_cpp17_input_iterator<_InputIter>::value,
+    _InputIter
+>
+next(_InputIter __x,
+     typename iterator_traits<_InputIter>::difference_type __n = 1)
+{
+    _LIBCUDACXX_ASSERT(__n >= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value,
+                       "Attempt to next(it, -n) on a non-bidi iterator");
+
+    _CUDA_VSTD::advance(__x, __n);
+    return __x;
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___ITERATOR_NEXT_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/ostreambuf_iterator.h

@@ -0,0 +1,71 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___ITERATOR_OSTREAMBUF_ITERATOR_H
+#define _LIBCUDACXX___ITERATOR_OSTREAMBUF_ITERATOR_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__iterator/iterator.h"
+#include "../__iterator/iterator_traits.h"
+#include "../cstddef"
+#include "../iosfwd"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+_LIBCUDACXX_SUPPRESS_DEPRECATED_PUSH
+template <class _CharT, class _Traits>
+class _LIBCUDACXX_TEMPLATE_VIS ostreambuf_iterator
+#if _LIBCUDACXX_STD_VER <= 14 || !defined(_LIBCUDACXX_ABI_NO_ITERATOR_BASES)
+    : public iterator<output_iterator_tag, void, void, void, void>
+#endif
+{
+_LIBCUDACXX_SUPPRESS_DEPRECATED_POP
+public:
+    typedef _CharT                          char_type;
+    typedef _Traits                         traits_type;
+    typedef basic_streambuf<_CharT,_Traits> streambuf_type;
+    typedef basic_ostream<_CharT,_Traits>   ostream_type;
+private:
+    streambuf_type* __sbuf_;
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY ostreambuf_iterator(ostream_type& __s) _NOEXCEPT
+        : __sbuf_(__s.rdbuf()) {}
+    _LIBCUDACXX_INLINE_VISIBILITY ostreambuf_iterator(streambuf_type* __s) _NOEXCEPT
+        : __sbuf_(__s) {}
+    _LIBCUDACXX_INLINE_VISIBILITY ostreambuf_iterator& operator=(_CharT __c)
+        {
+            if (__sbuf_ && traits_type::eq_int_type(__sbuf_->sputc(__c), traits_type::eof()))
+                __sbuf_ = 0;
+            return *this;
+        }
+    _LIBCUDACXX_INLINE_VISIBILITY ostreambuf_iterator& operator*()     {return *this;}
+    _LIBCUDACXX_INLINE_VISIBILITY ostreambuf_iterator& operator++()    {return *this;}
+    _LIBCUDACXX_INLINE_VISIBILITY ostreambuf_iterator& operator++(int) {return *this;}
+    _LIBCUDACXX_INLINE_VISIBILITY bool failed() const _NOEXCEPT {return __sbuf_ == 0;}
+
+    template <class _Ch, class _Tr>
+    friend
+    _LIBCUDACXX_HIDDEN _LIBCUDACXX_HOST_DEVICE
+    ostreambuf_iterator<_Ch, _Tr>
+    __pad_and_output(ostreambuf_iterator<_Ch, _Tr> __s,
+                     const _Ch* __ob, const _Ch* __op, const _Ch* __oe,
+                     ios_base& __iob, _Ch __fl);
+};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___ITERATOR_OSTREAMBUF_ITERATOR_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/prev.h

@@ -0,0 +1,47 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___ITERATOR_PREV_H
+#define _LIBCUDACXX___ITERATOR_PREV_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__assert"
+#include "../__iterator/advance.h"
+#include "../__iterator/iterator_traits.h"
+#include "../__type_traits/enable_if.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _InputIter>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+__enable_if_t
+<
+    __is_cpp17_input_iterator<_InputIter>::value,
+    _InputIter
+>
+prev(_InputIter __x,
+     typename iterator_traits<_InputIter>::difference_type __n = 1)
+{
+    _LIBCUDACXX_ASSERT(__n <= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value,
+                       "Attempt to prev(it, +n) on a non-bidi iterator");
+    _CUDA_VSTD::advance(__x, -__n);
+    return __x;
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___ITERATOR_PREV_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__iterator/reverse_iterator.h

@@ -0,0 +1,186 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___ITERATOR_REVERSE_ITERATOR_H
+#define _LIBCUDACXX___ITERATOR_REVERSE_ITERATOR_H
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__iterator/iterator.h"
+#include "../__iterator/iterator_traits.h"
+#include "../__memory/addressof.h"
+#include "../__type_traits/void_t.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp, class = void>
+struct __is_cpp17_stashing_iterator : false_type {};
+
+template <class _Tp>
+struct __is_cpp17_stashing_iterator<_Tp, __void_t<typename _Tp::__stashing_iterator_tag>>
+  : true_type {};
+
+_LIBCUDACXX_SUPPRESS_DEPRECATED_PUSH
+template <class _Iter>
+class _LIBCUDACXX_TEMPLATE_VIS reverse_iterator
+#if _LIBCUDACXX_STD_VER <= 14 || !defined(_LIBCUDACXX_ABI_NO_ITERATOR_BASES)
+    : public iterator<typename iterator_traits<_Iter>::iterator_category,
+                      typename iterator_traits<_Iter>::value_type,
+                      typename iterator_traits<_Iter>::difference_type,
+                      typename iterator_traits<_Iter>::pointer,
+                      typename iterator_traits<_Iter>::reference>
+#endif
+{
+_LIBCUDACXX_SUPPRESS_DEPRECATED_POP
+private:
+    /*mutable*/ _Iter __t;  // no longer used as of LWG #2360, not removed due to ABI break
+
+    static_assert(!__is_cpp17_stashing_iterator<_Iter>::value,
+      "The specified iterator type cannot be used with reverse_iterator; "
+      "Using stashing iterators with reverse_iterator causes undefined behavior");
+
+protected:
+    _Iter current;
+public:
+    typedef _Iter                                            iterator_type;
+    typedef typename iterator_traits<_Iter>::difference_type difference_type;
+    typedef typename iterator_traits<_Iter>::reference       reference;
+    typedef typename iterator_traits<_Iter>::pointer         pointer;
+
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    reverse_iterator() : __t(), current() {}
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    explicit reverse_iterator(_Iter __x) : __t(__x), current(__x) {}
+    template <class _Up>
+        _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+        reverse_iterator(const reverse_iterator<_Up>& __u) : __t(__u.base()), current(__u.base()) {}
+    template <class _Up>
+        _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+        reverse_iterator& operator=(const reverse_iterator<_Up>& __u)
+            { __t = current = __u.base(); return *this; }
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    _Iter base() const {return current;}
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    reference operator*() const {_Iter __tmp = current; return *--__tmp;}
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    pointer  operator->() const {return _CUDA_VSTD::addressof(operator*());}
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    reverse_iterator& operator++() {--current; return *this;}
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    reverse_iterator  operator++(int) {reverse_iterator __tmp(*this); --current; return __tmp;}
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    reverse_iterator& operator--() {++current; return *this;}
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    reverse_iterator  operator--(int) {reverse_iterator __tmp(*this); ++current; return __tmp;}
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    reverse_iterator  operator+ (difference_type __n) const {return reverse_iterator(current - __n);}
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    reverse_iterator& operator+=(difference_type __n) {current -= __n; return *this;}
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    reverse_iterator  operator- (difference_type __n) const {return reverse_iterator(current + __n);}
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    reverse_iterator& operator-=(difference_type __n) {current += __n; return *this;}
+    _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    reference         operator[](difference_type __n) const {return *(*this + __n);}
+};
+
+template <class _Iter1, class _Iter2>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+bool
+operator==(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
+{
+    return __x.base() == __y.base();
+}
+
+template <class _Iter1, class _Iter2>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+bool
+operator<(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
+{
+    return __x.base() > __y.base();
+}
+
+template <class _Iter1, class _Iter2>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+bool
+operator!=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
+{
+    return __x.base() != __y.base();
+}
+
+template <class _Iter1, class _Iter2>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+bool
+operator>(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
+{
+    return __x.base() < __y.base();
+}
+
+template <class _Iter1, class _Iter2>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+bool
+operator>=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
+{
+    return __x.base() <= __y.base();
+}
+
+template <class _Iter1, class _Iter2>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+bool
+operator<=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
+{
+    return __x.base() >= __y.base();
+}
+
+#ifndef _LIBCUDACXX_CXX03_LANG
+template <class _Iter1, class _Iter2>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+auto
+operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
+-> decltype(__y.base() - __x.base())
+{
+    return __y.base() - __x.base();
+}
+#else
+template <class _Iter1, class _Iter2>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+typename reverse_iterator<_Iter1>::difference_type
+operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
+{
+    return __y.base() - __x.base();
+}
+#endif
+
+template <class _Iter>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+reverse_iterator<_Iter>
+operator+(typename reverse_iterator<_Iter>::difference_type __n, const reverse_iterator<_Iter>& __x)
+{
+    return reverse_iterator<_Iter>(__x.base() - __n);
+}
+
+#if _LIBCUDACXX_STD_VER > 11
+template <class _Iter>
+inline _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+reverse_iterator<_Iter> make_reverse_iterator(_Iter __i)
+{
+    return reverse_iterator<_Iter>(__i);
+}
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___ITERATOR_REVERSE_ITERATOR_H

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/compressed_pair.h

@@ -0,0 +1,240 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 2.0
+//              Copyright (2019) Sandia Corporation
+//
+// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#ifndef _LIBCUDACXX___MDSPAN_COMPRESSED_PAIR_HPP
+#define _LIBCUDACXX___MDSPAN_COMPRESSED_PAIR_HPP
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__mdspan/macros.h"
+#ifdef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+#include "../__mdspan/no_unique_address.h"
+#endif
+#include "../__type_traits/enable_if.h"
+#include "../__type_traits/is_empty.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+namespace __detail {
+
+// For no unique address emulation, this is the case taken when neither are empty.
+// For real `[[no_unique_address]]`, this case is always taken.
+template <class _Tp, class _Up, class _Enable = void> struct __compressed_pair {
+  _LIBCUDACXX_NO_UNIQUE_ADDRESS _Tp __t_val;
+  _LIBCUDACXX_NO_UNIQUE_ADDRESS _Up __u_val;
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp &__first() noexcept { return __t_val; }
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp const &__first() const noexcept {
+    return __t_val;
+  }
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Up &__second() noexcept { return __u_val; }
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Up const &__second() const noexcept {
+    return __u_val;
+  }
+
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr __compressed_pair() noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr __compressed_pair(__compressed_pair const &) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr __compressed_pair(__compressed_pair &&) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  __MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair &
+  operator=(__compressed_pair const &) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  __MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair &
+  operator=(__compressed_pair &&) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  ~__compressed_pair() noexcept = default;
+  template <class _TLike, class _ULike>
+  __MDSPAN_INLINE_FUNCTION constexpr __compressed_pair(_TLike &&__t, _ULike &&__u)
+      : __t_val((_TLike &&) __t), __u_val((_ULike &&) __u) {}
+};
+
+#ifdef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+
+// First empty.
+template <class _Tp, class _Up>
+struct __compressed_pair<
+    _Tp, _Up,
+    _CUDA_VSTD::enable_if_t<_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_empty, _Tp) && !_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_empty, _Up)>>
+    : private _Tp {
+  _Up __u_val;
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp &__first() noexcept {
+    return *static_cast<_Tp *>(this);
+  }
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp const &__first() const noexcept {
+    return *static_cast<_Tp const *>(this);
+  }
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Up &__second() noexcept { return __u_val; }
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Up const &__second() const noexcept {
+    return __u_val;
+  }
+
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr __compressed_pair() noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr __compressed_pair(__compressed_pair const &) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr __compressed_pair(__compressed_pair &&) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  __MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair &
+  operator=(__compressed_pair const &) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  __MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair &
+  operator=(__compressed_pair &&) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  ~__compressed_pair() noexcept = default;
+  template <class _TLike, class _ULike>
+  __MDSPAN_INLINE_FUNCTION constexpr __compressed_pair(_TLike &&__t, _ULike &&__u)
+      : _Tp((_TLike &&) __t), __u_val((_ULike &&) __u) {}
+};
+
+// Second empty.
+template <class _Tp, class _Up>
+struct __compressed_pair<
+    _Tp, _Up,
+    _CUDA_VSTD::enable_if_t<!_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_empty, _Tp) && _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_empty, _Up)>>
+    : private _Up {
+  _Tp __t_val;
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp &__first() noexcept { return __t_val; }
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp const &__first() const noexcept {
+    return __t_val;
+  }
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Up &__second() noexcept {
+    return *static_cast<_Up *>(this);
+  }
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Up const &__second() const noexcept {
+    return *static_cast<_Up const *>(this);
+  }
+
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr __compressed_pair() noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr __compressed_pair(__compressed_pair const &) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr __compressed_pair(__compressed_pair &&) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  __MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair &
+  operator=(__compressed_pair const &) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  __MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair &
+  operator=(__compressed_pair &&) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  ~__compressed_pair() noexcept = default;
+
+  template <class _TLike, class _ULike>
+  __MDSPAN_INLINE_FUNCTION constexpr __compressed_pair(_TLike &&__t, _ULike &&__u)
+      : _Up((_ULike &&) __u), __t_val((_TLike &&) __t) {}
+};
+
+// Both empty.
+template <class _Tp, class _Up>
+struct __compressed_pair<
+    _Tp, _Up,
+    _CUDA_VSTD::enable_if_t<_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_empty, _Tp) && _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_empty, _Up)>>
+    // We need to use the __no_unique_address_emulation wrapper here to avoid
+    // base class ambiguities.
+#ifdef __MDSPAN_COMPILER_MSVC
+// MSVC doesn't allow you to access public static member functions of a type
+// when you *happen* to privately inherit from that type.
+    : protected __no_unique_address_emulation<_Tp, 0>,
+      protected __no_unique_address_emulation<_Up, 1>
+#else
+    : private __no_unique_address_emulation<_Tp, 0>,
+      private __no_unique_address_emulation<_Up, 1>
+#endif
+{
+  using __first_base_t = __no_unique_address_emulation<_Tp, 0>;
+  using __second_base_t = __no_unique_address_emulation<_Up, 1>;
+
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp &__first() noexcept {
+    return this->__first_base_t::__ref();
+  }
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Tp const &__first() const noexcept {
+    return this->__first_base_t::__ref();
+  }
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Up &__second() noexcept {
+    return this->__second_base_t::__ref();
+  }
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr _Up const &__second() const noexcept {
+    return this->__second_base_t::__ref();
+  }
+
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr __compressed_pair() noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr __compressed_pair(__compressed_pair const &) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  constexpr __compressed_pair(__compressed_pair &&) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  __MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair &
+  operator=(__compressed_pair const &) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  __MDSPAN_CONSTEXPR_14_DEFAULTED __compressed_pair &
+  operator=(__compressed_pair &&) noexcept = default;
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED
+  ~__compressed_pair() noexcept = default;
+  template <class _TLike, class _ULike>
+  __MDSPAN_INLINE_FUNCTION constexpr __compressed_pair(_TLike &&__t, _ULike &&__u) noexcept
+    : __first_base_t(_Tp((_TLike &&) __t)),
+      __second_base_t(_Up((_ULike &&) __u))
+  { }
+};
+
+#endif // !_LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+
+} // end namespace __detail
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MDSPAN_COMPRESSED_PAIR_HPP

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

@@ -0,0 +1,287 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 2.0
+//              Copyright (2019) Sandia Corporation
+//
+// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#ifndef _LIBCUDACXX___MDSPAN_CONFIG_HPP
+#define _LIBCUDACXX___MDSPAN_CONFIG_HPP
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#if _LIBCUDACXX_STD_VER > 11
+
+#ifndef __has_include
+#  define __has_include(x) 0
+#endif
+
+#ifndef __cuda_std__
+#if __has_include(<version>)
+#  include <version>
+#else
+#  include <type_traits>
+#  include <utility>
+#endif
+#endif
+
+#ifdef _MSVC_LANG
+#define __MDSPAN_CPLUSPLUS _MSVC_LANG
+#else
+#define __MDSPAN_CPLUSPLUS __cplusplus
+#endif
+
+#define __MDSPAN_CXX_STD_14 201402L
+#define __MDSPAN_CXX_STD_17 201703L
+#define __MDSPAN_CXX_STD_20 202002L
+
+#define __MDSPAN_HAS_CXX_14 (__MDSPAN_CPLUSPLUS >= __MDSPAN_CXX_STD_14)
+#define __MDSPAN_HAS_CXX_17 (__MDSPAN_CPLUSPLUS >= __MDSPAN_CXX_STD_17)
+#define __MDSPAN_HAS_CXX_20 (__MDSPAN_CPLUSPLUS >= __MDSPAN_CXX_STD_20)
+
+static_assert(__MDSPAN_CPLUSPLUS >= __MDSPAN_CXX_STD_14, "mdspan requires C++14 or later.");
+
+#ifndef __MDSPAN_COMPILER_CLANG
+#  if defined(__clang__)
+#    define __MDSPAN_COMPILER_CLANG __clang__
+#  endif
+#endif
+
+#if !defined(__MDSPAN_COMPILER_MSVC) && !defined(__MDSPAN_COMPILER_MSVC_CLANG)
+#  if defined(_MSC_VER)
+#    if !defined(__MDSPAN_COMPILER_CLANG)
+#      define __MDSPAN_COMPILER_MSVC _MSC_VER
+#    else
+#      define __MDSPAN_COMPILER_MSVC_CLANG _MSC_VER
+#    endif
+#  endif
+#endif
+
+#ifndef __MDSPAN_COMPILER_INTEL
+#  ifdef __INTEL_COMPILER
+#    define __MDSPAN_COMPILER_INTEL __INTEL_COMPILER
+#  endif
+#endif
+
+#ifndef __MDSPAN_COMPILER_APPLECLANG
+#  ifdef __apple_build_version__
+#    define __MDSPAN_COMPILER_APPLECLANG __apple_build_version__
+#  endif
+#endif
+
+#ifndef __MDSPAN_HAS_CUDA
+#  if defined(__CUDACC__)
+#    define __MDSPAN_HAS_CUDA __CUDACC__
+#  endif
+#endif
+
+#ifndef __MDSPAN_HAS_HIP
+#  if defined(__HIPCC__)
+#    define __MDSPAN_HAS_HIP __HIPCC__
+#  endif
+#endif
+
+#ifndef __has_cpp_attribute
+#  define __has_cpp_attribute(x) 0
+#endif
+
+#ifndef __MDSPAN_PRESERVE_STANDARD_LAYOUT
+// Preserve standard layout by default, but we're not removing the old version
+// that turns this off until we're sure this doesn't have an unreasonable cost
+// to the compiler or optimizer.
+#  define __MDSPAN_PRESERVE_STANDARD_LAYOUT 1
+#endif
+
+#ifndef __MDSPAN_USE_CONCEPTS
+// Looks like concepts doesn't work in CUDA 12
+#  if defined(__cpp_concepts) && __cpp_concepts >= 201507L && !defined __cuda_std__
+#    define __MDSPAN_USE_CONCEPTS 1
+#  endif
+#endif
+
+#ifndef __MDSPAN_USE_FOLD_EXPRESSIONS
+#  if (defined(__cpp_fold_expressions) && __cpp_fold_expressions >= 201603L) \
+          || (!defined(__cpp_fold_expressions) && __MDSPAN_HAS_CXX_17)
+#    define __MDSPAN_USE_FOLD_EXPRESSIONS 1
+#  endif
+#endif
+
+#ifndef __MDSPAN_NEEDS_TRAIT_VARIABLE_TEMPLATE_BACKPORTS
+#  if (!(defined(__cpp_lib_type_trait_variable_templates) && __cpp_lib_type_trait_variable_templates >= 201510L) \
+          || !__MDSPAN_HAS_CXX_17)
+#    if !(defined(__MDSPAN_COMPILER_APPLECLANG) && __MDSPAN_HAS_CXX_17)
+#      define __MDSPAN_NEEDS_TRAIT_VARIABLE_TEMPLATE_BACKPORTS 1
+#    endif
+#  endif
+#endif
+
+#ifndef __MDSPAN_USE_VARIABLE_TEMPLATES
+#  if (defined(__cpp_variable_templates) && __cpp_variable_templates >= 201304 && __MDSPAN_HAS_CXX_17) \
+        || (!defined(__cpp_variable_templates) && __MDSPAN_HAS_CXX_17)
+#    define __MDSPAN_USE_VARIABLE_TEMPLATES 1
+#  endif
+#endif // __MDSPAN_USE_VARIABLE_TEMPLATES
+
+#ifndef __MDSPAN_USE_CONSTEXPR_14
+#  if (defined(__cpp_constexpr) && __cpp_constexpr >= 201304) \
+        || (!defined(__cpp_constexpr) && __MDSPAN_HAS_CXX_14) \
+        && (!(defined(__INTEL_COMPILER) && __INTEL_COMPILER <= 1700))
+#    define __MDSPAN_USE_CONSTEXPR_14 1
+#  endif
+#endif
+
+#ifndef __MDSPAN_USE_INTEGER_SEQUENCE
+#  if defined(__MDSPAN_COMPILER_MSVC)
+#    if (defined(__cpp_lib_integer_sequence) && __cpp_lib_integer_sequence >= 201304)
+#      define __MDSPAN_USE_INTEGER_SEQUENCE 1
+#    endif
+#  endif
+#endif
+#ifndef __MDSPAN_USE_INTEGER_SEQUENCE
+#  if (defined(__cpp_lib_integer_sequence) && __cpp_lib_integer_sequence >= 201304) \
+        || (!defined(__cpp_lib_integer_sequence) && __MDSPAN_HAS_CXX_14) \
+        /* as far as I can tell, libc++ seems to think this is a C++11 feature... */ \
+        || (defined(__GLIBCXX__) && __GLIBCXX__ > 20150422 && __GNUC__ < 5 && !defined(__INTEL_CXX11_MODE__))
+     // several compilers lie about integer_sequence working properly unless the C++14 standard is used
+#    define __MDSPAN_USE_INTEGER_SEQUENCE 1
+#  elif defined(__MDSPAN_COMPILER_APPLECLANG) && __MDSPAN_HAS_CXX_14
+     // appleclang seems to be missing the __cpp_lib_... macros, but doesn't seem to lie about C++14 making
+     // integer_sequence work
+#    define __MDSPAN_USE_INTEGER_SEQUENCE 1
+#  endif
+#endif
+
+#ifndef __MDSPAN_USE_RETURN_TYPE_DEDUCTION
+#  if (defined(__cpp_return_type_deduction) && __cpp_return_type_deduction >= 201304) \
+          || (!defined(__cpp_return_type_deduction) && __MDSPAN_HAS_CXX_14)
+#    define __MDSPAN_USE_RETURN_TYPE_DEDUCTION 1
+#  endif
+#endif
+
+#ifndef __MDSPAN_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION
+// GCC 10 is known not to work with CTAD for this case.
+#  if (defined(__MDSPAN_COMPILER_CLANG) || !defined(_LIBCUDACXX_COMPILER_GCC) || __GNUC__ >= 11) \
+      && ((defined(__cpp_deduction_guides) && __cpp_deduction_guides >= 201703) \
+         || (!defined(__cpp_deduction_guides) && __MDSPAN_HAS_CXX_17))
+#    define __MDSPAN_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION 1
+#  endif
+#endif
+
+#ifndef __MDSPAN_USE_ALIAS_TEMPLATE_ARGUMENT_DEDUCTION
+// GCC 10 is known not to work with CTAD for this case.
+#  if (defined(__MDSPAN_COMPILER_CLANG) || !defined(_LIBCUDACXX_COMPILER_GCC) || __GNUC__ >= 11) \
+      && ((defined(__cpp_deduction_guides) && __cpp_deduction_guides >= 201907) \
+          || (!defined(__cpp_deduction_guides) && __MDSPAN_HAS_CXX_20))
+#    define __MDSPAN_USE_ALIAS_TEMPLATE_ARGUMENT_DEDUCTION 1
+#  endif
+#endif
+
+#ifndef __MDSPAN_USE_STANDARD_TRAIT_ALIASES
+#  if (defined(__cpp_lib_transformation_trait_aliases) && __cpp_lib_transformation_trait_aliases >= 201304) \
+          || (!defined(__cpp_lib_transformation_trait_aliases) && __MDSPAN_HAS_CXX_14)
+#    define __MDSPAN_USE_STANDARD_TRAIT_ALIASES 1
+#  elif defined(__MDSPAN_COMPILER_APPLECLANG) && __MDSPAN_HAS_CXX_14
+     // appleclang seems to be missing the __cpp_lib_... macros, but doesn't seem to lie about C++14
+#    define __MDSPAN_USE_STANDARD_TRAIT_ALIASES 1
+#  endif
+#endif
+
+#ifndef __MDSPAN_DEFAULTED_CONSTRUCTORS_INHERITANCE_WORKAROUND
+#  ifdef __GNUC__
+#    if __GNUC__ < 9
+#      define __MDSPAN_DEFAULTED_CONSTRUCTORS_INHERITANCE_WORKAROUND 1
+#    endif
+#  endif
+#endif
+
+#ifndef __MDSPAN_CONDITIONAL_EXPLICIT
+#  if __MDSPAN_HAS_CXX_20 && !defined(__MDSPAN_COMPILER_MSVC)
+#    define __MDSPAN_CONDITIONAL_EXPLICIT(COND) explicit(COND)
+#  else
+#    define __MDSPAN_CONDITIONAL_EXPLICIT(COND)
+#  endif
+#endif
+
+#ifndef __MDSPAN_USE_BRACKET_OPERATOR
+#  if defined(__cpp_multidimensional_subscript)
+#    define __MDSPAN_USE_BRACKET_OPERATOR 1
+#  else
+#    define __MDSPAN_USE_BRACKET_OPERATOR 0
+#  endif
+#endif
+
+#ifndef __MDSPAN_USE_PAREN_OPERATOR
+#  if !__MDSPAN_USE_BRACKET_OPERATOR
+#    define __MDSPAN_USE_PAREN_OPERATOR 1
+#  else
+#    define __MDSPAN_USE_PAREN_OPERATOR 0
+#  endif
+#endif
+
+#if __MDSPAN_USE_BRACKET_OPERATOR
+#  define __MDSPAN_OP(mds,...) mds[__VA_ARGS__]
+// Corentins demo compiler for subscript chokes on empty [] call,
+// though I believe the proposal supports it?
+#ifdef __MDSPAN_NO_EMPTY_BRACKET_OPERATOR
+#  define __MDSPAN_OP0(mds) mds.accessor().access(mds.data_handle(),0)
+#else
+#  define __MDSPAN_OP0(mds) mds[]
+#endif
+#  define __MDSPAN_OP1(mds, a) mds[a]
+#  define __MDSPAN_OP2(mds, a, b) mds[a,b]
+#  define __MDSPAN_OP3(mds, a, b, c) mds[a,b,c]
+#  define __MDSPAN_OP4(mds, a, b, c, d) mds[a,b,c,d]
+#  define __MDSPAN_OP5(mds, a, b, c, d, e) mds[a,b,c,d,e]
+#  define __MDSPAN_OP6(mds, a, b, c, d, e, f) mds[a,b,c,d,e,f]
+#else
+#  define __MDSPAN_OP(mds,...) mds(__VA_ARGS__)
+#  define __MDSPAN_OP0(mds) mds()
+#  define __MDSPAN_OP1(mds, a) mds(a)
+#  define __MDSPAN_OP2(mds, a, b) mds(a,b)
+#  define __MDSPAN_OP3(mds, a, b, c) mds(a,b,c)
+#  define __MDSPAN_OP4(mds, a, b, c, d) mds(a,b,c,d)
+#  define __MDSPAN_OP5(mds, a, b, c, d, e) mds(a,b,c,d,e)
+#  define __MDSPAN_OP6(mds, a, b, c, d, e, f) mds(a,b,c,d,e,f)
+#endif
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+#endif // _LIBCUDACXX___MDSPAN_CONFIG_HPP

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/default_accessor.h

@@ -0,0 +1,99 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 2.0
+//              Copyright (2019) Sandia Corporation
+//
+// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#ifndef _LIBCUDACXX___MDSPAN_DEFAULT_ACCESSOR_HPP
+#define _LIBCUDACXX___MDSPAN_DEFAULT_ACCESSOR_HPP
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__mdspan/macros.h"
+#include "../__type_traits/is_convertible.h"
+#include "../cstddef"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+template <class _ElementType>
+struct default_accessor {
+
+  using offset_policy = default_accessor;
+  using element_type = _ElementType;
+  using reference = _ElementType&;
+  using data_handle_type = _ElementType*;
+
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr default_accessor() noexcept = default;
+
+  __MDSPAN_TEMPLATE_REQUIRES(
+    class _OtherElementType,
+    /* requires */ (
+      _LIBCUDACXX_TRAIT(is_convertible, _OtherElementType(*)[], element_type(*)[])
+    )
+  )
+  __MDSPAN_INLINE_FUNCTION
+  constexpr default_accessor(default_accessor<_OtherElementType>) noexcept {}
+
+  __MDSPAN_INLINE_FUNCTION
+  constexpr data_handle_type
+  offset(data_handle_type __p, size_t __i) const noexcept {
+    return __p + __i;
+  }
+
+  __MDSPAN_FORCE_INLINE_FUNCTION
+  constexpr reference access(data_handle_type __p, size_t __i) const noexcept {
+    return __p[__i];
+  }
+
+};
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MDSPAN_DEFAULT_ACCESSOR_HPP

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/dynamic_extent.h

@@ -0,0 +1,83 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 2.0
+//              Copyright (2019) Sandia Corporation
+//
+// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#ifndef _LIBCUDACXX___MDSPAN_DYNAMIC_EXTENT_HPP
+#define _LIBCUDACXX___MDSPAN_DYNAMIC_EXTENT_HPP
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__fwd/span.h" // dynamic_extent
+#include "../__mdspan/macros.h"
+#include "../cstddef"
+#include "../limits" // numeric_limits
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+namespace __detail {
+
+template <class>
+_LIBCUDACXX_HOST_DEVICE constexpr auto __make_dynamic_extent() {
+  return dynamic_extent;
+}
+
+template <size_t>
+_LIBCUDACXX_HOST_DEVICE constexpr auto __make_dynamic_extent_integral() {
+  return dynamic_extent;
+}
+
+} // end namespace __detail
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+//==============================================================================================================
+
+#endif // _LIBCUDACXX___MDSPAN_DYNAMIC_EXTENT_HPP

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/extents.h

@@ -0,0 +1,579 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 2.0
+//              Copyright (2019) Sandia Corporation
+//
+// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#ifndef _LIBCUDACXX___MDSPAN_EXTENTS_HPP
+#define _LIBCUDACXX___MDSPAN_EXTENTS_HPP
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__mdspan/macros.h"
+#ifdef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+#include "../__mdspan/no_unique_address.h"
+#endif
+#include "../__mdspan/static_array.h"
+#include "../__mdspan/standard_layout_static_array.h"
+#include "../__type_traits/conditional.h"
+#include "../__type_traits/integral_constant.h"
+#include "../__type_traits/is_convertible.h"
+#include "../__type_traits/is_nothrow_constructible.h"
+#include "../__type_traits/make_unsigned.h"
+#include "../__utility/integer_sequence.h"
+#include "../array"
+#include "../cstddef"
+#include "../span"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+#if defined(_LIBCUDACXX_PUSH_MACROS)
+  _LIBCUDACXX_PUSH_MACROS
+#endif
+#include "../__undef_macros"
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+namespace __detail {
+
+template<size_t ... _Extents>
+struct __count_dynamic_extents;
+
+template<size_t _Ep, size_t ... _Extents>
+struct __count_dynamic_extents<_Ep,_Extents...> {
+  static constexpr size_t val = (_Ep==dynamic_extent?1:0) + __count_dynamic_extents<_Extents...>::val;
+};
+
+template<>
+struct __count_dynamic_extents<> {
+  static constexpr size_t val = 0;
+};
+
+template <size_t... _Extents, size_t... _OtherExtents>
+_LIBCUDACXX_HOST_DEVICE
+static constexpr false_type __check_compatible_extents(
+  false_type, _CUDA_VSTD::integer_sequence<size_t, _Extents...>, _CUDA_VSTD::integer_sequence<size_t, _OtherExtents...>
+) noexcept { return { }; }
+
+// This helper prevents ICE's on MSVC.
+template <size_t _Lhs, size_t _Rhs>
+struct __compare_extent_compatible : integral_constant<bool,
+    _Lhs == dynamic_extent ||
+    _Rhs == dynamic_extent ||
+    _Lhs == _Rhs>
+{};
+
+template <size_t... _Extents, size_t... _OtherExtents>
+static integral_constant<
+  bool,
+  __MDSPAN_FOLD_AND(
+    (
+      __compare_extent_compatible<_Extents, _OtherExtents>::value
+    ) /* && ... */
+  )
+>
+_LIBCUDACXX_HOST_DEVICE
+__check_compatible_extents(
+  true_type, _CUDA_VSTD::integer_sequence<size_t, _Extents...>, _CUDA_VSTD::integer_sequence<size_t, _OtherExtents...>
+) noexcept { return { }; }
+
+struct __extents_tag { };
+
+} // end namespace __detail
+
+template <class _ThisIndexType, size_t... _Extents>
+class extents
+#ifdef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+  : private __detail::__no_unique_address_emulation<
+      __detail::__partially_static_sizes_tagged<__detail::__extents_tag, _ThisIndexType , size_t, _Extents...>>
+#endif
+{
+public:
+
+  using rank_type = size_t;
+  using index_type = _ThisIndexType;
+  using size_type = make_unsigned_t<index_type>;
+
+// internal typedefs which for technical reasons are public
+  using __storage_t = __detail::__partially_static_sizes_tagged<__detail::__extents_tag, index_type, size_t, _Extents...>;
+
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+  _LIBCUDACXX_NO_UNIQUE_ADDRESS __storage_t __storage_;
+#else
+  using __base_t = __detail::__no_unique_address_emulation<__storage_t>;
+#endif
+
+// private members dealing with the way we internally store dynamic extents
+ private:
+
+  __MDSPAN_FORCE_INLINE_FUNCTION constexpr
+  __storage_t& __storage() noexcept {
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+    return __storage_;
+#else
+    return this->__base_t::__ref();
+#endif
+  }
+  __MDSPAN_FORCE_INLINE_FUNCTION
+  constexpr __storage_t const& __storage() const noexcept {
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+    return __storage_;
+#else
+    return this->__base_t::__ref();
+#endif
+  }
+
+  template <size_t... _Idxs>
+  __MDSPAN_FORCE_INLINE_FUNCTION
+  static constexpr
+  index_type _static_extent_impl(size_t __n, _CUDA_VSTD::integer_sequence<size_t, _Idxs...>) noexcept {
+    return __MDSPAN_FOLD_PLUS_RIGHT(((_Idxs == __n) ? _Extents : 0), /* + ... + */ 0);
+  }
+
+  template <class, size_t...>
+  friend class extents;
+
+  template <class _OtherIndexType, size_t... _OtherExtents, size_t... _Idxs>
+  __MDSPAN_INLINE_FUNCTION
+  constexpr bool _eq_impl(_CUDA_VSTD::extents<_OtherIndexType, _OtherExtents...>, false_type, _CUDA_VSTD::index_sequence<_Idxs...>) const noexcept { return false; }
+  template <class _OtherIndexType, size_t... _OtherExtents, size_t... _Idxs>
+  __MDSPAN_INLINE_FUNCTION
+  constexpr bool _eq_impl(
+    _CUDA_VSTD::extents<_OtherIndexType, _OtherExtents...> __other,
+    true_type, _CUDA_VSTD::index_sequence<_Idxs...>
+  ) const noexcept {
+    return __MDSPAN_FOLD_AND(
+      (__storage().template __get_n<_Idxs>() == __other.__storage().template __get_n<_Idxs>()) /* && ... */
+    );
+  }
+
+  template <class _OtherIndexType, size_t... _OtherExtents, size_t... _Idxs>
+  __MDSPAN_INLINE_FUNCTION
+  constexpr bool _not_eq_impl(_CUDA_VSTD::extents<_OtherIndexType, _OtherExtents...>, false_type, _CUDA_VSTD::index_sequence<_Idxs...>) const noexcept { return true; }
+  template <class _OtherIndexType, size_t... _OtherExtents, size_t... _Idxs>
+  __MDSPAN_INLINE_FUNCTION
+  constexpr bool _not_eq_impl(
+    _CUDA_VSTD::extents<_OtherIndexType, _OtherExtents...> __other,
+    true_type, _CUDA_VSTD::index_sequence<_Idxs...>
+  ) const noexcept {
+    return __MDSPAN_FOLD_OR(
+      (__storage().template __get_n<_Idxs>() != __other.__storage().template __get_n<_Idxs>()) /* || ... */
+    );
+  }
+
+#ifdef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+  __MDSPAN_INLINE_FUNCTION constexpr explicit
+  extents(__base_t&& __b) noexcept
+    : __base_t(_CUDA_VSTD::move(__b))
+  { }
+#endif
+
+
+// public interface:
+public:
+  /* Defined above for use in the private code
+  using rank_type = size_t;
+  using index_type = _ThisIndexType;
+  */
+
+  __MDSPAN_INLINE_FUNCTION
+  static constexpr rank_type rank() noexcept { return sizeof...(_Extents); }
+  __MDSPAN_INLINE_FUNCTION
+  static constexpr rank_type rank_dynamic() noexcept { return __MDSPAN_FOLD_PLUS_RIGHT((rank_type(_Extents == dynamic_extent)), /* + ... + */ 0); }
+
+  //--------------------------------------------------------------------------------
+  // Constructors, Destructors, and Assignment
+
+  // Default constructor
+  __MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr extents() noexcept = default;
+
+  // Converting constructor
+  __MDSPAN_TEMPLATE_REQUIRES(
+    class _OtherIndexType, size_t... _OtherExtents,
+    /* requires */ (
+      /* multi-stage check to protect from invalid pack expansion when sizes don't match? */
+      decltype(__detail::__check_compatible_extents(
+        integral_constant<bool, sizeof...(_Extents) == sizeof...(_OtherExtents)>{},
+        _CUDA_VSTD::integer_sequence<size_t, _Extents...>{},
+        _CUDA_VSTD::integer_sequence<size_t, _OtherExtents...>{}
+      ))::value
+    )
+  )
+  __MDSPAN_INLINE_FUNCTION
+  __MDSPAN_CONDITIONAL_EXPLICIT(
+    (((_Extents != dynamic_extent) && (_OtherExtents == dynamic_extent)) || ...) ||
+    (_CUDA_VSTD::numeric_limits<index_type>::max() < _CUDA_VSTD::numeric_limits<_OtherIndexType>::max()))
+  constexpr extents(const extents<_OtherIndexType, _OtherExtents...>& __other)
+    noexcept
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+    : __storage_{
+#else
+    : __base_t(__base_t{__storage_t{
+#endif
+        __other.__storage().__enable_psa_conversion()
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+      }
+#else
+      }})
+#endif
+  {
+    /* TODO: precondition check
+     * __other.extent(r) equals Er for each r for which Er is a static extent, and
+     * either
+     *   - sizeof...(_OtherExtents) is zero, or
+     *   - __other.extent(r) is a representable value of type index_type for all rank index r of __other
+     */
+  }
+
+#ifdef __NVCC__
+    __MDSPAN_TEMPLATE_REQUIRES(
+    class... _Integral,
+    /* requires */ (
+      // TODO: check whether the other version works with newest NVCC, doesn't with 11.4
+      // NVCC seems to pick up rank_dynamic from the wrong extents type???
+      __MDSPAN_FOLD_AND(_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _Integral, index_type) /* && ... */) &&
+      __MDSPAN_FOLD_AND(_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, index_type, _Integral) /* && ... */) &&
+      // NVCC chokes on the fold thingy here so wrote the workaround
+      ((sizeof...(_Integral) == __detail::__count_dynamic_extents<_Extents...>::val) ||
+       (sizeof...(_Integral) == sizeof...(_Extents)))
+      )
+    )
+#else
+    __MDSPAN_TEMPLATE_REQUIRES(
+    class... _Integral,
+    /* requires */ (
+       __MDSPAN_FOLD_AND(_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _Integral, index_type) /* && ... */) &&
+       __MDSPAN_FOLD_AND(_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, index_type, _Integral) /* && ... */) &&
+       ((sizeof...(_Integral) == rank_dynamic()) || (sizeof...(_Integral) == rank()))
+      )
+    )
+#endif
+  __MDSPAN_INLINE_FUNCTION
+  explicit constexpr extents(_Integral... __exts) noexcept
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+    : __storage_{
+#else
+    : __base_t(__base_t{typename __base_t::__stored_type{
+#endif
+      _CUDA_VSTD::conditional_t<sizeof...(_Integral)==rank_dynamic(),
+        __detail::__construct_psa_from_dynamic_exts_values_tag_t,
+        __detail::__construct_psa_from_all_exts_values_tag_t>(),
+        static_cast<index_type>(__exts)...
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+      }
+#else
+      }})
+#endif
+  {
+    /* TODO: precondition check
+     * If sizeof...(_IndexTypes) != rank_dynamic() is true, exts_arr[r] equals Er for each r for which Er is a static extent, and
+     * either
+     *   - sizeof...(__exts) == 0 is true, or
+     *   - each element of __exts is nonnegative and is a representable value of type index_type.
+     */
+  }
+
+    // TODO: check whether this works with newest NVCC, doesn't with 11.4
+#ifdef __NVCC__
+  // NVCC seems to pick up rank_dynamic from the wrong extents type???
+  // NVCC chokes on the fold thingy here so wrote the workaround
+  __MDSPAN_TEMPLATE_REQUIRES(
+    class _IndexType, size_t _Np,
+    /* requires */ (
+      _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _IndexType, index_type) &&
+      _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, index_type, _IndexType) &&
+      ((_Np == __detail::__count_dynamic_extents<_Extents...>::val) ||
+       (_Np == sizeof...(_Extents)))
+    )
+  )
+#else
+    __MDSPAN_TEMPLATE_REQUIRES(
+        class _IndexType, size_t _Np,
+        /* requires */ (
+          _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _IndexType, index_type) &&
+          _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, index_type, _IndexType) &&
+          (_Np == rank() || _Np == rank_dynamic())
+    )
+  )
+#endif
+  __MDSPAN_CONDITIONAL_EXPLICIT(_Np != rank_dynamic())
+  __MDSPAN_INLINE_FUNCTION
+  constexpr
+  extents(_CUDA_VSTD::array<_IndexType, _Np> const& __exts) noexcept
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+    : __storage_{
+#else
+    : __base_t(__base_t{typename __base_t::__stored_type{
+#endif
+      _CUDA_VSTD::conditional_t<_Np==rank_dynamic(),
+        __detail::__construct_psa_from_dynamic_exts_array_tag_t<0>,
+        __detail::__construct_psa_from_all_exts_array_tag_t>(),
+      _CUDA_VSTD::array<_IndexType,_Np>{__exts}
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+      }
+#else
+      }})
+#endif
+  {
+    /* TODO: precondition check
+     * If _Np != rank_dynamic() is true, __exts[r] equals Er for each r for which Er is a static extent, and
+     * either
+     *   - _Np is zero, or
+     *   - __exts[r] is nonnegative and is a representable value of type index_type for all rank index r
+     */
+  }
+
+  // TODO: check whether the below works with newest NVCC, doesn't with 11.4
+#ifdef __NVCC__
+  // NVCC seems to pick up rank_dynamic from the wrong extents type???
+  // NVCC chokes on the fold thingy here so wrote the workaround
+  __MDSPAN_TEMPLATE_REQUIRES(
+    class _IndexType, size_t _Np,
+    /* requires */ (
+      _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _IndexType, index_type) &&
+      _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, index_type, _IndexType) &&
+      ((_Np == __detail::__count_dynamic_extents<_Extents...>::val) ||
+       (_Np == sizeof...(_Extents)))
+    )
+  )
+#else
+    __MDSPAN_TEMPLATE_REQUIRES(
+        class _IndexType, size_t _Np,
+        /* requires */ (
+          _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _IndexType, index_type) &&
+          _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, index_type, _IndexType) &&
+          (_Np == rank() || _Np == rank_dynamic())
+    )
+  )
+#endif
+  __MDSPAN_CONDITIONAL_EXPLICIT(_Np != rank_dynamic())
+  __MDSPAN_INLINE_FUNCTION
+  constexpr
+  extents(_CUDA_VSTD::span<_IndexType, _Np> __exts) noexcept
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+    : __storage_{
+#else
+    : __base_t(__base_t{typename __base_t::__stored_type{
+#endif
+      _CUDA_VSTD::conditional_t<_Np==rank_dynamic(),
+        __detail::__construct_psa_from_dynamic_exts_array_tag_t<0>,
+        __detail::__construct_psa_from_all_exts_array_tag_t>(),
+      __exts
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+      }
+#else
+      }})
+#endif
+  {
+    /* TODO: precondition check
+     * If _Np != rank_dynamic() is true, __exts[r] equals Er for each r for which Er is a static extent, and
+     * either
+     *   - _Np is zero, or
+     *   - __exts[r] is nonnegative and is a representable value of type index_type for all rank index r
+     */
+  }
+
+  // Need this constructor for some submdspan implementation stuff
+  // for the layout_stride case where I use an extents object for strides
+  __MDSPAN_INLINE_FUNCTION
+  constexpr explicit
+  extents(__storage_t const& __sto ) noexcept
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+    : __storage_{
+#else
+    : __base_t(__base_t{
+#endif
+        __sto
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+      }
+#else
+      })
+#endif
+  { }
+
+  //--------------------------------------------------------------------------------
+
+  __MDSPAN_INLINE_FUNCTION
+  static constexpr
+  size_t static_extent(size_t __n) noexcept {
+    // Can't do assert here since that breaks true constexpr ness
+    // assert(__n<rank());
+    return _static_extent_impl(__n, _CUDA_VSTD::make_integer_sequence<size_t, sizeof...(_Extents)>{});
+  }
+
+  __MDSPAN_INLINE_FUNCTION
+  constexpr
+  index_type extent(size_t __n) const noexcept {
+    // Can't do assert here since that breaks true constexpr ness
+    // assert(__n<rank());
+    return __storage().__get(__n);
+  }
+
+  //--------------------------------------------------------------------------------
+
+  template<class _OtherIndexType, size_t... _RHS>
+  __MDSPAN_INLINE_FUNCTION
+  friend constexpr bool operator==(extents const& lhs, extents<_OtherIndexType, _RHS...> const& __rhs) noexcept {
+    return lhs._eq_impl(
+      __rhs, integral_constant<bool, (sizeof...(_RHS) == rank())>{},
+      _CUDA_VSTD::make_index_sequence<sizeof...(_RHS)>{}
+    );
+  }
+
+#if !(__MDSPAN_HAS_CXX_20)
+  template<class _OtherIndexType, size_t... _RHS>
+  __MDSPAN_INLINE_FUNCTION
+  friend constexpr bool operator!=(extents const& lhs, extents<_OtherIndexType, _RHS...> const& __rhs) noexcept {
+    return lhs._not_eq_impl(
+      __rhs, integral_constant<bool, (sizeof...(_RHS) == rank())>{},
+      _CUDA_VSTD::make_index_sequence<sizeof...(_RHS)>{}
+    );
+  }
+#endif
+
+  // End of public interface
+
+public:  // (but not really)
+
+  __MDSPAN_INLINE_FUNCTION static constexpr
+  extents __make_extents_impl(__detail::__partially_static_sizes<index_type, size_t,_Extents...>&& __bs) noexcept {
+    // This effectively amounts to a sideways cast that can be done in a constexpr
+    // context, but we have to do it to handle the case where the extents and the
+    // strides could accidentally end up with the same types in their hierarchies
+    // somehow (which would cause layout_stride::mapping to not be standard_layout)
+    return extents(
+#ifdef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+      __base_t{
+#endif
+        _CUDA_VSTD::move(__bs.template __with_tag<__detail::__extents_tag>())
+#ifdef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+      }
+#endif
+    );
+  }
+
+  template <size_t _Np>
+  __MDSPAN_FORCE_INLINE_FUNCTION
+  constexpr
+  index_type __extent() const noexcept {
+    return __storage().template __get_n<_Np>();
+  }
+
+  template <size_t _Np, size_t _Default=dynamic_extent>
+  __MDSPAN_INLINE_FUNCTION
+  static constexpr
+  index_type __static_extent() noexcept {
+    return __storage_t::template __get_static_n<_Np, _Default>();
+  }
+
+};
+
+namespace __detail {
+
+template <class _IndexType, size_t _Rank, class _Extents = _CUDA_VSTD::extents<_IndexType>>
+struct __make_dextents;
+
+template <class _IndexType, size_t _Rank, size_t... _ExtentsPack>
+struct __make_dextents<_IndexType, _Rank, _CUDA_VSTD::extents<_IndexType, _ExtentsPack...>> {
+  using type = typename __make_dextents<_IndexType, _Rank - 1,
+    _CUDA_VSTD::extents<_IndexType, _CUDA_VSTD::dynamic_extent, _ExtentsPack...>>::type;
+};
+
+template <class _IndexType, size_t... _ExtentsPack>
+struct __make_dextents<_IndexType, 0, _CUDA_VSTD::extents<_IndexType, _ExtentsPack...>> {
+  using type = _CUDA_VSTD::extents<_IndexType, _ExtentsPack...>;
+};
+
+} // end namespace __detail
+
+template <class _IndexType, size_t _Rank>
+using dextents = typename __detail::__make_dextents<_IndexType, _Rank>::type;
+
+#if defined(__MDSPAN_USE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION)
+template <class... _IndexTypes>
+extents(_IndexTypes...)
+  // Workaround for nvcc
+  //-> extents<size_t, __detail::__make_dynamic_extent<_IndexTypes>()...>;
+  // Adding "(void)" so that clang doesn't complain this is unused
+  -> extents<size_t, size_t(((void)_IndexTypes(), -1))...>;
+#endif
+
+namespace __detail {
+
+template <class _Tp>
+struct __is_extents : false_type {};
+
+template <class _IndexType, size_t... _ExtentsPack>
+struct __is_extents<_CUDA_VSTD::extents<_IndexType, _ExtentsPack...>> : true_type {};
+
+template <class _Tp>
+static constexpr bool __is_extents_v = __is_extents<_Tp>::value;
+
+
+template <typename _Extents>
+struct __extents_to_partially_static_sizes;
+
+template <class _IndexType, size_t... _ExtentsPack>
+struct __extents_to_partially_static_sizes<_CUDA_VSTD::extents<_IndexType, _ExtentsPack...>> {
+  using type = __detail::__partially_static_sizes<
+          typename _CUDA_VSTD::extents<_IndexType, _ExtentsPack...>::index_type, size_t,
+          _ExtentsPack...>;
+};
+
+template <typename _Extents>
+using __extents_to_partially_static_sizes_t = typename __extents_to_partially_static_sizes<_Extents>::type;
+
+} // end namespace __detail
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#if defined(_LIBCUDACXX_POP_MACROS)
+  _LIBCUDACXX_POP_MACROS
+#endif
+
+#endif // _LIBCUDACXX___MDSPAN_EXTENTS_HPP

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/full_extent_t.h

@@ -0,0 +1,69 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 2.0
+//              Copyright (2019) Sandia Corporation
+//
+// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#ifndef _LIBCUDACXX___MDSPAN_FULL_EXTENT_T_HPP
+#define _LIBCUDACXX___MDSPAN_FULL_EXTENT_T_HPP
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__mdspan/macros.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+struct full_extent_t { explicit full_extent_t() = default; };
+
+_LIBCUDACXX_INLINE_VAR constexpr auto full_extent = full_extent_t{ };
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MDSPAN_FULL_EXTENT_T_HPP

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/layout_left.h

@@ -0,0 +1,270 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 2.0
+//              Copyright (2019) Sandia Corporation
+//
+// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#ifndef _LIBCUDACXX___MDSPAN_LAYOUT_LEFT_HPP
+#define _LIBCUDACXX___MDSPAN_LAYOUT_LEFT_HPP
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__assert"
+#include "../__mdspan/extents.h"
+#include "../__mdspan/macros.h"
+#include "../__type_traits/is_constructible.h"
+#include "../__type_traits/is_convertible.h"
+#include "../__type_traits/is_nothrow_constructible.h"
+#include "../__utility/integer_sequence.h"
+#include "../cstddef"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+//==============================================================================
+
+template <class _Extents>
+class layout_left::mapping {
+  public:
+    using extents_type = _Extents;
+    using index_type = typename extents_type::index_type;
+    using size_type = typename extents_type::size_type;
+    using rank_type = typename extents_type::rank_type;
+    using layout_type = layout_left;
+  private:
+
+    static_assert(__detail::__is_extents_v<extents_type>, "layout_left::mapping must be instantiated with a specialization of _CUDA_VSTD::extents.");
+
+    template <class>
+    friend class mapping;
+
+    // i0+(i1 + E(1)*(i2 + E(2)*i3))
+    template <size_t _r, size_t _Rank>
+    struct __rank_count {};
+
+    template <size_t _r, size_t _Rank, class _Ip, class... _Indices>
+    _LIBCUDACXX_HOST_DEVICE
+    constexpr index_type __compute_offset(
+      __rank_count<_r,_Rank>, const _Ip& __i, _Indices... __idx) const {
+      return __compute_offset(__rank_count<_r+1,_Rank>(), __idx...) *
+                 __extents.template __extent<_r>() + __i;
+    }
+
+    template<class _Ip>
+    _LIBCUDACXX_HOST_DEVICE
+    constexpr index_type __compute_offset(
+      __rank_count<extents_type::rank()-1,extents_type::rank()>, const _Ip& __i) const {
+      return __i;
+    }
+
+    _LIBCUDACXX_HOST_DEVICE
+    constexpr index_type __compute_offset(__rank_count<0,0>) const { return 0; }
+
+  public:
+
+    //--------------------------------------------------------------------------------
+
+    __MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping() noexcept = default;
+    __MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping(mapping const&) noexcept = default;
+
+    _LIBCUDACXX_HOST_DEVICE
+    constexpr mapping(extents_type const& __exts) noexcept
+      :__extents(__exts)
+    { }
+
+    __MDSPAN_TEMPLATE_REQUIRES(
+      class _OtherExtents,
+      /* requires */ (
+        _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_constructible, extents_type, _OtherExtents)
+      )
+    )
+    __MDSPAN_CONDITIONAL_EXPLICIT((!_CUDA_VSTD::is_convertible<_OtherExtents, extents_type>::value)) // needs two () due to comma
+    __MDSPAN_INLINE_FUNCTION constexpr
+    mapping(mapping<_OtherExtents> const& __other) noexcept // NOLINT(google-explicit-constructor)
+      :__extents(__other.extents())
+    {
+       /*
+        * TODO: check precondition
+        * __other.required_span_size() is a representable value of type index_type
+        */
+    }
+
+    __MDSPAN_TEMPLATE_REQUIRES(
+      class _OtherExtents,
+      /* requires */ (
+        _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_constructible, extents_type, _OtherExtents) &&
+        (extents_type::rank() <= 1)
+      )
+    )
+    __MDSPAN_CONDITIONAL_EXPLICIT((!_CUDA_VSTD::is_convertible<_OtherExtents, extents_type>::value)) // needs two () due to comma
+    __MDSPAN_INLINE_FUNCTION constexpr
+    mapping(layout_right::mapping<_OtherExtents> const& __other) noexcept // NOLINT(google-explicit-constructor)
+      :__extents(__other.extents())
+    {
+       /*
+        * TODO: check precondition
+        * __other.required_span_size() is a representable value of type index_type
+        */
+    }
+
+    __MDSPAN_TEMPLATE_REQUIRES(
+      class _OtherExtents,
+      /* requires */ (
+        _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_constructible, extents_type, _OtherExtents)
+      )
+    )
+    __MDSPAN_CONDITIONAL_EXPLICIT((extents_type::rank() > 0))
+    __MDSPAN_INLINE_FUNCTION constexpr
+    mapping(layout_stride::mapping<_OtherExtents> const& __other) // NOLINT(google-explicit-constructor)
+      :__extents(__other.extents())
+    {
+       /*
+        * TODO: check precondition
+        * __other.required_span_size() is a representable value of type index_type
+        */
+      NV_IF_TARGET(NV_IS_HOST,(
+        size_t __stride = 1;
+        for(rank_type __r=0; __r<__extents.rank(); __r++) {
+          _LIBCUDACXX_THROW_RUNTIME_ERROR(__stride == static_cast<size_t>(__other.stride(__r)),
+                                          "Assigning layout_stride to layout_left with invalid strides.");
+          __stride *= __extents.extent(__r);
+        }
+      ))
+    }
+
+    __MDSPAN_INLINE_FUNCTION_DEFAULTED __MDSPAN_CONSTEXPR_14_DEFAULTED mapping& operator=(mapping const&) noexcept = default;
+
+    __MDSPAN_INLINE_FUNCTION
+    constexpr const extents_type& extents() const noexcept {
+      return __extents;
+    }
+
+    __MDSPAN_INLINE_FUNCTION
+    constexpr index_type required_span_size() const noexcept {
+      index_type __value = 1;
+      for(rank_type __r=0; __r<extents_type::rank(); __r++) __value*=__extents.extent(__r);
+      return __value;
+    }
+
+    //--------------------------------------------------------------------------------
+
+    __MDSPAN_TEMPLATE_REQUIRES(
+      class... _Indices,
+      /* requires */ (
+        (sizeof...(_Indices) == extents_type::rank()) &&
+        __MDSPAN_FOLD_AND(
+           (_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _Indices, index_type) &&
+            _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, index_type, _Indices))
+        )
+      )
+    )
+    _LIBCUDACXX_HOST_DEVICE
+    constexpr index_type operator()(_Indices... __idxs) const noexcept {
+      // Immediately cast incoming indices to `index_type`
+      return __compute_offset(__rank_count<0, extents_type::rank()>(), static_cast<index_type>(__idxs)...);
+    }
+
+
+
+    __MDSPAN_INLINE_FUNCTION static constexpr bool is_always_unique() noexcept { return true; }
+    __MDSPAN_INLINE_FUNCTION static constexpr bool is_always_exhaustive() noexcept { return true; }
+    __MDSPAN_INLINE_FUNCTION static constexpr bool is_always_strided() noexcept { return true; }
+
+    __MDSPAN_INLINE_FUNCTION constexpr bool is_unique() const noexcept { return true; }
+    __MDSPAN_INLINE_FUNCTION constexpr bool is_exhaustive() const noexcept { return true; }
+    __MDSPAN_INLINE_FUNCTION constexpr bool is_strided() const noexcept { return true; }
+
+    __MDSPAN_TEMPLATE_REQUIRES(
+      class _Ext = _Extents,
+      /* requires */ (
+        _Ext::rank() > 0
+      )
+    )
+    __MDSPAN_INLINE_FUNCTION
+    constexpr index_type stride(rank_type __i) const noexcept {
+      index_type __value = 1;
+      for(rank_type __r=0; __r<__i; __r++) __value*=__extents.extent(__r);
+      return __value;
+    }
+
+    template<class _OtherExtents>
+    __MDSPAN_INLINE_FUNCTION
+    friend constexpr bool operator==(mapping const& __lhs, mapping<_OtherExtents> const& __rhs) noexcept {
+      return __lhs.extents() == __rhs.extents();
+    }
+
+    // In C++ 20 the not equal exists if equal is found
+#if !(__MDSPAN_HAS_CXX_20)
+    template<class _OtherExtents>
+    __MDSPAN_INLINE_FUNCTION
+    friend constexpr bool operator!=(mapping const& __lhs, mapping<_OtherExtents> const& __rhs) noexcept {
+      return __lhs.extents() != __rhs.extents();
+    }
+#endif
+
+    // Not really public, but currently needed to implement fully constexpr useable submdspan:
+    template<size_t _Np, class _SizeType, size_t ... _Ep, size_t ... _Idx>
+    _LIBCUDACXX_HOST_DEVICE
+    constexpr index_type __get_stride(_CUDA_VSTD::extents<_SizeType, _Ep...>,_CUDA_VSTD::integer_sequence<size_t, _Idx...>) const {
+      return __MDSPAN_FOLD_TIMES_RIGHT((_Idx<_Np? __extents.template __extent<_Idx>():1),1);
+    }
+    template<size_t _Np>
+    _LIBCUDACXX_HOST_DEVICE
+    constexpr index_type stride() const noexcept {
+      return __get_stride<_Np>(__extents, _CUDA_VSTD::make_index_sequence<extents_type::rank()>());
+    }
+
+private:
+   _LIBCUDACXX_NO_UNIQUE_ADDRESS extents_type __extents{};
+
+};
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MDSPAN_LAYOUT_LEFT_HPP

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/layout_right.h

@@ -0,0 +1,270 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 2.0
+//              Copyright (2019) Sandia Corporation
+//
+// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#ifndef _LIBCUDACXX___MDSPAN_LAYOUT_RIGHT_HPP
+#define _LIBCUDACXX___MDSPAN_LAYOUT_RIGHT_HPP
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__assert"
+#include "../__mdspan/extents.h"
+#include "../__mdspan/layout_stride.h"
+#include "../__mdspan/macros.h"
+#include "../__type_traits/is_constructible.h"
+#include "../__type_traits/is_convertible.h"
+#include "../__type_traits/is_nothrow_constructible.h"
+#include "../__utility/integer_sequence.h"
+#include "../cstddef"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+//==============================================================================
+template <class _Extents>
+class layout_right::mapping {
+  public:
+    using extents_type = _Extents;
+    using index_type = typename extents_type::index_type;
+    using size_type = typename extents_type::size_type;
+    using rank_type = typename extents_type::rank_type;
+    using layout_type = layout_right;
+  private:
+
+    static_assert(__detail::__is_extents_v<extents_type>, "layout_right::mapping must be instantiated with a specialization of _CUDA_VSTD::extents.");
+
+    template <class>
+    friend class mapping;
+
+    // i0+(i1 + E(1)*(i2 + E(2)*i3))
+    template <size_t _r, size_t _Rank>
+    struct __rank_count {};
+
+    template <size_t _r, size_t _Rank, class _Ip, class... _Indices>
+    _LIBCUDACXX_HOST_DEVICE
+    constexpr index_type __compute_offset(
+      index_type __offset, __rank_count<_r,_Rank>, const _Ip& __i, _Indices... __idx) const {
+      return __compute_offset(__offset * __extents.template __extent<_r>() + __i,__rank_count<_r+1,_Rank>(),  __idx...);
+    }
+
+    template<class _Ip, class ... _Indices>
+    _LIBCUDACXX_HOST_DEVICE
+    constexpr index_type __compute_offset(
+      __rank_count<0,extents_type::rank()>, const _Ip& __i, _Indices... __idx) const {
+      return __compute_offset(__i,__rank_count<1,extents_type::rank()>(),__idx...);
+    }
+
+    _LIBCUDACXX_HOST_DEVICE
+    constexpr index_type __compute_offset(size_t __offset, __rank_count<extents_type::rank(), extents_type::rank()>) const {
+      return static_cast<index_type>(__offset);
+    }
+
+    _LIBCUDACXX_HOST_DEVICE
+    constexpr index_type __compute_offset(__rank_count<0,0>) const { return 0; }
+
+  public:
+
+    //--------------------------------------------------------------------------------
+
+    __MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping() noexcept = default;
+    __MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping(mapping const&) noexcept = default;
+
+    _LIBCUDACXX_HOST_DEVICE
+    constexpr mapping(extents_type const& __exts) noexcept
+      :__extents(__exts)
+    { }
+
+    __MDSPAN_TEMPLATE_REQUIRES(
+      class _OtherExtents,
+      /* requires */ (
+        _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_constructible, extents_type, _OtherExtents)
+      )
+    )
+    __MDSPAN_CONDITIONAL_EXPLICIT((!_CUDA_VSTD::is_convertible<_OtherExtents, extents_type>::value)) // needs two () due to comma
+    __MDSPAN_INLINE_FUNCTION constexpr
+    mapping(mapping<_OtherExtents> const& __other) noexcept // NOLINT(google-explicit-constructor)
+      :__extents(__other.extents())
+    {
+       /*
+        * TODO: check precondition
+        * __other.required_span_size() is a representable value of type index_type
+        */
+    }
+
+    __MDSPAN_TEMPLATE_REQUIRES(
+      class _OtherExtents,
+      /* requires */ (
+        _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_constructible, extents_type, _OtherExtents) &&
+        (extents_type::rank() <= 1)
+      )
+    )
+    __MDSPAN_CONDITIONAL_EXPLICIT((!_CUDA_VSTD::is_convertible<_OtherExtents, extents_type>::value)) // needs two () due to comma
+    __MDSPAN_INLINE_FUNCTION constexpr
+    mapping(layout_left::mapping<_OtherExtents> const& __other) noexcept // NOLINT(google-explicit-constructor)
+      :__extents(__other.extents())
+    {
+       /*
+        * TODO: check precondition
+        * __other.required_span_size() is a representable value of type index_type
+        */
+    }
+
+    __MDSPAN_TEMPLATE_REQUIRES(
+      class _OtherExtents,
+      /* requires */ (
+        _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_constructible, extents_type, _OtherExtents)
+      )
+    )
+    __MDSPAN_CONDITIONAL_EXPLICIT((extents_type::rank() > 0))
+    __MDSPAN_INLINE_FUNCTION constexpr
+    mapping(layout_stride::mapping<_OtherExtents> const& __other) // NOLINT(google-explicit-constructor)
+      :__extents(__other.extents())
+    {
+       /*
+        * TODO: check precondition
+        * __other.required_span_size() is a representable value of type index_type
+        */
+      NV_IF_TARGET(NV_IS_HOST,(
+        size_t __stride = 1;
+        for(rank_type __r=__extents.rank(); __r>0; __r--) {
+          _LIBCUDACXX_THROW_RUNTIME_ERROR(__stride == static_cast<size_t>(__other.stride(__r-1)),
+                                          "Assigning layout_stride to layout_right with invalid strides.");
+          __stride *= __extents.extent(__r-1);
+        }
+      ))
+    }
+
+    __MDSPAN_INLINE_FUNCTION_DEFAULTED __MDSPAN_CONSTEXPR_14_DEFAULTED mapping& operator=(mapping const&) noexcept = default;
+
+    __MDSPAN_INLINE_FUNCTION
+    constexpr const extents_type& extents() const noexcept {
+      return __extents;
+    }
+
+    __MDSPAN_INLINE_FUNCTION
+    constexpr index_type required_span_size() const noexcept {
+      index_type __value = 1;
+      for(rank_type __r=0; __r != extents_type::rank(); ++__r) __value*=__extents.extent(__r);
+      return __value;
+    }
+
+    //--------------------------------------------------------------------------------
+
+    __MDSPAN_TEMPLATE_REQUIRES(
+      class... _Indices,
+      /* requires */ (
+        (sizeof...(_Indices) == extents_type::rank()) &&
+        __MDSPAN_FOLD_AND(
+           (_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _Indices, index_type) &&
+            _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, index_type, _Indices))
+        )
+      )
+    )
+    _LIBCUDACXX_HOST_DEVICE
+    constexpr index_type operator()(_Indices... __idxs) const noexcept {
+      return __compute_offset(__rank_count<0, extents_type::rank()>(), static_cast<index_type>(__idxs)...);
+    }
+
+    __MDSPAN_INLINE_FUNCTION static constexpr bool is_always_unique() noexcept { return true; }
+    __MDSPAN_INLINE_FUNCTION static constexpr bool is_always_exhaustive() noexcept { return true; }
+    __MDSPAN_INLINE_FUNCTION static constexpr bool is_always_strided() noexcept { return true; }
+    __MDSPAN_INLINE_FUNCTION constexpr bool is_unique() const noexcept { return true; }
+    __MDSPAN_INLINE_FUNCTION constexpr bool is_exhaustive() const noexcept { return true; }
+    __MDSPAN_INLINE_FUNCTION constexpr bool is_strided() const noexcept { return true; }
+
+    __MDSPAN_TEMPLATE_REQUIRES(
+      class _Ext = _Extents,
+      /* requires */ (
+        _Ext::rank() > 0
+      )
+    )
+    __MDSPAN_INLINE_FUNCTION
+    constexpr index_type stride(rank_type __i) const noexcept {
+      index_type __value = 1;
+      for(rank_type __r=extents_type::rank()-1; __r>__i; __r--) __value*=__extents.extent(__r);
+      return __value;
+    }
+
+    template<class _OtherExtents>
+    __MDSPAN_INLINE_FUNCTION
+    friend constexpr bool operator==(mapping const& __lhs, mapping<_OtherExtents> const& __rhs) noexcept {
+      return __lhs.extents() == __rhs.extents();
+    }
+
+    // In C++ 20 the not equal exists if equal is found
+#if !(__MDSPAN_HAS_CXX_20)
+    template<class _OtherExtents>
+    __MDSPAN_INLINE_FUNCTION
+    friend constexpr bool operator!=(mapping const& __lhs, mapping<_OtherExtents> const& __rhs) noexcept {
+      return __lhs.extents() != __rhs.extents();
+    }
+#endif
+
+    // Not really public, but currently needed to implement fully constexpr useable submdspan:
+    template<size_t _Np, class _SizeType, size_t ... _Ep, size_t ... _Idx>
+    _LIBCUDACXX_HOST_DEVICE
+    constexpr index_type __get_stride(_CUDA_VSTD::extents<_SizeType, _Ep...>,_CUDA_VSTD::integer_sequence<size_t, _Idx...>) const {
+      return __MDSPAN_FOLD_TIMES_RIGHT((_Idx>_Np? __extents.template __extent<_Idx>():1),1);
+    }
+    template<size_t _Np>
+    _LIBCUDACXX_HOST_DEVICE
+    constexpr index_type __stride() const noexcept {
+      return __get_stride<_Np>(__extents, _CUDA_VSTD::make_index_sequence<extents_type::rank()>());
+    }
+
+private:
+   _LIBCUDACXX_NO_UNIQUE_ADDRESS extents_type __extents{};
+
+};
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MDSPAN_LAYOUT_RIGHT_HPP

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/layout_stride.h

@@ -0,0 +1,555 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 2.0
+//              Copyright (2019) Sandia Corporation
+//
+// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+#ifndef _LIBCUDACXX___MDSPAN_LAYOUT_STRIDE_HPP
+#define _LIBCUDACXX___MDSPAN_LAYOUT_STRIDE_HPP
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__mdspan/compressed_pair.h"
+#include "../__mdspan/extents.h"
+#include "../__mdspan/macros.h"
+#ifdef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+#include "../__mdspan/no_unique_address.h"
+#endif
+#include "../__mdspan/static_array.h"
+#include "../__type_traits/is_same.h"
+#include "../__type_traits/is_constructible.h"
+#include "../__type_traits/is_convertible.h"
+#include "../__type_traits/is_nothrow_constructible.h"
+#include "../__type_traits/remove_const.h"
+#include "../__utility/integer_sequence.h"
+#include "../__utility/move.h"
+#include "../algorithm"
+#include "../array"
+#if __MDSPAN_USE_CONCEPTS && __MDSPAN_HAS_CXX_20
+#include "../concepts"
+#endif
+#include "../numeric"
+#include "../span"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 11
+
+struct layout_left {
+  template<class _Extents>
+    class mapping;
+};
+struct layout_right {
+  template<class _Extents>
+    class mapping;
+};
+
+namespace __detail {
+  template<class _Layout, class _Mapping>
+  constexpr bool __is_mapping_of =
+    _CUDA_VSTD::is_same<typename _Layout::template mapping<typename _Mapping::extents_type>, _Mapping>::value;
+
+#if  __MDSPAN_USE_CONCEPTS && __MDSPAN_HAS_CXX_20
+  template<class _Mp>
+  concept __layout_mapping_alike = requires {
+    requires __is_extents<typename _Mp::extents_type>::value;
+    { _Mp::is_always_strided() } -> same_as<bool>;
+    { _Mp::is_always_exhaustive() } -> same_as<bool>;
+    { _Mp::is_always_unique() } -> same_as<bool>;
+    bool_constant<_Mp::is_always_strided()>::value;
+    bool_constant<_Mp::is_always_exhaustive()>::value;
+    bool_constant<_Mp::is_always_unique()>::value;
+  };
+#endif
+} // namespace __detail
+
+struct layout_stride {
+  template <class _Extents>
+  class mapping
+#ifdef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+    : private __detail::__no_unique_address_emulation<
+        __detail::__compressed_pair<
+          _Extents,
+          _CUDA_VSTD::array<typename _Extents::index_type, _Extents::rank()>
+        >
+      >
+#endif
+  {
+  public:
+    using extents_type = _Extents;
+    using index_type = typename extents_type::index_type;
+    using size_type = typename extents_type::size_type;
+    using rank_type = typename extents_type::rank_type;
+    using layout_type = layout_stride;
+
+    // This could be a `requires`, but I think it's better and clearer as a `static_assert`.
+    static_assert(__detail::__is_extents_v<_Extents>, "layout_stride::mapping must be instantiated with a specialization of _CUDA_VSTD::extents.");
+
+
+  private:
+
+    //----------------------------------------------------------------------------
+
+    using __strides_storage_t = _CUDA_VSTD::array<index_type, extents_type::rank()>;//_CUDA_VSTD::dextents<index_type, extents_type::rank()>;
+    using __member_pair_t = __detail::__compressed_pair<extents_type, __strides_storage_t>;
+
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+    _LIBCUDACXX_NO_UNIQUE_ADDRESS __member_pair_t __members;
+#else
+    using __base_t = __detail::__no_unique_address_emulation<__member_pair_t>;
+#endif
+
+    __MDSPAN_FORCE_INLINE_FUNCTION constexpr __strides_storage_t const&
+    __strides_storage() const noexcept {
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+      return __members.__second();
+#else
+      return this->__base_t::__ref().__second();
+#endif
+    }
+    __MDSPAN_FORCE_INLINE_FUNCTION constexpr __strides_storage_t&
+    __strides_storage() noexcept {
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+      return __members.__second();
+#else
+      return this->__base_t::__ref().__second();
+#endif
+    }
+
+    template<class _SizeType, size_t ... _Ep, size_t ... _Idx>
+    _LIBCUDACXX_HOST_DEVICE
+    constexpr index_type __get_size(_CUDA_VSTD::extents<_SizeType, _Ep...>,_CUDA_VSTD::integer_sequence<size_t, _Idx...>) const {
+      return __MDSPAN_FOLD_TIMES_RIGHT( static_cast<index_type>(extents().extent(_Idx)), 1 );
+    }
+
+    //----------------------------------------------------------------------------
+
+    template <class>
+    friend class mapping;
+
+    //----------------------------------------------------------------------------
+
+    // Workaround for non-deducibility of the index sequence template parameter if it's given at the top level
+    template <class>
+    struct __deduction_workaround;
+
+    template <size_t... _Idxs>
+    struct __deduction_workaround<_CUDA_VSTD::index_sequence<_Idxs...>>
+    {
+      template <class _OtherExtents>
+      __MDSPAN_INLINE_FUNCTION
+      static constexpr bool _eq_impl(mapping const& __self, mapping<_OtherExtents> const& __other) noexcept {
+        return    __MDSPAN_FOLD_AND((__self.stride(_Idxs) == __other.stride(_Idxs)) /* && ... */)
+               && __MDSPAN_FOLD_AND((__self.extents().extent(_Idxs) == __other.extents().extent(_Idxs)) /* || ... */);
+      }
+      template <class _OtherExtents>
+      __MDSPAN_INLINE_FUNCTION
+      static constexpr bool _not_eq_impl(mapping const& __self, mapping<_OtherExtents> const& __other) noexcept {
+        return    __MDSPAN_FOLD_OR((__self.stride(_Idxs) != __other.stride(_Idxs)) /* || ... */)
+               || __MDSPAN_FOLD_OR((__self.extents().extent(_Idxs) != __other.extents().extent(_Idxs)) /* || ... */);
+      }
+
+      template <class... _Integral>
+      __MDSPAN_FORCE_INLINE_FUNCTION
+      static constexpr size_t _call_op_impl(mapping const& __self, _Integral... __idxs) noexcept {
+        return __MDSPAN_FOLD_PLUS_RIGHT((__idxs * __self.stride(_Idxs)), /* + ... + */ 0);
+      }
+
+      __MDSPAN_INLINE_FUNCTION
+      static constexpr size_t _req_span_size_impl(mapping const& __self) noexcept {
+        // assumes no negative strides; not sure if I'm allowed to assume that or not
+        return __impl::_call_op_impl(__self, (__self.extents().template __extent<_Idxs>() - 1)...) + 1;
+      }
+
+      template<class _OtherMapping>
+      __MDSPAN_INLINE_FUNCTION
+      static constexpr const __strides_storage_t fill_strides(const _OtherMapping& __map) {
+        return __strides_storage_t{static_cast<index_type>(__map.stride(_Idxs))...};
+      }
+
+      __MDSPAN_INLINE_FUNCTION
+      static constexpr const __strides_storage_t& fill_strides(const __strides_storage_t& __s) {
+        return __s;
+      }
+
+      template<class _IntegralType>
+      __MDSPAN_INLINE_FUNCTION
+      static constexpr const __strides_storage_t fill_strides(const _CUDA_VSTD::array<_IntegralType,extents_type::rank()>& __s) {
+        return __strides_storage_t{static_cast<index_type>(__s[_Idxs])...};
+      }
+
+      template<class _IntegralType>
+      __MDSPAN_INLINE_FUNCTION
+      static constexpr const __strides_storage_t fill_strides(const _CUDA_VSTD::span<_IntegralType,extents_type::rank()>& __s) {
+        return __strides_storage_t{static_cast<index_type>(__s[_Idxs])...};
+      }
+
+      __MDSPAN_INLINE_FUNCTION
+      static constexpr const __strides_storage_t fill_strides(
+        __detail::__extents_to_partially_static_sizes_t<
+          _CUDA_VSTD::dextents<index_type, extents_type::rank()>>&& __s) {
+        return __strides_storage_t{static_cast<index_type>(__s.template __get_n<_Idxs>())...};
+      }
+
+      template<size_t K>
+      __MDSPAN_INLINE_FUNCTION
+      static constexpr size_t __return_zero() { return 0; }
+
+      template<class _Mapping>
+      __MDSPAN_INLINE_FUNCTION
+      static constexpr typename _Mapping::index_type
+        __OFFSET(const _Mapping& m) { return m(__return_zero<_Idxs>()...); }
+    };
+
+    // Can't use defaulted parameter in the __deduction_workaround template because of a bug in MSVC warning C4348.
+    using __impl = __deduction_workaround<_CUDA_VSTD::make_index_sequence<_Extents::rank()>>;
+
+
+    //----------------------------------------------------------------------------
+
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+    __MDSPAN_INLINE_FUNCTION constexpr explicit
+    mapping(__member_pair_t&& __m) : __members(_CUDA_VSTD::move(__m)) {}
+#else
+    __MDSPAN_INLINE_FUNCTION constexpr explicit
+    mapping(__base_t&& __b) : __base_t(_CUDA_VSTD::move(__b)) {}
+#endif
+
+  public: // but not really
+    __MDSPAN_INLINE_FUNCTION
+    static constexpr mapping
+    __make_mapping(
+      __detail::__extents_to_partially_static_sizes_t<_Extents>&& __exts,
+      __detail::__extents_to_partially_static_sizes_t<
+        _CUDA_VSTD::dextents<index_type, _Extents::rank()>>&& __strs
+    ) noexcept {
+      // call the private constructor we created for this purpose
+      return mapping(
+#ifdef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+        __base_t{
+#endif
+          __member_pair_t(
+            extents_type::__make_extents_impl(_CUDA_VSTD::move(__exts)),
+            __strides_storage_t{__impl::fill_strides(_CUDA_VSTD::move(__strs))}
+          )
+#ifdef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+        }
+#endif
+      );
+    }
+    //----------------------------------------------------------------------------
+
+
+  public:
+
+    //--------------------------------------------------------------------------------
+
+    __MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping() noexcept = default;
+    __MDSPAN_INLINE_FUNCTION_DEFAULTED constexpr mapping(mapping const&) noexcept = default;
+
+    __MDSPAN_TEMPLATE_REQUIRES(
+      class _IntegralTypes,
+      /* requires */ (
+        // MSVC 19.32 does not like using index_type here, requires the typename _Extents::index_type
+        // error C2641: cannot deduce template arguments for '_CUDA_VSTD::layout_stride::mapping'
+        _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, const remove_const_t<_IntegralTypes>&, typename _Extents::index_type) &&
+        _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, typename _Extents::index_type, const remove_const_t<_IntegralTypes>&)
+      )
+    )
+    __MDSPAN_INLINE_FUNCTION
+    constexpr
+    mapping(
+      extents_type const& __e,
+      _CUDA_VSTD::array<_IntegralTypes, extents_type::rank()> const& __s
+    ) noexcept
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+      : __members{
+#else
+      : __base_t(__base_t{__member_pair_t(
+#endif
+          __e, __strides_storage_t(__impl::fill_strides(__s))
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+        }
+#else
+        )})
+#endif
+    {
+      /*
+       * TODO: check preconditions
+       * - __s[i] > 0 is true for all i in the range [0, rank_ ).
+       * - REQUIRED-SPAN-SIZE(__e, __s) is a representable value of type index_type ([basic.fundamental]).
+       * - If rank_ is greater than 0, then there exists a permutation P of the integers in the
+       *   range [0, rank_), such that __s[ pi ] >= __s[ pi − 1 ] * __e.extent( pi − 1 ) is true for
+       *   all i in the range [1, rank_ ), where pi is the ith element of P.
+       */
+    }
+
+    __MDSPAN_TEMPLATE_REQUIRES(
+      class _IntegralTypes,
+      /* requires */ (
+        // MSVC 19.32 does not like using index_type here, requires the typename _Extents::index_type
+        // error C2641: cannot deduce template arguments for '_CUDA_VSTD::layout_stride::mapping'
+        _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, const remove_const_t<_IntegralTypes>&, typename _Extents::index_type) &&
+        _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, typename _Extents::index_type, const remove_const_t<_IntegralTypes>&)
+      )
+    )
+    __MDSPAN_INLINE_FUNCTION
+    constexpr
+    mapping(
+      extents_type const& __e,
+      _CUDA_VSTD::span<_IntegralTypes, extents_type::rank()> const& __s
+    ) noexcept
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+      : __members{
+#else
+      : __base_t(__base_t{__member_pair_t(
+#endif
+          __e, __strides_storage_t(__impl::fill_strides(__s))
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+        }
+#else
+        )})
+#endif
+    {
+      /*
+       * TODO: check preconditions
+       * - __s[i] > 0 is true for all i in the range [0, rank_ ).
+       * - REQUIRED-SPAN-SIZE(__e, __s) is a representable value of type index_type ([basic.fundamental]).
+       * - If rank_ is greater than 0, then there exists a permutation P of the integers in the
+       *   range [0, rank_), such that __s[ pi ] >= __s[ pi − 1 ] * __e.extent( pi − 1 ) is true for
+       *   all i in the range [1, rank_ ), where pi is the ith element of P.
+       */
+    }
+
+#if !(__MDSPAN_USE_CONCEPTS && __MDSPAN_HAS_CXX_20)
+    __MDSPAN_TEMPLATE_REQUIRES(
+      class _StridedLayoutMapping,
+      /* requires */ (
+        _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_constructible, extents_type, typename _StridedLayoutMapping::extents_type) &&
+        __detail::__is_mapping_of<typename _StridedLayoutMapping::layout_type, _StridedLayoutMapping> &&
+        _StridedLayoutMapping::is_always_unique() &&
+        _StridedLayoutMapping::is_always_strided()
+      )
+    )
+#else
+    template<class _StridedLayoutMapping>
+    requires(
+         __detail::__layout_mapping_alike<_StridedLayoutMapping> &&
+         _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_constructible, extents_type, typename _StridedLayoutMapping::extents_type) &&
+         _StridedLayoutMapping::is_always_unique() &&
+         _StridedLayoutMapping::is_always_strided()
+    )
+#endif
+    __MDSPAN_CONDITIONAL_EXPLICIT(
+      (!_CUDA_VSTD::is_convertible<typename _StridedLayoutMapping::extents_type, extents_type>::value) &&
+      (__detail::__is_mapping_of<layout_left, _StridedLayoutMapping> ||
+       __detail::__is_mapping_of<layout_right, _StridedLayoutMapping> ||
+       __detail::__is_mapping_of<layout_stride, _StridedLayoutMapping>)
+    ) // needs two () due to comma
+    __MDSPAN_INLINE_FUNCTION constexpr
+    mapping(_StridedLayoutMapping const& __other) noexcept // NOLINT(google-explicit-constructor)
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+      : __members{
+#else
+      : __base_t(__base_t{__member_pair_t(
+#endif
+          __other.extents(), __strides_storage_t(__impl::fill_strides(__other))
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+        }
+#else
+        )})
+#endif
+    {
+      /*
+       * TODO: check preconditions
+       * - __other.stride(i) > 0 is true for all i in the range [0, rank_ ).
+       * - __other.required_span_size() is a representable value of type index_type ([basic.fundamental]).
+       * - OFFSET(__other) == 0
+       */
+    }
+
+    //--------------------------------------------------------------------------------
+
+    __MDSPAN_INLINE_FUNCTION_DEFAULTED __MDSPAN_CONSTEXPR_14_DEFAULTED
+    mapping& operator=(mapping const&) noexcept = default;
+
+    __MDSPAN_INLINE_FUNCTION constexpr const extents_type& extents() const noexcept {
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+      return __members.__first();
+#else
+      return this->__base_t::__ref().__first();
+#endif
+    };
+
+    __MDSPAN_INLINE_FUNCTION
+    constexpr _CUDA_VSTD::array< index_type, extents_type::rank() > strides() const noexcept {
+      return __strides_storage();
+    }
+
+    __MDSPAN_INLINE_FUNCTION
+    constexpr index_type required_span_size() const noexcept {
+      index_type __span_size = 1;
+      for(unsigned __r = 0; __r < extents_type::rank(); __r++) {
+        // Return early if any of the extents are zero
+        if(extents().extent(__r)==0) return 0;
+        __span_size += ( static_cast<index_type>(extents().extent(__r) - 1 ) * __strides_storage()[__r]);
+      }
+      return __span_size;
+    }
+
+
+    __MDSPAN_TEMPLATE_REQUIRES(
+      class... _Indices,
+      /* requires */ (
+        sizeof...(_Indices) == _Extents::rank() &&
+        __MDSPAN_FOLD_AND(_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_convertible, _Indices, index_type) /*&& ...*/ ) &&
+        __MDSPAN_FOLD_AND(_LIBCUDACXX_TRAIT(_CUDA_VSTD::is_nothrow_constructible, index_type, _Indices) /*&& ...*/)
+      )
+    )
+    __MDSPAN_FORCE_INLINE_FUNCTION
+    constexpr index_type operator()(_Indices... __idxs) const noexcept {
+      // Should the op_impl operate in terms of `index_type` rather than `size_t`?
+      // Casting `size_t` to `index_type` here.
+      return static_cast<index_type>(__impl::_call_op_impl(*this, static_cast<index_type>(__idxs)...));
+    }
+
+    __MDSPAN_INLINE_FUNCTION static constexpr bool is_always_unique() noexcept { return true; }
+    __MDSPAN_INLINE_FUNCTION static constexpr bool is_always_exhaustive() noexcept {
+      return false;
+    }
+    __MDSPAN_INLINE_FUNCTION static constexpr bool is_always_strided() noexcept { return true; }
+
+    __MDSPAN_INLINE_FUNCTION static constexpr bool is_unique() noexcept { return true; }
+    __MDSPAN_INLINE_FUNCTION constexpr bool is_exhaustive() const noexcept {
+      return required_span_size() == __get_size( extents(), _CUDA_VSTD::make_index_sequence<extents_type::rank()>());
+    }
+    __MDSPAN_INLINE_FUNCTION static constexpr bool is_strided() noexcept { return true; }
+
+
+    __MDSPAN_TEMPLATE_REQUIRES(
+      class _Ext = _Extents,
+      /* requires */ (
+        _Ext::rank() > 0
+      )
+    )
+    __MDSPAN_INLINE_FUNCTION
+    constexpr index_type stride(rank_type __r) const noexcept {
+      return __strides_storage()[__r];
+    }
+
+#if !(__MDSPAN_USE_CONCEPTS && __MDSPAN_HAS_CXX_20)
+    __MDSPAN_TEMPLATE_REQUIRES(
+      class _StridedLayoutMapping,
+      /* requires */ (
+        __detail::__is_mapping_of<typename _StridedLayoutMapping::layout_type, _StridedLayoutMapping> &&
+        (extents_type::rank() == _StridedLayoutMapping::extents_type::rank()) &&
+        _StridedLayoutMapping::is_always_strided()
+      )
+    )
+#else
+    template<class _StridedLayoutMapping>
+    requires(
+         __detail::__layout_mapping_alike<_StridedLayoutMapping> &&
+         (extents_type::rank() == _StridedLayoutMapping::extents_type::rank()) &&
+         _StridedLayoutMapping::is_always_strided()
+    )
+#endif
+    __MDSPAN_INLINE_FUNCTION
+    friend constexpr bool operator==(const mapping& __x, const _StridedLayoutMapping& __y) noexcept {
+      bool __strides_match = true;
+      for(rank_type __r = 0; __r < extents_type::rank(); __r++)
+        __strides_match = __strides_match && (__x.stride(__r) == __y.stride(__r));
+      return (__x.extents() == __y.extents()) &&
+             (__impl::__OFFSET(__y)== static_cast<typename _StridedLayoutMapping::index_type>(0)) &&
+             __strides_match;
+    }
+
+    // This one is not technically part of the proposal. Just here to make implementation a bit more optimal hopefully
+    __MDSPAN_TEMPLATE_REQUIRES(
+      class _OtherExtents,
+      /* requires */ (
+        (extents_type::rank() == _OtherExtents::rank())
+      )
+    )
+    __MDSPAN_INLINE_FUNCTION
+    friend constexpr bool operator==(mapping const& __lhs, mapping<_OtherExtents> const& __rhs) noexcept {
+      return __impl::_eq_impl(__lhs, __rhs);
+    }
+
+#if !__MDSPAN_HAS_CXX_20
+    __MDSPAN_TEMPLATE_REQUIRES(
+      class _StridedLayoutMapping,
+      /* requires */ (
+        __detail::__is_mapping_of<typename _StridedLayoutMapping::layout_type, _StridedLayoutMapping> &&
+        (extents_type::rank() == _StridedLayoutMapping::extents_type::rank()) &&
+        _StridedLayoutMapping::is_always_strided()
+      )
+    )
+    __MDSPAN_INLINE_FUNCTION
+    friend constexpr bool operator!=(const mapping& __x, const _StridedLayoutMapping& __y) noexcept {
+      return not (__x == __y);
+    }
+
+    __MDSPAN_TEMPLATE_REQUIRES(
+      class _OtherExtents,
+      /* requires */ (
+        (extents_type::rank() == _OtherExtents::rank())
+      )
+    )
+    __MDSPAN_INLINE_FUNCTION
+    friend constexpr bool operator!=(mapping const& __lhs, mapping<_OtherExtents> const& __rhs) noexcept {
+      return __impl::_not_eq_impl(__lhs, __rhs);
+    }
+#endif
+
+  };
+};
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___MDSPAN_LAYOUT_STRIDE_HPP

videochat2/lib/python3.10/site-packages/tensorflow/include/external/local_config_cuda/cuda/cuda/include/cuda/std/detail/libcxx/include/__mdspan/macros.h

@@ -0,0 +1,639 @@
+/*
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 2.0
+//              Copyright (2019) Sandia Corporation
+//
+// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+// the U.S. Government retains certain rights in this software.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// 1. Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the Corporation nor the names of the
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Questions? Contact Christian R. Trott (crtrott@sandia.gov)
+//
+// ************************************************************************
+//@HEADER
+*/
+
+
+#ifndef _LIBCUDACXX___MDSPAN_MACROS_HPP
+#define _LIBCUDACXX___MDSPAN_MACROS_HPP
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "../__mdspan/config.h"
+#include "../__type_traits/enable_if.h"
+#include "../__type_traits/is_void.h"
+#include "../__type_traits/remove_reference.h"
+#include "../__utility/declval.h"
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_GCC_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+#if _LIBCUDACXX_STD_VER > 11
+
+#ifndef __MDSPAN_FORCE_INLINE_FUNCTION
+#  ifdef __MDSPAN_COMPILER_MSVC // Microsoft compilers
+#    define __MDSPAN_FORCE_INLINE_FUNCTION __forceinline _LIBCUDACXX_HOST_DEVICE
+#  else
+#    define __MDSPAN_FORCE_INLINE_FUNCTION __attribute__((always_inline)) _LIBCUDACXX_HOST_DEVICE
+#  endif
+#endif
+
+#ifndef __MDSPAN_INLINE_FUNCTION
+#  define __MDSPAN_INLINE_FUNCTION inline _LIBCUDACXX_HOST_DEVICE
+#endif
+
+// In CUDA defaulted functions do not need host device markup
+#ifndef __MDSPAN_INLINE_FUNCTION_DEFAULTED
+#  define __MDSPAN_INLINE_FUNCTION_DEFAULTED
+#endif
+
+//==============================================================================
+// <editor-fold desc="Preprocessor helpers"> {{{1
+
+#define __MDSPAN_PP_COUNT(...) \
+  __MDSPAN_PP_INTERNAL_EXPAND_ARGS_PRIVATE( \
+    __MDSPAN_PP_INTERNAL_ARGS_AUGMENTER(__VA_ARGS__) \
+  )
+
+#define __MDSPAN_PP_INTERNAL_ARGS_AUGMENTER(...) unused, __VA_ARGS__
+#define __MDSPAN_PP_INTERNAL_EXPAND(x) x
+#define __MDSPAN_PP_INTERNAL_EXPAND_ARGS_PRIVATE(...) \
+  __MDSPAN_PP_INTERNAL_EXPAND( \
+    __MDSPAN_PP_INTERNAL_COUNT_PRIVATE( \
+      __VA_ARGS__, 69, 68, 67, 66, 65, 64, 63, 62, 61, \
+      60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49,  \
+      48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37,  \
+      36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25,  \
+      24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13,  \
+      12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 \
+    ) \
+  )
+# define __MDSPAN_PP_INTERNAL_COUNT_PRIVATE( \
+         _1_, _2_, _3_, _4_, _5_, _6_, _7_, _8_, _9_, \
+    _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+    _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, \
+    _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, \
+    _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, \
+    _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, \
+    _60, _61, _62, _63, _64, _65, _66, _67, _68, _69, \
+    _70, count, ...) count \
+    /**/
+
+#define __MDSPAN_PP_STRINGIFY_IMPL(x) #x
+#define __MDSPAN_PP_STRINGIFY(x) __MDSPAN_PP_STRINGIFY_IMPL(x)
+
+#define __MDSPAN_PP_CAT_IMPL(x, y) x ## y
+#define __MDSPAN_PP_CAT(x, y) __MDSPAN_PP_CAT_IMPL(x, y)
+
+#define __MDSPAN_PP_EVAL(X, ...) X(__VA_ARGS__)
+
+#define __MDSPAN_PP_REMOVE_PARENS_IMPL(...) __VA_ARGS__
+#define __MDSPAN_PP_REMOVE_PARENS(...) __MDSPAN_PP_REMOVE_PARENS_IMPL __VA_ARGS__
+
+// </editor-fold> end Preprocessor helpers }}}1
+//==============================================================================
+
+//==============================================================================
+// <editor-fold desc="Concept emulation"> {{{1
+
+// These compatibility macros don't help with partial ordering, but they should do the trick
+// for what we need to do with concepts in mdspan
+#ifdef __MDSPAN_USE_CONCEPTS
+#  define __MDSPAN_CLOSE_ANGLE_REQUIRES(REQ) > requires REQ
+#  define __MDSPAN_FUNCTION_REQUIRES(PAREN_PREQUALS, FNAME, PAREN_PARAMS, QUALS, REQ) \
+     __MDSPAN_PP_REMOVE_PARENS(PAREN_PREQUALS) FNAME PAREN_PARAMS QUALS requires REQ \
+     /**/
+#else
+#  define __MDSPAN_CLOSE_ANGLE_REQUIRES(REQ) , typename _CUDA_VSTD::enable_if<(REQ), int>::type = 0>
+#  define __MDSPAN_FUNCTION_REQUIRES(PAREN_PREQUALS, FNAME, PAREN_PARAMS, QUALS, REQ) \
+     __MDSPAN_TEMPLATE_REQUIRES( \
+       class __function_requires_ignored=void, \
+       (_CUDA_VSTD::is_void<__function_requires_ignored>::value && REQ) \
+     ) __MDSPAN_PP_REMOVE_PARENS(PAREN_PREQUALS) FNAME PAREN_PARAMS QUALS \
+     /**/
+#endif
+
+
+#if defined(__MDSPAN_COMPILER_MSVC)
+#  define __MDSPAN_TEMPLATE_REQUIRES(...) \
+      __MDSPAN_PP_CAT( \
+        __MDSPAN_PP_CAT(__MDSPAN_TEMPLATE_REQUIRES_, __MDSPAN_PP_COUNT(__VA_ARGS__))\
+        (__VA_ARGS__), \
+      ) \
+    /**/
+#else
+#  define __MDSPAN_TEMPLATE_REQUIRES(...) \
+    __MDSPAN_PP_EVAL( \
+        __MDSPAN_PP_CAT(__MDSPAN_TEMPLATE_REQUIRES_, __MDSPAN_PP_COUNT(__VA_ARGS__)), \
+        __VA_ARGS__ \
+    ) \
+    /**/
+#endif
+
+#define __MDSPAN_TEMPLATE_REQUIRES_2(TP1, REQ) \
+  template<TP1 \
+    __MDSPAN_CLOSE_ANGLE_REQUIRES(REQ) \
+    /**/
+#define __MDSPAN_TEMPLATE_REQUIRES_3(TP1, TP2, REQ) \
+  template<TP1, TP2 \
+    __MDSPAN_CLOSE_ANGLE_REQUIRES(REQ) \
+    /**/
+#define __MDSPAN_TEMPLATE_REQUIRES_4(TP1, TP2, TP3, REQ) \
+  template<TP1, TP2, TP3 \
+    __MDSPAN_CLOSE_ANGLE_REQUIRES(REQ) \
+    /**/
+#define __MDSPAN_TEMPLATE_REQUIRES_5(TP1, TP2, TP3, TP4, REQ) \
+  template<TP1, TP2, TP3, TP4 \
+    __MDSPAN_CLOSE_ANGLE_REQUIRES(REQ) \
+    /**/
+#define __MDSPAN_TEMPLATE_REQUIRES_6(TP1, TP2, TP3, TP4, TP5, REQ) \
+  template<TP1, TP2, TP3, TP4, TP5 \
+    __MDSPAN_CLOSE_ANGLE_REQUIRES(REQ) \
+    /**/
+#define __MDSPAN_TEMPLATE_REQUIRES_7(TP1, TP2, TP3, TP4, TP5, TP6, REQ) \
+  template<TP1, TP2, TP3, TP4, TP5, TP6 \
+    __MDSPAN_CLOSE_ANGLE_REQUIRES(REQ) \
+    /**/
+#define __MDSPAN_TEMPLATE_REQUIRES_8(TP1, TP2, TP3, TP4, TP5, TP6, TP7, REQ) \
+  template<TP1, TP2, TP3, TP4, TP5, TP6, TP7 \
+    __MDSPAN_CLOSE_ANGLE_REQUIRES(REQ) \
+    /**/
+#define __MDSPAN_TEMPLATE_REQUIRES_9(TP1, TP2, TP3, TP4, TP5, TP6, TP7, TP8, REQ) \
+  template<TP1, TP2, TP3, TP4, TP5, TP6, TP7, TP8 \
+    __MDSPAN_CLOSE_ANGLE_REQUIRES(REQ) \
+    /**/
+#define __MDSPAN_TEMPLATE_REQUIRES_10(TP1, TP2, TP3, TP4, TP5, TP6, TP7, TP8, TP9, REQ) \
+  template<TP1, TP2, TP3, TP4, TP5, TP6, TP7, TP8, TP9 \
+    __MDSPAN_CLOSE_ANGLE_REQUIRES(REQ) \
+    /**/
+#define __MDSPAN_TEMPLATE_REQUIRES_11(TP1, TP2, TP3, TP4, TP5, TP6, TP7, TP8, TP9, TP10, REQ) \
+  template<TP1, TP2, TP3, TP4, TP5, TP6, TP7, TP8, TP9, TP10 \
+    __MDSPAN_CLOSE_ANGLE_REQUIRES(REQ) \
+    /**/
+#define __MDSPAN_TEMPLATE_REQUIRES_12(TP1, TP2, TP3, TP4, TP5, TP6, TP7, TP8, TP9, TP10, TP11, REQ) \
+  template<TP1, TP2, TP3, TP4, TP5, TP6, TP7, TP8, TP9, TP10, TP11 \
+    __MDSPAN_CLOSE_ANGLE_REQUIRES(REQ) \
+    /**/
+#define __MDSPAN_TEMPLATE_REQUIRES_13(TP1, TP2, TP3, TP4, TP5, TP6, TP7, TP8, TP9, TP10, TP11, TP12, REQ) \
+  template<TP1, TP2, TP3, TP4, TP5, TP6, TP7, TP8, TP9, TP10, TP11, TP12 \
+    __MDSPAN_CLOSE_ANGLE_REQUIRES(REQ) \
+    /**/
+#define __MDSPAN_TEMPLATE_REQUIRES_14(TP1, TP2, TP3, TP4, TP5, TP6, TP7, TP8, TP9, TP10, TP11, TP12, TP13, REQ) \
+  template<TP1, TP2, TP3, TP4, TP5, TP6, TP7, TP8, TP9, TP10, TP11, TP12, TP13 \
+    __MDSPAN_CLOSE_ANGLE_REQUIRES(REQ) \
+    /**/
+#define __MDSPAN_TEMPLATE_REQUIRES_15(TP1, TP2, TP3, TP4, TP5, TP6, TP7, TP8, TP9, TP10, TP11, TP12, TP13, TP14, REQ) \
+  template<TP1, TP2, TP3, TP4, TP5, TP6, TP7, TP8, TP9, TP10, TP11, TP12, TP13, TP14 \
+    __MDSPAN_CLOSE_ANGLE_REQUIRES(REQ) \
+    /**/
+#define __MDSPAN_TEMPLATE_REQUIRES_16(TP1, TP2, TP3, TP4, TP5, TP6, TP7, TP8, TP9, TP10, TP11, TP12, TP13, TP14, TP15, REQ) \
+  template<TP1, TP2, TP3, TP4, TP5, TP6, TP7, TP8, TP9, TP10, TP11, TP12, TP13, TP14, TP15 \
+    __MDSPAN_CLOSE_ANGLE_REQUIRES(REQ) \
+    /**/
+#define __MDSPAN_TEMPLATE_REQUIRES_17(TP1, TP2, TP3, TP4, TP5, TP6, TP7, TP8, TP9, TP10, TP11, TP12, TP13, TP14, TP15, TP16, REQ) \
+  template<TP1, TP2, TP3, TP4, TP5, TP6, TP7, TP8, TP9, TP10, TP11, TP12, TP13, TP14, TP15, TP16 \
+    __MDSPAN_CLOSE_ANGLE_REQUIRES(REQ) \
+    /**/
+#define __MDSPAN_TEMPLATE_REQUIRES_18(TP1, TP2, TP3, TP4, TP5, TP6, TP7, TP8, TP9, TP10, TP11, TP12, TP13, TP14, TP15, TP16, TP17, REQ) \
+  template<TP1, TP2, TP3, TP4, TP5, TP6, TP7, TP8, TP9, TP10, TP11, TP12, TP13, TP14, TP15, TP16, TP17 \
+    __MDSPAN_CLOSE_ANGLE_REQUIRES(REQ) \
+    /**/
+#define __MDSPAN_TEMPLATE_REQUIRES_19(TP1, TP2, TP3, TP4, TP5, TP6, TP7, TP8, TP9, TP10, TP11, TP12, TP13, TP14, TP15, TP16, TP17, TP18, REQ) \
+  template<TP1, TP2, TP3, TP4, TP5, TP6, TP7, TP8, TP9, TP10, TP11, TP12, TP13, TP14, TP15, TP16, TP17, TP18 \
+    __MDSPAN_CLOSE_ANGLE_REQUIRES(REQ) \
+    /**/
+#define __MDSPAN_TEMPLATE_REQUIRES_20(TP1, TP2, TP3, TP4, TP5, TP6, TP7, TP8, TP9, TP10, TP11, TP12, TP13, TP14, TP15, TP16, TP17, TP18, TP19, REQ) \
+  template<TP1, TP2, TP3, TP4, TP5, TP6, TP7, TP8, TP9, TP10, TP11, TP12, TP13, TP14, TP15, TP16, TP17, TP18, TP19 \
+    __MDSPAN_CLOSE_ANGLE_REQUIRES(REQ) \
+    /**/
+
+#define __MDSPAN_INSTANTIATE_ONLY_IF_USED \
+  __MDSPAN_TEMPLATE_REQUIRES( \
+    class __instantiate_only_if_used_tparam=void, \
+    ( _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_void, __instantiate_only_if_used_tparam) ) \
+  ) \
+  /**/
+
+// </editor-fold> end Concept emulation }}}1
+//==============================================================================
+
+//==============================================================================
+// <editor-fold desc="Return type deduction"> {{{1
+
+#if __MDSPAN_USE_RETURN_TYPE_DEDUCTION
+#  define __MDSPAN_DEDUCE_RETURN_TYPE_SINGLE_LINE(SIGNATURE, BODY) \
+    auto __MDSPAN_PP_REMOVE_PARENS(SIGNATURE) { return __MDSPAN_PP_REMOVE_PARENS(BODY); }
+#  define __MDSPAN_DEDUCE_DECLTYPE_AUTO_RETURN_TYPE_SINGLE_LINE(SIGNATURE, BODY) \
+    decltype(auto) __MDSPAN_PP_REMOVE_PARENS(SIGNATURE) { return __MDSPAN_PP_REMOVE_PARENS(BODY); }
+#else
+#  define __MDSPAN_DEDUCE_RETURN_TYPE_SINGLE_LINE(SIGNATURE, BODY) \
+    auto __MDSPAN_PP_REMOVE_PARENS(SIGNATURE) \
+      -> _CUDA_VSTD::remove_cv_t<_CUDA_VSTD::remove_reference_t<decltype(BODY)>> \
+    { return __MDSPAN_PP_REMOVE_PARENS(BODY); }
+#  define __MDSPAN_DEDUCE_DECLTYPE_AUTO_RETURN_TYPE_SINGLE_LINE(SIGNATURE, BODY) \
+    auto __MDSPAN_PP_REMOVE_PARENS(SIGNATURE) \
+      -> decltype(BODY) \
+    { return __MDSPAN_PP_REMOVE_PARENS(BODY); }
+
+#endif
+
+// </editor-fold> end Return type deduction }}}1
+//==============================================================================
+
+//==============================================================================
+// <editor-fold desc="fold expressions"> {{{1
+
+struct __mdspan_enable_fold_comma { };
+
+#ifdef __MDSPAN_USE_FOLD_EXPRESSIONS
+#  define __MDSPAN_FOLD_AND(...) ((__VA_ARGS__) && ...)
+#  define __MDSPAN_FOLD_AND_TEMPLATE(...) ((__VA_ARGS__) && ...)
+#  define __MDSPAN_FOLD_OR(...) ((__VA_ARGS__) || ...)
+#  define __MDSPAN_FOLD_ASSIGN_LEFT(__INIT, ...) (__INIT = ... = (__VA_ARGS__))
+#  define __MDSPAN_FOLD_ASSIGN_RIGHT(__PACK, ...) (__PACK = ... = (__VA_ARGS__))
+#  define __MDSPAN_FOLD_TIMES_RIGHT(__PACK, ...) (__PACK * ... * (__VA_ARGS__))
+#  define __MDSPAN_FOLD_PLUS_RIGHT(__PACK, ...) (__PACK + ... + (__VA_ARGS__))
+#  define __MDSPAN_FOLD_COMMA(...) ((__VA_ARGS__), ...)
+#else
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+namespace __fold_compatibility_impl {
+
+// We could probably be more clever here, but at the (small) risk of losing some compiler understanding.  For the
+// few operations we need, it's not worth generalizing over the operation
+
+#if __MDSPAN_USE_RETURN_TYPE_DEDUCTION
+
+__MDSPAN_FORCE_INLINE_FUNCTION
+constexpr decltype(auto) __fold_right_and_impl() {
+  return true;
+}
+
+template <class _Arg, class... _Args>
+__MDSPAN_FORCE_INLINE_FUNCTION
+constexpr decltype(auto) __fold_right_and_impl(_Arg&& __arg, _Args&&... __args) {
+  return ((_Arg&&)__arg) && __fold_compatibility_impl::__fold_right_and_impl((_Args&&)__args...);
+}
+
+__MDSPAN_FORCE_INLINE_FUNCTION
+constexpr decltype(auto) __fold_right_or_impl() {
+  return false;
+}
+
+template <class _Arg, class... _Args>
+__MDSPAN_FORCE_INLINE_FUNCTION
+constexpr auto __fold_right_or_impl(_Arg&& __arg, _Args&&... __args) {
+  return ((_Arg&&)__arg) || __fold_compatibility_impl::__fold_right_or_impl((_Args&&)__args...);
+}
+
+template <class _Arg1>
+__MDSPAN_FORCE_INLINE_FUNCTION
+constexpr auto __fold_left_assign_impl(_Arg1&& __arg1) {
+  return (_Arg1&&)__arg1;
+}
+
+template <class _Arg1, class _Arg2, class... _Args>
+__MDSPAN_FORCE_INLINE_FUNCTION
+constexpr auto __fold_left_assign_impl(_Arg1&& __arg1, _Arg2&& __arg2, _Args&&... __args) {
+  return __fold_compatibility_impl::__fold_left_assign_impl((((_Arg1&&)__arg1) = ((_Arg2&&)__arg2)), (_Args&&)__args...);
+}
+
+template <class _Arg1>
+__MDSPAN_FORCE_INLINE_FUNCTION
+constexpr auto __fold_right_assign_impl(_Arg1&& __arg1) {
+  return (_Arg1&&)__arg1;
+}
+
+template <class _Arg1, class _Arg2, class... _Args>
+__MDSPAN_FORCE_INLINE_FUNCTION
+constexpr auto __fold_right_assign_impl(_Arg1&& __arg1, _Arg2&& __arg2,  _Args&&... __args) {
+  return ((_Arg1&&)__arg1) = __fold_compatibility_impl::__fold_right_assign_impl((_Arg2&&)__arg2, (_Args&&)__args...);
+}
+
+template <class _Arg1>
+__MDSPAN_FORCE_INLINE_FUNCTION
+constexpr auto __fold_right_plus_impl(_Arg1&& __arg1) {
+  return (_Arg1&&)__arg1;
+}
+
+template <class _Arg1, class _Arg2, class... _Args>
+__MDSPAN_FORCE_INLINE_FUNCTION
+constexpr auto __fold_right_plus_impl(_Arg1&& __arg1, _Arg2&& __arg2, _Args&&... __args) {
+  return ((_Arg1&&)__arg1) + __fold_compatibility_impl::__fold_right_plus_impl((_Arg2&&)__arg2, (_Args&&)__args...);
+}
+
+template <class _Arg1>
+__MDSPAN_FORCE_INLINE_FUNCTION
+constexpr auto __fold_right_times_impl(_Arg1&& __arg1) {
+  return (_Arg1&&)__arg1;
+}
+
+template <class _Arg1, class _Arg2, class... _Args>
+__MDSPAN_FORCE_INLINE_FUNCTION
+constexpr auto __fold_right_times_impl(_Arg1&& __arg1, _Arg2&& __arg2, _Args&&... __args) {
+  return ((_Arg1&&)__arg1) * __fold_compatibility_impl::__fold_right_times_impl((_Arg2&&)__arg2, (_Args&&)__args...);
+}
+
+#else
+
+//------------------------------------------------------------------------------
+// <editor-fold desc="right and"> {{{2
+
+template <class... _Args>
+struct __fold_right_and_impl_;
+template <>
+struct __fold_right_and_impl_<> {
+  using __rv = bool;
+  __MDSPAN_FORCE_INLINE_FUNCTION
+  static constexpr __rv
+  __impl() noexcept {
+    return true;
+  }
+};
+template <class _Arg, class... _Args>
+struct __fold_right_and_impl_<_Arg, _Args...> {
+  using __next_t = __fold_right_and_impl_<_Args...>;
+  using __rv = decltype(_CUDA_VSTD::declval<_Arg>() && _CUDA_VSTD::declval<typename __next_t::__rv>());
+  __MDSPAN_FORCE_INLINE_FUNCTION
+  static constexpr __rv
+  __impl(_Arg&& __arg, _Args&&... __args) noexcept {
+    return ((_Arg&&)__arg) && __next_t::__impl((_Args&&)__args...);
+  }
+};
+
+template <class... _Args>
+__MDSPAN_FORCE_INLINE_FUNCTION
+constexpr typename __fold_right_and_impl_<_Args...>::__rv
+__fold_right_and_impl(_Args&&... __args) {
+  return __fold_right_and_impl_<_Args...>::__impl((_Args&&)__args...);
+}
+
+// </editor-fold> end right and }}}2
+//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+// <editor-fold desc="right or"> {{{2
+
+template <class... _Args>
+struct __fold_right_or_impl_;
+template <>
+struct __fold_right_or_impl_<> {
+  using __rv = bool;
+  __MDSPAN_FORCE_INLINE_FUNCTION
+  static constexpr __rv
+  __impl() noexcept {
+    return false;
+  }
+};
+template <class _Arg, class... _Args>
+struct __fold_right_or_impl_<_Arg, _Args...> {
+  using __next_t = __fold_right_or_impl_<_Args...>;
+  using __rv = decltype(_CUDA_VSTD::declval<_Arg>() || _CUDA_VSTD::declval<typename __next_t::__rv>());
+  __MDSPAN_FORCE_INLINE_FUNCTION
+  static constexpr __rv
+  __impl(_Arg&& __arg, _Args&&... __args) noexcept {
+    return ((_Arg&&)__arg) || __next_t::__impl((_Args&&)__args...);
+  }
+};
+
+template <class... _Args>
+__MDSPAN_FORCE_INLINE_FUNCTION
+constexpr typename __fold_right_or_impl_<_Args...>::__rv
+__fold_right_or_impl(_Args&&... __args) {
+  return __fold_right_or_impl_<_Args...>::__impl((_Args&&)__args...);
+}
+
+// </editor-fold> end right or }}}2
+//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+// <editor-fold desc="right plus"> {{{2
+
+template <class... _Args>
+struct __fold_right_plus_impl_;
+template <class _Arg>
+struct __fold_right_plus_impl_<_Arg> {
+  using __rv = _Arg&&;
+  __MDSPAN_FORCE_INLINE_FUNCTION
+  static constexpr __rv
+  __impl(_Arg&& __arg) noexcept {
+    return (_Arg&&)__arg;
+  }
+};
+template <class _Arg1, class _Arg2, class... _Args>
+struct __fold_right_plus_impl_<_Arg1, _Arg2, _Args...> {
+  using __next_t = __fold_right_plus_impl_<_Arg2, _Args...>;
+  using __rv = decltype(_CUDA_VSTD::declval<_Arg1>() + _CUDA_VSTD::declval<typename __next_t::__rv>());
+  __MDSPAN_FORCE_INLINE_FUNCTION
+  static constexpr __rv
+  __impl(_Arg1&& __arg, _Arg2&& __arg2, _Args&&... __args) noexcept {
+    return ((_Arg1&&)__arg) + __next_t::__impl((_Arg2&&)__arg2, (_Args&&)__args...);
+  }
+};
+
+template <class... _Args>
+__MDSPAN_FORCE_INLINE_FUNCTION
+constexpr typename __fold_right_plus_impl_<_Args...>::__rv
+__fold_right_plus_impl(_Args&&... __args) {
+  return __fold_right_plus_impl_<_Args...>::__impl((_Args&&)__args...);
+}
+
+// </editor-fold> end right plus }}}2
+//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+// <editor-fold desc="right times"> {{{2
+
+template <class... _Args>
+struct __fold_right_times_impl_;
+template <class _Arg>
+struct __fold_right_times_impl_<_Arg> {
+  using __rv = _Arg&&;
+  __MDSPAN_FORCE_INLINE_FUNCTION
+  static constexpr __rv
+  __impl(_Arg&& __arg) noexcept {
+    return (_Arg&&)__arg;
+  }
+};
+template <class _Arg1, class _Arg2, class... _Args>
+struct __fold_right_times_impl_<_Arg1, _Arg2, _Args...> {
+  using __next_t = __fold_right_times_impl_<_Arg2, _Args...>;
+  using __rv = decltype(_CUDA_VSTD::declval<_Arg1>() * _CUDA_VSTD::declval<typename __next_t::__rv>());
+  __MDSPAN_FORCE_INLINE_FUNCTION
+  static constexpr __rv
+  __impl(_Arg1&& __arg, _Arg2&& __arg2, _Args&&... __args) noexcept {
+    return ((_Arg1&&)__arg) * __next_t::__impl((_Arg2&&)__arg2, (_Args&&)__args...);
+  }
+};
+
+template <class... _Args>
+__MDSPAN_FORCE_INLINE_FUNCTION
+constexpr typename __fold_right_times_impl_<_Args...>::__rv
+__fold_right_times_impl(_Args&&... __args) {
+  return __fold_right_times_impl_<_Args...>::__impl((_Args&&)__args...);
+}
+
+// </editor-fold> end right times }}}2
+//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+// <editor-fold desc="right assign"> {{{2
+
+template <class... _Args>
+struct __fold_right_assign_impl_;
+template <class _Arg>
+struct __fold_right_assign_impl_<_Arg> {
+  using __rv = _Arg&&;
+  __MDSPAN_FORCE_INLINE_FUNCTION
+  static constexpr __rv
+  __impl(_Arg&& __arg) noexcept {
+    return (_Arg&&)__arg;
+  }
+};
+template <class _Arg1, class _Arg2, class... _Args>
+struct __fold_right_assign_impl_<_Arg1, _Arg2, _Args...> {
+  using __next_t = __fold_right_assign_impl_<_Arg2, _Args...>;
+  using __rv = decltype(_CUDA_VSTD::declval<_Arg1>() = _CUDA_VSTD::declval<typename __next_t::__rv>());
+  __MDSPAN_FORCE_INLINE_FUNCTION
+  static constexpr __rv
+  __impl(_Arg1&& __arg, _Arg2&& __arg2, _Args&&... __args) noexcept {
+    return ((_Arg1&&)__arg) = __next_t::__impl((_Arg2&&)__arg2, (_Args&&)__args...);
+  }
+};
+
+template <class... _Args>
+__MDSPAN_FORCE_INLINE_FUNCTION
+constexpr typename __fold_right_assign_impl_<_Args...>::__rv
+__fold_right_assign_impl(_Args&&... __args) {
+  return __fold_right_assign_impl_<_Args...>::__impl((_Args&&)__args...);
+}
+
+// </editor-fold> end right assign }}}2
+//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+// <editor-fold desc="left assign"> {{{2
+
+template <class... _Args>
+struct __fold_left_assign_impl_;
+template <class _Arg>
+struct __fold_left_assign_impl_<_Arg> {
+  using __rv = _Arg&&;
+  __MDSPAN_FORCE_INLINE_FUNCTION
+  static constexpr __rv
+  __impl(_Arg&& __arg) noexcept {
+    return (_Arg&&)__arg;
+  }
+};
+template <class _Arg1, class _Arg2, class... _Args>
+struct __fold_left_assign_impl_<_Arg1, _Arg2, _Args...> {
+  using __assign_result_t = decltype(_CUDA_VSTD::declval<_Arg1>() = _CUDA_VSTD::declval<_Arg2>());
+  using __next_t = __fold_left_assign_impl_<__assign_result_t, _Args...>;
+  using __rv = typename __next_t::__rv;
+  __MDSPAN_FORCE_INLINE_FUNCTION
+  static constexpr __rv
+  __impl(_Arg1&& __arg, _Arg2&& __arg2, _Args&&... __args) noexcept {
+    return __next_t::__impl(((_Arg1&&)__arg) = (_Arg2&&)__arg2, (_Args&&)__args...);
+  }
+};
+
+template <class... _Args>
+__MDSPAN_FORCE_INLINE_FUNCTION
+constexpr typename __fold_left_assign_impl_<_Args...>::__rv
+__fold_left_assign_impl(_Args&&... __args) {
+  return __fold_left_assign_impl_<_Args...>::__impl((_Args&&)__args...);
+}
+
+// </editor-fold> end left assign }}}2
+//------------------------------------------------------------------------------
+
+#endif
+
+
+template <class... _Args>
+_LIBCUDACXX_HOST_DEVICE
+constexpr __mdspan_enable_fold_comma __fold_comma_impl(_Args&&...) noexcept { return { }; }
+
+template <bool... _Bs>
+struct __bools;
+
+} // __fold_compatibility_impl
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#  define __MDSPAN_FOLD_AND(...) _CUDA_VSTD::__fold_compatibility_impl::__fold_right_and_impl((__VA_ARGS__)...)
+#  define __MDSPAN_FOLD_OR(...) _CUDA_VSTD::__fold_compatibility_impl::__fold_right_or_impl((__VA_ARGS__)...)
+#  define __MDSPAN_FOLD_ASSIGN_LEFT(__INIT, ...) _CUDA_VSTD::__fold_compatibility_impl::__fold_left_assign_impl(__INIT, (__VA_ARGS__)...)
+#  define __MDSPAN_FOLD_ASSIGN_RIGHT(__PACK, ...) _CUDA_VSTD::__fold_compatibility_impl::__fold_right_assign_impl((__PACK)..., __VA_ARGS__)
+#  define __MDSPAN_FOLD_TIMES_RIGHT(__PACK, ...) _CUDA_VSTD::__fold_compatibility_impl::__fold_right_times_impl((__PACK)..., __VA_ARGS__)
+#  define __MDSPAN_FOLD_PLUS_RIGHT(__PACK, ...) _CUDA_VSTD::__fold_compatibility_impl::__fold_right_plus_impl((__PACK)..., __VA_ARGS__)
+#  define __MDSPAN_FOLD_COMMA(...) _CUDA_VSTD::__fold_compatibility_impl::__fold_comma_impl((__VA_ARGS__)...)
+
+#  define __MDSPAN_FOLD_AND_TEMPLATE(...) \
+  _LIBCUDACXX_TRAIT(_CUDA_VSTD::is_same, __fold_compatibility_impl::__bools<(__VA_ARGS__)..., true>, __fold_compatibility_impl::__bools<true, (__VA_ARGS__)...>)
+
+#endif
+
+// </editor-fold> end Variable template compatibility }}}1
+//==============================================================================
+
+//==============================================================================
+// <editor-fold desc="Pre-C++14 constexpr"> {{{1
+
+#if __MDSPAN_USE_CONSTEXPR_14
+// Workaround for a bug (I think?) in EDG frontends
+#  ifdef __EDG__
+#    define __MDSPAN_CONSTEXPR_14_DEFAULTED
+#  else
+#    define __MDSPAN_CONSTEXPR_14_DEFAULTED constexpr
+#  endif
+#else
+#  define __MDSPAN_CONSTEXPR_14_DEFAULTED
+#endif
+
+// </editor-fold> end Pre-C++14 constexpr }}}1
+//==============================================================================
+
+#endif // _LIBCUDACXX_STD_VER > 11
+
+#ifndef _LIBCUDACXX_NO_EXCEPTIONS
+#define _LIBCUDACXX_THROW_RUNTIME_ERROR(_COND, _MESSAGE) \
+  if (!(_COND)) __throw_runtime_error(_MESSAGE)
+#else
+#define _LIBCUDACXX_THROW_RUNTIME_ERROR(_COND, _MESSAGE) \
+  _LIBCUDACXX_ASSERT(_COND, _MESSAGE)
+#endif
+
+#endif // _LIBCUDACXX___MDSPAN_MACROS_HPP