Add files using upload-large-folder tool

cuda_toolkit/bin/ant

@@ -0,0 +1,336 @@
+#! /bin/sh
+
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Extract launch and ant arguments, (see details below).
+ant_exec_args=
+no_config=false
+use_jikes_default=false
+ant_exec_debug=false
+show_help=false
+for arg in "$@" ; do
+  if [ "$arg" = "--noconfig" ] ; then
+    no_config=true
+  elif [ "$arg" = "--usejikes" ] ; then
+    use_jikes_default=true
+  elif [ "$arg" = "--execdebug" ] ; then
+    ant_exec_debug=true
+  elif [ my"$arg" = my"--h"  -o my"$arg" = my"--help"  ] ; then
+    show_help=true
+    ant_exec_args="$ant_exec_args -h"
+  else
+    if [  my"$arg" = my"-h"  -o  my"$arg" = my"-help" ] ; then
+      show_help=true
+    fi
+    ant_exec_args="$ant_exec_args \"$arg\""
+  fi
+done
+
+# Source/default ant configuration
+if $no_config ; then
+  rpm_mode=false
+  usejikes=$use_jikes_default
+else
+  # load system-wide ant configuration (ONLY if ANT_HOME has NOT been set)
+  if [ -z "$ANT_HOME" -o "$ANT_HOME" = "/usr/share/ant" ]; then
+      if [ -f "/etc/ant.conf" ] ; then
+          . /etc/ant.conf
+      fi
+  fi
+
+  # load user ant configuration
+  if [ -f "$HOME/.ant/ant.conf" ] ; then
+    . $HOME/.ant/ant.conf
+  fi
+  if [ -f "$HOME/.antrc" ] ; then
+    . "$HOME/.antrc"
+  fi
+
+  # provide default configuration values
+  if [ -z "$rpm_mode" ] ; then
+    rpm_mode=false
+  fi
+  if [ -z "$usejikes" ] ; then
+    usejikes=$use_jikes_default
+  fi
+fi
+
+# Setup Java environment in rpm mode
+if $rpm_mode ; then
+  if [ -f /usr/share/java-utils/java-functions ] ; then
+    . /usr/share/java-utils/java-functions
+    set_jvm
+    set_javacmd
+  fi
+fi
+
+# OS specific support.  $var _must_ be set to either true or false.
+cygwin=false;
+darwin=false;
+mingw=false;
+case "`uname`" in
+  CYGWIN*) cygwin=true ;;
+  Darwin*) darwin=true
+           if [ -z "$JAVA_HOME" ] ; then
+               if [ -x '/usr/libexec/java_home' ] ; then
+                   JAVA_HOME=`/usr/libexec/java_home`
+               elif [ -d "/System/Library/Frameworks/JavaVM.framework/Versions/CurrentJDK/Home" ]; then
+                   JAVA_HOME=/System/Library/Frameworks/JavaVM.framework/Versions/CurrentJDK/Home
+               fi
+           fi
+           ;;
+  MINGW*) mingw=true ;;
+esac
+
+if [ -z "$ANT_HOME" -o ! -d "$ANT_HOME" ] ; then
+  ## resolve links - $0 may be a link to ant's home
+  PRG="$0"
+  progname=`basename "$0"`
+
+  # need this for relative symlinks
+  while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+    PRG="$link"
+    else
+    PRG=`dirname "$PRG"`"/$link"
+    fi
+  done
+
+  ANT_HOME=`dirname "$PRG"`/..
+
+  # make it fully qualified
+  ANT_HOME=`cd "$ANT_HOME" > /dev/null && pwd`
+fi
+
+# For Cygwin and Mingw, ensure paths are in UNIX format before
+# anything is touched
+if $cygwin ; then
+  [ -n "$ANT_HOME" ] &&
+    ANT_HOME=`cygpath --unix "$ANT_HOME"`
+  [ -n "$JAVA_HOME" ] &&
+    JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
+fi
+if $mingw ; then
+  [ -n "$ANT_HOME" ] &&
+    ANT_HOME="`(cd "$ANT_HOME"; pwd)`"
+  [ -n "$JAVA_HOME" ] &&
+    JAVA_HOME="`(cd "$JAVA_HOME"; pwd)`"
+fi
+
+# set ANT_LIB location
+ANT_LIB="${ANT_HOME}/lib"
+
+if [ -z "$JAVACMD" ] ; then
+  if [ -n "$JAVA_HOME"  ] ; then
+    # IBM's JDK on AIX uses strange locations for the executables
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+      JAVACMD="$JAVA_HOME/jre/sh/java"
+    elif [ -x "$JAVA_HOME/jre/bin/java" ] ; then
+      JAVACMD="$JAVA_HOME/jre/bin/java"
+    else
+      JAVACMD="$JAVA_HOME/bin/java"
+    fi
+  else
+    JAVACMD=`which java 2> /dev/null `
+    if [ -z "$JAVACMD" ] ; then
+        JAVACMD=java
+    fi
+  fi
+fi
+
+if [ ! -x "$JAVACMD" ] ; then
+  echo "Error: JAVA_HOME is not defined correctly."
+  echo "  We cannot execute $JAVACMD"
+  exit 1
+fi
+
+# Build local classpath using just the launcher in non-rpm mode or
+# use the Jpackage helper in rpm mode with basic and default jars
+# specified in the ant.conf configuration. Because the launcher is
+# used, libraries linked in ANT_HOME/lib will also be included, but this
+# is discouraged as it is not java-version safe. A user should
+# request optional jars and their dependencies via the OPT_JAR_LIST
+# variable
+if $rpm_mode && [ -x /usr/bin/build-classpath ] ; then
+  LOCALCLASSPATH="$(/usr/bin/build-classpath ant ant-launcher jaxp_parser_impl xml-commons-apis)"
+
+  # If no optional jars have been specified then build the default list
+  if [ -z "$OPT_JAR_LIST" ] ; then
+    for file in /etc/ant.d/*; do
+      if [ -f "$file" ]; then
+        case "$file" in
+        *~) ;;
+        *#*) ;;
+        *.rpmsave) ;;
+        *.rpmnew) ;;
+        *)
+          for dep in `cat "$file"`; do
+            OPT_JAR_LIST="$OPT_JAR_LIST${OPT_JAR_LIST:+ }$dep"
+          done
+        esac
+      fi
+    done
+  fi
+
+  # If the user requested to try to add some other jars to the classpath
+  if [ -n "$OPT_JAR_LIST" ] ; then
+    _OPTCLASSPATH="$(/usr/bin/build-classpath $OPT_JAR_LIST 2> /dev/null)"
+    if [ -n "$_OPTCLASSPATH" ] ; then 
+      LOCALCLASSPATH="$LOCALCLASSPATH:$_OPTCLASSPATH"
+    fi
+  fi
+
+  # Explicitly add javac path to classpath, assume JAVA_HOME set
+  # properly in rpm mode
+  if [ -f "$JAVA_HOME/lib/tools.jar" ] ; then
+    LOCALCLASSPATH="$LOCALCLASSPATH:$JAVA_HOME/lib/tools.jar"
+  fi
+  if [ -f "$JAVA_HOME/lib/classes.zip" ] ; then
+    LOCALCLASSPATH="$LOCALCLASSPATH:$JAVA_HOME/lib/classes.zip"
+  fi
+
+  # if CLASSPATH_OVERRIDE env var is set, LOCALCLASSPATH will be
+  # user CLASSPATH first and ant-found jars after.
+  # In that case, the user CLASSPATH will override ant-found jars
+  #
+  # if CLASSPATH_OVERRIDE is not set, we'll have the normal behaviour
+  # with ant-found jars first and user CLASSPATH after
+  if [ -n "$CLASSPATH" ] ; then
+    # merge local and specified classpath 
+    if [ -z "$LOCALCLASSPATH" ] ; then 
+      LOCALCLASSPATH="$CLASSPATH"
+    elif [ -n "$CLASSPATH_OVERRIDE" ] ; then
+      LOCALCLASSPATH="$CLASSPATH:$LOCALCLASSPATH"
+    else
+      LOCALCLASSPATH="$LOCALCLASSPATH:$CLASSPATH"
+    fi
+
+    # remove class path from launcher -cp option
+    CLASSPATH=""
+  fi
+else
+  # not using rpm_mode; use launcher to determine classpaths
+  if [ -z "$LOCALCLASSPATH" ] ; then
+      LOCALCLASSPATH=$ANT_LIB/ant-launcher.jar
+  else
+      LOCALCLASSPATH=$ANT_LIB/ant-launcher.jar:$LOCALCLASSPATH
+  fi
+fi
+
+if [ -n "$JAVA_HOME" ] ; then
+  # OSX hack to make Ant work with jikes
+  if $darwin ; then
+    OSXHACK="${JAVA_HOME}/../Classes"
+    if [ -d "${OSXHACK}" ] ; then
+      for i in "${OSXHACK}"/*.jar
+      do
+        JIKESPATH="$JIKESPATH:$i"
+      done
+    fi
+  fi
+fi
+
+# Allow Jikes support (off by default)
+if $usejikes; then
+  ANT_OPTS="$ANT_OPTS -Dbuild.compiler=jikes"
+fi
+
+# For Cygwin, switch paths to appropriate format before running java
+# For PATHs convert to unix format first, then to windows format to ensure
+# both formats are supported. Probably this will fail on directories with ;
+# in the name in the path. Let's assume that paths containing ; are more
+# rare than windows style paths on cygwin.
+if $cygwin; then
+  if [ "$OS" = "Windows_NT" ] && cygpath -m .>/dev/null 2>/dev/null ; then
+    format=mixed
+  else
+    format=windows
+  fi
+  [ -n "$ANT_HOME" ] && ANT_HOME=`cygpath --$format "$ANT_HOME"`
+  ANT_LIB=`cygpath --$format "$ANT_LIB"`
+  [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --$format "$JAVA_HOME"`
+  LCP_TEMP=`cygpath --path --unix "$LOCALCLASSPATH"`
+  LOCALCLASSPATH=`cygpath --path --$format "$LCP_TEMP"`
+  if [ -n "$CLASSPATH" ] ; then
+    CP_TEMP=`cygpath --path --unix "$CLASSPATH"`
+    CLASSPATH=`cygpath --path --$format "$CP_TEMP"`
+  fi
+  CYGHOME=`cygpath --$format "$HOME"`
+fi
+
+# Show script help if requested
+if $show_help ; then
+  echo $0 '[script options] [options] [target [target2 [target3] ..]]'
+  echo 'Script Options:'
+  echo '  --help, --h            print this message and ant help'
+  echo '  --noconfig             suppress sourcing of /etc/ant.conf,'
+  echo '                         $HOME/.ant/ant.conf, and $HOME/.antrc'
+  echo '                         configuration files'
+  echo '  --usejikes             enable use of jikes by default, unless'
+  echo '                         set explicitly in configuration files'
+  echo '  --execdebug            print ant exec line generated by this'
+  echo '                         launch script'
+  echo '  '
+fi
+# add a second backslash to variables terminated by a backslash under cygwin
+if $cygwin; then
+  case "$ANT_HOME" in
+    *\\ )
+    ANT_HOME="$ANT_HOME\\"
+    ;;
+  esac
+  case "$CYGHOME" in
+    *\\ )
+    CYGHOME="$CYGHOME\\"
+    ;;
+  esac
+  case "$JIKESPATH" in
+    *\\ )
+    JIKESPATH="$JIKESPATH\\"
+    ;;
+  esac
+  case "$LOCALCLASSPATH" in
+    *\\ )
+    LOCALCLASSPATH="$LOCALCLASSPATH\\"
+    ;;
+  esac
+  case "$CLASSPATH" in
+    *\\ )
+    CLASSPATH="$CLASSPATH\\"
+    ;;
+  esac
+fi
+# Execute ant using eval/exec to preserve spaces in paths,
+# java options, and ant args
+ant_sys_opts=
+if [ -n "$CYGHOME" ]; then
+  if [ -n "$JIKESPATH" ]; then
+    ant_sys_opts="-Djikes.class.path=\"$JIKESPATH\" -Dcygwin.user.home=\"$CYGHOME\""
+  else
+    ant_sys_opts="-Dcygwin.user.home=\"$CYGHOME\""
+  fi
+else
+  if [ -n "$JIKESPATH" ]; then
+    ant_sys_opts="-Djikes.class.path=\"$JIKESPATH\""
+  fi
+fi
+ant_exec_command="exec \"$JAVACMD\" $ANT_OPTS -classpath \"$LOCALCLASSPATH\" -Dant.home=\"$ANT_HOME\" -Dant.library.dir=\"$ANT_LIB\" $ant_sys_opts org.apache.tools.ant.launch.Launcher $ANT_ARGS -cp \"$CLASSPATH\""
+if $ant_exec_debug ; then
+    echo $ant_exec_command $ant_exec_args
+fi
+eval $ant_exec_command "$ant_exec_args"

cuda_toolkit/bin/ant.bat

@@ -0,0 +1,218 @@
+@echo off
+
+REM  Licensed to the Apache Software Foundation (ASF) under one or more
+REM  contributor license agreements.  See the NOTICE file distributed with
+REM  this work for additional information regarding copyright ownership.
+REM  The ASF licenses this file to You under the Apache License, Version 2.0
+REM  (the "License"); you may not use this file except in compliance with
+REM  the License.  You may obtain a copy of the License at
+REM 
+REM      http://www.apache.org/licenses/LICENSE-2.0
+REM 
+REM  Unless required by applicable law or agreed to in writing, software
+REM  distributed under the License is distributed on an "AS IS" BASIS,
+REM  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+REM  See the License for the specific language governing permissions and
+REM  limitations under the License.
+
+REM This is an inordinately troublesome piece of code, particularly because it
+REM tries to work on both Win9x and WinNT-based systems. If we could abandon '9x
+REM support, things would be much easier, but sadly, it is not yet time.
+REM Be cautious about editing this, and only add WinNT specific stuff in code that
+REM only runs on WinNT.
+
+if "%HOME%"=="" goto homeDrivePathPre
+if exist "%HOME%\antrc_pre.bat" call "%HOME%\antrc_pre.bat"
+
+:homeDrivePathPre
+if "%HOMEDRIVE%%HOMEPATH%"=="" goto userProfilePre
+if "%HOMEDRIVE%%HOMEPATH%"=="%HOME%" goto userProfilePre
+if exist "%HOMEDRIVE%%HOMEPATH%\antrc_pre.bat" call "%HOMEDRIVE%%HOMEPATH%\antrc_pre.bat"
+
+:userProfilePre
+if "%USERPROFILE%"=="" goto alpha
+if "%USERPROFILE%"=="%HOME%" goto alpha
+if "%USERPROFILE%"=="%HOMEDRIVE%%HOMEPATH%" goto alpha
+if exist "%USERPROFILE%\antrc_pre.bat" call "%USERPROFILE%\antrc_pre.bat"
+
+:alpha
+
+if "%OS%"=="Windows_NT" @setlocal
+if "%OS%"=="WINNT" @setlocal
+
+if "%ANT_HOME%"=="" goto setDefaultAntHome
+
+:stripAntHome
+if not _%ANT_HOME:~-1%==_\ goto checkClasspath
+set ANT_HOME=%ANT_HOME:~0,-1%
+goto stripAntHome
+
+:setDefaultAntHome
+rem %~dp0 is expanded pathname of the current script under NT
+set ANT_HOME=%~dp0..
+
+:checkClasspath
+set _USE_CLASSPATH=yes
+rem CLASSPATH must not be used if it is equal to ""
+if "%CLASSPATH%"=="""" set _USE_CLASSPATH=no
+if "%CLASSPATH%"=="" set _USE_CLASSPATH=no
+
+rem Slurp the command line arguments. This loop allows for an unlimited number
+rem of arguments (up to the command line limit, anyway).
+set ANT_CMD_LINE_ARGS=
+:setupArgs
+if ""%1""=="""" goto doneStart
+if ""%1""==""-noclasspath"" goto clearclasspath
+set ANT_CMD_LINE_ARGS=%ANT_CMD_LINE_ARGS% %1
+shift
+goto setupArgs
+
+rem here is there is a -noclasspath in the options
+:clearclasspath
+set _USE_CLASSPATH=no
+shift
+goto setupArgs
+
+rem This label provides a place for the argument list loop to break out
+rem and for NT handling to skip to.
+
+:doneStart
+
+if "%_USE_CLASSPATH%"=="no" goto findAntHome
+
+:stripClasspath
+if not _%CLASSPATH:~-1%==_\ goto findAntHome
+set CLASSPATH=%CLASSPATH:~0,-1%
+goto stripClasspath
+
+:findAntHome
+rem find ANT_HOME if it does not exist due to either an invalid value passed
+rem by the user or the %0 problem on Windows 9x
+if exist "%ANT_HOME%\lib\ant.jar" goto checkJava
+
+rem check for ant in Program Files
+if not exist "%ProgramFiles%\ant" goto checkSystemDrive
+set ANT_HOME=%ProgramFiles%\ant
+goto checkJava
+
+:checkSystemDrive
+rem check for ant in root directory of system drive
+if not exist %SystemDrive%\ant\lib\ant.jar goto checkCDrive
+set ANT_HOME=%SystemDrive%\ant
+goto checkJava
+
+:checkCDrive
+rem check for ant in C:\ant for Win9X users
+if not exist C:\ant\lib\ant.jar goto noAntHome
+set ANT_HOME=C:\ant
+goto checkJava
+
+:noAntHome
+echo ANT_HOME is set incorrectly or ant could not be located. Please set ANT_HOME.
+goto end
+
+:checkJava
+set _JAVACMD=%JAVACMD%
+
+if "%JAVA_HOME%" == "" goto noJavaHome
+if not exist "%JAVA_HOME%\bin\java.exe" goto noJavaHome
+if "%_JAVACMD%" == "" set _JAVACMD=%JAVA_HOME%\bin\java.exe
+goto checkJikes
+
+:noJavaHome
+if "%_JAVACMD%" == "" set _JAVACMD=java.exe
+
+:checkJikes
+if not "%JIKESPATH%"=="" goto runAntWithJikes
+
+:runAnt
+if "%_USE_CLASSPATH%"=="no" goto runAntNoClasspath
+:runAntWithClasspath
+"%_JAVACMD%" %ANT_OPTS% -classpath "%ANT_HOME%\lib\ant-launcher.jar" "-Dant.home=%ANT_HOME%" org.apache.tools.ant.launch.Launcher %ANT_ARGS% -cp "%CLASSPATH%" %ANT_CMD_LINE_ARGS%
+rem Check the error code of the Ant build
+if not "%OS%"=="Windows_NT" goto onError
+set ANT_ERROR=%ERRORLEVEL%
+goto end
+
+:runAntNoClasspath
+"%_JAVACMD%" %ANT_OPTS% -classpath "%ANT_HOME%\lib\ant-launcher.jar" "-Dant.home=%ANT_HOME%" org.apache.tools.ant.launch.Launcher %ANT_ARGS% %ANT_CMD_LINE_ARGS%
+rem Check the error code of the Ant build
+if not "%OS%"=="Windows_NT" goto onError
+set ANT_ERROR=%ERRORLEVEL%
+goto end
+
+:runAntWithJikes
+
+if not _%JIKESPATH:~-1%==_\ goto checkJikesAndClasspath
+set JIKESPATH=%JIKESPATH:~0,-1%
+goto runAntWithJikes
+
+:checkJikesAndClasspath
+
+if "%_USE_CLASSPATH%"=="no" goto runAntWithJikesNoClasspath
+
+:runAntWithJikesAndClasspath
+"%_JAVACMD%" %ANT_OPTS% -classpath "%ANT_HOME%\lib\ant-launcher.jar" "-Dant.home=%ANT_HOME%" "-Djikes.class.path=%JIKESPATH%" org.apache.tools.ant.launch.Launcher %ANT_ARGS%  -cp "%CLASSPATH%" %ANT_CMD_LINE_ARGS%
+rem Check the error code of the Ant build
+if not "%OS%"=="Windows_NT" goto onError
+set ANT_ERROR=%ERRORLEVEL%
+goto end
+
+:runAntWithJikesNoClasspath
+"%_JAVACMD%" %ANT_OPTS% -classpath "%ANT_HOME%\lib\ant-launcher.jar" "-Dant.home=%ANT_HOME%" "-Djikes.class.path=%JIKESPATH%" org.apache.tools.ant.launch.Launcher %ANT_ARGS% %ANT_CMD_LINE_ARGS%
+rem Check the error code of the Ant build
+if not "%OS%"=="Windows_NT" goto onError
+set ANT_ERROR=%ERRORLEVEL%
+goto end
+
+:onError
+rem Windows 9x way of checking the error code.  It matches via brute force.
+for %%i in (1 10 100) do set err%%i=
+for %%i in (0 1 2) do if errorlevel %%i00 set err100=%%i
+if %err100%==2 goto onError200
+if %err100%==0 set err100=
+for %%i in (0 1 2 3 4 5 6 7 8 9) do if errorlevel %err100%%%i0 set err10=%%i
+if "%err100%"=="" if %err10%==0 set err10=
+:onError1
+for %%i in (0 1 2 3 4 5 6 7 8 9) do if errorlevel %err100%%err10%%%i set err1=%%i
+goto onErrorEnd
+:onError200
+for %%i in (0 1 2 3 4 5) do if errorlevel 2%%i0 set err10=%%i
+if err10==5 for %%i in (0 1 2 3 4 5) do if errorlevel 25%%i set err1=%%i
+if not err10==5 goto onError1
+:onErrorEnd
+set ANT_ERROR=%err100%%err10%%err1%
+for %%i in (1 10 100) do set err%%i=
+
+:end
+rem bug ID 32069: resetting an undefined env variable changes the errorlevel.
+if not "%_JAVACMD%"=="" set _JAVACMD=
+if not "%_ANT_CMD_LINE_ARGS%"=="" set ANT_CMD_LINE_ARGS=
+
+if "%ANT_ERROR%"=="0" goto mainEnd
+
+goto omega
+
+:mainEnd
+
+rem If there were no errors, we run the post script.
+if "%OS%"=="Windows_NT" @endlocal
+if "%OS%"=="WINNT" @endlocal
+
+if "%HOME%"=="" goto homeDrivePathPost
+if exist "%HOME%\antrc_post.bat" call "%HOME%\antrc_post.bat"
+
+:homeDrivePathPost
+if "%HOMEDRIVE%%HOMEPATH%"=="" goto userProfilePost
+if "%HOMEDRIVE%%HOMEPATH%"=="%HOME%" goto userProfilePost
+if exist "%HOMEDRIVE%%HOMEPATH%\antrc_post.bat" call "%HOMEDRIVE%%HOMEPATH%\antrc_post.bat"
+
+:userProfilePost
+if "%USERPROFILE%"=="" goto omega
+if "%USERPROFILE%"=="%HOME%" goto omega
+if "%USERPROFILE%"=="%HOMEDRIVE%%HOMEPATH%" goto omega
+if exist "%USERPROFILE%\antrc_post.bat" call "%USERPROFILE%\antrc_post.bat"
+
+:omega
+
+exit /b %ANT_ERROR%

cuda_toolkit/bin/ant.cmd

@@ -0,0 +1,93 @@
+/* 
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+ 
+    Run ant
+*/
+
+'@echo off'
+parse arg mode envarg '::' antarg
+
+if mode\='.' & mode\='..' & mode\='/' then do
+  envarg = mode envarg
+  mode = ''
+end
+
+if antarg = '' then do
+  antarg = envarg
+  envarg = ''
+end
+
+x = setlocal()
+
+env="OS2ENVIRONMENT"
+antenv = _getenv_('antenv')
+if _testenv_() = 0 then interpret 'call "' || antenv || '"' '"' || envarg || '"'
+
+if mode = '' then mode = _getenv_('ANT_MODE' '..')
+if mode \= '/' then do
+  runrc = _getenv_('runrc')
+  antrc = _getenv_('antrc' 'antrc.cmd')
+  if mode = '..' then mode = '-r'
+  else mode = ''
+  interpret 'call "' || runrc || '"' antrc '"' || mode || '"'
+end
+
+if _testenv_() = 0 then do
+  say 'Ant environment is not set properly'
+  x = endlocal()
+  exit 16
+end
+
+settings = '-Dant.home=' || ANT_HOME '-Djava.home=' || JAVA_HOME
+
+java = _getenv_('javacmd' 'java')
+opts = value('ANT_OPTS',,env)
+args = value('ANT_ARGS',,env)
+lcp = value('LOCALCLASSPATH',,env)
+cp = value('CLASSPATH',,env)
+if value('ANT_USE_CP',,env) \= '' then do
+  if lcp \= '' & right(lcp, 1) \= ';' then lcp = lcp || ';'
+  lcp = lcp || cp
+  'SET CLASSPATH='
+end
+if lcp\='' then lcp = '-classpath' lcp
+
+cmd = java opts lcp '-jar' ANT_HOME ||'\lib\ant-launcher.jar' settings args antarg
+launcher = stream(ANT_HOME ||'\lib\ant-launcher.jar', 'C', 'query exists')
+if launcher = '' then entry = 'org.apache.tools.ant.Main'
+else entry = 'org.apache.tools.ant.launch.Launcher'
+java opts lcp entry settings args antarg
+
+x = endlocal()
+
+return rc
+
+_testenv_: procedure expose env ANT_HOME JAVA_HOME
+ANT_HOME = value('ANT_HOME',,env)
+if ANT_HOME = '' then return 0
+JAVA_HOME = value('JAVA_HOME',,env)
+if JAVA_HOME = '' then return 0
+cp = translate(value('CLASSPATH',,env))
+if pos(translate(ANT_HOME), cp) = 0 then return 0
+if pos(translate(JAVA_HOME), cp) = 0 then return 0
+return 1
+
+_getenv_: procedure expose env
+parse arg envar default
+if default = '' then default = envar
+var = value(translate(envar),,env)
+if var = '' then var = default
+return var

cuda_toolkit/bin/antRun

@@ -0,0 +1,24 @@
+#! /bin/sh
+
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Args: DIR command
+cd "$1"
+CMD="$2"
+shift
+shift
+
+exec "$CMD" "$@"

cuda_toolkit/bin/antRun.bat

@@ -0,0 +1,50 @@
+@echo off
+
+REM  Licensed to the Apache Software Foundation (ASF) under one or more
+REM  contributor license agreements.  See the NOTICE file distributed with
+REM  this work for additional information regarding copyright ownership.
+REM  The ASF licenses this file to You under the Apache License, Version 2.0
+REM  (the "License"); you may not use this file except in compliance with
+REM  the License.  You may obtain a copy of the License at
+REM 
+REM      http://www.apache.org/licenses/LICENSE-2.0
+REM 
+REM  Unless required by applicable law or agreed to in writing, software
+REM  distributed under the License is distributed on an "AS IS" BASIS,
+REM  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+REM  See the License for the specific language governing permissions and
+REM  limitations under the License.
+
+if "%OS%"=="Windows_NT" @setlocal
+if "%OS%"=="WINNT" @setlocal
+
+if ""%1""=="""" goto runCommand
+
+rem Change drive and directory to %1
+if "%OS%"=="Windows_NT" goto nt_cd
+if "%OS%"=="WINNT" goto nt_cd
+cd ""%1""
+goto end_cd
+:nt_cd
+cd /d ""%1""
+:end_cd
+shift
+
+rem Slurp the command line arguments. This loop allows for an unlimited number
+rem of arguments (up to the command line limit, anyway).
+set ANT_RUN_CMD=%1
+if ""%1""=="""" goto runCommand
+shift
+:loop
+if ""%1""=="""" goto runCommand
+set ANT_RUN_CMD=%ANT_RUN_CMD% %1
+shift
+goto loop
+
+:runCommand
+rem echo %ANT_RUN_CMD%
+%ANT_RUN_CMD%
+
+if "%OS%"=="Windows_NT" @endlocal
+if "%OS%"=="WINNT" @endlocal
+

cuda_toolkit/bin/antRun.pl

@@ -0,0 +1,66 @@
+#!/usr/bin/perl
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+#  contributor license agreements.  See the NOTICE file distributed with
+#  this work for additional information regarding copyright ownership.
+#  The ASF licenses this file to You under the Apache License, Version 2.0
+#  (the "License"); you may not use this file except in compliance with
+#  the License.  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+#######################################################################
+#
+# antRun.pl
+#
+# wrapper script for invoking commands on a platform with Perl installed
+# this is akin to antRun.bat, and antRun the SH script 
+#
+# created:         2001-10-18
+# author:          Jeff Tulley jtulley@novell.com 
+#######################################################################
+#be fussy about variables
+use strict;
+
+#turn warnings on during dev; generates a few spurious uninitialised var access warnings
+#use warnings;
+
+#and set $debug to 1 to turn on trace info (currently unused)
+my $debug=1;
+
+#######################################################################
+# change drive and directory to "%1"
+my $ANT_RUN_CMD = @ARGV[0];
+
+# assign current run command to "%2"
+chdir (@ARGV[0]) || die "Can't cd to $ARGV[0]: $!\n";
+if ($^O eq "NetWare") {
+    # There is a bug in Perl 5 on NetWare, where chdir does not
+    # do anything.  On NetWare, the following path-prefixed form should 
+    # always work. (afaict)
+    $ANT_RUN_CMD .= "/".@ARGV[1];
+}
+else {
+    $ANT_RUN_CMD = @ARGV[1];
+}
+
+# dispose of the first two arguments, leaving only the command's args.
+shift;
+shift;
+
+# run the command
+my $returnValue = system $ANT_RUN_CMD, @ARGV;
+if ($returnValue eq 0) {
+    exit 0;
+}
+else {
+    # only 0 and 1 are widely recognized as exit values
+    # so change the exit value to 1
+    exit 1;
+}

cuda_toolkit/bin/antenv.cmd

@@ -0,0 +1,98 @@
+/* 
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+'@echo off'
+call RxFuncAdd "SysLoadFuncs", "RexxUtil", "SysLoadFuncs"
+call SysLoadFuncs
+
+/* Prepare the parameters for later use */
+parse arg argv
+mode = ''
+args = ''
+opts = ''
+cp = ''
+lcp = ''
+
+do i = 1 to words(argv)
+  param = word(argv, i)
+  select
+    when param='-lcp' then mode = 'l'
+    when param='-cp' | param='-classpath' then mode = 'c'
+    when abbrev('-opts', param, 4) then mode = 'o'
+    when abbrev('-args', param, 4) then mode = 'a'
+  otherwise
+    select
+      when mode = 'a' then args = space(args param, 1)
+      when mode = 'c' then cp = space(cp param, 1)
+      when mode = 'l' then lcp = space(lcp param, 1)
+      when mode = 'o' then opts = space(opts param, 1)
+    otherwise
+      say 'Option' param 'ignored'
+    end
+  end
+end
+
+env="OS2ENVIRONMENT"
+antconf = _getenv_('antconf' 'antconf.cmd')
+runrc = _getenv_('runrc')
+interpret 'call "' || runrc || '"' '"' || antconf || '"' 'ETC'
+ANT_HOME = value('ANT_HOME',,env)
+JAVA_HOME = value('JAVA_HOME',,env)
+classpath = value('CLASSPATH',,env)
+classes = stream(JAVA_HOME || "\lib\classes.zip", "C", "QUERY EXISTS")
+if classes \= '' then classpath = prepend(classpath classes)
+classes = stream(JAVA_HOME || "\lib\tools.jar", "C", "QUERY EXISTS")
+if classes \= '' then classpath = prepend(classpath classes)
+
+classpath = prepend(classpath ANT_HOME || '\lib\ant-launcher.jar')
+'SET CLASSPATH=' || classpath
+
+/* Setting classpathes, options and arguments */
+envset = _getenv_('envset')
+if cp\=''   then interpret 'call "' || envset || '"' '"; CLASSPATH"' '"' || cp || '"'
+if lcp\=''  then interpret 'call "' || envset || '"' '"; LOCALCLASSPATH"' '"' || lcp || '"'
+if opts\='' then interpret 'call "' || envset || '"' '"-D ANT_OPTS"' '"' || opts || '"'
+if args\='' then interpret 'call "' || envset || '"' '"ANT_ARGS"' '"' || args || '"'
+
+exit 0
+
+addpath: procedure
+parse arg path elem
+if elem = '' then do
+  if path\='' & right(path, 1)\=';' then path = path || ';'
+  return path
+end
+if substr(path, length(path)) = ';' then glue = ''
+else glue = ';'
+if pos(translate(elem), translate(path)) = 0 then path = path || glue || elem || ';'
+return path
+
+prepend: procedure
+parse arg path elem
+if elem = '' then do
+  if path\='' & right(path, 1)\=';' then path = path || ';'
+  return path
+end
+if pos(translate(elem), translate(path)) = 0 then path = elem || ';' || path
+return path
+
+_getenv_: procedure expose env
+parse arg envar default
+if default = '' then default = envar
+var = value(translate(envar),,env)
+if var = '' then var = default
+return var

cuda_toolkit/bin/complete-ant-cmd.pl

@@ -0,0 +1,114 @@
+#!/usr/bin/perl
+#
+#  Licensed to the Apache Software Foundation (ASF) under one or more
+#  contributor license agreements.  See the NOTICE file distributed with
+#  this work for additional information regarding copyright ownership.
+#  The ASF licenses this file to You under the Apache License, Version 2.0
+#  (the "License"); you may not use this file except in compliance with
+#  the License.  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+# A script to allow Bash or Z-Shell to complete an Ant command-line.  
+#
+# To install for Bash 2.0 or better, add the following to ~/.bashrc:
+# 
+#     complete -C complete-ant-cmd.pl ant build.sh
+#
+# To install for Z-Shell 2.5 or better, add the following to ~/.zshrc:
+#
+#     function ant_complete () {
+#         local args_line args
+#         read -l args_line
+#         set -A args $args_line
+#         set -A reply $(COMP_LINE=$args_line complete-ant-cmd.pl ${args[1]} $1)
+#     }
+#     compctl -K ant_complete ant build.sh
+#     
+# @author Mike Williams <mikew@cortexebusiness.com.au>
+
+my $cmdLine = $ENV{'COMP_LINE'};
+my $antCmd = $ARGV[0];
+my $word = $ARGV[1];
+
+my @completions;
+if ($word =~ /^-/) {
+    list( restrict( $word, getArguments() ));
+} elsif ($cmdLine =~ /-(f|buildfile)\s+\S*$/) {
+    list( getBuildFiles($word) );
+} else {
+    list( restrict( $word, getTargets() ));
+}
+
+exit(0);
+
+sub list {
+    for (@_) {
+        print "$_\n";
+    }
+}
+
+sub restrict {
+    my ($word, @completions) = @_;
+    grep( /^\Q$word\E/, @completions );
+}
+
+sub getArguments {
+    qw(-buildfile -debug -emacs -f -find -help -listener -logfile 
+       -logger -projecthelp -quiet -verbose -version); 
+}
+
+
+sub getBuildFiles {
+    my ($word) = @_;
+    grep( /\.xml$/, glob( "$word*" ));
+}
+
+sub getTargets {
+
+    # Look for build-file
+    my $buildFile = 'build.xml';
+    if ($cmdLine =~ /-(f|buildfile)\s+(\S+)/) {
+        $buildFile = $2;
+    }
+    return () unless (-f $buildFile);
+
+    # Run "ant -projecthelp" to list targets.  Keep a cache of results in a
+    # cache-file.
+    my $cacheFile = $buildFile;
+    $cacheFile =~ s|(.*/)?(.*)|${1}.ant-targets-${2}|;
+    if ((!-e $cacheFile) || (-z $cacheFile) || (-M $buildFile) < (-M $cacheFile)) {
+        open( CACHE, '>'.$cacheFile ) || die "can\'t write $cacheFile: $!\n";
+        open( HELP, "$antCmd -projecthelp -f '$buildFile'|" ) || return(); 
+        my %targets;
+        while( <HELP> ) {
+            if (/^\s+(\S+)/) {
+                $targets{$1}++;
+            }
+        }
+        my @targets = sort keys %targets;
+        for (@targets) { print CACHE "$_\n"; }
+        return @targets;
+    }
+    
+    # Read the target-cache
+    open( CACHE, $cacheFile ) || die "can\'t read $cacheFile: $!\n";
+    my @targets;
+    while (<CACHE>) {
+        chop;
+        s/\r$//;  # for Cygwin
+        push( @targets, $_ );
+    }
+    close( CACHE );
+    @targets;
+
+}
+
+
+

cuda_toolkit/bin/compute-sanitizer.bat

@@ -0,0 +1,2 @@
+@echo off
+"%~dp0\..\compute-sanitizer\compute-sanitizer.exe" %*

cuda_toolkit/bin/envset.cmd

@@ -0,0 +1,131 @@
+/*
+
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+SET environment variables
+First optional parameter:
+   ;     parameters are considered parts of a path variable, semicolons are
+         appended to each element if not already present
+   -D    parameters are properties for Java or Makefile etc., -D will be
+         prepended and the parameters will be separated by a space
+   =D    the same as above but equal sign is not required
+   ,     parameters should be comma separated in the environment variable
+   -     parameters should be separated by the next parameter
+   Other values mean that the first parameter is missing and the environment
+   variable will be set to the space separated parameters
+
+Second parameter: name of the environment variable
+
+Next parameters: values
+; implies that the equal sign is considered a part of the parameter and is
+not interpreted
+
+-D requires parameters in the form name=value. If the equal sign is not found,
+the parameters are changed to name=expanded_name
+
+Other options have optional equal sign. If it is found, only the part after
+the equal sign will be oprionally expanded.
+
+If the parameter is the minus sign, the next parameter will not be expanded.
+If the parameter is a single dot, it will be replaced with the value of the
+environment variable as it existed before envset was invoked.
+
+For other parameters the batch looks for the environment variable with the
+same name (in uppercase). If it is found, it forms the expanded_name. If
+the environment variable with such a name does not exist, the expanded_name
+will hold the parameter name without case conversion.
+*/
+
+parse arg mode envar args
+
+equal = 0
+sep = ' '
+
+/* Parse command line parameters */
+select
+  when mode='-' then do
+    sep = envar
+    parse var args envar args
+  end
+  when mode=';' then do
+    sep = ''
+    equal = -1
+  end
+  when mode='-D' then equal = 1
+  when mode='=D' then mode = '-D'
+  when mode=',' then sep = ','
+otherwise
+  args = envar args
+  envar = mode
+  mode = ''
+end
+
+env = 'OS2ENVIRONMENT'
+envar = translate(envar)
+orig = value(envar,,env)
+newval = ''
+expand = 1
+
+/* for each parameter... */
+do i = 1 to words(args)
+  if expand > 0 & word(args, i) = '-' then expand = 0
+  else call addval word(args, i)
+end
+
+/* Optionally enclose path variable by quotes */
+if mode = ';' & pos(' ', newval) > 0 then newval = '"' || newval || '"'
+
+/* Set the new value, 'SET' cannot be used since it does not allow '=' */
+x = value(envar, newval, env)
+exit 0
+
+addval: procedure expose sep equal orig expand newval mode env
+parse arg var
+
+if var = '.' then expvar = orig
+else do
+  if equal >= 0 then do
+    parse var var name '=' val
+    if val = '' then var = name
+    else var = val
+  end
+  if expand = 0 then expvar = var
+  else expvar = value(translate(var),,env)
+  if expvar = '' then expvar = var
+  if equal >= 0 then do
+    if val = '' then do
+      parse var expvar key '=' val
+      if val <> '' then name = key
+      else do
+        if equal > 0 then val = key
+        else name = key
+      end
+    end
+    else val = expvar
+    if pos(' ', val) > 0 | pos('=', val) > 0 then val = '"' || val || '"'
+    if val = '' then expvar = name
+    else expvar = name || '=' || val
+  end
+  if mode = '-D' then expvar = '-D' || expvar
+  if mode = ';' then do
+    if right(expvar, 1) <> ';' then expvar = expvar || ';'
+  end
+end
+
+if newval = '' then newval = expvar
+else newval = newval || sep || expvar
+expand = 1
+return

cuda_toolkit/bin/lcp.bat

@@ -0,0 +1,31 @@
+REM
+REM  Licensed to the Apache Software Foundation (ASF) under one or more
+REM  contributor license agreements.  See the NOTICE file distributed with
+REM  this work for additional information regarding copyright ownership.
+REM  The ASF licenses this file to You under the Apache License, Version 2.0
+REM  (the "License"); you may not use this file except in compliance with
+REM  the License.  You may obtain a copy of the License at
+REM 
+REM      http://www.apache.org/licenses/LICENSE-2.0
+REM 
+REM  Unless required by applicable law or agreed to in writing, software
+REM  distributed under the License is distributed on an "AS IS" BASIS,
+REM  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+REM  See the License for the specific language governing permissions and
+REM  limitations under the License.
+REM
+REM
+
+set _CLASSPATHCOMPONENT=%1
+if ""%1""=="""" goto gotAllArgs
+shift
+
+:argCheck
+if ""%1""=="""" goto gotAllArgs
+set _CLASSPATHCOMPONENT=%_CLASSPATHCOMPONENT% %1
+shift
+goto argCheck
+
+:gotAllArgs
+set LOCALCLASSPATH=%LOCALCLASSPATH%;%_CLASSPATHCOMPONENT%
+

cuda_toolkit/bin/mouseLut.json

@@ -0,0 +1,1732 @@
+{
+    "db": [
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 16889,
+            "avgLmbLatencyUs": 16889,
+            "make": "Microsoft",
+            "mode": "none",
+            "model": "Basic Optical Mouse 2.0",
+            "perClickLatency": false,
+            "pid": "00cb",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0100",
+            "vid": "045e"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 39752,
+            "avgLmbLatencyUs": 39752,
+            "make": "Microsoft",
+            "mode": "none",
+            "model": "Optical Mouse 200",
+            "perClickLatency": false,
+            "pid": "0797",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0200",
+            "vid": "045e"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 4125,
+            "avgLmbLatencyUs": 4125,
+            "make": "Alienware",
+            "mode": "none",
+            "model": "AW610M (wired)",
+            "perClickLatency": true,
+            "pid": "4e9d",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0308",
+            "vid": "0461"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 4543,
+            "avgLmbLatencyUs": 4543,
+            "make": "Alienware",
+            "mode": "none",
+            "model": "AW610M (wireless)",
+            "perClickLatency": true,
+            "pid": "4ec0",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0303",
+            "vid": "0461"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 1843,
+            "avgLmbLatencyUs": 1843,
+            "make": "Logitech G",
+            "mode": "wireless",
+            "model": "PRO X SUPERLIGHT (wireless)",
+            "perClickLatency": false,
+            "pid": "4093",
+            "polledActuation": false,
+            "reportExtension": true,
+            "revision": "0000",
+            "vid": "046d"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 2919,
+            "avgLmbLatencyUs": 2919,
+            "make": "Logitech G",
+            "mode": "none",
+            "model": "G403",
+            "perClickLatency": false,
+            "pid": "c083",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0801",
+            "vid": "046d"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 3179,
+            "avgLmbLatencyUs": 3179,
+            "make": "Logitech G",
+            "mode": "none",
+            "model": "G203",
+            "perClickLatency": false,
+            "pid": "c084",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0703",
+            "vid": "046d"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 3025,
+            "avgLmbLatencyUs": 3025,
+            "make": "Logitech G",
+            "mode": "none",
+            "model": "PRO",
+            "perClickLatency": false,
+            "pid": "c085",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "1002",
+            "vid": "046d"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 2562,
+            "avgLmbLatencyUs": 2562,
+            "make": "Logitech G",
+            "mode": "none",
+            "model": "PRO Wireless Ghost White (wired), PRO Wireless Easter Pink (wired), PRO Wireless Black (wired)",
+            "perClickLatency": false,
+            "pid": "c088",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "1502",
+            "vid": "046d"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 2523,
+            "avgLmbLatencyUs": 2537,
+            "make": "Logitech G",
+            "mode": "none",
+            "model": "PRO Wireless Ghost White (wired), PRO Wireless Easter Pink (wired), PRO Wireless Black (wired)",
+            "perClickLatency": true,
+            "pid": "c088",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "1510",
+            "vid": "046d"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 2497,
+            "avgLmbLatencyUs": 2497,
+            "make": "Logitech G",
+            "mode": "none",
+            "model": "G502",
+            "perClickLatency": false,
+            "pid": "c08b",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "2702",
+            "vid": "046d"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 2554,
+            "avgLmbLatencyUs": 2554,
+            "make": "Logitech G",
+            "mode": "none",
+            "model": "PRO",
+            "perClickLatency": false,
+            "pid": "c08c",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "2801",
+            "vid": "046d"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 2527,
+            "avgLmbLatencyUs": 2527,
+            "make": "Logitech G",
+            "mode": "none",
+            "model": "502 Lightspeed (wired)",
+            "perClickLatency": false,
+            "pid": "c08d",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "1700",
+            "vid": "046d"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 2809,
+            "avgLmbLatencyUs": 2809,
+            "make": "Logitech G",
+            "mode": "none",
+            "model": "MX518",
+            "perClickLatency": false,
+            "pid": "c08e",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "4000",
+            "vid": "046d"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 2562,
+            "avgLmbLatencyUs": 2562,
+            "make": "Logitech G",
+            "mode": "none",
+            "model": "403 Hero",
+            "perClickLatency": false,
+            "pid": "c08f",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "4501",
+            "vid": "046d"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 2537,
+            "avgLmbLatencyUs": 2537,
+            "make": "Logitech G",
+            "mode": "none",
+            "model": "703 Lightspeed (wired)",
+            "perClickLatency": false,
+            "pid": "c090",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "2202",
+            "vid": "046d"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 2516,
+            "avgLmbLatencyUs": 2516,
+            "make": "Logitech G",
+            "mode": "none",
+            "model": "903 Lightspeed (wired)",
+            "perClickLatency": false,
+            "pid": "c091",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "2301",
+            "vid": "046d"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 808,
+            "avgLmbLatencyUs": 808,
+            "make": "Logitech G",
+            "mode": "none",
+            "model": "PRO X SUPERLIGHT (wired)",
+            "perClickLatency": true,
+            "pid": "c094",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "2500",
+            "vid": "046d"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 831,
+            "avgLmbLatencyUs": 831,
+            "make": "Logitech",
+            "mode": "none",
+            "model": "G PRO X SUPERLIGHT",
+            "perClickLatency": true,
+            "pid": "c094",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "2501",
+            "vid": "046d"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 834,
+            "avgLmbLatencyUs": 834,
+            "make": "Logitech",
+            "mode": "none",
+            "model": "G303 SHROUD EDITION",
+            "perClickLatency": true,
+            "pid": "c097",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "2900",
+            "vid": "046d"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 1169,
+            "avgLmbLatencyUs": 1169,
+            "make": "Logitech",
+            "mode": "none",
+            "model": "G303 SHROUD EDITION",
+            "perClickLatency": false,
+            "pid": "c547",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0402",
+            "vid": "046d"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 7237,
+            "avgLmbLatencyUs": 7658,
+            "make": "Zowie",
+            "mode": "none",
+            "model": "EC2-B Divina Edition, EC2-B, S2 Divina, EC2 Tyloo Edition, S1 Divina",
+            "perClickLatency": false,
+            "pid": "8001",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0020",
+            "vid": "04a5"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 6132,
+            "avgLmbLatencyUs": 6595,
+            "make": "Finalmouse",
+            "mode": "none",
+            "model": "Ultralight Phantom, Air58 Ninja CBB, Ultralight 2 Cape Town, Ninja Air58 CBR",
+            "perClickLatency": false,
+            "pid": "ad50",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0100",
+            "vid": "04d9"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 8380,
+            "avgLmbLatencyUs": 8380,
+            "make": "HyperX",
+            "mode": "none",
+            "model": "Pulsefire FPS",
+            "perClickLatency": false,
+            "pid": "16bc",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0007",
+            "vid": "0951"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 5748,
+            "avgLmbLatencyUs": 5748,
+            "make": "HyperX",
+            "mode": "none",
+            "model": "PulseFire Haste",
+            "perClickLatency": true,
+            "pid": "1727",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0110",
+            "vid": "0951"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 1309,
+            "avgLmbLatencyUs": 1309,
+            "make": "ASUS",
+            "mode": "none",
+            "model": "ROG Chakram (wired)",
+            "perClickLatency": true,
+            "pid": "18e3",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0131",
+            "vid": "0b05"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 2115,
+            "avgLmbLatencyUs": 2115,
+            "make": "ASUS",
+            "mode": "none",
+            "model": "ROG Chakram (wired)",
+            "perClickLatency": false,
+            "pid": "18e3",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0928",
+            "vid": "0b05"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 2440,
+            "avgLmbLatencyUs": 2440,
+            "make": "ASUS",
+            "mode": "none",
+            "model": "ROG Chakram (wireless)",
+            "perClickLatency": false,
+            "pid": "18e5",
+            "polledActuation": false,
+            "reportExtension": true,
+            "revision": "0131",
+            "vid": "0b05"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 2993,
+            "avgLmbLatencyUs": 2993,
+            "make": "ASUS",
+            "mode": "none",
+            "model": "ROG Chakram (wireless)",
+            "perClickLatency": false,
+            "pid": "18e5",
+            "polledActuation": false,
+            "reportExtension": true,
+            "revision": "0930",
+            "vid": "0b05"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 616,
+            "avgLmbLatencyUs": 616,
+            "make": "ASUS",
+            "mode": "none",
+            "model": "ROG Chakram Core",
+            "perClickLatency": true,
+            "pid": "1958",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0108",
+            "vid": "0b05"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 659,
+            "avgLmbLatencyUs": 659,
+            "make": "ASUS",
+            "mode": "none",
+            "model": "ROG Keris",
+            "perClickLatency": true,
+            "pid": "195c",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0108",
+            "vid": "0b05"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 1250,
+            "avgLmbLatencyUs": 1250,
+            "make": "ASUS",
+            "mode": "none",
+            "model": "ROG Keris Wireless (wired)",
+            "perClickLatency": true,
+            "pid": "195e",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0113",
+            "vid": "0b05"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 2252,
+            "avgLmbLatencyUs": 2252,
+            "make": "ASUS",
+            "mode": "none",
+            "model": "ROG Keris Wireless",
+            "perClickLatency": false,
+            "pid": "1960",
+            "polledActuation": false,
+            "reportExtension": true,
+            "revision": "0203",
+            "vid": "0b05"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 1409,
+            "avgLmbLatencyUs": 1409,
+            "make": "ASUS",
+            "mode": "none",
+            "model": "ROG Spatha X (Wired)",
+            "perClickLatency": true,
+            "pid": "1977",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0117",
+            "vid": "0b05"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 9213,
+            "avgLmbLatencyUs": 9213,
+            "make": "ASUS",
+            "mode": "none",
+            "model": "ROG Spatha X (Wireless)",
+            "perClickLatency": false,
+            "pid": "1979",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0119",
+            "vid": "0b05"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 626,
+            "avgLmbLatencyUs": 626,
+            "make": "ASUS",
+            "mode": "none",
+            "model": "ROG Gladius III ",
+            "perClickLatency": true,
+            "pid": "197b",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0116",
+            "vid": "0b05"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 1394,
+            "avgLmbLatencyUs": 1394,
+            "make": "ASUS",
+            "mode": "none",
+            "model": "ROG Gladius III Wireless (Wired)",
+            "perClickLatency": true,
+            "pid": "197d",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0120",
+            "vid": "0b05"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 3194,
+            "avgLmbLatencyUs": 3194,
+            "make": "ASUS",
+            "mode": "none",
+            "model": "ROG Gladius III Wireless (Wireless)",
+            "perClickLatency": false,
+            "pid": "197f",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0121",
+            "vid": "0b05"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 181,
+            "avgLmbLatencyUs": 181,
+            "make": "Asus",
+            "mode": "none",
+            "model": "ROG Chakram X",
+            "perClickLatency": true,
+            "pid": "1a18",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0211",
+            "vid": "0b05"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 8482,
+            "avgLmbLatencyUs": 8482,
+            "make": "Asus",
+            "mode": "none",
+            "model": "ROG Chakram X",
+            "perClickLatency": false,
+            "pid": "1a1a",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0110",
+            "vid": "0b05"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 18801,
+            "avgLmbLatencyUs": 18801,
+            "make": "MSI",
+            "mode": "none",
+            "model": "Clutch GM08",
+            "perClickLatency": false,
+            "pid": "0d08",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0100",
+            "vid": "0db0"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 1710,
+            "avgLmbLatencyUs": 1710,
+            "make": "MSI",
+            "mode": "none",
+            "model": "GM11",
+            "perClickLatency": false,
+            "pid": "0d11",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0309",
+            "vid": "0db0"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 10781,
+            "avgLmbLatencyUs": 10781,
+            "make": "MSI",
+            "mode": "none",
+            "model": "Clutch GM20 Elite",
+            "perClickLatency": false,
+            "pid": "0d2e",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0108",
+            "vid": "0db0"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 8416,
+            "avgLmbLatencyUs": 8416,
+            "make": "MSI",
+            "mode": "none",
+            "model": "Clutch GM30",
+            "perClickLatency": false,
+            "pid": "0d30",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0210",
+            "vid": "0db0"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 4348,
+            "avgLmbLatencyUs": 4348,
+            "make": "MSI",
+            "mode": "none",
+            "model": "GM41",
+            "perClickLatency": true,
+            "pid": "0d41",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0210",
+            "vid": "0db0"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 4191,
+            "avgLmbLatencyUs": 4191,
+            "make": "MSI",
+            "mode": "none",
+            "model": "Clutch GM41 Lightweight Wireless (wired)",
+            "perClickLatency": true,
+            "pid": "0d4b",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0091",
+            "vid": "0db0"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 4080,
+            "avgLmbLatencyUs": 4080,
+            "make": "MSI",
+            "mode": "none",
+            "model": "Clutch GM41 Lightweight Wireless (wired)",
+            "perClickLatency": true,
+            "pid": "0d4b",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0092",
+            "vid": "0db0"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 4354,
+            "avgLmbLatencyUs": 4354,
+            "make": "MSI",
+            "mode": "none",
+            "model": "Clutch GM41 Lightweight Wireless (wireless)",
+            "perClickLatency": true,
+            "pid": "0d4c",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0091",
+            "vid": "0db0"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 4533,
+            "avgLmbLatencyUs": 4533,
+            "make": "MSI",
+            "mode": "none",
+            "model": "Clutch GM41 Lightweight Wireless (wireless)",
+            "perClickLatency": true,
+            "pid": "0d4c",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0092",
+            "vid": "0db0"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 13592,
+            "avgLmbLatencyUs": 13592,
+            "make": "MSI",
+            "mode": "none",
+            "model": "Clutch GM50",
+            "perClickLatency": false,
+            "pid": "0d50",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0132",
+            "vid": "0db0"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 8790,
+            "avgLmbLatencyUs": 8790,
+            "make": "SteelSeries",
+            "mode": "none",
+            "model": "Rival 300",
+            "perClickLatency": false,
+            "pid": "1710",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0024",
+            "vid": "1038"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 8542,
+            "avgLmbLatencyUs": 8542,
+            "make": "Steelseries",
+            "mode": "none",
+            "model": "Rival 600",
+            "perClickLatency": false,
+            "pid": "1724",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0233",
+            "vid": "1038"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 5123,
+            "avgLmbLatencyUs": 5123,
+            "make": "SteelSeries",
+            "mode": "none",
+            "model": "Rival 3",
+            "perClickLatency": true,
+            "pid": "184c",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0025",
+            "vid": "1038"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 3108,
+            "avgLmbLatencyUs": 3108,
+            "make": "SteelSeries",
+            "mode": "none",
+            "model": "Rival 3",
+            "perClickLatency": true,
+            "pid": "eeee",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "00ee",
+            "vid": "1038"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 0,
+            "avgLmbLatencyUs": 0,
+            "make": "NVIDIA LUT Version",
+            "mode": "none",
+            "model": "v1.0.6 4-26-2022",
+            "perClickLatency": true,
+            "pid": "0000",
+            "polledActuation": true,
+            "reportExtension": true,
+            "revision": "0000",
+            "vid": "10de"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 10150,
+            "avgLmbLatencyUs": 10150,
+            "make": "Razer",
+            "mode": "none",
+            "model": "Deathadder Elite",
+            "perClickLatency": false,
+            "pid": "005c",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0200",
+            "vid": "1532"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 841,
+            "avgLmbLatencyUs": 841,
+            "make": "Razer",
+            "mode": "none",
+            "model": "Viper Ultimate (Wired)",
+            "perClickLatency": true,
+            "pid": "007a",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0100",
+            "vid": "1532"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 1400,
+            "avgLmbLatencyUs": 1400,
+            "make": "Razer",
+            "mode": "none",
+            "model": "Deathadder V2 Pro (wired)",
+            "perClickLatency": true,
+            "pid": "007c",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0100",
+            "vid": "1532"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 1587,
+            "avgLmbLatencyUs": 1587,
+            "make": "Razer",
+            "mode": "none",
+            "model": "Deathadder V2 Pro (wireless)",
+            "perClickLatency": false,
+            "pid": "007d",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0100",
+            "vid": "1532"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 2905,
+            "avgLmbLatencyUs": 2905,
+            "make": "Razer",
+            "mode": "none",
+            "model": "Viper Ultimate (Wireless)",
+            "perClickLatency": false,
+            "pid": "007e",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0200",
+            "vid": "1532"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 710,
+            "avgLmbLatencyUs": 710,
+            "make": "Razer",
+            "mode": "none",
+            "model": "DeathAdder V2",
+            "perClickLatency": true,
+            "pid": "0084",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0200",
+            "vid": "1532"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 926,
+            "avgLmbLatencyUs": 926,
+            "make": "Razer",
+            "mode": "none",
+            "model": "Basilisk Ultimate (Wired)",
+            "perClickLatency": true,
+            "pid": "0086",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0100",
+            "vid": "1532"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 2530,
+            "avgLmbLatencyUs": 2530,
+            "make": "Razer",
+            "mode": "none",
+            "model": "Basilisk Ultimate (Wireless)",
+            "perClickLatency": false,
+            "pid": "0088",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0200",
+            "vid": "1532"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 844,
+            "avgLmbLatencyUs": 844,
+            "make": "Razer",
+            "mode": "none",
+            "model": "VIPER MINI",
+            "perClickLatency": false,
+            "pid": "008a",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0200",
+            "vid": "1532"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 724,
+            "avgLmbLatencyUs": 724,
+            "make": "Razer",
+            "mode": "none",
+            "model": "NAGA X",
+            "perClickLatency": false,
+            "pid": "0096",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0200",
+            "vid": "1532"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 10067,
+            "avgLmbLatencyUs": 10364,
+            "make": "Zowie",
+            "mode": "none",
+            "model": "EC1-A White, EC1-A, EC2-A, FK1, FK2 White, FK2, ZA12, EC1-B",
+            "perClickLatency": false,
+            "pid": "0001",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0001",
+            "vid": "1af3"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 1367,
+            "avgLmbLatencyUs": 1367,
+            "make": "CORSAIR",
+            "mode": "none",
+            "model": "M65 RGB ELITE",
+            "perClickLatency": true,
+            "pid": "1b5a",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0341",
+            "vid": "1b1c"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 1368,
+            "avgLmbLatencyUs": 1368,
+            "make": "CORSAIR",
+            "mode": "none",
+            "model": "NIGHTSWORD RGB",
+            "perClickLatency": true,
+            "pid": "1b5c",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0341",
+            "vid": "1b1c"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 573,
+            "avgLmbLatencyUs": 573,
+            "make": "Corsair",
+            "mode": "none",
+            "model": "CHAMPION SERIES SABRE RGB PRO",
+            "perClickLatency": true,
+            "pid": "1b79",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0109",
+            "vid": "1b1c"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 609,
+            "avgLmbLatencyUs": 609,
+            "make": "Corsair",
+            "mode": "none",
+            "model": "CHAMPION SERIES SABRE PRO",
+            "perClickLatency": true,
+            "pid": "1b7a",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0109",
+            "vid": "1b1c"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 648,
+            "avgLmbLatencyUs": 648,
+            "make": "Corsair",
+            "mode": "none",
+            "model": "Dark Core RGB PRO SE (wired)",
+            "perClickLatency": true,
+            "pid": "1b7e",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0207",
+            "vid": "1b1c"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 715,
+            "avgLmbLatencyUs": 715,
+            "make": "Corsair",
+            "mode": "none",
+            "model": "Dark Core RGB PRO SE (wired)",
+            "perClickLatency": true,
+            "pid": "1b7e",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0500",
+            "vid": "1b1c"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 1220,
+            "avgLmbLatencyUs": 1220,
+            "make": "Corsair",
+            "mode": "none",
+            "model": "Dark Core RGB PRO SE (wireless)",
+            "perClickLatency": true,
+            "pid": "1b7f",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0204",
+            "vid": "1b1c"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 1186,
+            "avgLmbLatencyUs": 1186,
+            "make": "Corsair",
+            "mode": "none",
+            "model": "Dark Core RGB PRO SE (wireless)",
+            "perClickLatency": true,
+            "pid": "1b7f",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0500",
+            "vid": "1b1c"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 648,
+            "avgLmbLatencyUs": 648,
+            "make": "Corsair",
+            "mode": "none",
+            "model": "Dark Core RGB Pro (wired)",
+            "perClickLatency": true,
+            "pid": "1b80",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0207",
+            "vid": "1b1c"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 713,
+            "avgLmbLatencyUs": 713,
+            "make": "Corsair",
+            "mode": "none",
+            "model": "Dark Core RGB Pro (wired)",
+            "perClickLatency": true,
+            "pid": "1b80",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0500",
+            "vid": "1b1c"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 1202,
+            "avgLmbLatencyUs": 1202,
+            "make": "Corsair",
+            "mode": "none",
+            "model": "Dark Core RGB Pro (wireless)",
+            "perClickLatency": true,
+            "pid": "1b81",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0204",
+            "vid": "1b1c"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 1169,
+            "avgLmbLatencyUs": 1169,
+            "make": "Corsair",
+            "mode": "none",
+            "model": "Dark Core RGB Pro (wireless)",
+            "perClickLatency": true,
+            "pid": "1b81",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0500",
+            "vid": "1b1c"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 1394,
+            "avgLmbLatencyUs": 1394,
+            "make": "Corsair",
+            "mode": "none",
+            "model": "KATAR PRO Wireless",
+            "perClickLatency": true,
+            "pid": "1b94",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0201",
+            "vid": "1b1c"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 887,
+            "avgLmbLatencyUs": 887,
+            "make": "Corsair",
+            "mode": "none",
+            "model": "KATAR PRO XT",
+            "perClickLatency": true,
+            "pid": "1bac",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0105",
+            "vid": "1b1c"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 1273,
+            "avgLmbLatencyUs": 1273,
+            "make": "ROCCAT",
+            "mode": "none",
+            "model": "Kone Pro",
+            "perClickLatency": true,
+            "pid": "2c88",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0117",
+            "vid": "1e7d"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 1398,
+            "avgLmbLatencyUs": 1398,
+            "make": "ROCCAT",
+            "mode": "none",
+            "model": "Kone XP",
+            "perClickLatency": true,
+            "pid": "2c8b",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0108",
+            "vid": "1e7d"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 2895,
+            "avgLmbLatencyUs": 2895,
+            "make": "ROCCAT",
+            "mode": "none",
+            "model": "Kone Pro Air (Wireless)",
+            "perClickLatency": false,
+            "pid": "2c8e",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0417",
+            "vid": "1e7d"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 1231,
+            "avgLmbLatencyUs": 1231,
+            "make": "ROCCAT",
+            "mode": "none",
+            "model": "Kone Pro Air (Wired)",
+            "perClickLatency": true,
+            "pid": "2c92",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0430",
+            "vid": "1e7d"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 5821,
+            "avgLmbLatencyUs": 5821,
+            "make": "Roccat",
+            "mode": "none",
+            "model": "Burst Pro Air",
+            "perClickLatency": true,
+            "pid": "2cab",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0043",
+            "vid": "1e7d"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 1446,
+            "avgLmbLatencyUs": 1446,
+            "make": "ROCCAT",
+            "mode": "none",
+            "model": "Burst Pro",
+            "perClickLatency": true,
+            "pid": "2de1",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0111",
+            "vid": "1e7d"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 1295,
+            "avgLmbLatencyUs": 1295,
+            "make": "Roccat",
+            "mode": "none",
+            "model": "Kone XP",
+            "perClickLatency": true,
+            "pid": "2de6",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0101",
+            "vid": "1e7d"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 13461,
+            "avgLmbLatencyUs": 13461,
+            "make": "Glorious",
+            "mode": "none",
+            "model": "Model O",
+            "perClickLatency": false,
+            "pid": "0036",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0100",
+            "vid": "258a"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 4802,
+            "avgLmbLatencyUs": 4802,
+            "make": "AOC",
+            "mode": "none",
+            "model": "GM510",
+            "perClickLatency": true,
+            "pid": "006d",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0114",
+            "vid": "258a"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 5267,
+            "avgLmbLatencyUs": 5267,
+            "make": "AOC",
+            "mode": "none",
+            "model": "GM510",
+            "perClickLatency": true,
+            "pid": "006d",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0115",
+            "vid": "258a"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 4606,
+            "avgLmbLatencyUs": 4606,
+            "make": "AOC",
+            "mode": "none",
+            "model": "AGM 600",
+            "perClickLatency": true,
+            "pid": "0081",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0000",
+            "vid": "258a"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 7623,
+            "avgLmbLatencyUs": 7623,
+            "make": "Zowie",
+            "mode": "none",
+            "model": "ZA13",
+            "perClickLatency": false,
+            "pid": "0001",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0002",
+            "vid": "3057"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 655,
+            "avgLmbLatencyUs": 655,
+            "make": "EVGA",
+            "mode": "none",
+            "model": "X17",
+            "perClickLatency": true,
+            "pid": "240d",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "a168",
+            "vid": "3842"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 685,
+            "avgLmbLatencyUs": 685,
+            "make": "EVGA",
+            "mode": "none",
+            "model": "X15",
+            "perClickLatency": true,
+            "pid": "2415",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "a124",
+            "vid": "3842"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 2305,
+            "avgLmbLatencyUs": 2305,
+            "make": "EVGA",
+            "mode": "none",
+            "model": "X12",
+            "perClickLatency": true,
+            "pid": "2422",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "a177",
+            "vid": "3842"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 16580,
+            "avgLmbLatencyUs": 16580,
+            "make": "Acer",
+            "mode": "none",
+            "model": "Predator Cestus 350 (wired)",
+            "perClickLatency": true,
+            "pid": "1172",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0121",
+            "vid": "3938"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 1576,
+            "avgLmbLatencyUs": 1576,
+            "make": "Acer",
+            "mode": "none",
+            "model": "Predator Cestus 350 (wired)",
+            "perClickLatency": true,
+            "pid": "1172",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0122",
+            "vid": "3938"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 16560,
+            "avgLmbLatencyUs": 16560,
+            "make": "Acer",
+            "mode": "none",
+            "model": "AOPEN Fire Legend GM310",
+            "perClickLatency": true,
+            "pid": "1176",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0104",
+            "vid": "3938"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 5241,
+            "avgLmbLatencyUs": 5241,
+            "make": "AOC",
+            "mode": "none",
+            "model": "GM500",
+            "perClickLatency": true,
+            "pid": "1179",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0202",
+            "vid": "3938"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 16916,
+            "avgLmbLatencyUs": 16916,
+            "make": "Acer",
+            "mode": "none",
+            "model": "Predator Cestus 330",
+            "perClickLatency": true,
+            "pid": "1184",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0101",
+            "vid": "3938"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 1576,
+            "avgLmbLatencyUs": 1576,
+            "make": "Acer",
+            "mode": "none",
+            "model": "Predator Cestus 330",
+            "perClickLatency": true,
+            "pid": "1184",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0109",
+            "vid": "3938"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 17589,
+            "avgLmbLatencyUs": 17589,
+            "make": "Acer",
+            "mode": "none",
+            "model": "Predator Cestus 350",
+            "perClickLatency": false,
+            "pid": "1218",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0107",
+            "vid": "3938"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 2001,
+            "avgLmbLatencyUs": 2001,
+            "make": "Alienware",
+            "mode": "none",
+            "model": "720M",
+            "perClickLatency": true,
+            "pid": "3028",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0219",
+            "vid": "413c"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 4265,
+            "avgLmbLatencyUs": 4265,
+            "make": "Alienware",
+            "mode": "none",
+            "model": "720M",
+            "perClickLatency": true,
+            "pid": "3029",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0209",
+            "vid": "413c"
+        },
+        {
+            "actuationDetectionDurationUs": 0,
+            "adjustedAvgLmbLatencyUs": 4881,
+            "avgLmbLatencyUs": 4881,
+            "make": "Alienware",
+            "mode": "none",
+            "model": "AW320M",
+            "perClickLatency": true,
+            "pid": "302a",
+            "polledActuation": false,
+            "reportExtension": false,
+            "revision": "0031",
+            "vid": "413c"
+        }
+    ],
+    "signature": [
+        116,
+        199,
+        223,
+        205,
+        23,
+        140,
+        185,
+        27,
+        56,
+        15,
+        215,
+        3,
+        29,
+        227,
+        183,
+        128,
+        143,
+        112,
+        246,
+        113,
+        38,
+        201,
+        172,
+        110,
+        13,
+        55,
+        98,
+        241,
+        233,
+        116,
+        133,
+        74,
+        189,
+        189,
+        207,
+        250,
+        108,
+        34,
+        56,
+        116,
+        254,
+        0,
+        156,
+        51,
+        51,
+        221,
+        48,
+        173,
+        5,
+        98,
+        132,
+        97,
+        255,
+        220,
+        91,
+        40,
+        57,
+        36,
+        199,
+        177,
+        90,
+        125,
+        82,
+        221,
+        2,
+        174,
+        19,
+        237,
+        214,
+        133,
+        102,
+        217,
+        216,
+        152,
+        114,
+        185,
+        170,
+        79,
+        222,
+        15,
+        219,
+        72,
+        144,
+        166,
+        227,
+        23,
+        187,
+        200,
+        191,
+        240,
+        195,
+        197,
+        110,
+        115,
+        151,
+        105,
+        185,
+        87,
+        52,
+        146,
+        130,
+        241,
+        100,
+        74,
+        232,
+        105,
+        200,
+        221,
+        247,
+        190,
+        178,
+        192,
+        189,
+        238,
+        192,
+        179,
+        93,
+        140,
+        78,
+        231,
+        154,
+        128,
+        221,
+        64,
+        166,
+        242,
+        134,
+        173,
+        33,
+        39,
+        49,
+        131,
+        70,
+        211,
+        141,
+        164,
+        57,
+        249,
+        64,
+        182,
+        252,
+        46,
+        239,
+        191,
+        148,
+        139,
+        44,
+        49,
+        7,
+        31,
+        189,
+        78,
+        44,
+        236,
+        107,
+        168,
+        163,
+        115,
+        17,
+        54,
+        165,
+        158,
+        132,
+        146,
+        127,
+        0,
+        197,
+        111,
+        75,
+        114,
+        165,
+        237,
+        121,
+        222,
+        178,
+        81,
+        114,
+        136,
+        200,
+        204,
+        51,
+        36,
+        169,
+        181,
+        13,
+        238,
+        234,
+        142,
+        226,
+        146,
+        26,
+        163,
+        103,
+        174,
+        36,
+        214,
+        135,
+        41,
+        68,
+        122,
+        196,
+        241,
+        86,
+        223,
+        212,
+        104,
+        164,
+        133,
+        167,
+        236,
+        197,
+        0,
+        236,
+        103,
+        0,
+        11,
+        128,
+        127,
+        190,
+        215,
+        189,
+        254,
+        248,
+        240,
+        93,
+        140,
+        196,
+        2,
+        34,
+        34,
+        104,
+        12,
+        232,
+        181,
+        163,
+        47,
+        178,
+        60,
+        231,
+        232,
+        66,
+        50,
+        239,
+        24,
+        16,
+        32,
+        242,
+        247,
+        33,
+        16,
+        198,
+        12,
+        169,
+        199,
+        52,
+        29
+    ]
+}

cuda_toolkit/bin/nvcc.profile

@@ -0,0 +1,13 @@
+
+TOP              = $(_HERE_)/..
+
+NVVMIR_LIBRARY_DIR = $(TOP)/$(_NVVM_BRANCH_)/libdevice
+
+PATH            += $(TOP)/$(_NVVM_BRANCH_)/bin;$(_HERE_);$(TOP)/lib;
+
+INCLUDES        +=  "-I$(TOP)/include" $(_SPACE_)
+
+LIBRARIES        =+ $(_SPACE_) "/LIBPATH:$(TOP)/lib/$(_WIN_PLATFORM_)"
+
+CUDAFE_FLAGS    +=
+PTXAS_FLAGS     +=

cuda_toolkit/bin/nvvp.bat

@@ -0,0 +1,5 @@
+@echo off 
+setlocal
+    setx PATH "%~dp0\..\extras\CUPTI\lib64;%PATH%"
+    start "" "%~dp0\..\libnvvp\nvvp.exe" %*
+endlocal

cuda_toolkit/bin/runant.pl

@@ -0,0 +1,153 @@
+#!/usr/bin/perl
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+#  contributor license agreements.  See the NOTICE file distributed with
+#  this work for additional information regarding copyright ownership.
+#  The ASF licenses this file to You under the Apache License, Version 2.0
+#  (the "License"); you may not use this file except in compliance with
+#  the License.  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+#######################################################################
+#
+# runant.pl
+#
+# wrapper script for invoking ant in a platform with Perl installed
+# this may include cgi-bin invocation, which is considered somewhat daft.
+# (slo: that should be a separate file which can be derived from this
+# and returns the XML formatted output)
+#
+# the code is not totally portable due to classpath and directory splitting
+# issues. oops. (NB, use File::Spec::Functions  will help and the code is
+# structured for the catfile() call, but because of perl version funnies
+# the code is not included. 
+#
+# created:         2000-8-24
+# author:          Steve Loughran steve_l@sourceforge.net
+#######################################################################
+#
+# Assumptions:
+#
+# - the "java" executable/script is on the command path
+# - ANT_HOME has been set
+# - target platform uses ":" as classpath separator or perl indicates it is dos/win32
+# - target platform uses "/" as directory separator.
+
+#be fussy about variables
+use strict;
+
+#platform specifics (disabled)
+#use File::Spec::Functions;
+
+#turn warnings on during dev; generates a few spurious uninitialised var access warnings
+#use warnings;
+
+#and set $debug to 1 to turn on trace info
+my $debug=1;
+
+#######################################################################
+#
+# check to make sure environment is setup
+#
+
+my $HOME = $ENV{ANT_HOME};
+if ($HOME eq "")
+        {
+    die "\n\nANT_HOME *MUST* be set!\n\n";
+        }
+
+my $JAVACMD = $ENV{JAVACMD};
+$JAVACMD = "java" if $JAVACMD eq "";
+
+my $onnetware = 0;
+if ($^O eq "NetWare")
+{
+  $onnetware = 1;
+}
+
+my $oncygwin = ($^O eq "cygwin");
+
+#ISSUE: what java wants to split up classpath varies from platform to platform 
+#and perl is not too hot at hinting which box it is on.
+#here I assume ":" 'cept on win32, dos, and netware. Add extra tests here as needed.
+my $s=":";
+if(($^O eq "MSWin32") || ($^O eq "dos") || ($^O eq "cygwin") ||
+   ($onnetware == 1))
+        {
+        $s=";";
+        }
+
+#build up standard classpath
+my $localpath = "$HOME/lib/ant-launcher.jar";
+#set JVM options and Ant arguments, if any
+my @ANT_OPTS=split(" ", $ENV{ANT_OPTS});
+my @ANT_ARGS=split(" ", $ENV{ANT_ARGS});
+
+#jikes
+if($ENV{JIKESPATH} ne "")
+        {
+        push @ANT_OPTS, "-Djikes.class.path=$ENV{JIKESPATH}";
+        }
+
+#construct arguments to java
+my @ARGS;
+push @ARGS, @ANT_OPTS;
+
+my $CYGHOME = "";
+
+my $classpath=$ENV{CLASSPATH};
+if ($oncygwin == 1) {
+  $localpath = `cygpath --path --windows $localpath`;
+  chomp ($localpath);
+  if (! $classpath eq "")
+  {
+    $classpath = `cygpath --path --windows "$classpath"`;
+    chomp ($classpath);
+  }
+  $HOME = `cygpath --path --windows $HOME`;
+  chomp ($HOME);
+  $CYGHOME = `cygpath --path --windows $ENV{HOME}`;
+  chomp ($CYGHOME);
+}
+push @ARGS, "-classpath", "$localpath";
+push @ARGS, "-Dant.home=$HOME";
+if ( ! $CYGHOME eq "" )
+{
+  push @ARGS, "-Dcygwin.user.home=\"$CYGHOME\""
+}
+push @ARGS, "org.apache.tools.ant.launch.Launcher", @ANT_ARGS;
+push @ARGS, @ARGV;
+if (! $classpath eq "")
+{
+  if ($onnetware == 1)
+  {
+    # make classpath literally $CLASSPATH
+    # this is to avoid pushing us over the 512 character limit
+    # even skip the ; - that is already in $localpath
+    push @ARGS, "-lib", "\$CLASSPATH";
+  }
+  else
+  {
+    push @ARGS, "-lib", "$classpath";
+  }
+}
+print "\n $JAVACMD @ARGS\n\n" if ($debug);
+
+my $returnValue = system $JAVACMD, @ARGS;
+if ($returnValue eq 0)
+        {
+        exit 0;
+        }
+else
+        {
+        # only 0 and 1 are widely recognized as exit values
+        # so change the exit value to 1
+        exit 1;
+        }

cuda_toolkit/bin/runant.py

@@ -0,0 +1,102 @@
+#!/usr/bin/python
+# Licensed to the Apache Software Foundation (ASF) under one or more
+#  contributor license agreements.  See the NOTICE file distributed with
+#  this work for additional information regarding copyright ownership.
+#  The ASF licenses this file to You under the Apache License, Version 2.0
+#  (the "License"); you may not use this file except in compliance with
+#  the License.  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+
+"""
+
+ runant.py
+
+    This script is a translation of the runant.pl written by Steve Loughran.
+    It runs ant with/out arguments, it should be quite portable (thanks to
+    the python os library)
+    This script has been tested with Python2.0/Win2K
+
+ created:         2001-04-11
+ author:          Pierre Dittgen pierre.dittgen@criltelecom.com
+
+ Assumptions:
+
+ - the "java" executable/script is on the command path
+"""
+import os, os.path, string, sys
+
+# Change it to 1 to get extra debug information
+debug = 0
+
+#######################################################################
+
+# If ANT_HOME is not set default to script's parent directory
+if os.environ.has_key('ANT_HOME'):
+    ANT_HOME = os.environ['ANT_HOME']
+else:
+    ANT_HOME = os.path.dirname(os.path.dirname(os.path.abspath(sys.argv[0])))
+
+# set ANT_LIB location
+ANT_LIB = os.path.join(ANT_HOME, 'lib')
+
+# set JAVACMD (check variables JAVACMD and JAVA_HOME)
+JAVACMD = None
+if not os.environ.has_key('JAVACMD'):
+    if os.environ.has_key('JAVA_HOME'):
+        if not os.path.exists(os.environ['JAVA_HOME']):
+            print "Warning: JAVA_HOME is not defined correctly."
+        else:
+            JAVACMD = os.path.join(os.environ['JAVA_HOME'], 'bin', 'java')
+    else:
+        print "Warning: JAVA_HOME not set."
+else:
+    JAVACMD = os.environ['JAVACMD']
+if not JAVACMD:
+    JAVACMD = 'java'
+
+launcher_jar = os.path.join(ANT_LIB, 'ant-launcher.jar')
+if not os.path.exists(launcher_jar):
+    print 'Warning: Unable to locate ant-launcher.jar. Expected to find it in %s' % \
+        ANT_LIB
+
+# Build up standard classpath (LOCALCLASSPATH)
+LOCALCLASSPATH = launcher_jar
+if os.environ.has_key('LOCALCLASSPATH'):
+    LOCALCLASSPATH += os.pathsep + os.environ['LOCALCLASSPATH']
+
+ANT_OPTS = ""
+if os.environ.has_key('ANT_OPTS'):
+    ANT_OPTS = os.environ['ANT_OPTS']
+
+OPTS = ""
+if os.environ.has_key('JIKESPATH'):
+    OPTS = '-Djikes.class.path=\"%s\"' % os.environ['JIKESPATH']
+
+ANT_ARGS = ""
+if os.environ.has_key('ANT_ARGS'):
+    ANT_ARGS = os.environ['ANT_ARGS']
+
+CLASSPATH = ""
+if os.environ.has_key('CLASSPATH'):
+    CLASSPATH = "-lib " + os.environ['CLASSPATH']
+
+# Builds the commandline
+cmdline = ('%s %s -classpath %s -Dant.home=%s %s ' + \
+    'org.apache.tools.ant.launch.Launcher %s %s %s') \
+     % (JAVACMD, ANT_OPTS, LOCALCLASSPATH, ANT_HOME, OPTS, ANT_ARGS, \
+        CLASSPATH, string.join(sys.argv[1:], ' '))
+
+if debug:
+    print '\n%s\n\n' % (cmdline)
+sys.stdout.flush()
+
+# Run the biniou!
+os.system(cmdline)

cuda_toolkit/bin/runrc.cmd

@@ -0,0 +1,60 @@
+/* 
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+   Run RC file, name is in the first arg, second arg is either PATH
+   ENV  or -r or nothing 
+*/
+
+parse arg name path rest
+
+if name = '' then do
+  say 'RC file name is missing'
+  exit 1
+end
+
+if rest \= '' then do
+  say 'Too many parameters'
+  exit 1
+end
+
+call runit name path
+exit 0
+
+runit: procedure
+parse arg name path dir
+
+if path \= '' & path \= '-r' then do
+  dir = value(translate(path),,'OS2ENVIRONMENT')
+  if dir = '' then return
+  dir = translate(dir, '\', '/') /* change UNIX-like path to OS/2 */
+end
+
+if dir = '' then dir = directory()
+
+if path = '-r' then do /* recursive call */
+  subdir = filespec('path', dir)
+  if subdir \= '\' then do
+    subdir = left(subdir, length(subdir)-1)
+    call runit name path filespec('drive', dir) || subdir
+  end
+end
+
+/* Look for the file and run it */
+if right(dir, 1) \= '\' then dir = dir || '\'
+rcfile = stream(dir || name, 'c', 'query exists')
+if rcfile \= '' then interpret 'call "' || rcfile || '"'
+
+return

cuda_toolkit/compute-sanitizer/LICENSE

@@ -0,0 +1,1632 @@
+End User License Agreement
+--------------------------
+
+NVIDIA Software License Agreement and CUDA Supplement to
+Software License Agreement.
+
+The CUDA Toolkit End User License Agreement applies to the
+NVIDIA CUDA Toolkit, the NVIDIA CUDA Samples, the NVIDIA
+Display Driver, NVIDIA Nsight tools (Visual Studio Edition),
+and the associated documentation on CUDA APIs, programming
+model and development tools. If you do not agree with the
+terms and conditions of the license agreement, then do not
+download or use the software.
+
+Last updated: January 12, 2024.
+
+
+Preface
+-------
+
+The Software License Agreement in Chapter 1 and the Supplement
+in Chapter 2 contain license terms and conditions that govern
+the use of NVIDIA toolkit. By accepting this agreement, you
+agree to comply with all the terms and conditions applicable
+to the product(s) included herein.
+
+
+NVIDIA Driver
+
+
+Description
+
+This package contains the operating system driver and
+fundamental system software components for NVIDIA GPUs.
+
+
+NVIDIA CUDA Toolkit
+
+
+Description
+
+The NVIDIA CUDA Toolkit provides command-line and graphical
+tools for building, debugging and optimizing the performance
+of applications accelerated by NVIDIA GPUs, runtime and math
+libraries, and documentation including programming guides,
+user manuals, and API references.
+
+
+Default Install Location of CUDA Toolkit
+
+Windows platform:
+
+%ProgramFiles%\NVIDIA GPU Computing Toolkit\CUDA\v#.#
+
+Linux platform:
+
+/usr/local/cuda-#.#
+
+Mac platform:
+
+/Developer/NVIDIA/CUDA-#.#
+
+
+NVIDIA CUDA Samples
+
+
+Description
+
+CUDA Samples are now located in
+https://github.com/nvidia/cuda-samples, which includes
+instructions for obtaining, building, and running the samples.
+They are no longer included in the CUDA toolkit.
+
+
+NVIDIA Nsight Visual Studio Edition (Windows only)
+
+
+Description
+
+NVIDIA Nsight Development Platform, Visual Studio Edition is a
+development environment integrated into Microsoft Visual
+Studio that provides tools for debugging, profiling, analyzing
+and optimizing your GPU computing and graphics applications.
+
+
+Default Install Location of Nsight Visual Studio Edition
+
+Windows platform:
+
+%ProgramFiles(x86)%\NVIDIA Corporation\Nsight Visual Studio Edition #.#
+
+
+1. License Agreement for NVIDIA Software Development Kits
+---------------------------------------------------------
+
+
+Important Notice—Read before downloading, installing,
+copying or using the licensed software:
+-------------------------------------------------------
+
+This license agreement, including exhibits attached
+("Agreement”) is a legal agreement between you and NVIDIA
+Corporation ("NVIDIA") and governs your use of a NVIDIA
+software development kit (“SDK”).
+
+Each SDK has its own set of software and materials, but here
+is a description of the types of items that may be included in
+a SDK: source code, header files, APIs, data sets and assets
+(examples include images, textures, models, scenes, videos,
+native API input/output files), binary software, sample code,
+libraries, utility programs, programming code and
+documentation.
+
+This Agreement can be accepted only by an adult of legal age
+of majority in the country in which the SDK is used.
+
+If you are entering into this Agreement on behalf of a company
+or other legal entity, you represent that you have the legal
+authority to bind the entity to this Agreement, in which case
+“you” will mean the entity you represent.
+
+If you don’t have the required age or authority to accept
+this Agreement, or if you don’t accept all the terms and
+conditions of this Agreement, do not download, install or use
+the SDK.
+
+You agree to use the SDK only for purposes that are permitted
+by (a) this Agreement, and (b) any applicable law, regulation
+or generally accepted practices or guidelines in the relevant
+jurisdictions.
+
+
+1.1. License
+
+
+1.1.1. License Grant
+
+Subject to the terms of this Agreement, NVIDIA hereby grants
+you a non-exclusive, non-transferable license, without the
+right to sublicense (except as expressly provided in this
+Agreement) to:
+
+  1. Install and use the SDK,
+
+  2. Modify and create derivative works of sample source code
+    delivered in the SDK, and
+
+  3. Distribute those portions of the SDK that are identified
+    in this Agreement as distributable, as incorporated in
+    object code format into a software application that meets
+    the distribution requirements indicated in this Agreement.
+
+
+1.1.2. Distribution Requirements
+
+These are the distribution requirements for you to exercise
+the distribution grant:
+
+  1. Your application must have material additional
+    functionality, beyond the included portions of the SDK.
+
+  2. The distributable portions of the SDK shall only be
+    accessed by your application.
+
+  3. The following notice shall be included in modifications
+    and derivative works of sample source code distributed:
+    “This software contains source code provided by NVIDIA
+    Corporation.”
+
+  4. Unless a developer tool is identified in this Agreement
+    as distributable, it is delivered for your internal use
+    only.
+
+  5. The terms under which you distribute your application
+    must be consistent with the terms of this Agreement,
+    including (without limitation) terms relating to the
+    license grant and license restrictions and protection of
+    NVIDIA’s intellectual property rights. Additionally, you
+    agree that you will protect the privacy, security and
+    legal rights of your application users.
+
+  6. You agree to notify NVIDIA in writing of any known or
+    suspected distribution or use of the SDK not in compliance
+    with the requirements of this Agreement, and to enforce
+    the terms of your agreements with respect to distributed
+    SDK.
+
+
+1.1.3. Authorized Users
+
+You may allow employees and contractors of your entity or of
+your subsidiary(ies) to access and use the SDK from your
+secure network to perform work on your behalf.
+
+If you are an academic institution you may allow users
+enrolled or employed by the academic institution to access and
+use the SDK from your secure network.
+
+You are responsible for the compliance with the terms of this
+Agreement by your authorized users. If you become aware that
+your authorized users didn’t follow the terms of this
+Agreement, you agree to take reasonable steps to resolve the
+non-compliance and prevent new occurrences.
+
+
+1.1.4. Pre-Release SDK
+
+The SDK versions identified as alpha, beta, preview or
+otherwise as pre-release, may not be fully functional, may
+contain errors or design flaws, and may have reduced or
+different security, privacy, accessibility, availability, and
+reliability standards relative to commercial versions of
+NVIDIA software and materials. Use of a pre-release SDK may
+result in unexpected results, loss of data, project delays or
+other unpredictable damage or loss.
+
+You may use a pre-release SDK at your own risk, understanding
+that pre-release SDKs are not intended for use in production
+or business-critical systems.
+
+NVIDIA may choose not to make available a commercial version
+of any pre-release SDK. NVIDIA may also choose to abandon
+development and terminate the availability of a pre-release
+SDK at any time without liability.
+
+
+1.1.5. Updates
+
+NVIDIA may, at its option, make available patches, workarounds
+or other updates to this SDK. Unless the updates are provided
+with their separate governing terms, they are deemed part of
+the SDK licensed to you as provided in this Agreement. You
+agree that the form and content of the SDK that NVIDIA
+provides may change without prior notice to you. While NVIDIA
+generally maintains compatibility between versions, NVIDIA may
+in some cases make changes that introduce incompatibilities in
+future versions of the SDK.
+
+
+1.1.6. Components Under Other Licenses
+
+The SDK may come bundled with, or otherwise include or be
+distributed with, NVIDIA or third-party components with
+separate legal notices or terms as may be described in
+proprietary notices accompanying the SDK. If and to the extent
+there is a conflict between the terms in this Agreement and
+the license terms associated with the component, the license
+terms associated with the components control only to the
+extent necessary to resolve the conflict.
+
+Subject to the other terms of this Agreement, you may use the
+SDK to develop and test applications released under Open
+Source Initiative (OSI) approved open source software
+licenses.
+
+
+1.1.7. Reservation of Rights
+
+NVIDIA reserves all rights, title, and interest in and to the
+SDK, not expressly granted to you under this Agreement.
+
+
+1.2. Limitations
+
+The following license limitations apply to your use of the
+SDK:
+
+  1. You may not reverse engineer, decompile or disassemble,
+    or remove copyright or other proprietary notices from any
+    portion of the SDK or copies of the SDK.
+
+  2. Except as expressly provided in this Agreement, you may
+    not copy, sell, rent, sublicense, transfer, distribute,
+    modify, or create derivative works of any portion of the
+    SDK. For clarity, you may not distribute or sublicense the
+    SDK as a stand-alone product.
+
+  3. Unless you have an agreement with NVIDIA for this
+    purpose, you may not indicate that an application created
+    with the SDK is sponsored or endorsed by NVIDIA.
+
+  4. You may not bypass, disable, or circumvent any
+    encryption, security, digital rights management or
+    authentication mechanism in the SDK.
+
+  5. You may not use the SDK in any manner that would cause it
+    to become subject to an open source software license. As
+    examples, licenses that require as a condition of use,
+    modification, and/or distribution that the SDK be:
+
+      a. Disclosed or distributed in source code form;
+
+      b. Licensed for the purpose of making derivative works;
+        or
+
+      c. Redistributable at no charge.
+
+  6.  You acknowledge that the SDK as delivered is not tested
+    or certified by NVIDIA for use in connection with the
+    design, construction, maintenance, and/or operation of any
+    system where the use or failure of such system could
+    result in a situation that threatens the safety of human
+    life or results in catastrophic damages (each, a "Critical
+    Application"). Examples of Critical Applications include
+    use in avionics, navigation, autonomous vehicle
+    applications, ai solutions for automotive products,
+    military, medical, life support or other life critical
+    applications. NVIDIA shall not be liable to you or any
+    third party, in whole or in part, for any claims or
+    damages arising from such uses. You are solely responsible
+    for ensuring that any product or service developed with
+    the SDK as a whole includes sufficient features to comply
+    with all applicable legal and regulatory standards and
+    requirements.
+
+  7.  You agree to defend, indemnify and hold harmless NVIDIA
+    and its affiliates, and their respective employees,
+    contractors, agents, officers and directors, from and
+    against any and all claims, damages, obligations, losses,
+    liabilities, costs or debt, fines, restitutions and
+    expenses (including but not limited to attorney’s fees
+    and costs incident to establishing the right of
+    indemnification) arising out of or related to products or
+    services that use the SDK in or for Critical Applications,
+    and for use of the SDK outside of the scope of this
+    Agreement or not in compliance with its terms.
+
+  8. You may not reverse engineer, decompile or disassemble
+    any portion of the output generated using SDK elements for
+    the purpose of translating such output artifacts to target
+    a non-NVIDIA platform.
+
+
+1.3. Ownership
+
+  1.  NVIDIA or its licensors hold all rights, title and
+    interest in and to the SDK and its modifications and
+    derivative works, including their respective intellectual
+    property rights, subject to your rights under Section
+    1.3.2. This SDK may include software and materials from
+    NVIDIA’s licensors, and these licensors are intended
+    third party beneficiaries that may enforce this Agreement
+    with respect to their intellectual property rights.
+
+  2.  You hold all rights, title and interest in and to your
+    applications and your derivative works of the sample
+    source code delivered in the SDK, including their
+    respective intellectual property rights, subject to
+    NVIDIA’s rights under Section 1.3.1.
+
+  3. You may, but don’t have to, provide to NVIDIA
+    suggestions, feature requests or other feedback regarding
+    the SDK, including possible enhancements or modifications
+    to the SDK. For any feedback that you voluntarily provide,
+    you hereby grant NVIDIA and its affiliates a perpetual,
+    non-exclusive, worldwide, irrevocable license to use,
+    reproduce, modify, license, sublicense (through multiple
+    tiers of sublicensees), and distribute (through multiple
+    tiers of distributors) it without the payment of any
+    royalties or fees to you. NVIDIA will use feedback at its
+    choice. NVIDIA is constantly looking for ways to improve
+    its products, so you may send feedback to NVIDIA through
+    the developer portal at https://developer.nvidia.com.
+
+
+1.4. No Warranties
+
+THE SDK IS PROVIDED BY NVIDIA “AS IS” AND “WITH ALL
+FAULTS.” TO THE MAXIMUM EXTENT PERMITTED BY LAW, NVIDIA AND
+ITS AFFILIATES EXPRESSLY DISCLAIM ALL WARRANTIES OF ANY KIND
+OR NATURE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING,
+BUT NOT LIMITED TO, ANY WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE, TITLE, NON-INFRINGEMENT, OR THE
+ABSENCE OF ANY DEFECTS THEREIN, WHETHER LATENT OR PATENT. NO
+WARRANTY IS MADE ON THE BASIS OF TRADE USAGE, COURSE OF
+DEALING OR COURSE OF TRADE.
+
+
+1.5. Limitation of Liability
+
+TO THE MAXIMUM EXTENT PERMITTED BY LAW, NVIDIA AND ITS
+AFFILIATES SHALL NOT BE LIABLE FOR ANY (I) SPECIAL, INCIDENTAL,
+PUNITIVE OR CONSEQUENTIAL DAMAGES, OR (II) DAMAGES FOR (A) ANY 
+LOST PROFITS, LOSS OF USE, LOSS OF DATA OR LOSS OF GOODWILL, 
+OR THE COSTS OF PROCURING SUBSTITUTE PRODUCTS, ARISING OUT OF 
+OR IN CONNECTION WITH THIS AGREEMENT OR THE USE OR PERFORMANCE 
+OF THE SDK, WHETHER SUCH LIABILITY ARISES FROM ANY CLAIM BASED 
+UPON BREACH OF CONTRACT, BREACH OF WARRANTY, TORT (INCLUDING 
+NEGLIGENCE), PRODUCT LIABILITY OR ANY OTHER CAUSE OF ACTION OR 
+THEORY OF LIABILITY. IN NO EVENT WILL NVIDIA’S AND ITS AFFILIATES
+TOTAL CUMULATIVE LIABILITY UNDER OR ARISING OUT OF THIS
+AGREEMENT EXCEED US$10.00. THE NATURE OF THE LIABILITY OR THE
+NUMBER OF CLAIMS OR SUITS SHALL NOT ENLARGE OR EXTEND THIS
+LIMIT.
+
+These exclusions and limitations of liability shall apply
+regardless if NVIDIA or its affiliates have been advised of
+the possibility of such damages, and regardless of whether a
+remedy fails its essential purpose. These exclusions and
+limitations of liability form an essential basis of the
+bargain between the parties, and, absent any of these
+exclusions or limitations of liability, the provisions of this
+Agreement, including, without limitation, the economic terms,
+would be substantially different.
+
+
+1.6. Termination
+
+  1. This Agreement will continue to apply until terminated by
+    either you or NVIDIA as described below.
+
+  2. If you want to terminate this Agreement, you may do so by
+    stopping to use the SDK.
+
+  3. NVIDIA may, at any time, terminate this Agreement if:
+
+      a. (i) you fail to comply with any term of this
+        Agreement and the non-compliance is not fixed within
+        thirty (30) days following notice from NVIDIA (or
+        immediately if you violate NVIDIA’s intellectual
+        property rights);
+
+      b. (ii) you commence or participate in any legal
+        proceeding against NVIDIA with respect to the SDK; or
+
+      c. (iii) NVIDIA decides to no longer provide the SDK in
+        a country or, in NVIDIA’s sole discretion, the
+        continued use of it is no longer commercially viable.
+
+  4. Upon any termination of this Agreement, you agree to
+    promptly discontinue use of the SDK and destroy all copies
+    in your possession or control. Your prior distributions in
+    accordance with this Agreement are not affected by the
+    termination of this Agreement. Upon written request, you
+    will certify in writing that you have complied with your
+    commitments under this section. Upon any termination of
+    this Agreement all provisions survive except for the
+    license grant provisions.
+
+
+1.7. General
+
+If you wish to assign this Agreement or your rights and
+obligations, including by merger, consolidation, dissolution
+or operation of law, contact NVIDIA to ask for permission. Any
+attempted assignment not approved by NVIDIA in writing shall
+be void and of no effect. NVIDIA may assign, delegate or
+transfer this Agreement and its rights and obligations, and if
+to a non-affiliate you will be notified.
+
+You agree to cooperate with NVIDIA and provide reasonably
+requested information to verify your compliance with this
+Agreement.
+
+This Agreement will be governed in all respects by the laws of
+the United States and of the State of Delaware, without regard to the
+conflicts of laws principles. The United Nations Convention on
+Contracts for the International Sale of Goods is specifically
+disclaimed. You agree to all terms of this Agreement in the
+English language.
+
+The state or federal courts residing in Santa Clara County,
+California shall have exclusive jurisdiction over any dispute
+or claim arising out of this Agreement. Notwithstanding this,
+you agree that NVIDIA shall still be allowed to apply for
+injunctive remedies or an equivalent type of urgent legal
+relief in any jurisdiction.
+
+If any court of competent jurisdiction determines that any
+provision of this Agreement is illegal, invalid or
+unenforceable, such provision will be construed as limited to
+the extent necessary to be consistent with and fully
+enforceable under the law and the remaining provisions will
+remain in full force and effect. Unless otherwise specified,
+remedies are cumulative.
+
+Each party acknowledges and agrees that the other is an
+independent contractor in the performance of this Agreement.
+
+The SDK has been developed entirely at private expense and is
+“commercial items” consisting of “commercial computer
+software” and “commercial computer software
+documentation” provided with RESTRICTED RIGHTS. Use,
+duplication or disclosure by the U.S. Government or a U.S.
+Government subcontractor is subject to the restrictions in
+this Agreement pursuant to DFARS 227.7202-3(a) or as set forth
+in subparagraphs (c)(1) and (2) of the Commercial Computer
+Software - Restricted Rights clause at FAR 52.227-19, as
+applicable. Contractor/manufacturer is NVIDIA, 2788 San Tomas
+Expressway, Santa Clara, CA 95051.
+
+The SDK is subject to United States export laws and
+regulations. You agree that you will not ship, transfer or
+export the SDK into any country, or use the SDK in any manner,
+prohibited by the United States Bureau of Industry and
+Security or economic sanctions regulations administered by the
+U.S. Department of Treasury’s Office of Foreign Assets
+Control (OFAC), or any applicable export laws, restrictions or
+regulations. These laws include restrictions on destinations,
+end users and end use. By accepting this Agreement, you
+confirm that you are not located in a country currently 
+embargoed by the U.S. or otherwise prohibited from receiving 
+the SDK under U.S. law.
+
+Any notice delivered by NVIDIA to you under this Agreement
+will be delivered via mail, email or fax. You agree that any
+notices that NVIDIA sends you electronically will satisfy any
+legal communication requirements. Please direct your legal
+notices or other correspondence to NVIDIA Corporation, 2788
+San Tomas Expressway, Santa Clara, California 95051, United
+States of America, Attention: Legal Department.
+
+This Agreement and any exhibits incorporated into this
+Agreement constitute the entire agreement of the parties with
+respect to the subject matter of this Agreement and supersede
+all prior negotiations or documentation exchanged between the
+parties relating to this SDK license. Any additional and/or
+conflicting terms on documents issued by you are null, void,
+and invalid. Any amendment or waiver under this Agreement
+shall be in writing and signed by representatives of both
+parties.
+
+
+2. CUDA Toolkit Supplement to Software License Agreement for
+NVIDIA Software Development Kits
+------------------------------------------------------------
+
+The terms in this supplement govern your use of the NVIDIA
+CUDA Toolkit SDK under the terms of your license agreement
+(“Agreement”) as modified by this supplement. Capitalized
+terms used but not defined below have the meaning assigned to
+them in the Agreement.
+
+This supplement is an exhibit to the Agreement and is
+incorporated as an integral part of the Agreement. In the
+event of conflict between the terms in this supplement and the
+terms in the Agreement, the terms in this supplement govern.
+
+
+2.1. License Scope
+
+The SDK is licensed for you to develop applications only for
+use in systems with NVIDIA GPUs.
+
+
+2.2. Distribution
+
+The portions of the SDK that are distributable under the
+Agreement are listed in Attachment A.
+
+
+2.3. Operating Systems
+
+Those portions of the SDK designed exclusively for use on the
+Linux or FreeBSD operating systems, or other operating systems
+derived from the source code to these operating systems, may
+be copied and redistributed for use in accordance with this
+Agreement, provided that the object code files are not
+modified in any way (except for unzipping of compressed
+files).
+
+
+2.4. Audio and Video Encoders and Decoders
+
+You acknowledge and agree that it is your sole responsibility
+to obtain any additional third-party licenses required to
+make, have made, use, have used, sell, import, and offer for
+sale your products or services that include or incorporate any
+third-party software and content relating to audio and/or
+video encoders and decoders from, including but not limited
+to, Microsoft, Thomson, Fraunhofer IIS, Sisvel S.p.A.,
+MPEG-LA, and Coding Technologies. NVIDIA does not grant to you
+under this Agreement any necessary patent or other rights with
+respect to any audio and/or video encoders and decoders.
+
+
+2.5. Licensing
+
+If the distribution terms in this Agreement are not suitable
+for your organization, or for any questions regarding this
+Agreement, please contact NVIDIA at
+nvidia-compute-license-questions@nvidia.com.
+
+
+2.6. Attachment A
+
+The following CUDA Toolkit files may be distributed with
+applications developed by you, including certain
+variations of these files that have version number or
+architecture specific information embedded in the file name -
+as an example only, for release version 9.0 of the 64-bit
+Windows software, the file cudart64_90.dll is redistributable.
+
+Component
+
+CUDA Runtime
+
+Windows
+
+cudart.dll, cudart_static.lib, cudadevrt.lib
+
+Mac OSX
+
+libcudart.dylib, libcudart_static.a, libcudadevrt.a
+
+Linux
+
+libcudart.so, libcudart_static.a, libcudadevrt.a
+
+Android
+
+libcudart.so, libcudart_static.a, libcudadevrt.a
+
+Component
+
+CUDA FFT Library
+
+Windows
+
+cufft.dll, cufftw.dll, cufft.lib, cufftw.lib
+
+Mac OSX
+
+libcufft.dylib, libcufft_static.a, libcufftw.dylib,
+libcufftw_static.a
+
+Linux
+
+libcufft.so, libcufft_static.a, libcufftw.so,
+libcufftw_static.a
+
+Android
+
+libcufft.so, libcufft_static.a, libcufftw.so,
+libcufftw_static.a
+
+Component
+
+CUDA BLAS Library
+
+Windows
+
+cublas.dll, cublasLt.dll
+
+Mac OSX
+
+libcublas.dylib, libcublasLt.dylib, libcublas_static.a,
+libcublasLt_static.a
+
+Linux
+
+libcublas.so, libcublasLt.so, libcublas_static.a,
+libcublasLt_static.a
+
+Android
+
+libcublas.so, libcublasLt.so, libcublas_static.a,
+libcublasLt_static.a
+
+Component
+
+NVIDIA "Drop-in" BLAS Library
+
+Windows
+
+nvblas.dll
+
+Mac OSX
+
+libnvblas.dylib
+
+Linux
+
+libnvblas.so
+
+Component
+
+CUDA Sparse Matrix Library
+
+Windows
+
+cusparse.dll, cusparse.lib
+
+Mac OSX
+
+libcusparse.dylib, libcusparse_static.a
+
+Linux
+
+libcusparse.so, libcusparse_static.a
+
+Android
+
+libcusparse.so, libcusparse_static.a
+
+Component
+
+CUDA Linear Solver Library
+
+Windows
+
+cusolver.dll, cusolver.lib
+
+Mac OSX
+
+libcusolver.dylib, libcusolver_static.a
+
+Linux
+
+libcusolver.so, libcusolver_static.a
+
+Android
+
+libcusolver.so, libcusolver_static.a
+
+Component
+
+CUDA Random Number Generation Library
+
+Windows
+
+curand.dll, curand.lib
+
+Mac OSX
+
+libcurand.dylib, libcurand_static.a
+
+Linux
+
+libcurand.so, libcurand_static.a
+
+Android
+
+libcurand.so, libcurand_static.a
+
+Component
+
+NVIDIA Performance Primitives Library
+
+Windows
+
+nppc.dll, nppc.lib, nppial.dll, nppial.lib, nppicc.dll,
+nppicc.lib, nppicom.dll, nppicom.lib, nppidei.dll,
+nppidei.lib, nppif.dll, nppif.lib, nppig.dll, nppig.lib,
+nppim.dll, nppim.lib, nppist.dll, nppist.lib, nppisu.dll,
+nppisu.lib, nppitc.dll, nppitc.lib, npps.dll, npps.lib
+
+Mac OSX
+
+libnppc.dylib, libnppc_static.a, libnppial.dylib,
+libnppial_static.a, libnppicc.dylib, libnppicc_static.a,
+libnppicom.dylib, libnppicom_static.a, libnppidei.dylib,
+libnppidei_static.a, libnppif.dylib, libnppif_static.a,
+libnppig.dylib, libnppig_static.a, libnppim.dylib,
+libnppisu_static.a, libnppitc.dylib, libnppitc_static.a,
+libnpps.dylib, libnpps_static.a
+
+Linux
+
+libnppc.so, libnppc_static.a, libnppial.so,
+libnppial_static.a, libnppicc.so, libnppicc_static.a,
+libnppicom.so, libnppicom_static.a, libnppidei.so,
+libnppidei_static.a, libnppif.so, libnppif_static.a
+libnppig.so, libnppig_static.a, libnppim.so,
+libnppim_static.a, libnppist.so, libnppist_static.a,
+libnppisu.so, libnppisu_static.a, libnppitc.so
+libnppitc_static.a, libnpps.so, libnpps_static.a
+
+Android
+
+libnppc.so, libnppc_static.a, libnppial.so,
+libnppial_static.a, libnppicc.so, libnppicc_static.a,
+libnppicom.so, libnppicom_static.a, libnppidei.so,
+libnppidei_static.a, libnppif.so, libnppif_static.a
+libnppig.so, libnppig_static.a, libnppim.so,
+libnppim_static.a, libnppist.so, libnppist_static.a,
+libnppisu.so, libnppisu_static.a, libnppitc.so
+libnppitc_static.a, libnpps.so, libnpps_static.a
+
+Component
+
+NVIDIA JPEG Library
+
+Windows
+
+nvjpeg.lib, nvjpeg.dll
+
+Linux
+
+libnvjpeg.so, libnvjpeg_static.a
+
+Component
+
+Internal common library required for statically linking to
+cuBLAS, cuSPARSE, cuFFT, cuRAND, nvJPEG and NPP
+
+Mac OSX
+
+libculibos.a
+
+Linux
+
+libculibos.a
+
+Component
+
+NVIDIA Runtime Compilation Library and Header
+
+All
+
+nvrtc.h
+
+Windows
+
+nvrtc.dll, nvrtc-builtins.dll
+
+Mac OSX
+
+libnvrtc.dylib, libnvrtc-builtins.dylib
+
+Linux
+
+libnvrtc.so, libnvrtc-builtins.so, libnvrtc_static.a, libnvrtx-builtins_static.a
+
+Component
+
+NVIDIA Optimizing Compiler Library
+
+Windows
+
+nvvm.dll
+
+Mac OSX
+
+libnvvm.dylib
+
+Linux
+
+libnvvm.so
+
+Component
+
+NVIDIA JIT Linking Library
+
+Windows
+
+libnvJitLink.dll, libnvJitLink.lib
+
+Linux
+
+libnvJitLink.so, libnvJitLink_static.a
+
+Component
+
+NVIDIA Common Device Math Functions Library
+
+Windows
+
+libdevice.10.bc
+
+Mac OSX
+
+libdevice.10.bc
+
+Linux
+
+libdevice.10.bc
+
+Component
+
+CUDA Occupancy Calculation Header Library
+
+All
+
+cuda_occupancy.h
+
+Component
+
+CUDA Half Precision Headers
+
+All
+
+cuda_fp16.h, cuda_fp16.hpp
+
+Component
+
+CUDA Profiling Tools Interface (CUPTI) Library
+
+Windows
+
+cupti.dll
+
+Mac OSX
+
+libcupti.dylib
+
+Linux
+
+libcupti.so
+
+Component
+
+NVIDIA Tools Extension Library
+
+Windows
+
+nvToolsExt.dll, nvToolsExt.lib
+
+Mac OSX
+
+libnvToolsExt.dylib
+
+Linux
+
+libnvToolsExt.so
+
+Component
+
+NVIDIA CUDA Driver Libraries
+
+Linux
+
+libcuda.so, libnvidia-ptxjitcompiler.so, libnvptxcompiler_static.a
+
+Component
+
+NVIDIA CUDA File IO Libraries and Header
+
+All
+
+cufile.h
+
+Linux
+
+libcufile.so, libcufile_rdma.so, libcufile_static.a,
+libcufile_rdma_static.a
+
+In addition to the rights above, for parties that are
+developing software intended solely for use on Jetson
+development kits or Jetson modules, and running Linux for
+Tegra software, the following shall apply:
+
+  * The SDK may be distributed in its entirety, as provided by
+    NVIDIA, and without separation of its components, for you
+    and/or your licensees to create software development kits
+    for use only on the Jetson platform and running Linux for
+    Tegra software.
+
+
+2.7. Attachment B
+
+
+Additional Licensing Obligations
+
+The following third party components included in the SOFTWARE
+are licensed to Licensee pursuant to the following terms and
+conditions:
+
+  1. Licensee's use of the GDB third party component is
+    subject to the terms and conditions of GNU GPL v3:
+
+    This product includes copyrighted third-party software licensed
+    under the terms of the GNU General Public License v3 ("GPL v3").
+    All third-party software packages are copyright by their respective
+    authors. GPL v3 terms and conditions are hereby incorporated into
+    the Agreement by this reference:     http://www.gnu.org/licenses/gpl.txt
+
+    Consistent with these licensing requirements, the software
+    listed below is provided under the terms of the specified
+    open source software licenses. To obtain source code for
+    software provided under licenses that require
+    redistribution of source code, including the GNU General
+    Public License (GPL) and GNU Lesser General Public License
+    (LGPL), contact oss-requests@nvidia.com. This offer is
+    valid for a period of three (3) years from the date of the
+    distribution of this product by NVIDIA CORPORATION.
+
+    Component          License
+    CUDA-GDB           GPL v3  
+
+  2. Licensee represents and warrants that any and all third
+    party licensing and/or royalty payment obligations in
+    connection with Licensee's use of the H.264 video codecs
+    are solely the responsibility of Licensee.
+
+  3. Licensee's use of the Thrust library is subject to the
+    terms and conditions of the Apache License Version 2.0.
+    All third-party software packages are copyright by their
+    respective authors. Apache License Version 2.0 terms and
+    conditions are hereby incorporated into the Agreement by
+    this reference.
+    http://www.apache.org/licenses/LICENSE-2.0.html
+
+    In addition, Licensee acknowledges the following notice:
+    Thrust includes source code from the Boost Iterator,
+    Tuple, System, and Random Number libraries.
+
+    Boost Software License - Version 1.0 - August 17th, 2003
+    . . . .
+    
+    Permission is hereby granted, free of charge, to any person or 
+    organization obtaining a copy of the software and accompanying 
+    documentation covered by this license (the "Software") to use, 
+    reproduce, display, distribute, execute, and transmit the Software, 
+    and to prepare derivative works of the Software, and to permit 
+    third-parties to whom the Software is furnished to do so, all 
+    subject to the following:
+    
+    The copyright notices in the Software and this entire statement, 
+    including the above license grant, this restriction and the following 
+    disclaimer, must be included in all copies of the Software, in whole 
+    or in part, and all derivative works of the Software, unless such 
+    copies or derivative works are solely in the form of machine-executable 
+    object code generated by a source language processor.
+    
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND 
+    NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR 
+    ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR 
+    OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING 
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 
+    OTHER DEALINGS IN THE SOFTWARE.  
+
+  4. Licensee's use of the LLVM third party component is
+    subject to the following terms and conditions:
+
+    ======================================================
+    LLVM Release License
+    ======================================================
+    University of Illinois/NCSA
+    Open Source License
+    
+    Copyright (c) 2003-2010 University of Illinois at Urbana-Champaign.
+    All rights reserved.
+    
+    Developed by:
+    
+        LLVM Team
+    
+        University of Illinois at Urbana-Champaign
+    
+        http://llvm.org
+    
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to 
+    deal with the Software without restriction, including without limitation the
+    rights to use, copy, modify, merge, publish, distribute, sublicense, and/or 
+    sell copies of the Software, and to permit persons to whom the Software is 
+    furnished to do so, subject to the following conditions:
+    
+    *  Redistributions of source code must retain the above copyright notice, 
+       this list of conditions and the following disclaimers.
+    
+    *  Redistributions in binary form must reproduce the above copyright 
+       notice, this list of conditions and the following disclaimers in the 
+       documentation and/or other materials provided with the distribution.
+    
+    *  Neither the names of the LLVM Team, University of Illinois at Urbana-
+       Champaign, nor the names of its contributors may be used to endorse or
+       promote products derived from this Software without specific prior 
+       written permission.
+    
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL 
+    THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 
+    OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+    ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+    DEALINGS WITH THE SOFTWARE.  
+
+  5. Licensee's use of the PCRE third party component is
+    subject to the following terms and conditions:
+
+    ------------
+    PCRE LICENCE
+    ------------
+    PCRE is a library of functions to support regular expressions whose syntax
+    and semantics are as close as possible to those of the Perl 5 language.
+    Release 8 of PCRE is distributed under the terms of the "BSD" licence, as
+    specified below. The documentation for PCRE, supplied in the "doc" 
+    directory, is distributed under the same terms as the software itself. The
+    basic library functions are written in C and are freestanding. Also 
+    included in the distribution is a set of C++ wrapper functions, and a just-
+    in-time compiler that can be used to optimize pattern matching. These are 
+    both optional features that can be omitted when the library is built.
+    
+    THE BASIC LIBRARY FUNCTIONS
+    ---------------------------
+    Written by:       Philip Hazel
+    Email local part: ph10
+    Email domain:     cam.ac.uk
+    University of Cambridge Computing Service,
+    Cambridge, England.
+    Copyright (c) 1997-2012 University of Cambridge
+    All rights reserved.
+    
+    PCRE JUST-IN-TIME COMPILATION SUPPORT
+    -------------------------------------
+    Written by:       Zoltan Herczeg
+    Email local part: hzmester
+    Emain domain:     freemail.hu
+    Copyright(c) 2010-2012 Zoltan Herczeg
+    All rights reserved.
+    
+    STACK-LESS JUST-IN-TIME COMPILER
+    --------------------------------
+    Written by:       Zoltan Herczeg
+    Email local part: hzmester
+    Emain domain:     freemail.hu
+    Copyright(c) 2009-2012 Zoltan Herczeg
+    All rights reserved.
+    
+    THE C++ WRAPPER FUNCTIONS
+    -------------------------
+    Contributed by:   Google Inc.
+    Copyright (c) 2007-2012, Google Inc.
+    All rights reserved.
+
+    THE "BSD" LICENCE
+    -----------------
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are met:
+    
+      * Redistributions of source code must retain the above copyright notice, 
+        this list of conditions and the following disclaimer.
+    
+      * Redistributions in binary form must reproduce the above copyright 
+        notice, this list of conditions and the following disclaimer in the 
+        documentation and/or other materials provided with the distribution.
+    
+      * Neither the name of the University of Cambridge nor the name of Google 
+        Inc. nor the names of their contributors may be used to endorse or 
+        promote products derived from this software without specific prior 
+        written permission.
+    
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+    ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 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.  
+
+  6. Some of the cuBLAS library routines were written by or
+    derived from code written by Vasily Volkov and are subject
+    to the Modified Berkeley Software Distribution License as
+    follows:
+
+    Copyright (c) 2007-2009, Regents of the University of California
+    
+    All rights reserved.
+    
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+        * Redistributions of source code must retain the above copyright
+          notice, this list of conditions and the following disclaimer.
+        * Redistributions in binary form must reproduce the above
+          copyright notice, this list of conditions and the following
+          disclaimer in the documentation and/or other materials provided
+          with the distribution.
+        * Neither the name of the University of California, Berkeley nor
+          the names of its contributors may be used to endorse or promote
+          products derived from this software without specific prior
+          written permission.
+    
+    THIS SOFTWARE IS PROVIDED BY THE AUTHOR "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 THE AUTHOR 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.  
+
+  7. Some of the cuBLAS library routines were written by or
+    derived from code written by Davide Barbieri and are
+    subject to the Modified Berkeley Software Distribution
+    License as follows:
+
+    Copyright (c) 2008-2009 Davide Barbieri @ University of Rome Tor Vergata.
+    
+    All rights reserved.
+    
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+        * Redistributions of source code must retain the above copyright
+          notice, this list of conditions and the following disclaimer.
+        * Redistributions in binary form must reproduce the above
+          copyright notice, this list of conditions and the following
+          disclaimer in the documentation and/or other materials provided
+          with the distribution.
+        * The name of the author may not be used to endorse or promote
+          products derived from this software without specific prior
+          written permission.
+    
+    THIS SOFTWARE IS PROVIDED BY THE AUTHOR "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 THE AUTHOR 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.  
+
+  8. Some of the cuBLAS library routines were derived from
+    code developed by the University of Tennessee and are
+    subject to the Modified Berkeley Software Distribution
+    License as follows:
+
+    Copyright (c) 2010 The University of Tennessee.
+    
+    All rights reserved.
+    
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+        * Redistributions of source code must retain the above copyright
+          notice, this list of conditions and the following disclaimer.
+        * Redistributions in binary form must reproduce the above
+          copyright notice, this list of conditions and the following
+          disclaimer listed in this license in the documentation and/or
+          other materials provided with the distribution.
+        * Neither the name of the copyright holders nor the names of its
+          contributors may be used to endorse or promote products derived
+          from this software without specific prior written permission.
+    
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR 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.  
+
+  9. Some of the cuBLAS library routines were written by or
+    derived from code written by Jonathan Hogg and are subject
+    to the Modified Berkeley Software Distribution License as
+    follows:
+
+    Copyright (c) 2012, The Science and Technology Facilities Council (STFC).
+    
+    All rights reserved.
+    
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+        * Redistributions of source code must retain the above copyright
+          notice, this list of conditions and the following disclaimer.
+        * Redistributions in binary form must reproduce the above
+          copyright notice, this list of conditions and the following
+          disclaimer in the documentation and/or other materials provided
+          with the distribution.
+        * Neither the name of the STFC nor the names of its contributors
+          may be used to endorse or promote products derived from this
+          software without specific prior written permission.
+    
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE STFC 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.  
+
+  10. Some of the cuBLAS library routines were written by or
+    derived from code written by Ahmad M. Abdelfattah, David
+    Keyes, and Hatem Ltaief, and are subject to the Apache
+    License, Version 2.0, as follows:
+
+     -- (C) Copyright 2013 King Abdullah University of Science and Technology
+      Authors:
+      Ahmad Abdelfattah (ahmad.ahmad@kaust.edu.sa)
+      David Keyes (david.keyes@kaust.edu.sa)
+      Hatem Ltaief (hatem.ltaief@kaust.edu.sa)
+    
+      Redistribution  and  use  in  source and binary forms, with or without
+      modification,  are  permitted  provided  that the following conditions
+      are met:
+    
+      * Redistributions  of  source  code  must  retain  the above copyright
+        notice,  this  list  of  conditions  and  the  following  disclaimer.
+      * Redistributions  in  binary  form must reproduce the above copyright
+        notice,  this list of conditions and the following disclaimer in the
+        documentation  and/or other materials provided with the distribution.
+      * Neither  the  name of the King Abdullah University of Science and
+        Technology nor the names of its contributors may be used to endorse 
+        or promote products derived from this software without specific prior 
+        written permission.
+    
+      THIS  SOFTWARE  IS  PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+      ``AS IS''  AND  ANY  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+      LIMITED  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+      A  PARTICULAR  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+      HOLDERS OR 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  
+
+  11. Some of the cuSPARSE library routines were written by or
+    derived from code written by Li-Wen Chang and are subject
+    to the NCSA Open Source License as follows:
+
+    Copyright (c) 2012, University of Illinois.
+    
+    All rights reserved.
+    
+    Developed by: IMPACT Group, University of Illinois, http://impact.crhc.illinois.edu
+    
+    Permission is hereby granted, free of charge, to any person obtaining
+    a copy of this software and associated documentation files (the
+    "Software"), to deal with the Software without restriction, including
+    without limitation the rights to use, copy, modify, merge, publish,
+    distribute, sublicense, and/or sell copies of the Software, and to
+    permit persons to whom the Software is furnished to do so, subject to
+    the following conditions:
+        * Redistributions of source code must retain the above copyright
+          notice, this list of conditions and the following disclaimer.
+        * Redistributions in binary form must reproduce the above
+          copyright notice, this list of conditions and the following
+          disclaimers in the documentation and/or other materials provided
+          with the distribution.
+        * Neither the names of IMPACT Group, University of Illinois, nor
+          the names of its contributors may be used to endorse or promote
+          products derived from this Software without specific prior
+          written permission.
+    
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    NONINFRINGEMENT. IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT
+    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+    IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+    IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
+    SOFTWARE.  
+
+  12. Some of the cuRAND library routines were written by or
+    derived from code written by Mutsuo Saito and Makoto
+    Matsumoto and are subject to the following license:
+
+    Copyright (c) 2009, 2010 Mutsuo Saito, Makoto Matsumoto and Hiroshima
+    University. All rights reserved.
+    
+    Copyright (c) 2011 Mutsuo Saito, Makoto Matsumoto, Hiroshima
+    University and University of Tokyo.  All rights reserved.
+    
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+        * Redistributions of source code must retain the above copyright
+          notice, this list of conditions and the following disclaimer.
+        * Redistributions in binary form must reproduce the above
+          copyright notice, this list of conditions and the following
+          disclaimer in the documentation and/or other materials provided
+          with the distribution.
+        * Neither the name of the Hiroshima University nor the names of
+          its contributors may be used to endorse or promote products
+          derived from this software without specific prior written
+          permission.
+    
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR 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.  
+
+  13. Some of the cuRAND library routines were derived from
+    code developed by D. E. Shaw Research and are subject to
+    the following license:
+
+    Copyright 2010-2011, D. E. Shaw Research.
+    
+    All rights reserved.
+    
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+        * Redistributions of source code must retain the above copyright
+          notice, this list of conditions, and the following disclaimer.
+        * Redistributions in binary form must reproduce the above
+          copyright notice, this list of conditions, and the following
+          disclaimer in the documentation and/or other materials provided
+          with the distribution.
+        * Neither the name of D. E. Shaw Research nor the names of its
+          contributors may be used to endorse or promote products derived
+          from this software without specific prior written permission.
+    
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR 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.  
+
+  14. Some of the Math library routines were written by or
+    derived from code developed by Norbert Juffa and are
+    subject to the following license:
+
+    Copyright (c) 2015-2017, Norbert Juffa
+    All rights reserved.
+    
+    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.
+    
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    HOLDER OR 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.  
+
+  15. Licensee's use of the lz4 third party component is
+    subject to the following terms and conditions:
+
+    Copyright (C) 2011-2013, Yann Collet.
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+    
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+    
+        * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+        * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+    
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR 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.  
+
+  16. The NPP library uses code from the Boost Math Toolkit,
+    and is subject to the following license:
+
+    Boost Software License - Version 1.0 - August 17th, 2003
+    . . . .
+    
+    Permission is hereby granted, free of charge, to any person or 
+    organization obtaining a copy of the software and accompanying 
+    documentation covered by this license (the "Software") to use, 
+    reproduce, display, distribute, execute, and transmit the Software, 
+    and to prepare derivative works of the Software, and to permit 
+    third-parties to whom the Software is furnished to do so, all 
+    subject to the following:
+    
+    The copyright notices in the Software and this entire statement, 
+    including the above license grant, this restriction and the following 
+    disclaimer, must be included in all copies of the Software, in whole 
+    or in part, and all derivative works of the Software, unless such 
+    copies or derivative works are solely in the form of machine-executable 
+    object code generated by a source language processor.
+    
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND 
+    NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR 
+    ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR 
+    OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING 
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 
+    OTHER DEALINGS IN THE SOFTWARE.  
+
+  17. Portions of the Nsight Eclipse Edition is subject to the
+    following license:
+
+    The Eclipse Foundation makes available all content in this plug-in
+    ("Content"). Unless otherwise indicated below, the Content is provided
+    to you under the terms and conditions of the Eclipse Public License
+    Version 1.0 ("EPL"). A copy of the EPL is available at http://
+    www.eclipse.org/legal/epl-v10.html. For purposes of the EPL, "Program"
+    will mean the Content.
+    
+    If you did not receive this Content directly from the Eclipse
+    Foundation, the Content is being redistributed by another party
+    ("Redistributor") and different terms and conditions may apply to your
+    use of any object code in the Content. Check the Redistributor's
+    license that was provided with the Content. If no such license exists,
+    contact the Redistributor. Unless otherwise indicated below, the terms
+    and conditions of the EPL still apply to any source code in the
+    Content and such source code may be obtained at http://www.eclipse.org.  
+
+  18. Some of the cuBLAS library routines uses code from
+    OpenAI, which is subject to the following license:
+
+    License URL 
+    https://github.com/openai/openai-gemm/blob/master/LICENSE
+    
+    License Text 
+    The MIT License
+    
+    Copyright (c) 2016 OpenAI (http://openai.com), 2016 Google Inc.
+    
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+    
+    The above copyright notice and this permission notice shall be included in
+    all copies or substantial portions of the Software.
+    
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+    THE SOFTWARE.   
+
+  19. Licensee's use of the Visual Studio Setup Configuration
+    Samples is subject to the following license:
+
+    The MIT License (MIT) 
+    Copyright (C) Microsoft Corporation. All rights reserved.
+    
+    Permission is hereby granted, free of charge, to any person 
+    obtaining a copy of this software and associated documentation 
+    files (the "Software"), to deal in the Software without restriction, 
+    including without limitation the rights to use, copy, modify, merge, 
+    publish, distribute, sublicense, and/or sell copies of the Software, 
+    and to permit persons to whom the Software is furnished to do so, 
+    subject to the following conditions:
+    
+    The above copyright notice and this permission notice shall be included 
+    in all copies or substantial portions of the Software.
+    
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
+    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  
+
+  20. Licensee's use of linmath.h header for CPU functions for
+    GL vector/matrix operations from lunarG is subject to the
+    Apache License Version 2.0.
+
+  21. The DX12-CUDA sample uses the d3dx12.h header, which is
+    subject to the MIT license.
+
+  22. Components of the driver and compiler used for binary management, including 
+    nvFatBin, nvcc, and cuobjdump, use the Zstandard library which is subject to
+	the following license:
+
+    BSD License
+
+    For Zstandard software
+
+    Copyright (c) Meta Platforms, Inc. and affiliates. All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without modification,
+ 	are permitted provided that the following conditions are met:
+
+        * Redistributions of source code must retain the above copyright notice, this
+      list of conditions and the following disclaimer.
+
+        * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+
+        * Neither the name Facebook, nor Meta, nor the names of its contributors may
+      be used to endorse or promote products derived from this software without
+      specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 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.
+
+-----------------

cuda_toolkit/include/__assert

@@ -0,0 +1,70 @@
+// -*- 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___ASSERT
+#define _LIBCUDACXX___ASSERT
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "__verbose_abort"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// This is for backwards compatibility with code that might have been enabling
+// assertions through the Debug mode previously.
+// TODO: In LLVM 16, make it an error to define _LIBCUDACXX_DEBUG
+#if defined(_LIBCUDACXX_DEBUG)
+# ifndef _LIBCUDACXX_ENABLE_ASSERTIONS
+#   define _LIBCUDACXX_ENABLE_ASSERTIONS 1
+# endif
+#endif
+
+// Automatically enable assertions when the debug mode is enabled.
+#if defined(_LIBCUDACXX_ENABLE_DEBUG_MODE)
+# ifndef _LIBCUDACXX_ENABLE_ASSERTIONS
+#   define _LIBCUDACXX_ENABLE_ASSERTIONS 1
+# endif
+#endif
+
+#ifndef _LIBCUDACXX_ENABLE_ASSERTIONS
+# define _LIBCUDACXX_ENABLE_ASSERTIONS _LIBCUDACXX_ENABLE_ASSERTIONS_DEFAULT
+#endif
+
+#if _LIBCUDACXX_ENABLE_ASSERTIONS != 0 && _LIBCUDACXX_ENABLE_ASSERTIONS != 1
+# error "_LIBCUDACXX_ENABLE_ASSERTIONS must be set to 0 or 1"
+#endif
+
+#if _LIBCUDACXX_ENABLE_ASSERTIONS
+# define _LIBCUDACXX_ASSERT(expression, message)                                \
+    (_CCCL_DIAG_PUSH                                                            \
+    _CCCL_DIAG_SUPPRESS_CLANG("-Wassume")                                       \
+    __builtin_expect(static_cast<bool>(expression), 1) ?                        \
+      (void)0 :                                                                 \
+      ::_CUDA_VSTD::__libcpp_verbose_abort("%s:%d: assertion %s failed: %s", __FILE__, __LINE__, #expression, message)
+    _CCCL_DIAG_POP)
+#elif 0 // !defined(_LIBCUDACXX_ASSERTIONS_DISABLE_ASSUME) && __has_builtin(__builtin_assume)
+# define _LIBCUDACXX_ASSERT(expression, message)                                \
+    (_CCCL_DIAG_PUSH                                                            \
+    _CCCL_DIAG_SUPPRESS_CLANG("-Wassume")                                       \
+    __builtin_assume(static_cast<bool>(expression))                             \
+    _CCCL_DIAG_POP)
+#else
+# define _LIBCUDACXX_ASSERT(expression, message) ((void)0)
+#endif
+
+#endif // _LIBCUDACXX___ASSERT

cuda_toolkit/include/__availability

@@ -0,0 +1,306 @@
+// -*- 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___AVAILABILITY
+#define _LIBCUDACXX___AVAILABILITY
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// Libc++ is shipped by various vendors. In particular, it is used as a system
+// library on macOS, iOS and other Apple platforms. In order for users to be
+// able to compile a binary that is intended to be deployed to an older version
+// of a platform, Clang provides availability attributes [1]. These attributes
+// can be placed on declarations and are used to describe the life cycle of a
+// symbol in the library.
+//
+// The main goal is to ensure a compile-time error if a symbol that hasn't been
+// introduced in a previously released library is used in a program that targets
+// that previously released library. Normally, this would be a load-time error
+// when one tries to launch the program against the older library.
+//
+// For example, the filesystem library was introduced in the dylib in macOS 10.15.
+// If a user compiles on a macOS 10.15 host but targets macOS 10.13 with their
+// program, the compiler would normally not complain (because the required
+// declarations are in the headers), but the dynamic loader would fail to find
+// the symbols when actually trying to launch the program on macOS 10.13. To
+// turn this into a compile-time issue instead, declarations are annotated with
+// when they were introduced, and the compiler can produce a diagnostic if the
+// program references something that isn't available on the deployment target.
+//
+// This mechanism is general in nature, and any vendor can add their markup to
+// the library (see below). Whenever a new feature is added that requires support
+// in the shared library, a macro should be added below to mark this feature
+// as unavailable. When vendors decide to ship the feature as part of their
+// shared library, they can update the markup appropriately.
+//
+// Furthermore, many features in the standard library have corresponding
+// feature-test macros. When a feature is made unavailable on some deployment
+// target, a macro should be defined to signal that it is unavailable. That
+// macro can then be picked up when feature-test macros are generated (see
+// generate_feature_test_macro_components.py) to make sure that feature-test
+// macros don't announce a feature as being implemented if it has been marked
+// as unavailable.
+//
+// Note that this mechanism is disabled by default in the "upstream" libc++.
+// Availability annotations are only meaningful when shipping libc++ inside
+// a platform (i.e. as a system library), and so vendors that want them should
+// turn those annotations on at CMake configuration time.
+//
+// [1]: https://clang.llvm.org/docs/AttributeReference.html#availability
+
+
+// For backwards compatibility, allow users to define _LIBCUDACXX_DISABLE_AVAILABILITY
+// for a while.
+#if defined(_LIBCUDACXX_DISABLE_AVAILABILITY)
+#   if !defined(_LIBCUDACXX_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS)
+#       define _LIBCUDACXX_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS
+#   endif
+#endif
+
+// Availability markup is disabled when building the library, or when the compiler
+// doesn't support the proper attributes.
+#if defined(_LIBCUDACXX_BUILDING_LIBRARY) ||                                        \
+    defined(_LIBCXXABI_BUILDING_LIBRARY) ||                                     \
+    !__has_feature(attribute_availability_with_strict) ||                       \
+    !__has_feature(attribute_availability_in_templates) ||                      \
+    !__has_extension(pragma_clang_attribute_external_declaration)
+#   if !defined(_LIBCUDACXX_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS)
+#       define _LIBCUDACXX_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS
+#   endif
+#endif
+
+#if defined(_LIBCUDACXX_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS)
+
+    // This controls the availability of std::shared_mutex and std::shared_timed_mutex,
+    // which were added to the dylib later.
+#   define _LIBCUDACXX_AVAILABILITY_SHARED_MUTEX
+// #   define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_mutex
+// #   define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_timed_mutex
+
+    // These macros control the availability of std::bad_optional_access and
+    // other exception types. These were put in the shared library to prevent
+    // code bloat from every user program defining the vtable for these exception
+    // types.
+    //
+    // Note that when exceptions are disabled, the methods that normally throw
+    // these exceptions can be used even on older deployment targets, but those
+    // methods will abort instead of throwing.
+#   define _LIBCUDACXX_AVAILABILITY_BAD_OPTIONAL_ACCESS
+#   define _LIBCUDACXX_AVAILABILITY_BAD_VARIANT_ACCESS
+#   define _LIBCUDACXX_AVAILABILITY_BAD_ANY_CAST
+
+    // This controls the availability of std::uncaught_exceptions().
+#   define _LIBCUDACXX_AVAILABILITY_UNCAUGHT_EXCEPTIONS
+
+    // This controls the availability of the sized version of ::operator delete,
+    // ::operator delete[], and their align_val_t variants, which were all added
+    // in C++17, and hence not present in early dylibs.
+#   define _LIBCUDACXX_AVAILABILITY_SIZED_NEW_DELETE
+
+    // This controls the availability of the std::future_error exception.
+    //
+    // Note that when exceptions are disabled, the methods that normally throw
+    // std::future_error can be used even on older deployment targets, but those
+    // methods will abort instead of throwing.
+#   define _LIBCUDACXX_AVAILABILITY_FUTURE_ERROR
+
+    // This controls the availability of std::type_info's vtable.
+    // I can't imagine how using std::type_info can work at all if
+    // this isn't supported.
+#   define _LIBCUDACXX_AVAILABILITY_TYPEINFO_VTABLE
+
+    // This controls the availability of std::locale::category members
+    // (e.g. std::locale::collate), which are defined in the dylib.
+#   define _LIBCUDACXX_AVAILABILITY_LOCALE_CATEGORY
+
+    // This controls the availability of atomic operations on std::shared_ptr
+    // (e.g. `std::atomic_store(std::shared_ptr)`), which require a shared
+    // lock table located in the dylib.
+#   define _LIBCUDACXX_AVAILABILITY_ATOMIC_SHARED_PTR
+
+    // These macros control the availability of all parts of <filesystem> that
+    // depend on something in the dylib.
+#   define _LIBCUDACXX_AVAILABILITY_FILESYSTEM
+#   define _LIBCUDACXX_AVAILABILITY_FILESYSTEM_PUSH
+#   define _LIBCUDACXX_AVAILABILITY_FILESYSTEM_POP
+// #   define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem
+
+    // This controls the availability of floating-point std::to_chars functions.
+    // These overloads were added later than the integer overloads.
+#   define _LIBCUDACXX_AVAILABILITY_TO_CHARS_FLOATING_POINT
+
+    // This controls the availability of the C++20 synchronization library,
+    // which requires shared library support for various operations
+    // (see libcxx/src/atomic.cpp). This includes <barier>, <latch>,
+    // <semaphore>, and notification functions on std::atomic.
+#   define _LIBCUDACXX_AVAILABILITY_SYNC
+// #   define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_atomic_wait
+// #   define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_barrier
+// #   define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_latch
+// #   define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_semaphore
+
+    // This controls the availability of the C++20 format library.
+    // The library is in development and not ABI stable yet. P2216 is
+    // retroactively accepted in C++20. This paper contains ABI breaking
+    // changes.
+#   define _LIBCUDACXX_AVAILABILITY_FORMAT
+// #   define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_format
+
+    // This controls whether the default verbose termination function is
+    // provided by the library.
+    //
+    // Note that when users provide their own custom function, it doesn't
+    // matter whether the dylib provides a default function, and the
+    // availability markup can actually give a false positive diagnostic
+    // (it will think that no function is provided, when in reality the
+    // user has provided their own).
+    //
+    // Users can pass -D_LIBCUDACXX_AVAILABILITY_CUSTOM_VERBOSE_ABORT_PROVIDED
+    // to the compiler to tell the library not to define its own verbose abort.
+    // Note that defining this macro but failing to define a custom function
+    // will lead to a load-time error on back-deployment targets, so it should
+    // be avoided.
+// #   define _LIBCUDACXX_HAS_NO_VERBOSE_ABORT_IN_LIBRARY
+
+#elif defined(__APPLE__)
+
+#   define _LIBCUDACXX_AVAILABILITY_SHARED_MUTEX                                    \
+        __attribute__((availability(macos,strict,introduced=10.12)))            \
+        __attribute__((availability(ios,strict,introduced=10.0)))               \
+        __attribute__((availability(tvos,strict,introduced=10.0)))              \
+        __attribute__((availability(watchos,strict,introduced=3.0)))
+#   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101200) ||    \
+        (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 100000) || \
+        (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 100000) ||         \
+        (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 30000)
+#       define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_mutex
+#       define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_timed_mutex
+#   endif
+
+        // Note: bad_optional_access & friends were not introduced in the matching
+        // macOS and iOS versions, so the version mismatch between macOS and others
+        // is intended.
+#   define _LIBCUDACXX_AVAILABILITY_BAD_OPTIONAL_ACCESS                             \
+        __attribute__((availability(macos,strict,introduced=10.13)))            \
+        __attribute__((availability(ios,strict,introduced=12.0)))               \
+        __attribute__((availability(tvos,strict,introduced=12.0)))              \
+        __attribute__((availability(watchos,strict,introduced=5.0)))
+#   define _LIBCUDACXX_AVAILABILITY_BAD_VARIANT_ACCESS                              \
+        _LIBCUDACXX_AVAILABILITY_BAD_OPTIONAL_ACCESS
+#   define _LIBCUDACXX_AVAILABILITY_BAD_ANY_CAST                                    \
+        _LIBCUDACXX_AVAILABILITY_BAD_OPTIONAL_ACCESS
+
+#   define _LIBCUDACXX_AVAILABILITY_UNCAUGHT_EXCEPTIONS                             \
+        __attribute__((availability(macos,strict,introduced=10.12)))            \
+        __attribute__((availability(ios,strict,introduced=10.0)))               \
+        __attribute__((availability(tvos,strict,introduced=10.0)))              \
+        __attribute__((availability(watchos,strict,introduced=3.0)))
+
+#   define _LIBCUDACXX_AVAILABILITY_SIZED_NEW_DELETE                                \
+        __attribute__((availability(macos,strict,introduced=10.12)))            \
+        __attribute__((availability(ios,strict,introduced=10.0)))               \
+        __attribute__((availability(tvos,strict,introduced=10.0)))              \
+        __attribute__((availability(watchos,strict,introduced=3.0)))
+
+#   define _LIBCUDACXX_AVAILABILITY_FUTURE_ERROR                                    \
+        __attribute__((availability(ios,strict,introduced=6.0)))
+
+#   define _LIBCUDACXX_AVAILABILITY_TYPEINFO_VTABLE                                 \
+        __attribute__((availability(macos,strict,introduced=10.9)))             \
+        __attribute__((availability(ios,strict,introduced=7.0)))
+
+#   define _LIBCUDACXX_AVAILABILITY_LOCALE_CATEGORY                                 \
+        __attribute__((availability(macos,strict,introduced=10.9)))             \
+        __attribute__((availability(ios,strict,introduced=7.0)))
+
+#   define _LIBCUDACXX_AVAILABILITY_ATOMIC_SHARED_PTR                               \
+        __attribute__((availability(macos,strict,introduced=10.9)))             \
+        __attribute__((availability(ios,strict,introduced=7.0)))
+
+#   define _LIBCUDACXX_AVAILABILITY_FILESYSTEM                                      \
+        __attribute__((availability(macos,strict,introduced=10.15)))            \
+        __attribute__((availability(ios,strict,introduced=13.0)))               \
+        __attribute__((availability(tvos,strict,introduced=13.0)))              \
+        __attribute__((availability(watchos,strict,introduced=6.0)))
+#   define _LIBCUDACXX_AVAILABILITY_FILESYSTEM_PUSH                                 \
+        _Pragma("clang attribute push(__attribute__((availability(macos,strict,introduced=10.15))), apply_to=any(function,record))") \
+        _Pragma("clang attribute push(__attribute__((availability(ios,strict,introduced=13.0))), apply_to=any(function,record))")    \
+        _Pragma("clang attribute push(__attribute__((availability(tvos,strict,introduced=13.0))), apply_to=any(function,record))")   \
+        _Pragma("clang attribute push(__attribute__((availability(watchos,strict,introduced=6.0))), apply_to=any(function,record))")
+#   define _LIBCUDACXX_AVAILABILITY_FILESYSTEM_POP                                  \
+        _Pragma("clang attribute pop")                                          \
+        _Pragma("clang attribute pop")                                          \
+        _Pragma("clang attribute pop")                                          \
+        _Pragma("clang attribute pop")
+#   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101500) ||    \
+        (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 130000) || \
+        (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 130000) ||         \
+        (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 60000)
+#       define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem
+#   endif
+
+#   define _LIBCUDACXX_AVAILABILITY_TO_CHARS_FLOATING_POINT                         \
+        __attribute__((unavailable))
+
+#   define _LIBCUDACXX_AVAILABILITY_SYNC                                            \
+        __attribute__((availability(macos,strict,introduced=11.0)))             \
+        __attribute__((availability(ios,strict,introduced=14.0)))               \
+        __attribute__((availability(tvos,strict,introduced=14.0)))              \
+        __attribute__((availability(watchos,strict,introduced=7.0)))
+#   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 110000) ||    \
+        (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 140000) || \
+        (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 140000) ||         \
+        (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 70000)
+#       define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_atomic_wait
+#       define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_barrier
+#       define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_latch
+#       define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_semaphore
+#   endif
+
+#   define _LIBCUDACXX_AVAILABILITY_FORMAT                                          \
+        __attribute__((unavailable))
+#   define _LIBCUDACXX_AVAILABILITY_DISABLE_FTM___cpp_lib_format
+
+#   define _LIBCUDACXX_HAS_NO_VERBOSE_ABORT_IN_LIBRARY
+
+#else
+
+// ...New vendors can add availability markup here...
+
+#   error "It looks like you're trying to enable vendor availability markup, but you haven't defined the corresponding macros yet!"
+
+#endif
+
+// Define availability attributes that depend on _LIBCUDACXX_NO_EXCEPTIONS.
+// Those are defined in terms of the availability attributes above, and
+// should not be vendor-specific.
+#if defined(_LIBCUDACXX_NO_EXCEPTIONS)
+#   define _LIBCUDACXX_AVAILABILITY_FUTURE
+#   define _LIBCUDACXX_AVAILABILITY_THROW_BAD_ANY_CAST
+#   define _LIBCUDACXX_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
+#   define _LIBCUDACXX_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
+#else
+#   define _LIBCUDACXX_AVAILABILITY_FUTURE                    _LIBCUDACXX_AVAILABILITY_FUTURE_ERROR
+#   define _LIBCUDACXX_AVAILABILITY_THROW_BAD_ANY_CAST        _LIBCUDACXX_AVAILABILITY_BAD_ANY_CAST
+#   define _LIBCUDACXX_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS _LIBCUDACXX_AVAILABILITY_BAD_OPTIONAL_ACCESS
+#   define _LIBCUDACXX_AVAILABILITY_THROW_BAD_VARIANT_ACCESS  _LIBCUDACXX_AVAILABILITY_BAD_VARIANT_ACCESS
+#endif
+
+#endif // _LIBCUDACXX___AVAILABILITY

cuda_toolkit/include/__bit_reference

@@ -0,0 +1,1293 @@
+// -*- 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___BIT_REFERENCE
+#define _LIBCUDACXX___BIT_REFERENCE
+
+#include <__config>
+#include <bit>
+#include <algorithm>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_PUSH_MACROS
+#include <__undef_macros>
+
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Cp, bool _IsConst, typename _Cp::__storage_type = 0> class __bit_iterator;
+template <class _Cp> class __bit_const_reference;
+
+template <class _Tp>
+struct __has_storage_type
+{
+    static const bool value = false;
+};
+
+template <class _Cp, bool = __has_storage_type<_Cp>::value>
+class __bit_reference
+{
+    typedef typename _Cp::__storage_type    __storage_type;
+    typedef typename _Cp::__storage_pointer __storage_pointer;
+
+    __storage_pointer __seg_;
+    __storage_type    __mask_;
+
+    friend typename _Cp::__self;
+
+    friend class __bit_const_reference<_Cp>;
+    friend class __bit_iterator<_Cp, false>;
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __bit_reference(const __bit_reference&) = default;
+
+    _LIBCUDACXX_INLINE_VISIBILITY operator bool() const noexcept
+        {return static_cast<bool>(*__seg_ & __mask_);}
+    _LIBCUDACXX_INLINE_VISIBILITY bool operator ~() const noexcept
+        {return !static_cast<bool>(*this);}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __bit_reference& operator=(bool __x) noexcept
+    {
+        if (__x)
+            *__seg_ |= __mask_;
+        else
+            *__seg_ &= ~__mask_;
+        return *this;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __bit_reference& operator=(const __bit_reference& __x) noexcept
+        {return operator=(static_cast<bool>(__x));}
+
+    _LIBCUDACXX_INLINE_VISIBILITY void flip() noexcept {*__seg_ ^= __mask_;}
+    _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator<_Cp, false> operator&() const noexcept
+        {return __bit_iterator<_Cp, false>(__seg_, static_cast<unsigned>(__libcpp_ctz(__mask_)));}
+private:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __bit_reference(__storage_pointer __s, __storage_type __m) noexcept
+        : __seg_(__s), __mask_(__m) {}
+};
+
+template <class _Cp>
+class __bit_reference<_Cp, false>
+{
+};
+
+template <class _Cp>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+void
+swap(__bit_reference<_Cp> __x, __bit_reference<_Cp> __y) noexcept
+{
+    bool __t = __x;
+    __x = __y;
+    __y = __t;
+}
+
+template <class _Cp, class _Dp>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+void
+swap(__bit_reference<_Cp> __x, __bit_reference<_Dp> __y) noexcept
+{
+    bool __t = __x;
+    __x = __y;
+    __y = __t;
+}
+
+template <class _Cp>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+void
+swap(__bit_reference<_Cp> __x, bool& __y) noexcept
+{
+    bool __t = __x;
+    __x = __y;
+    __y = __t;
+}
+
+template <class _Cp>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+void
+swap(bool& __x, __bit_reference<_Cp> __y) noexcept
+{
+    bool __t = __x;
+    __x = __y;
+    __y = __t;
+}
+
+template <class _Cp>
+class __bit_const_reference
+{
+    typedef typename _Cp::__storage_type          __storage_type;
+    typedef typename _Cp::__const_storage_pointer __storage_pointer;
+
+    __storage_pointer        __seg_;
+    __storage_type __mask_;
+
+    friend typename _Cp::__self;
+    friend class __bit_iterator<_Cp, true>;
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __bit_const_reference(const __bit_const_reference&) = default;
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __bit_const_reference(const __bit_reference<_Cp>& __x) noexcept
+        : __seg_(__x.__seg_), __mask_(__x.__mask_) {}
+
+    _LIBCUDACXX_INLINE_VISIBILITY constexpr operator bool() const noexcept
+        {return static_cast<bool>(*__seg_ & __mask_);}
+
+    _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator<_Cp, true> operator&() const noexcept
+        {return __bit_iterator<_Cp, true>(__seg_, static_cast<unsigned>(__libcpp_ctz(__mask_)));}
+private:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    constexpr
+    __bit_const_reference(__storage_pointer __s, __storage_type __m) noexcept
+        : __seg_(__s), __mask_(__m) {}
+
+    __bit_const_reference& operator=(const __bit_const_reference&) = delete;
+};
+
+// find
+
+template <class _Cp, bool _IsConst>
+__bit_iterator<_Cp, _IsConst>
+__find_bool_true(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n)
+{
+    typedef __bit_iterator<_Cp, _IsConst> _It;
+    typedef typename _It::__storage_type __storage_type;
+    static const int __bits_per_word = _It::__bits_per_word;
+    // do first partial word
+    if (__first.__ctz_ != 0)
+    {
+        __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
+        __storage_type __dn = _CUDA_VSTD::min(__clz_f, __n);
+        __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
+        __storage_type __b = *__first.__seg_ & __m;
+        if (__b)
+            return _It(__first.__seg_, static_cast<unsigned>(_CUDA_VSTD::__libcpp_ctz(__b)));
+        if (__n == __dn)
+            return __first + __n;
+        __n -= __dn;
+        ++__first.__seg_;
+    }
+    // do middle whole words
+    for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word)
+        if (*__first.__seg_)
+            return _It(__first.__seg_, static_cast<unsigned>(_CUDA_VSTD::__libcpp_ctz(*__first.__seg_)));
+    // do last partial word
+    if (__n > 0)
+    {
+        __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
+        __storage_type __b = *__first.__seg_ & __m;
+        if (__b)
+            return _It(__first.__seg_, static_cast<unsigned>(_CUDA_VSTD::__libcpp_ctz(__b)));
+    }
+    return _It(__first.__seg_, static_cast<unsigned>(__n));
+}
+
+template <class _Cp, bool _IsConst>
+__bit_iterator<_Cp, _IsConst>
+__find_bool_false(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n)
+{
+    typedef __bit_iterator<_Cp, _IsConst> _It;
+    typedef typename _It::__storage_type __storage_type;
+    const int __bits_per_word = _It::__bits_per_word;
+    // do first partial word
+    if (__first.__ctz_ != 0)
+    {
+        __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
+        __storage_type __dn = _CUDA_VSTD::min(__clz_f, __n);
+        __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
+        __storage_type __b = ~*__first.__seg_ & __m;
+        if (__b)
+            return _It(__first.__seg_, static_cast<unsigned>(_CUDA_VSTD::__libcpp_ctz(__b)));
+        if (__n == __dn)
+            return __first + __n;
+        __n -= __dn;
+        ++__first.__seg_;
+    }
+    // do middle whole words
+    for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word)
+    {
+        __storage_type __b = ~*__first.__seg_;
+        if (__b)
+            return _It(__first.__seg_, static_cast<unsigned>(_CUDA_VSTD::__libcpp_ctz(__b)));
+    }
+    // do last partial word
+    if (__n > 0)
+    {
+        __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
+        __storage_type __b = ~*__first.__seg_ & __m;
+        if (__b)
+            return _It(__first.__seg_, static_cast<unsigned>(_CUDA_VSTD::__libcpp_ctz(__b)));
+    }
+    return _It(__first.__seg_, static_cast<unsigned>(__n));
+}
+
+template <class _Cp, bool _IsConst, class _Tp>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+__bit_iterator<_Cp, _IsConst>
+find(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value_)
+{
+    if (static_cast<bool>(__value_))
+        return __find_bool_true(__first, static_cast<typename _Cp::size_type>(__last - __first));
+    return __find_bool_false(__first, static_cast<typename _Cp::size_type>(__last - __first));
+}
+
+// count
+
+template <class _Cp, bool _IsConst>
+typename __bit_iterator<_Cp, _IsConst>::difference_type
+__count_bool_true(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n)
+{
+    typedef __bit_iterator<_Cp, _IsConst> _It;
+    typedef typename _It::__storage_type __storage_type;
+    typedef typename _It::difference_type difference_type;
+    const int __bits_per_word = _It::__bits_per_word;
+    difference_type __r = 0;
+    // do first partial word
+    if (__first.__ctz_ != 0)
+    {
+        __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
+        __storage_type __dn = _CUDA_VSTD::min(__clz_f, __n);
+        __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
+        __r = _CUDA_VSTD::__libcpp_popcount(*__first.__seg_ & __m);
+        __n -= __dn;
+        ++__first.__seg_;
+    }
+    // do middle whole words
+    for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word)
+        __r += _CUDA_VSTD::__libcpp_popcount(*__first.__seg_);
+    // do last partial word
+    if (__n > 0)
+    {
+        __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
+        __r += _CUDA_VSTD::__libcpp_popcount(*__first.__seg_ & __m);
+    }
+    return __r;
+}
+
+template <class _Cp, bool _IsConst>
+typename __bit_iterator<_Cp, _IsConst>::difference_type
+__count_bool_false(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n)
+{
+    typedef __bit_iterator<_Cp, _IsConst> _It;
+    typedef typename _It::__storage_type __storage_type;
+    typedef typename _It::difference_type difference_type;
+    const int __bits_per_word = _It::__bits_per_word;
+    difference_type __r = 0;
+    // do first partial word
+    if (__first.__ctz_ != 0)
+    {
+        __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
+        __storage_type __dn = _CUDA_VSTD::min(__clz_f, __n);
+        __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
+        __r = _CUDA_VSTD::__libcpp_popcount(~*__first.__seg_ & __m);
+        __n -= __dn;
+        ++__first.__seg_;
+    }
+    // do middle whole words
+    for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word)
+        __r += _CUDA_VSTD::__libcpp_popcount(~*__first.__seg_);
+    // do last partial word
+    if (__n > 0)
+    {
+        __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
+        __r += _CUDA_VSTD::__libcpp_popcount(~*__first.__seg_ & __m);
+    }
+    return __r;
+}
+
+template <class _Cp, bool _IsConst, class _Tp>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+typename __bit_iterator<_Cp, _IsConst>::difference_type
+count(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value_)
+{
+    if (static_cast<bool>(__value_))
+        return __count_bool_true(__first, static_cast<typename _Cp::size_type>(__last - __first));
+    return __count_bool_false(__first, static_cast<typename _Cp::size_type>(__last - __first));
+}
+
+// fill_n
+
+template <class _Cp>
+void
+__fill_n_false(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n)
+{
+    typedef __bit_iterator<_Cp, false> _It;
+    typedef typename _It::__storage_type __storage_type;
+    const int __bits_per_word = _It::__bits_per_word;
+    // do first partial word
+    if (__first.__ctz_ != 0)
+    {
+        __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
+        __storage_type __dn = _CUDA_VSTD::min(__clz_f, __n);
+        __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
+        *__first.__seg_ &= ~__m;
+        __n -= __dn;
+        ++__first.__seg_;
+    }
+    // do middle whole words
+    __storage_type __nw = __n / __bits_per_word;
+    _CUDA_VSTD::memset(_CUDA_VSTD::__to_raw_pointer(__first.__seg_), 0, __nw * sizeof(__storage_type));
+    __n -= __nw * __bits_per_word;
+    // do last partial word
+    if (__n > 0)
+    {
+        __first.__seg_ += __nw;
+        __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
+        *__first.__seg_ &= ~__m;
+    }
+}
+
+template <class _Cp>
+void
+__fill_n_true(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n)
+{
+    typedef __bit_iterator<_Cp, false> _It;
+    typedef typename _It::__storage_type __storage_type;
+    const int __bits_per_word = _It::__bits_per_word;
+    // do first partial word
+    if (__first.__ctz_ != 0)
+    {
+        __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
+        __storage_type __dn = _CUDA_VSTD::min(__clz_f, __n);
+        __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
+        *__first.__seg_ |= __m;
+        __n -= __dn;
+        ++__first.__seg_;
+    }
+    // do middle whole words
+    __storage_type __nw = __n / __bits_per_word;
+    _CUDA_VSTD::memset(_CUDA_VSTD::__to_raw_pointer(__first.__seg_), -1, __nw * sizeof(__storage_type));
+    __n -= __nw * __bits_per_word;
+    // do last partial word
+    if (__n > 0)
+    {
+        __first.__seg_ += __nw;
+        __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
+        *__first.__seg_ |= __m;
+    }
+}
+
+template <class _Cp>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+void
+fill_n(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n, bool __value_)
+{
+    if (__n > 0)
+    {
+        if (__value_)
+            __fill_n_true(__first, __n);
+        else
+            __fill_n_false(__first, __n);
+    }
+}
+
+// fill
+
+template <class _Cp>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+void
+fill(__bit_iterator<_Cp, false> __first, __bit_iterator<_Cp, false> __last, bool __value_)
+{
+    _CUDA_VSTD::fill_n(__first, static_cast<typename _Cp::size_type>(__last - __first), __value_);
+}
+
+// copy
+
+template <class _Cp, bool _IsConst>
+__bit_iterator<_Cp, false>
+__copy_aligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,
+                                                     __bit_iterator<_Cp, false> __result)
+{
+    typedef __bit_iterator<_Cp, _IsConst> _In;
+    typedef  typename _In::difference_type difference_type;
+    typedef typename _In::__storage_type __storage_type;
+    const int __bits_per_word = _In::__bits_per_word;
+    difference_type __n = __last - __first;
+    if (__n > 0)
+    {
+        // do first word
+        if (__first.__ctz_ != 0)
+        {
+            unsigned __clz = __bits_per_word - __first.__ctz_;
+            difference_type __dn = _CUDA_VSTD::min(static_cast<difference_type>(__clz), __n);
+            __n -= __dn;
+            __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz - __dn));
+            __storage_type __b = *__first.__seg_ & __m;
+            *__result.__seg_ &= ~__m;
+            *__result.__seg_ |= __b;
+            __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
+            __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_)  % __bits_per_word);
+            ++__first.__seg_;
+            // __first.__ctz_ = 0;
+        }
+        // __first.__ctz_ == 0;
+        // do middle words
+        __storage_type __nw = __n / __bits_per_word;
+        _CUDA_VSTD::memmove(_CUDA_VSTD::__to_raw_pointer(__result.__seg_),
+                       _CUDA_VSTD::__to_raw_pointer(__first.__seg_),
+                       __nw * sizeof(__storage_type));
+        __n -= __nw * __bits_per_word;
+        __result.__seg_ += __nw;
+        // do last word
+        if (__n > 0)
+        {
+            __first.__seg_ += __nw;
+            __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
+            __storage_type __b = *__first.__seg_ & __m;
+            *__result.__seg_ &= ~__m;
+            *__result.__seg_ |= __b;
+            __result.__ctz_ = static_cast<unsigned>(__n);
+        }
+    }
+    return __result;
+}
+
+template <class _Cp, bool _IsConst>
+__bit_iterator<_Cp, false>
+__copy_unaligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,
+                                                       __bit_iterator<_Cp, false> __result)
+{
+    typedef __bit_iterator<_Cp, _IsConst> _In;
+    typedef  typename _In::difference_type difference_type;
+    typedef typename _In::__storage_type __storage_type;
+    static const int __bits_per_word = _In::__bits_per_word;
+    difference_type __n = __last - __first;
+    if (__n > 0)
+    {
+        // do first word
+        if (__first.__ctz_ != 0)
+        {
+            unsigned __clz_f = __bits_per_word - __first.__ctz_;
+            difference_type __dn = _CUDA_VSTD::min(static_cast<difference_type>(__clz_f), __n);
+            __n -= __dn;
+            __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
+            __storage_type __b = *__first.__seg_ & __m;
+            unsigned __clz_r = __bits_per_word - __result.__ctz_;
+            __storage_type __ddn = _CUDA_VSTD::min<__storage_type>(__dn, __clz_r);
+            __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn));
+            *__result.__seg_ &= ~__m;
+            if (__result.__ctz_ > __first.__ctz_)
+                *__result.__seg_ |= __b << (__result.__ctz_ - __first.__ctz_);
+            else
+                *__result.__seg_ |= __b >> (__first.__ctz_ - __result.__ctz_);
+            __result.__seg_ += (__ddn + __result.__ctz_) / __bits_per_word;
+            __result.__ctz_ = static_cast<unsigned>((__ddn + __result.__ctz_)  % __bits_per_word);
+            __dn -= __ddn;
+            if (__dn > 0)
+            {
+                __m = ~__storage_type(0) >> (__bits_per_word - __dn);
+                *__result.__seg_ &= ~__m;
+                *__result.__seg_ |= __b >> (__first.__ctz_ + __ddn);
+                __result.__ctz_ = static_cast<unsigned>(__dn);
+            }
+            ++__first.__seg_;
+            // __first.__ctz_ = 0;
+        }
+        // __first.__ctz_ == 0;
+        // do middle words
+        unsigned __clz_r = __bits_per_word - __result.__ctz_;
+        __storage_type __m = ~__storage_type(0) << __result.__ctz_;
+        for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first.__seg_)
+        {
+            __storage_type __b = *__first.__seg_;
+            *__result.__seg_ &= ~__m;
+            *__result.__seg_ |= __b << __result.__ctz_;
+            ++__result.__seg_;
+            *__result.__seg_ &= __m;
+            *__result.__seg_ |= __b >> __clz_r;
+        }
+        // do last word
+        if (__n > 0)
+        {
+            __m = ~__storage_type(0) >> (__bits_per_word - __n);
+            __storage_type __b = *__first.__seg_ & __m;
+            __storage_type __dn = _CUDA_VSTD::min(__n, static_cast<difference_type>(__clz_r));
+            __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn));
+            *__result.__seg_ &= ~__m;
+            *__result.__seg_ |= __b << __result.__ctz_;
+            __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
+            __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_)  % __bits_per_word);
+            __n -= __dn;
+            if (__n > 0)
+            {
+                __m = ~__storage_type(0) >> (__bits_per_word - __n);
+                *__result.__seg_ &= ~__m;
+                *__result.__seg_ |= __b >> __dn;
+                __result.__ctz_ = static_cast<unsigned>(__n);
+            }
+        }
+    }
+    return __result;
+}
+
+template <class _Cp, bool _IsConst>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+__bit_iterator<_Cp, false>
+copy(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result)
+{
+    if (__first.__ctz_ == __result.__ctz_)
+        return __copy_aligned(__first, __last, __result);
+    return __copy_unaligned(__first, __last, __result);
+}
+
+// copy_backward
+
+template <class _Cp, bool _IsConst>
+__bit_iterator<_Cp, false>
+__copy_backward_aligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,
+                                                     __bit_iterator<_Cp, false> __result)
+{
+    typedef __bit_iterator<_Cp, _IsConst> _In;
+    typedef  typename _In::difference_type difference_type;
+    typedef typename _In::__storage_type __storage_type;
+    const int __bits_per_word = _In::__bits_per_word;
+    difference_type __n = __last - __first;
+    if (__n > 0)
+    {
+        // do first word
+        if (__last.__ctz_ != 0)
+        {
+            difference_type __dn = _CUDA_VSTD::min(static_cast<difference_type>(__last.__ctz_), __n);
+            __n -= __dn;
+            unsigned __clz = __bits_per_word - __last.__ctz_;
+            __storage_type __m = (~__storage_type(0) << (__last.__ctz_ - __dn)) & (~__storage_type(0) >> __clz);
+            __storage_type __b = *__last.__seg_ & __m;
+            *__result.__seg_ &= ~__m;
+            *__result.__seg_ |= __b;
+            __result.__ctz_ = static_cast<unsigned>(((-__dn & (__bits_per_word - 1)) +
+                                                       __result.__ctz_)  % __bits_per_word);
+            // __last.__ctz_ = 0
+         }
+        // __last.__ctz_ == 0 || __n == 0
+        // __result.__ctz_ == 0 || __n == 0
+        // do middle words
+        __storage_type __nw = __n / __bits_per_word;
+        __result.__seg_ -= __nw;
+        __last.__seg_ -= __nw;
+        _CUDA_VSTD::memmove(_CUDA_VSTD::__to_raw_pointer(__result.__seg_),
+                       _CUDA_VSTD::__to_raw_pointer(__last.__seg_),
+                       __nw * sizeof(__storage_type));
+        __n -= __nw * __bits_per_word;
+        // do last word
+        if (__n > 0)
+        {
+            __storage_type __m = ~__storage_type(0) << (__bits_per_word - __n);
+            __storage_type __b = *--__last.__seg_ & __m;
+            *--__result.__seg_ &= ~__m;
+            *__result.__seg_ |= __b;
+            __result.__ctz_ = static_cast<unsigned>(-__n & (__bits_per_word - 1));
+        }
+    }
+    return __result;
+}
+
+template <class _Cp, bool _IsConst>
+__bit_iterator<_Cp, false>
+__copy_backward_unaligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,
+                                                       __bit_iterator<_Cp, false> __result)
+{
+    typedef __bit_iterator<_Cp, _IsConst> _In;
+    typedef  typename _In::difference_type difference_type;
+    typedef typename _In::__storage_type __storage_type;
+    const int __bits_per_word = _In::__bits_per_word;
+    difference_type __n = __last - __first;
+    if (__n > 0)
+    {
+        // do first word
+        if (__last.__ctz_ != 0)
+        {
+            difference_type __dn = _CUDA_VSTD::min(static_cast<difference_type>(__last.__ctz_), __n);
+            __n -= __dn;
+            unsigned __clz_l = __bits_per_word - __last.__ctz_;
+            __storage_type __m = (~__storage_type(0) << (__last.__ctz_ - __dn)) & (~__storage_type(0) >> __clz_l);
+            __storage_type __b = *__last.__seg_ & __m;
+            unsigned __clz_r = __bits_per_word - __result.__ctz_;
+            __storage_type __ddn = _CUDA_VSTD::min(__dn, static_cast<difference_type>(__result.__ctz_));
+            if (__ddn > 0)
+            {
+                __m = (~__storage_type(0) << (__result.__ctz_ - __ddn)) & (~__storage_type(0) >> __clz_r);
+                *__result.__seg_ &= ~__m;
+                if (__result.__ctz_ > __last.__ctz_)
+                    *__result.__seg_ |= __b << (__result.__ctz_ - __last.__ctz_);
+                else
+                    *__result.__seg_ |= __b >> (__last.__ctz_ - __result.__ctz_);
+                __result.__ctz_ = static_cast<unsigned>(((-__ddn & (__bits_per_word - 1)) +
+                                                         __result.__ctz_)  % __bits_per_word);
+                __dn -= __ddn;
+            }
+            if (__dn > 0)
+            {
+                // __result.__ctz_ == 0
+                --__result.__seg_;
+                __result.__ctz_ = static_cast<unsigned>(-__dn & (__bits_per_word - 1));
+                __m = ~__storage_type(0) << __result.__ctz_;
+                *__result.__seg_ &= ~__m;
+                __last.__ctz_ -= __dn + __ddn;
+                *__result.__seg_ |= __b << (__result.__ctz_ - __last.__ctz_);
+            }
+            // __last.__ctz_ = 0
+         }
+        // __last.__ctz_ == 0 || __n == 0
+        // __result.__ctz_ != 0 || __n == 0
+        // do middle words
+        unsigned __clz_r = __bits_per_word - __result.__ctz_;
+        __storage_type __m = ~__storage_type(0) >> __clz_r;
+        for (; __n >= __bits_per_word; __n -= __bits_per_word)
+        {
+            __storage_type __b = *--__last.__seg_;
+            *__result.__seg_ &= ~__m;
+            *__result.__seg_ |= __b >> __clz_r;
+            *--__result.__seg_ &= __m;
+            *__result.__seg_ |= __b << __result.__ctz_;
+        }
+        // do last word
+        if (__n > 0)
+        {
+            __m = ~__storage_type(0) << (__bits_per_word - __n);
+            __storage_type __b = *--__last.__seg_ & __m;
+            __clz_r = __bits_per_word - __result.__ctz_;
+            __storage_type __dn = _CUDA_VSTD::min(__n, static_cast<difference_type>(__result.__ctz_));
+            __m = (~__storage_type(0) << (__result.__ctz_ - __dn)) & (~__storage_type(0) >> __clz_r);
+            *__result.__seg_ &= ~__m;
+            *__result.__seg_ |= __b >> (__bits_per_word - __result.__ctz_);
+            __result.__ctz_ = static_cast<unsigned>(((-__dn & (__bits_per_word - 1)) +
+                                                     __result.__ctz_)  % __bits_per_word);
+            __n -= __dn;
+            if (__n > 0)
+            {
+                // __result.__ctz_ == 0
+                --__result.__seg_;
+                __result.__ctz_ = static_cast<unsigned>(-__n & (__bits_per_word - 1));
+                __m = ~__storage_type(0) << __result.__ctz_;
+                *__result.__seg_ &= ~__m;
+                *__result.__seg_ |= __b << (__result.__ctz_ - (__bits_per_word - __n - __dn));
+            }
+        }
+    }
+    return __result;
+}
+
+template <class _Cp, bool _IsConst>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+__bit_iterator<_Cp, false>
+copy_backward(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result)
+{
+    if (__last.__ctz_ == __result.__ctz_)
+        return __copy_backward_aligned(__first, __last, __result);
+    return __copy_backward_unaligned(__first, __last, __result);
+}
+
+// move
+
+template <class _Cp, bool _IsConst>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+__bit_iterator<_Cp, false>
+move(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result)
+{
+    return _CUDA_VSTD::copy(__first, __last, __result);
+}
+
+// move_backward
+
+template <class _Cp, bool _IsConst>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+__bit_iterator<_Cp, false>
+move_backward(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result)
+{
+    return _CUDA_VSTD::copy_backward(__first, __last, __result);
+}
+
+// swap_ranges
+
+template <class __C1, class __C2>
+__bit_iterator<__C2, false>
+__swap_ranges_aligned(__bit_iterator<__C1, false> __first, __bit_iterator<__C1, false> __last,
+                      __bit_iterator<__C2, false> __result)
+{
+    typedef __bit_iterator<__C1, false> _I1;
+    typedef  typename _I1::difference_type difference_type;
+    typedef typename _I1::__storage_type __storage_type;
+    const int __bits_per_word = _I1::__bits_per_word;
+    difference_type __n = __last - __first;
+    if (__n > 0)
+    {
+        // do first word
+        if (__first.__ctz_ != 0)
+        {
+            unsigned __clz = __bits_per_word - __first.__ctz_;
+            difference_type __dn = _CUDA_VSTD::min(static_cast<difference_type>(__clz), __n);
+            __n -= __dn;
+            __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz - __dn));
+            __storage_type __b1 = *__first.__seg_ & __m;
+            *__first.__seg_ &= ~__m;
+            __storage_type __b2 = *__result.__seg_ & __m;
+            *__result.__seg_ &= ~__m;
+            *__result.__seg_ |= __b1;
+            *__first.__seg_  |= __b2;
+            __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
+            __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_)  % __bits_per_word);
+            ++__first.__seg_;
+            // __first.__ctz_ = 0;
+        }
+        // __first.__ctz_ == 0;
+        // do middle words
+        for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first.__seg_, ++__result.__seg_)
+            swap(*__first.__seg_, *__result.__seg_);
+        // do last word
+        if (__n > 0)
+        {
+            __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
+            __storage_type __b1 = *__first.__seg_ & __m;
+            *__first.__seg_ &= ~__m;
+            __storage_type __b2 = *__result.__seg_ & __m;
+            *__result.__seg_ &= ~__m;
+            *__result.__seg_ |= __b1;
+            *__first.__seg_  |= __b2;
+            __result.__ctz_ = static_cast<unsigned>(__n);
+        }
+    }
+    return __result;
+}
+
+template <class __C1, class __C2>
+__bit_iterator<__C2, false>
+__swap_ranges_unaligned(__bit_iterator<__C1, false> __first, __bit_iterator<__C1, false> __last,
+                        __bit_iterator<__C2, false> __result)
+{
+    typedef __bit_iterator<__C1, false> _I1;
+    typedef  typename _I1::difference_type difference_type;
+    typedef typename _I1::__storage_type __storage_type;
+    const int __bits_per_word = _I1::__bits_per_word;
+    difference_type __n = __last - __first;
+    if (__n > 0)
+    {
+        // do first word
+        if (__first.__ctz_ != 0)
+        {
+            unsigned __clz_f = __bits_per_word - __first.__ctz_;
+            difference_type __dn = _CUDA_VSTD::min(static_cast<difference_type>(__clz_f), __n);
+            __n -= __dn;
+            __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
+            __storage_type __b1 = *__first.__seg_ & __m;
+            *__first.__seg_ &= ~__m;
+            unsigned __clz_r = __bits_per_word - __result.__ctz_;
+            __storage_type __ddn = _CUDA_VSTD::min<__storage_type>(__dn, __clz_r);
+            __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn));
+            __storage_type __b2 = *__result.__seg_ & __m;
+            *__result.__seg_ &= ~__m;
+            if (__result.__ctz_ > __first.__ctz_)
+            {
+                unsigned __s = __result.__ctz_ - __first.__ctz_;
+                *__result.__seg_ |= __b1 << __s;
+                *__first.__seg_  |= __b2 >> __s;
+            }
+            else
+            {
+                unsigned __s = __first.__ctz_ - __result.__ctz_;
+                *__result.__seg_ |= __b1 >> __s;
+                *__first.__seg_  |= __b2 << __s;
+            }
+            __result.__seg_ += (__ddn + __result.__ctz_) / __bits_per_word;
+            __result.__ctz_ = static_cast<unsigned>((__ddn + __result.__ctz_)  % __bits_per_word);
+            __dn -= __ddn;
+            if (__dn > 0)
+            {
+                __m = ~__storage_type(0) >> (__bits_per_word - __dn);
+                __b2 = *__result.__seg_ & __m;
+                *__result.__seg_ &= ~__m;
+                unsigned __s = __first.__ctz_ + __ddn;
+                *__result.__seg_ |= __b1 >> __s;
+                *__first.__seg_  |= __b2 << __s;
+                __result.__ctz_ = static_cast<unsigned>(__dn);
+            }
+            ++__first.__seg_;
+            // __first.__ctz_ = 0;
+        }
+        // __first.__ctz_ == 0;
+        // do middle words
+        __storage_type __m = ~__storage_type(0) << __result.__ctz_;
+        unsigned __clz_r = __bits_per_word - __result.__ctz_;
+        for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first.__seg_)
+        {
+            __storage_type __b1 = *__first.__seg_;
+            __storage_type __b2 = *__result.__seg_ & __m;
+            *__result.__seg_ &= ~__m;
+            *__result.__seg_ |= __b1 << __result.__ctz_;
+            *__first.__seg_  = __b2 >> __result.__ctz_;
+            ++__result.__seg_;
+            __b2 = *__result.__seg_ & ~__m;
+            *__result.__seg_ &= __m;
+            *__result.__seg_ |= __b1 >> __clz_r;
+            *__first.__seg_  |= __b2 << __clz_r;
+        }
+        // do last word
+        if (__n > 0)
+        {
+            __m = ~__storage_type(0) >> (__bits_per_word - __n);
+            __storage_type __b1 = *__first.__seg_ & __m;
+            *__first.__seg_ &= ~__m;
+            __storage_type __dn = _CUDA_VSTD::min<__storage_type>(__n, __clz_r);
+            __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn));
+            __storage_type __b2 = *__result.__seg_ & __m;
+            *__result.__seg_ &= ~__m;
+            *__result.__seg_ |= __b1 << __result.__ctz_;
+            *__first.__seg_  |= __b2 >> __result.__ctz_;
+            __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
+            __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_)  % __bits_per_word);
+            __n -= __dn;
+            if (__n > 0)
+            {
+                __m = ~__storage_type(0) >> (__bits_per_word - __n);
+                __b2 = *__result.__seg_ & __m;
+                *__result.__seg_ &= ~__m;
+                *__result.__seg_ |= __b1 >> __dn;
+                *__first.__seg_  |= __b2 << __dn;
+                __result.__ctz_ = static_cast<unsigned>(__n);
+            }
+        }
+    }
+    return __result;
+}
+
+template <class __C1, class __C2>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+__bit_iterator<__C2, false>
+swap_ranges(__bit_iterator<__C1, false> __first1, __bit_iterator<__C1, false> __last1,
+            __bit_iterator<__C2, false> __first2)
+{
+    if (__first1.__ctz_ == __first2.__ctz_)
+        return __swap_ranges_aligned(__first1, __last1, __first2);
+    return __swap_ranges_unaligned(__first1, __last1, __first2);
+}
+
+// rotate
+
+template <class _Cp>
+struct __bit_array
+{
+    typedef typename _Cp::difference_type difference_type;
+    typedef typename _Cp::__storage_type  __storage_type;
+    typedef typename _Cp::__storage_pointer __storage_pointer;
+    typedef typename _Cp::iterator        iterator;
+    static const unsigned __bits_per_word = _Cp::__bits_per_word;
+    static const unsigned _Np = 4;
+
+    difference_type __size_;
+    __storage_type __word_[_Np];
+
+    _LIBCUDACXX_INLINE_VISIBILITY static difference_type capacity()
+        {return static_cast<difference_type>(_Np * __bits_per_word);}
+    _LIBCUDACXX_INLINE_VISIBILITY explicit __bit_array(difference_type __s) : __size_(__s) {}
+    _LIBCUDACXX_INLINE_VISIBILITY iterator begin()
+    {
+        return iterator(pointer_traits<__storage_pointer>::pointer_to(__word_[0]), 0);
+    }
+    _LIBCUDACXX_INLINE_VISIBILITY iterator end()
+    {
+        return iterator(pointer_traits<__storage_pointer>::pointer_to(__word_[0]) + __size_ / __bits_per_word,
+                                                  static_cast<unsigned>(__size_ % __bits_per_word));
+    }
+};
+
+template <class _Cp>
+__bit_iterator<_Cp, false>
+rotate(__bit_iterator<_Cp, false> __first, __bit_iterator<_Cp, false> __middle, __bit_iterator<_Cp, false> __last)
+{
+    typedef __bit_iterator<_Cp, false> _I1;
+    typedef  typename _I1::difference_type difference_type;
+    difference_type __d1 = __middle - __first;
+    difference_type __d2 = __last - __middle;
+    _I1 __r = __first + __d2;
+    while (__d1 != 0 && __d2 != 0)
+    {
+        if (__d1 <= __d2)
+        {
+            if (__d1 <= __bit_array<_Cp>::capacity())
+            {
+                __bit_array<_Cp> __b(__d1);
+                _CUDA_VSTD::copy(__first, __middle, __b.begin());
+                _CUDA_VSTD::copy(__b.begin(), __b.end(), _CUDA_VSTD::copy(__middle, __last, __first));
+                break;
+            }
+            else
+            {
+                __bit_iterator<_Cp, false> __mp = _CUDA_VSTD::swap_ranges(__first, __middle, __middle);
+                __first = __middle;
+                __middle = __mp;
+                __d2 -= __d1;
+            }
+        }
+        else
+        {
+            if (__d2 <= __bit_array<_Cp>::capacity())
+            {
+                __bit_array<_Cp> __b(__d2);
+                _CUDA_VSTD::copy(__middle, __last, __b.begin());
+                _CUDA_VSTD::copy_backward(__b.begin(), __b.end(), _CUDA_VSTD::copy_backward(__first, __middle, __last));
+                break;
+            }
+            else
+            {
+                __bit_iterator<_Cp, false> __mp = __first + __d2;
+                _CUDA_VSTD::swap_ranges(__first, __mp, __middle);
+                __first = __mp;
+                __d1 -= __d2;
+            }
+        }
+    }
+    return __r;
+}
+
+// equal
+
+template <class _Cp, bool _IC1, bool _IC2>
+bool
+__equal_unaligned(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1,
+                  __bit_iterator<_Cp, _IC2> __first2)
+{
+    typedef __bit_iterator<_Cp, _IC1> _It;
+    typedef  typename _It::difference_type difference_type;
+    typedef typename _It::__storage_type __storage_type;
+    static const int __bits_per_word = _It::__bits_per_word;
+    difference_type __n = __last1 - __first1;
+    if (__n > 0)
+    {
+        // do first word
+        if (__first1.__ctz_ != 0)
+        {
+            unsigned __clz_f = __bits_per_word - __first1.__ctz_;
+            difference_type __dn = _CUDA_VSTD::min(static_cast<difference_type>(__clz_f), __n);
+            __n -= __dn;
+            __storage_type __m = (~__storage_type(0) << __first1.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
+            __storage_type __b = *__first1.__seg_ & __m;
+            unsigned __clz_r = __bits_per_word - __first2.__ctz_;
+            __storage_type __ddn = _CUDA_VSTD::min<__storage_type>(__dn, __clz_r);
+            __m = (~__storage_type(0) << __first2.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn));
+            if (__first2.__ctz_ > __first1.__ctz_)
+            {
+                if ((*__first2.__seg_ & __m) != (__b << (__first2.__ctz_ - __first1.__ctz_)))
+                    return false;
+            }
+            else
+            {
+                if ((*__first2.__seg_ & __m) != (__b >> (__first1.__ctz_ - __first2.__ctz_)))
+                    return false;
+            }
+            __first2.__seg_ += (__ddn + __first2.__ctz_) / __bits_per_word;
+            __first2.__ctz_ = static_cast<unsigned>((__ddn + __first2.__ctz_)  % __bits_per_word);
+            __dn -= __ddn;
+            if (__dn > 0)
+            {
+                __m = ~__storage_type(0) >> (__bits_per_word - __dn);
+                if ((*__first2.__seg_ & __m) != (__b >> (__first1.__ctz_ + __ddn)))
+                    return false;
+                __first2.__ctz_ = static_cast<unsigned>(__dn);
+            }
+            ++__first1.__seg_;
+            // __first1.__ctz_ = 0;
+        }
+        // __first1.__ctz_ == 0;
+        // do middle words
+        unsigned __clz_r = __bits_per_word - __first2.__ctz_;
+        __storage_type __m = ~__storage_type(0) << __first2.__ctz_;
+        for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first1.__seg_)
+        {
+            __storage_type __b = *__first1.__seg_;
+            if ((*__first2.__seg_ & __m) != (__b << __first2.__ctz_))
+                return false;
+            ++__first2.__seg_;
+            if ((*__first2.__seg_ & ~__m) != (__b >> __clz_r))
+                return false;
+        }
+        // do last word
+        if (__n > 0)
+        {
+            __m = ~__storage_type(0) >> (__bits_per_word - __n);
+            __storage_type __b = *__first1.__seg_ & __m;
+            __storage_type __dn = _CUDA_VSTD::min(__n, static_cast<difference_type>(__clz_r));
+            __m = (~__storage_type(0) << __first2.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn));
+            if ((*__first2.__seg_ & __m) != (__b << __first2.__ctz_))
+                return false;
+            __first2.__seg_ += (__dn + __first2.__ctz_) / __bits_per_word;
+            __first2.__ctz_ = static_cast<unsigned>((__dn + __first2.__ctz_)  % __bits_per_word);
+            __n -= __dn;
+            if (__n > 0)
+            {
+                __m = ~__storage_type(0) >> (__bits_per_word - __n);
+                if ((*__first2.__seg_ & __m) != (__b >> __dn))
+                    return false;
+            }
+        }
+    }
+    return true;
+}
+
+template <class _Cp, bool _IC1, bool _IC2>
+bool
+__equal_aligned(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1,
+                __bit_iterator<_Cp, _IC2> __first2)
+{
+    typedef __bit_iterator<_Cp, _IC1> _It;
+    typedef  typename _It::difference_type difference_type;
+    typedef typename _It::__storage_type __storage_type;
+    static const int __bits_per_word = _It::__bits_per_word;
+    difference_type __n = __last1 - __first1;
+    if (__n > 0)
+    {
+        // do first word
+        if (__first1.__ctz_ != 0)
+        {
+            unsigned __clz = __bits_per_word - __first1.__ctz_;
+            difference_type __dn = _CUDA_VSTD::min(static_cast<difference_type>(__clz), __n);
+            __n -= __dn;
+            __storage_type __m = (~__storage_type(0) << __first1.__ctz_) & (~__storage_type(0) >> (__clz - __dn));
+            if ((*__first2.__seg_ & __m) != (*__first1.__seg_ & __m))
+                return false;
+            ++__first2.__seg_;
+            ++__first1.__seg_;
+            // __first1.__ctz_ = 0;
+            // __first2.__ctz_ = 0;
+        }
+        // __first1.__ctz_ == 0;
+        // __first2.__ctz_ == 0;
+        // do middle words
+        for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first1.__seg_, ++__first2.__seg_)
+            if (*__first2.__seg_ != *__first1.__seg_)
+                return false;
+        // do last word
+        if (__n > 0)
+        {
+            __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
+            if ((*__first2.__seg_ & __m) != (*__first1.__seg_ & __m))
+                return false;
+        }
+    }
+    return true;
+}
+
+template <class _Cp, bool _IC1, bool _IC2>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool
+equal(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1, __bit_iterator<_Cp, _IC2> __first2)
+{
+    if (__first1.__ctz_ == __first2.__ctz_)
+        return __equal_aligned(__first1, __last1, __first2);
+    return __equal_unaligned(__first1, __last1, __first2);
+}
+
+template <class _Cp, bool _IsConst,
+          typename _Cp::__storage_type>
+class __bit_iterator
+{
+public:
+    typedef typename _Cp::difference_type                                                          difference_type;
+    typedef bool                                                                                  value_type;
+    typedef __bit_iterator                                                                        pointer;
+    typedef typename conditional<_IsConst, __bit_const_reference<_Cp>, __bit_reference<_Cp> >::type reference;
+    typedef random_access_iterator_tag                                                            iterator_category;
+
+private:
+    typedef typename _Cp::__storage_type                                           __storage_type;
+    typedef typename conditional<_IsConst, typename _Cp::__const_storage_pointer,
+                                           typename _Cp::__storage_pointer>::type  __storage_pointer;
+    static const unsigned __bits_per_word = _Cp::__bits_per_word;
+
+    __storage_pointer __seg_;
+    unsigned          __ctz_;
+
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator() noexcept
+#if _LIBCUDACXX_STD_VER > 11
+    : __seg_(nullptr), __ctz_(0)
+#endif
+    {}
+    // avoid re-declaring a copy constructor for the non-const version.
+    using __type_for_copy_to_const =
+      _If<_IsConst, __bit_iterator<_Cp, false>, struct __private_nat>;
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __bit_iterator(const __type_for_copy_to_const& __it) noexcept
+        : __seg_(__it.__seg_), __ctz_(__it.__ctz_) {}
+
+    _LIBCUDACXX_INLINE_VISIBILITY reference operator*() const noexcept
+        {return reference(__seg_, __storage_type(1) << __ctz_);}
+
+    _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator& operator++()
+    {
+        if (__ctz_ != __bits_per_word-1)
+            ++__ctz_;
+        else
+        {
+            __ctz_ = 0;
+            ++__seg_;
+        }
+        return *this;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator operator++(int)
+    {
+        __bit_iterator __tmp = *this;
+        ++(*this);
+        return __tmp;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator& operator--()
+    {
+        if (__ctz_ != 0)
+            --__ctz_;
+        else
+        {
+            __ctz_ = __bits_per_word - 1;
+            --__seg_;
+        }
+        return *this;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator operator--(int)
+    {
+        __bit_iterator __tmp = *this;
+        --(*this);
+        return __tmp;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator& operator+=(difference_type __n)
+    {
+        if (__n >= 0)
+            __seg_ += (__n + __ctz_) / __bits_per_word;
+        else
+            __seg_ += static_cast<difference_type>(__n - __bits_per_word + __ctz_ + 1)
+                    / static_cast<difference_type>(__bits_per_word);
+        __n &= (__bits_per_word - 1);
+        __ctz_ = static_cast<unsigned>((__n + __ctz_)  % __bits_per_word);
+        return *this;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator& operator-=(difference_type __n)
+    {
+        return *this += -__n;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator operator+(difference_type __n) const
+    {
+        __bit_iterator __t(*this);
+        __t += __n;
+        return __t;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY __bit_iterator operator-(difference_type __n) const
+    {
+        __bit_iterator __t(*this);
+        __t -= __n;
+        return __t;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    friend __bit_iterator operator+(difference_type __n, const __bit_iterator& __it) {return __it + __n;}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    friend difference_type operator-(const __bit_iterator& __x, const __bit_iterator& __y)
+        {return (__x.__seg_ - __y.__seg_) * __bits_per_word + __x.__ctz_ - __y.__ctz_;}
+
+    _LIBCUDACXX_INLINE_VISIBILITY reference operator[](difference_type __n) const {return *(*this + __n);}
+
+    _LIBCUDACXX_INLINE_VISIBILITY friend bool operator==(const __bit_iterator& __x, const __bit_iterator& __y)
+        {return __x.__seg_ == __y.__seg_ && __x.__ctz_ == __y.__ctz_;}
+
+    _LIBCUDACXX_INLINE_VISIBILITY friend bool operator!=(const __bit_iterator& __x, const __bit_iterator& __y)
+        {return !(__x == __y);}
+
+    _LIBCUDACXX_INLINE_VISIBILITY friend bool operator<(const __bit_iterator& __x, const __bit_iterator& __y)
+        {return __x.__seg_ < __y.__seg_ || (__x.__seg_ == __y.__seg_ && __x.__ctz_ < __y.__ctz_);}
+
+    _LIBCUDACXX_INLINE_VISIBILITY friend bool operator>(const __bit_iterator& __x, const __bit_iterator& __y)
+        {return __y < __x;}
+
+    _LIBCUDACXX_INLINE_VISIBILITY friend bool operator<=(const __bit_iterator& __x, const __bit_iterator& __y)
+        {return !(__y < __x);}
+
+    _LIBCUDACXX_INLINE_VISIBILITY friend bool operator>=(const __bit_iterator& __x, const __bit_iterator& __y)
+        {return !(__x < __y);}
+
+private:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __bit_iterator(__storage_pointer __s, unsigned __ctz) noexcept
+        : __seg_(__s), __ctz_(__ctz) {}
+
+    friend typename _Cp::__self;
+
+    friend class __bit_reference<_Cp>;
+    friend class __bit_const_reference<_Cp>;
+    friend class __bit_iterator<_Cp, true>;
+    template <class _Dp> friend struct __bit_array;
+    template <class _Dp> friend void __fill_n_false(__bit_iterator<_Dp, false> __first, typename _Dp::size_type __n);
+    template <class _Dp> friend void __fill_n_true(__bit_iterator<_Dp, false> __first, typename _Dp::size_type __n);
+    template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> __copy_aligned(__bit_iterator<_Dp, _IC> __first,
+                                                                                  __bit_iterator<_Dp, _IC> __last,
+                                                                                  __bit_iterator<_Dp, false> __result);
+    template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> __copy_unaligned(__bit_iterator<_Dp, _IC> __first,
+                                                                                    __bit_iterator<_Dp, _IC> __last,
+                                                                                    __bit_iterator<_Dp, false> __result);
+    template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> copy(__bit_iterator<_Dp, _IC> __first,
+                                                                        __bit_iterator<_Dp, _IC> __last,
+                                                                        __bit_iterator<_Dp, false> __result);
+    template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> __copy_backward_aligned(__bit_iterator<_Dp, _IC> __first,
+                                                                                           __bit_iterator<_Dp, _IC> __last,
+                                                                                           __bit_iterator<_Dp, false> __result);
+    template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> __copy_backward_unaligned(__bit_iterator<_Dp, _IC> __first,
+                                                                                             __bit_iterator<_Dp, _IC> __last,
+                                                                                             __bit_iterator<_Dp, false> __result);
+    template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> copy_backward(__bit_iterator<_Dp, _IC> __first,
+                                                                                 __bit_iterator<_Dp, _IC> __last,
+                                                                                 __bit_iterator<_Dp, false> __result);
+    template <class __C1, class __C2>friend __bit_iterator<__C2, false> __swap_ranges_aligned(__bit_iterator<__C1, false>,
+                                                                                           __bit_iterator<__C1, false>,
+                                                                                           __bit_iterator<__C2, false>);
+    template <class __C1, class __C2>friend __bit_iterator<__C2, false> __swap_ranges_unaligned(__bit_iterator<__C1, false>,
+                                                                                             __bit_iterator<__C1, false>,
+                                                                                             __bit_iterator<__C2, false>);
+    template <class __C1, class __C2>friend __bit_iterator<__C2, false> swap_ranges(__bit_iterator<__C1, false>,
+                                                                                 __bit_iterator<__C1, false>,
+                                                                                 __bit_iterator<__C2, false>);
+    template <class _Dp> friend __bit_iterator<_Dp, false> rotate(__bit_iterator<_Dp, false>,
+                                                                __bit_iterator<_Dp, false>,
+                                                                __bit_iterator<_Dp, false>);
+    template <class _Dp, bool _IC1, bool _IC2> friend bool __equal_aligned(__bit_iterator<_Dp, _IC1>,
+                                                    __bit_iterator<_Dp, _IC1>,
+                                                    __bit_iterator<_Dp, _IC2>);
+    template <class _Dp, bool _IC1, bool _IC2> friend bool __equal_unaligned(__bit_iterator<_Dp, _IC1>,
+                                                      __bit_iterator<_Dp, _IC1>,
+                                                      __bit_iterator<_Dp, _IC2>);
+    template <class _Dp, bool _IC1, bool _IC2> friend bool equal(__bit_iterator<_Dp, _IC1>,
+                                                                __bit_iterator<_Dp, _IC1>,
+                                                                __bit_iterator<_Dp, _IC2>);
+    template <class _Dp, bool _IC> friend __bit_iterator<_Dp, _IC> __find_bool_true(__bit_iterator<_Dp, _IC>,
+                                                                          typename _Dp::size_type);
+    template <class _Dp, bool _IC> friend __bit_iterator<_Dp, _IC> __find_bool_false(__bit_iterator<_Dp, _IC>,
+                                                                           typename _Dp::size_type);
+    template <class _Dp, bool _IC> friend typename __bit_iterator<_Dp, _IC>::difference_type
+                   __count_bool_true(__bit_iterator<_Dp, _IC>, typename _Dp::size_type);
+    template <class _Dp, bool _IC> friend typename __bit_iterator<_Dp, _IC>::difference_type
+                   __count_bool_false(__bit_iterator<_Dp, _IC>, typename _Dp::size_type);
+};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+_LIBCUDACXX_POP_MACROS
+
+#endif  // _LIBCUDACXX___BIT_REFERENCE

cuda_toolkit/include/__bsd_locale_defaults.h

@@ -0,0 +1,40 @@
+// -*- C++ -*-
+//===---------------------- __bsd_locale_defaults.h -----------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+// The BSDs have lots of *_l functions.  We don't want to define those symbols
+// on other platforms though, for fear of conflicts with user code.  So here,
+// we will define the mapping from an internal macro to the real BSD symbol.
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_BSD_LOCALE_DEFAULTS_H
+#define _LIBCUDACXX_BSD_LOCALE_DEFAULTS_H
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#define __libcpp_mb_cur_max_l(loc)                          MB_CUR_MAX_L(loc)
+#define __libcpp_btowc_l(ch, loc)                           btowc_l(ch, loc)
+#define __libcpp_wctob_l(wch, loc)                          wctob_l(wch, loc)
+#define __libcpp_wcsnrtombs_l(dst, src, nwc, len, ps, loc)  wcsnrtombs_l(dst, src, nwc, len, ps, loc)
+#define __libcpp_wcrtomb_l(src, wc, ps, loc)                wcrtomb_l(src, wc, ps, loc)
+#define __libcpp_mbsnrtowcs_l(dst, src, nms, len, ps, loc)  mbsnrtowcs_l(dst, src, nms, len, ps, loc)
+#define __libcpp_mbrtowc_l(pwc, s, n, ps, l)                mbrtowc_l(pwc, s, n, ps, l)
+#define __libcpp_mbtowc_l(pwc, pmb, max, l)                 mbtowc_l(pwc, pmb, max, l)
+#define __libcpp_mbrlen_l(s, n, ps, l)                      mbrlen_l(s, n, ps, l)
+#define __libcpp_localeconv_l(l)                            localeconv_l(l)
+#define __libcpp_mbsrtowcs_l(dest, src, len, ps, l)         mbsrtowcs_l(dest, src, len, ps, l)
+#define __libcpp_snprintf_l(...)                            snprintf_l(__VA_ARGS__)
+#define __libcpp_asprintf_l(...)                            asprintf_l(__VA_ARGS__)
+#define __libcpp_sscanf_l(...)                              sscanf_l(__VA_ARGS__)
+
+#endif // _LIBCUDACXX_BSD_LOCALE_DEFAULTS_H

cuda_toolkit/include/__bsd_locale_fallbacks.h

@@ -0,0 +1,143 @@
+// -*- C++ -*-
+//===---------------------- __bsd_locale_fallbacks.h ----------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+// The BSDs have lots of *_l functions.  This file provides reimplementations
+// of those functions for non-BSD platforms.
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_BSD_LOCALE_FALLBACKS_DEFAULTS_H
+#define _LIBCUDACXX_BSD_LOCALE_FALLBACKS_DEFAULTS_H
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include <memory>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+decltype(MB_CUR_MAX) __libcpp_mb_cur_max_l(locale_t __l)
+{
+    __libcpp_locale_guard __current(__l);
+    return MB_CUR_MAX;
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+wint_t __libcpp_btowc_l(int __c, locale_t __l)
+{
+    __libcpp_locale_guard __current(__l);
+    return btowc(__c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+int __libcpp_wctob_l(wint_t __c, locale_t __l)
+{
+    __libcpp_locale_guard __current(__l);
+    return wctob(__c);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+size_t __libcpp_wcsnrtombs_l(char *__dest, const wchar_t **__src, size_t __nwc,
+                         size_t __len, mbstate_t *__ps, locale_t __l)
+{
+    __libcpp_locale_guard __current(__l);
+    return wcsnrtombs(__dest, __src, __nwc, __len, __ps);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+size_t __libcpp_wcrtomb_l(char *__s, wchar_t __wc, mbstate_t *__ps, locale_t __l)
+{
+    __libcpp_locale_guard __current(__l);
+    return wcrtomb(__s, __wc, __ps);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+size_t __libcpp_mbsnrtowcs_l(wchar_t * __dest, const char **__src, size_t __nms,
+                      size_t __len, mbstate_t *__ps, locale_t __l)
+{
+    __libcpp_locale_guard __current(__l);
+    return mbsnrtowcs(__dest, __src, __nms, __len, __ps);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+size_t __libcpp_mbrtowc_l(wchar_t *__pwc, const char *__s, size_t __n,
+                   mbstate_t *__ps, locale_t __l)
+{
+    __libcpp_locale_guard __current(__l);
+    return mbrtowc(__pwc, __s, __n, __ps);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+int __libcpp_mbtowc_l(wchar_t *__pwc, const char *__pmb, size_t __max, locale_t __l)
+{
+    __libcpp_locale_guard __current(__l);
+    return mbtowc(__pwc, __pmb, __max);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+size_t __libcpp_mbrlen_l(const char *__s, size_t __n, mbstate_t *__ps, locale_t __l)
+{
+    __libcpp_locale_guard __current(__l);
+    return mbrlen(__s, __n, __ps);
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+lconv *__libcpp_localeconv_l(locale_t __l)
+{
+    __libcpp_locale_guard __current(__l);
+    return localeconv();
+}
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+size_t __libcpp_mbsrtowcs_l(wchar_t *__dest, const char **__src, size_t __len,
+                     mbstate_t *__ps, locale_t __l)
+{
+    __libcpp_locale_guard __current(__l);
+    return mbsrtowcs(__dest, __src, __len, __ps);
+}
+
+inline
+int __libcpp_snprintf_l(char *__s, size_t __n, locale_t __l, const char *__format, ...) {
+    va_list __va;
+    va_start(__va, __format);
+    __libcpp_locale_guard __current(__l);
+    int __res = vsnprintf(__s, __n, __format, __va);
+    va_end(__va);
+    return __res;
+}
+
+inline
+int __libcpp_asprintf_l(char **__s, locale_t __l, const char *__format, ...) {
+    va_list __va;
+    va_start(__va, __format);
+    __libcpp_locale_guard __current(__l);
+    int __res = vasprintf(__s, __format, __va);
+    va_end(__va);
+    return __res;
+}
+
+inline
+int __libcpp_sscanf_l(const char *__s, locale_t __l, const char *__format, ...) {
+    va_list __va;
+    va_start(__va, __format);
+    __libcpp_locale_guard __current(__l);
+    int __res = vsscanf(__s, __format, __va);
+    va_end(__va);
+    return __res;
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX_BSD_LOCALE_FALLBACKS_DEFAULTS_H

cuda_toolkit/include/__cccl_config

@@ -0,0 +1,194 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// 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 __CCCL_CONFIG
+#define __CCCL_CONFIG
+
+// Determine the host compiler
+#if defined(__INTEL_LLVM_COMPILER)
+#  define _CCCL_COMPILER_ICC_LLVM
+#elif defined(__INTEL_COMPILER)
+#  define _CCCL_COMPILER_ICC
+#elif defined(__NVCOMPILER)
+#  define _CCCL_COMPILER_NVHPC
+#elif defined(__clang__)
+#  define _CCCL_COMPILER_CLANG
+#elif defined(__GNUC__)
+#  define _CCCL_COMPILER_GCC
+#elif defined(_MSC_VER)
+#  define _CCCL_COMPILER_MSVC
+#elif defined(__IBMCPP__)
+#  define _CCCL_COMPILER_IBM
+#elif defined(__CUDACC_RTC__)
+#  define _CCCL_COMPILER_NVRTC
+#endif
+
+// Convenient shortcut to determine which version of MSVC we are dealing with
+#if defined(_CCCL_COMPILER_MSVC)
+#  if _MSC_VER < 1917
+#    define _CCCL_COMPILER_MSVC_2017
+#  elif _MSC_VER < 1930
+#    define _CCCL_COMPILER_MSVC_2019
+#  else // _MSC_VER < 1940
+#    define _CCCL_COMPILER_MSVC_2022
+#  endif // _MSC_VER < 1940
+#endif // _CCCL_COMPILER_MSVC
+
+// Determine the cuda compiler
+#if defined(__NVCC__)
+#  define _CCCL_CUDA_COMPILER_NVCC
+#elif defined(_NVHPC_CUDA)
+#  define _CCCL_CUDA_COMPILER_NVHPC
+#elif defined(__CUDA__) && defined(_CCCL_COMPILER_CLANG)
+#  define _CCCL_CUDA_COMPILER_CLANG
+#endif
+
+// Shorthand to check whether there is a cuda compiler available
+#if defined(_CCCL_CUDA_COMPILER_NVCC) || defined(_CCCL_CUDA_COMPILER_NVHPC) || defined(_CCCL_CUDA_COMPILER_CLANG) \
+  || defined(_CCCL_COMPILER_NVRTC)
+#  define _CCCL_CUDA_COMPILER
+#endif // cuda compiler available
+
+// Enforce that cccl headers are treated as system headers
+#if defined(_CCCL_COMPILER_GCC) || defined(_CCCL_COMPILER_NVHPC) || defined(_CCCL_COMPILER_ICC) \
+  || defined(_CCCL_COMPILER_ICC_LLVM)
+#  define _CCCL_FORCE_SYSTEM_HEADER_GCC
+#elif defined(_CCCL_COMPILER_CLANG)
+#  define _CCCL_FORCE_SYSTEM_HEADER_CLANG
+#elif defined(_CCCL_COMPILER_MSVC)
+#  define _CCCL_FORCE_SYSTEM_HEADER_MSVC
+#endif // other compilers
+
+// Potentially enable that cccl headers are treated as system headers
+#if !defined(_CCCL_NO_SYSTEM_HEADER)                                                     \
+  && !(defined(_CCCL_COMPILER_MSVC) && defined(_LIBCUDACXX_DISABLE_PRAGMA_MSVC_WARNING)) \
+  && !defined(_CCCL_COMPILER_NVRTC) && !defined(_LIBCUDACXX_DISABLE_PRAGMA_GCC_SYSTEM_HEADER)
+#  if defined(_CCCL_COMPILER_GCC) || defined(_CCCL_COMPILER_NVHPC) || defined(_CCCL_COMPILER_ICC) \
+    || defined(_CCCL_COMPILER_ICC_LLVM)
+#    define _CCCL_IMPLICIT_SYSTEM_HEADER_GCC
+#  elif defined(_CCCL_COMPILER_CLANG)
+#    define _CCCL_IMPLICIT_SYSTEM_HEADER_CLANG
+#  elif defined(_CCCL_COMPILER_MSVC)
+#    define _CCCL_IMPLICIT_SYSTEM_HEADER_MSVC
+#  endif // other compilers
+#endif // Use system header
+
+// Potentially silence all warnings from this header
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// Enable us to selectively silence host compiler warnings
+#define _CCCL_TOSTRING2(_STR) #_STR
+#define _CCCL_TOSTRING(_STR)  _CCCL_TOSTRING2(_STR)
+#ifdef _CCCL_COMPILER_CLANG
+#  define _CCCL_DIAG_PUSH                _Pragma("clang diagnostic push")
+#  define _CCCL_DIAG_POP                 _Pragma("clang diagnostic pop")
+#  define _CCCL_DIAG_SUPPRESS_CLANG(str) _Pragma(_CCCL_TOSTRING(clang diagnostic ignored str))
+#  define _CCCL_DIAG_SUPPRESS_GCC(str)
+#  define _CCCL_DIAG_SUPPRESS_NVHPC(str)
+#  define _CCCL_DIAG_SUPPRESS_MSVC(str)
+#elif defined(_CCCL_COMPILER_GCC)
+#  define _CCCL_DIAG_PUSH _Pragma("GCC diagnostic push")
+#  define _CCCL_DIAG_POP  _Pragma("GCC diagnostic pop")
+#  define _CCCL_DIAG_SUPPRESS_CLANG(str)
+#  define _CCCL_DIAG_SUPPRESS_GCC(str) _Pragma(_CCCL_TOSTRING(GCC diagnostic ignored str))
+#  define _CCCL_DIAG_SUPPRESS_NVHPC(str)
+#  define _CCCL_DIAG_SUPPRESS_MSVC(str)
+#elif defined(_CCCL_COMPILER_NVHPC)
+#  define _CCCL_DIAG_PUSH _Pragma("diagnostic push")
+#  define _CCCL_DIAG_POP  _Pragma("diagnostic pop")
+#  define _CCCL_DIAG_SUPPRESS_CLANG(str)
+#  define _CCCL_DIAG_SUPPRESS_GCC(str)
+#  define _CCCL_DIAG_SUPPRESS_NVHPC(str) _Pragma(_CCCL_TOSTRING(diag_suppress str))
+#  define _CCCL_DIAG_SUPPRESS_MSVC(str)
+#elif defined(_CCCL_COMPILER_MSVC)
+#  define _CCCL_DIAG_PUSH __pragma(warning(push))
+#  define _CCCL_DIAG_POP  __pragma(warning(pop))
+#  define _CCCL_DIAG_SUPPRESS_CLANG(str)
+#  define _CCCL_DIAG_SUPPRESS_GCC(str)
+#  define _CCCL_DIAG_SUPPRESS_NVHPC(str)
+#  define _CCCL_DIAG_SUPPRESS_MSVC(str) __pragma(warning(disable : str))
+#else
+#  define _CCCL_DIAG_PUSH
+#  define _CCCL_DIAG_POP
+#  define _CCCL_DIAG_SUPPRESS_CLANG(str)
+#  define _CCCL_DIAG_SUPPRESS_GCC(str)
+#  define _CCCL_DIAG_SUPPRESS_NVHPC(str)
+#  define _CCCL_DIAG_SUPPRESS_MSVC(str)
+#endif
+
+// Convenient shortcuts to silence common warnings
+#if defined(_CCCL_COMPILER_CLANG)
+#  define _CCCL_DIAG_SUPPRESS_DEPRECATED_PUSH \
+    _CCCL_DIAG_PUSH                           \
+    _CCCL_DIAG_SUPPRESS_CLANG("-Wdeprecated") \
+    _CCCL_DIAG_SUPPRESS_CLANG("-Wdeprecated-declarations")
+#  define _CCCL_DIAG_SUPPRESS_DEPRECATED_POP _CCCL_DIAG_POP
+#elif defined(_CCCL_COMPILER_GCC)
+#  define _CCCL_DIAG_SUPPRESS_DEPRECATED_PUSH \
+    _CCCL_DIAG_PUSH                           \
+    _CCCL_DIAG_SUPPRESS_GCC("-Wdeprecated")   \
+    _CCCL_DIAG_SUPPRESS_GCC("-Wdeprecated-declarations")
+#  define _CCCL_DIAG_SUPPRESS_DEPRECATED_POP _CCCL_DIAG_POP
+#elif defined(_CCCL_COMPILER_MSVC)
+#  define _CCCL_DIAG_SUPPRESS_DEPRECATED_PUSH \
+    _CCCL_DIAG_PUSH                           \
+    _CCCL_DIAG_SUPPRESS_MSVC(4996)
+#  define _CCCL_DIAG_SUPPRESS_DEPRECATED_POP _CCCL_DIAG_POP
+#else // !_CCCL_COMPILER_CLANG && !_CCCL_COMPILER_GCC
+#  define _CCCL_DIAG_SUPPRESS_DEPRECATED_PUSH
+#  define _CCCL_DIAG_SUPPRESS_DEPRECATED_POP
+#endif // !_CCCL_COMPILER_CLANG && !_CCCL_COMPILER_GCC
+
+// Enable us to selectively silence cuda compiler warnings
+#if defined(__CUDACC__)
+#  if !defined(_CCCL_CUDA_COMPILER_CLANG)
+#    define _CCCL_NV_DIAG_SUPPRESS(_WARNING)
+#    define _CCCL_NV_DIAG_DEFAULT(_WARNING)
+#  elif defined(__NVCC_DIAG_PRAGMA_SUPPORT__)
+#    if defined(_CCCL_COMPILER_MSVC)
+#      define _CCCL_NV_DIAG_SUPPRESS(_WARNING) __pragma(_CCCL_TOSTRING(nv_diag_suppress _WARNING))
+#      define _CCCL_NV_DIAG_DEFAULT(_WARNING)  __pragma(_CCCL_TOSTRING(nv_diag_default _WARNING))
+#    else // ^^^ _CCCL_COMPILER_MSVC ^^^ / vvv !_CCCL_COMPILER_MSVC vvv
+#      define _CCCL_NV_DIAG_SUPPRESS(_WARNING) \
+        _Pragma(_CCCL_TOSTRING(nv_diagnostic push)) _Pragma(_CCCL_TOSTRING(nv_diag_suppress _WARNING))
+#      define _CCCL_NV_DIAG_DEFAULT(_WARNING) _Pragma(_CCCL_TOSTRING(nv_diagnostic pop))
+#    endif // !_CCCL_COMPILER_MSVC
+#  elif defined(_CCCL_COMPILER_NVHPC)
+#    define _CCCL_NV_DIAG_SUPPRESS(_WARNING) \
+      _Pragma(_CCCL_TOSTRING(diagnostic push)) _Pragma(_CCCL_TOSTRING(diag_suppress _WARNING))
+#    define _CCCL_NV_DIAG_DEFAULT(_WARNING) _Pragma(_CCCL_TOSTRING(diagnostic pop))
+#  else // ^^^ __NVCC_DIAG_PRAGMA_SUPPORT__ ^^^ / vvv !__NVCC_DIAG_PRAGMA_SUPPORT__ vvv
+#    if defined(_CCCL_COMPILER_MSVC_2017) // MSVC 2017 has issues with restoring the warning
+#      define _CCCL_NV_DIAG_SUPPRESS(_WARNING) __pragma(_CCCL_TOSTRING(diag_suppress _WARNING))
+#      define _CCCL_NV_DIAG_DEFAULT(_WARNING)
+#    elif defined(_CCCL_COMPILER_MSVC)
+#      define _CCCL_NV_DIAG_SUPPRESS(_WARNING) __pragma(_CCCL_TOSTRING(diag_suppress _WARNING))
+#      define _CCCL_NV_DIAG_DEFAULT(_WARNING)  __pragma(_CCCL_TOSTRING(diag_default _WARNING))
+#    else // ^^^ _CCCL_COMPILER_MSVC ^^^ / vvv !_CCCL_COMPILER_MSVC vvv
+#      define _CCCL_NV_DIAG_SUPPRESS(_WARNING) _Pragma(_CCCL_TOSTRING(diag_suppress _WARNING))
+#      define _CCCL_NV_DIAG_DEFAULT(_WARNING)  _Pragma(_CCCL_TOSTRING(diag_default _WARNING))
+#    endif // !_CCCL_COMPILER_MSVC
+#  endif // !__NVCC_DIAG_PRAGMA_SUPPORT__
+#else // ^^^ __CUDACC__ ^^^ / vvv !__CUDACC__ vvv
+#  define _CCCL_NV_DIAG_SUPPRESS(_WARNING)
+#  define _CCCL_NV_DIAG_DEFAULT(_WARNING)
+#endif // other compilers
+
+#include "__cccl/ptx_isa.h"
+#include "__cccl/version.h"
+#include "__cccl/visibility.h"
+
+#endif // __CCCL_CONFIG

cuda_toolkit/include/__config

@@ -0,0 +1,2250 @@
+// -*- C++ -*-
+//===--------------------------- __config ---------------------------------===//
+//
+// 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_CONFIG
+#define _LIBCUDACXX_CONFIG
+
+#include "__cccl_config"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#if defined(__INTEL_LLVM_COMPILER)
+#  define _LIBCUDACXX_COMPILER_ICC_LLVM
+#elif defined(__INTEL_COMPILER)
+#  define _LIBCUDACXX_COMPILER_ICC
+#elif defined(__NVCOMPILER)
+#  define _LIBCUDACXX_COMPILER_NVHPC
+#elif defined(__clang__)
+#  define _LIBCUDACXX_COMPILER_CLANG
+#  ifndef __apple_build_version__
+#    define _LIBCUDACXX_CLANG_VER (__clang_major__ * 100 + __clang_minor__)
+#  endif
+#elif defined(__GNUC__)
+#  define _LIBCUDACXX_COMPILER_GCC
+#elif defined(_MSC_VER)
+#  define _LIBCUDACXX_COMPILER_MSVC
+#elif defined(__IBMCPP__)
+#  define _LIBCUDACXX_COMPILER_IBM
+#elif defined(__CUDACC_RTC__)
+#  define _LIBCUDACXX_COMPILER_NVRTC
+#endif
+
+#if defined(_LIBCUDACXX_COMPILER_MSVC)
+#if _MSC_VER < 1917
+#define _LIBCUDACXX_COMPILER_MSVC_2017
+#elif _MSC_VER < 1930
+#define _LIBCUDACXX_COMPILER_MSVC_2019
+#else
+#define _LIBCUDACXX_COMPILER_MSVC_2022
+#endif
+#endif // defined(_LIBCUDACXX_COMPILER_MSVC)
+
+#if defined(__NVCC__)
+// This is not mutually exclusive with other compilers, as NVCC uses a host
+// compiler.
+#  define _LIBCUDACXX_COMPILER_NVCC
+#elif defined(_NVHPC_CUDA)
+#  define _LIBCUDACXX_COMPILER_NVHPC_CUDA
+#elif defined(__CUDA__) && defined(_LIBCUDACXX_COMPILER_CLANG)
+#  define _LIBCUDACXX_COMPILER_CLANG_CUDA
+#endif
+
+#ifdef __CUDACC__
+#  define _LIBCUDACXX_CUDACC
+#  define _LIBCUDACXX_CUDACC_VER_MAJOR __CUDACC_VER_MAJOR__
+#  define _LIBCUDACXX_CUDACC_VER_MINOR __CUDACC_VER_MINOR__
+#  define _LIBCUDACXX_CUDACC_VER_BUILD __CUDACC_VER_BUILD__
+#  define _LIBCUDACXX_CUDACC_VER                                                  \
+      _LIBCUDACXX_CUDACC_VER_MAJOR * 100000 + _LIBCUDACXX_CUDACC_VER_MINOR * 1000 + \
+      _LIBCUDACXX_CUDACC_VER_BUILD
+
+// TODO: Determine if this is necessary, I don't know why we automatically include this in <config>
+#  if defined(__clang__) || defined(__FLT16_MANT_DIG__)
+#    include <cuda_fp16.h>
+#  endif
+#endif
+
+// Some convenience macros to filter CUDACC versions
+#if defined(_LIBCUDACXX_CUDACC) && _LIBCUDACXX_CUDACC_VER < 1102000
+#define _LIBCUDACXX_CUDACC_BELOW_11_2
+#endif // defined(_LIBCUDACXX_CUDACC) && _LIBCUDACXX_CUDACC_VER < 1102000
+#if defined(_LIBCUDACXX_CUDACC) && _LIBCUDACXX_CUDACC_VER < 1103000
+#define _LIBCUDACXX_CUDACC_BELOW_11_3
+#endif // defined(_LIBCUDACXX_CUDACC) && _LIBCUDACXX_CUDACC_VER < 1103000
+#if defined(_LIBCUDACXX_CUDACC) && _LIBCUDACXX_CUDACC_VER < 1108000
+#define _LIBCUDACXX_CUDACC_BELOW_11_8
+#endif // defined(_LIBCUDACXX_CUDACC) && _LIBCUDACXX_CUDACC_VER < 1108000
+#if defined(_LIBCUDACXX_CUDACC) && _LIBCUDACXX_CUDACC_VER < 1203000
+#define _LIBCUDACXX_CUDACC_BELOW_12_3
+#endif // defined(_LIBCUDACXX_CUDACC) && _LIBCUDACXX_CUDACC_VER < 1203000
+
+#if defined(_LIBCUDACXX_COMPILER_MSVC)
+#  define _LIBCUDACXX_HAS_PRAGMA_MSVC_WARNING
+#  if !defined(_LIBCUDACXX_DISABLE_PRAGMA_MSVC_WARNING)
+#    define _LIBCUDACXX_USE_PRAGMA_MSVC_WARNING
+#  endif // !_LIBCUDACXX_DISABLE_PRAGMA_MSVC_WARNING
+#endif // _LIBCUDACXX_COMPILER_MSVC
+
+#ifdef __cplusplus
+
+// __config may be included in `extern "C"` contexts, switch back to include <nv/target>
+extern "C++" {
+#include <nv/target>
+}
+
+#ifdef __GNUC__
+#  define _GNUC_VER (__GNUC__ * 100 + __GNUC_MINOR__)
+#else
+#  define _GNUC_VER 0
+#endif
+
+#define _LIBCUDACXX_VERSION 10000
+
+#ifndef _LIBCUDACXX_ABI_VERSION
+#  define _LIBCUDACXX_ABI_VERSION 1
+#endif
+
+#ifndef _LIBCUDACXX_STD_VER
+#  if defined(_MSC_VER)
+#    if   _MSVC_LANG <= 201103L
+#      define _LIBCUDACXX_STD_VER 11
+#    elif _MSVC_LANG <= 201402L
+#      define _LIBCUDACXX_STD_VER 14
+#    elif _MSVC_LANG <= 201703L
+#      define _LIBCUDACXX_STD_VER 17
+#    elif _MSVC_LANG <= 202002L
+#      define _LIBCUDACXX_STD_VER 20
+#    else
+#      define _LIBCUDACXX_STD_VER 23 // current year, or date of c++2b ratification
+#    endif
+#  else
+#    if __cplusplus <= 201103L
+#      define _LIBCUDACXX_STD_VER 11
+#    elif __cplusplus <= 201402L
+#      define _LIBCUDACXX_STD_VER 14
+#    elif __cplusplus <= 201703L
+#      define _LIBCUDACXX_STD_VER 17
+#    elif __cplusplus <= 202002L
+#      define _LIBCUDACXX_STD_VER 20
+#    else
+#      define _LIBCUDACXX_STD_VER 23 // current year, or date of c++2b ratification
+#    endif
+#  endif
+#endif  // _LIBCUDACXX_STD_VER
+
+#if _LIBCUDACXX_STD_VER < 11
+#  error libcu++ requires C++11 or later
+#endif
+
+#if (defined(_LIBCUDACXX_COMPILER_NVHPC) && defined(__linux__)) \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)
+    #define __ELF__
+#endif
+
+#if defined(__ELF__)
+#  define _LIBCUDACXX_OBJECT_FORMAT_ELF   1
+#elif defined(__MACH__)
+#  define _LIBCUDACXX_OBJECT_FORMAT_MACHO 1
+#elif defined(_WIN32)
+#  define _LIBCUDACXX_OBJECT_FORMAT_COFF  1
+#elif defined(__wasm__)
+#  define _LIBCUDACXX_OBJECT_FORMAT_WASM  1
+#else
+#  error Unknown object file format
+#endif
+
+#if defined(_LIBCUDACXX_ABI_UNSTABLE) || _LIBCUDACXX_ABI_VERSION >= 2 || defined(__cuda_std__)
+// Change short string representation so that string data starts at offset 0,
+// improving its alignment in some cases.
+#  define _LIBCUDACXX_ABI_ALTERNATE_STRING_LAYOUT
+// Fix deque iterator type in order to support incomplete types.
+#  define _LIBCUDACXX_ABI_INCOMPLETE_TYPES_IN_DEQUE
+// Fix undefined behavior in how std::list stores its linked nodes.
+#  define _LIBCUDACXX_ABI_LIST_REMOVE_NODE_POINTER_UB
+// Fix undefined behavior in  how __tree stores its end and parent nodes.
+#  define _LIBCUDACXX_ABI_TREE_REMOVE_NODE_POINTER_UB
+// Fix undefined behavior in how __hash_table stores its pointer types.
+#  define _LIBCUDACXX_ABI_FIX_UNORDERED_NODE_POINTER_UB
+#  define _LIBCUDACXX_ABI_FORWARD_LIST_REMOVE_NODE_POINTER_UB
+#  define _LIBCUDACXX_ABI_FIX_UNORDERED_CONTAINER_SIZE_TYPE
+// Don't use a nullptr_t simulation type in C++03 instead using C++11 nullptr
+// provided under the alternate keyword __nullptr, which changes the mangling
+// of nullptr_t. This option is ABI incompatible with GCC in C++03 mode.
+#  define _LIBCUDACXX_ABI_ALWAYS_USE_CXX11_NULLPTR
+// Define the `pointer_safety` enum as a C++11 strongly typed enumeration
+// instead of as a class simulating an enum. If this option is enabled
+// `pointer_safety` and `get_pointer_safety()` will no longer be available
+// in C++03.
+#  define _LIBCUDACXX_ABI_POINTER_SAFETY_ENUM_TYPE
+// Define a key function for `bad_function_call` in the library, to centralize
+// its vtable and typeinfo to libc++ rather than having all other libraries
+// using that class define their own copies.
+#  define _LIBCUDACXX_ABI_BAD_FUNCTION_CALL_KEY_FUNCTION
+// Enable optimized version of __do_get_(un)signed which avoids redundant copies.
+#  define _LIBCUDACXX_ABI_OPTIMIZED_LOCALE_NUM_GET
+// Use the smallest possible integer type to represent the index of the variant.
+// Previously libc++ used "unsigned int" exclusively.
+#  define _LIBCUDACXX_ABI_VARIANT_INDEX_TYPE_OPTIMIZATION
+// Unstable attempt to provide a more optimized std::function
+#  define _LIBCUDACXX_ABI_OPTIMIZED_FUNCTION
+// All the regex constants must be distinct and nonzero.
+#  define _LIBCUDACXX_ABI_REGEX_CONSTANTS_NONZERO
+#elif _LIBCUDACXX_ABI_VERSION == 1
+#  if !defined(_LIBCUDACXX_OBJECT_FORMAT_COFF)
+// Enable compiling copies of now inline methods into the dylib to support
+// applications compiled against older libraries. This is unnecessary with
+// COFF dllexport semantics, since dllexport forces a non-inline definition
+// of inline functions to be emitted anyway. Our own non-inline copy would
+// conflict with the dllexport-emitted copy, so we disable it.
+#    define _LIBCUDACXX_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS
+#  endif
+#endif
+
+#ifndef __has_attribute
+#define __has_attribute(__x) 0
+#endif
+
+#ifndef __has_builtin
+#define __has_builtin(__x) 0
+#endif
+
+#ifndef __has_extension
+#define __has_extension(__x) 0
+#endif
+
+#ifndef __has_feature
+#define __has_feature(__x) 0
+#endif
+
+#ifndef __has_cpp_attribute
+#define __has_cpp_attribute(__x) 0
+#endif
+
+// '__is_identifier' returns '0' if '__x' is a reserved identifier provided by
+// the compiler and '1' otherwise.
+#ifndef __is_identifier
+#define __is_identifier(__x) 1
+#endif
+
+#ifndef __has_declspec_attribute
+#define __has_declspec_attribute(__x) 0
+#endif
+
+#define __has_keyword(__x) !(__is_identifier(__x))
+
+#ifndef __has_include
+#define __has_include(...) 0
+#endif
+
+#if !defined(_LIBCUDACXX_COMPILER_NVCC) && !defined(_LIBCUDACXX_COMPILER_NVRTC)
+// If NVCC is not being used <complex> can safely use `long double` without warnings
+#  define _LIBCUDACXX_HAS_COMPLEX_LONG_DOUBLE
+// NVCC does not have a way of silencing non '_' prefixed UDLs
+#  define _LIBCUDACXX_HAS_STL_LITERALS
+#endif
+
+#if defined(_LIBCUDACXX_COMPILER_GCC) && __cplusplus < 201103L
+#error "libc++ does not support using GCC with C++03. Please enable C++11"
+#endif
+
+// FIXME: ABI detection should be done via compiler builtin macros. This
+// is just a placeholder until Clang implements such macros. For now assume
+// that Windows compilers pretending to be MSVC++ target the Microsoft ABI,
+// and allow the user to explicitly specify the ABI to handle cases where this
+// heuristic falls short.
+#if defined(_LIBCUDACXX_ABI_FORCE_ITANIUM) && defined(_LIBCUDACXX_ABI_FORCE_MICROSOFT)
+#  error "Only one of _LIBCUDACXX_ABI_FORCE_ITANIUM and _LIBCUDACXX_ABI_FORCE_MICROSOFT can be defined"
+#elif defined(_LIBCUDACXX_ABI_FORCE_ITANIUM)
+#  define _LIBCUDACXX_ABI_ITANIUM
+#elif defined(_LIBCUDACXX_ABI_FORCE_MICROSOFT)
+#  define _LIBCUDACXX_ABI_MICROSOFT
+#else
+#  if defined(_WIN32) && defined(_LIBCUDACXX_COMPILER_MSVC)
+#    define _LIBCUDACXX_ABI_MICROSOFT
+#  else
+#    define _LIBCUDACXX_ABI_ITANIUM
+#  endif
+#endif
+
+#if defined(_LIBCUDACXX_ABI_MICROSOFT) && !defined(_LIBCUDACXX_NO_VCRUNTIME)
+# define _LIBCUDACXX_ABI_VCRUNTIME
+#endif
+
+// Need to detect which libc we're using if we're on Linux.
+#if defined(__linux__)
+#  include <features.h>
+#  if defined(__GLIBC_PREREQ)
+#    define _LIBCUDACXX_GLIBC_PREREQ(a, b) __GLIBC_PREREQ(a, b)
+#  else
+#    define _LIBCUDACXX_GLIBC_PREREQ(a, b) 0
+#  endif // defined(__GLIBC_PREREQ)
+#endif // defined(__linux__)
+
+#ifdef __LITTLE_ENDIAN__
+#  if __LITTLE_ENDIAN__
+#    define _LIBCUDACXX_LITTLE_ENDIAN
+#  endif  // __LITTLE_ENDIAN__
+#endif  // __LITTLE_ENDIAN__
+
+#ifdef __BIG_ENDIAN__
+#  if __BIG_ENDIAN__
+#    define _LIBCUDACXX_BIG_ENDIAN
+#  endif  // __BIG_ENDIAN__
+#endif  // __BIG_ENDIAN__
+
+#ifdef __BYTE_ORDER__
+#  if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#    define _LIBCUDACXX_LITTLE_ENDIAN
+#  elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#    define _LIBCUDACXX_BIG_ENDIAN
+#  endif // __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#endif // __BYTE_ORDER__
+
+#ifdef __FreeBSD__
+#  include <sys/endian.h>
+#  if _BYTE_ORDER == _LITTLE_ENDIAN
+#    define _LIBCUDACXX_LITTLE_ENDIAN
+#  else  // _BYTE_ORDER == _LITTLE_ENDIAN
+#    define _LIBCUDACXX_BIG_ENDIAN
+#  endif  // _BYTE_ORDER == _LITTLE_ENDIAN
+#  ifndef __LONG_LONG_SUPPORTED
+#    define _LIBCUDACXX_HAS_NO_LONG_LONG
+#  endif  // __LONG_LONG_SUPPORTED
+#endif  // __FreeBSD__
+
+#ifdef __NetBSD__
+#  include <sys/endian.h>
+#  if _BYTE_ORDER == _LITTLE_ENDIAN
+#    define _LIBCUDACXX_LITTLE_ENDIAN
+#  else  // _BYTE_ORDER == _LITTLE_ENDIAN
+#    define _LIBCUDACXX_BIG_ENDIAN
+#  endif  // _BYTE_ORDER == _LITTLE_ENDIAN
+#  define _LIBCUDACXX_HAS_QUICK_EXIT
+#endif  // __NetBSD__
+
+#if defined(_WIN32)
+#  define _LIBCUDACXX_WIN32API
+#  define _LIBCUDACXX_LITTLE_ENDIAN
+#  define _LIBCUDACXX_SHORT_WCHAR   1
+// Both MinGW and native MSVC provide a "MSVC"-like environment
+#  define _LIBCUDACXX_MSVCRT_LIKE
+// If mingw not explicitly detected, assume using MS C runtime only if
+// a MS compatibility version is specified.
+#  if defined(_LIBCUDACXX_COMPILER_MSVC) && !defined(__MINGW32__)
+#    define _LIBCUDACXX_MSVCRT // Using Microsoft's C Runtime library
+#  endif
+#  if (defined(_M_AMD64) || defined(__x86_64__)) || (defined(_M_ARM) || defined(__arm__))
+#    define _LIBCUDACXX_HAS_BITSCAN64
+#  endif
+#  define _LIBCUDACXX_HAS_OPEN_WITH_WCHAR
+#  if defined(_LIBCUDACXX_MSVCRT)
+#    define _LIBCUDACXX_HAS_QUICK_EXIT
+#  endif
+
+// Some CRT APIs are unavailable to store apps
+#  if defined(WINAPI_FAMILY)
+#    include <winapifamily.h>
+#    if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) &&                  \
+        (!defined(WINAPI_PARTITION_SYSTEM) ||                                  \
+         !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_SYSTEM))
+#      define _LIBCUDACXX_WINDOWS_STORE_APP
+#    endif
+#  endif
+#endif // defined(_WIN32)
+
+#ifdef __sun__
+#  include <sys/isa_defs.h>
+#  ifdef _LITTLE_ENDIAN
+#    define _LIBCUDACXX_LITTLE_ENDIAN
+#  else
+#    define _LIBCUDACXX_BIG_ENDIAN
+#  endif
+#endif // __sun__
+
+#if defined(__CloudABI__)
+   // Certain architectures provide arc4random(). Prefer using
+   // arc4random() over /dev/{u,}random to make it possible to obtain
+   // random data even when using sandboxing mechanisms such as chroots,
+   // Capsicum, etc.
+#  define _LIBCUDACXX_USING_ARC4_RANDOM
+#elif defined(__Fuchsia__) || defined(__wasi__)
+#  define _LIBCUDACXX_USING_GETENTROPY
+#elif defined(__native_client__)
+   // NaCl's sandbox (which PNaCl also runs in) doesn't allow filesystem access,
+   // including accesses to the special files under /dev. C++11's
+   // std::random_device is instead exposed through a NaCl syscall.
+#  define _LIBCUDACXX_USING_NACL_RANDOM
+#elif defined(_LIBCUDACXX_WIN32API)
+#  define _LIBCUDACXX_USING_WIN32_RANDOM
+#else
+#  define _LIBCUDACXX_USING_DEV_RANDOM
+#endif
+
+#ifndef _LIBCUDACXX_LITTLE_ENDIAN
+#if defined(_LIBCUDACXX_COMPILER_NVRTC)
+#  define _LIBCUDACXX_LITTLE_ENDIAN
+#endif
+#endif // _LIBCUDACXX_LITTLE_ENDIAN
+
+#if !defined(_LIBCUDACXX_LITTLE_ENDIAN) && !defined(_LIBCUDACXX_BIG_ENDIAN)
+#  include <endian.h>
+#  if __BYTE_ORDER == __LITTLE_ENDIAN
+#    define _LIBCUDACXX_LITTLE_ENDIAN
+#  elif __BYTE_ORDER == __BIG_ENDIAN
+#    define _LIBCUDACXX_BIG_ENDIAN
+#  else  // __BYTE_ORDER == __BIG_ENDIAN
+#    error unable to determine endian
+#  endif
+#endif  // !defined(_LIBCUDACXX_LITTLE_ENDIAN) && !defined(_LIBCUDACXX_BIG_ENDIAN)
+
+#if __has_attribute(__no_sanitize__) && !defined(_LIBCUDACXX_COMPILER_GCC)
+#  define _LIBCUDACXX_NO_CFI __attribute__((__no_sanitize__("cfi")))
+#else
+#  define _LIBCUDACXX_NO_CFI
+#endif
+
+#if (defined(__ISO_C_VISIBLE) && __ISO_C_VISIBLE >= 2011) || __cplusplus >= 201103L
+#  if defined(__FreeBSD__)
+#    define _LIBCUDACXX_HAS_QUICK_EXIT
+#    define _LIBCUDACXX_HAS_C11_FEATURES
+#  elif defined(__Fuchsia__) || defined(__wasi__)
+#    define _LIBCUDACXX_HAS_QUICK_EXIT
+#    define _LIBCUDACXX_HAS_TIMESPEC_GET
+#    define _LIBCUDACXX_HAS_C11_FEATURES
+#  elif defined(__linux__)
+#    if !defined(_LIBCUDACXX_HAS_MUSL_LIBC)
+#      if _LIBCUDACXX_GLIBC_PREREQ(2, 15) || defined(__BIONIC__)
+#        define _LIBCUDACXX_HAS_QUICK_EXIT
+#      endif
+#      if _LIBCUDACXX_GLIBC_PREREQ(2, 17)
+#        define _LIBCUDACXX_HAS_C11_FEATURES
+#        define _LIBCUDACXX_HAS_TIMESPEC_GET
+#      endif
+#    else // defined(_LIBCUDACXX_HAS_MUSL_LIBC)
+#      define _LIBCUDACXX_HAS_QUICK_EXIT
+#      define _LIBCUDACXX_HAS_TIMESPEC_GET
+#      define _LIBCUDACXX_HAS_C11_FEATURES
+#    endif
+#  endif // __linux__
+#endif
+
+#if defined(_LIBCUDACXX_COMPILER_NVRTC)
+#  define __alignof(x) alignof(x)
+#endif // _LIBCUDACXX_COMPILER_NVRTC
+
+#if defined(_LIBCUDACXX_COMPILER_MSVC)
+#  define __alignof__ __alignof
+#endif
+
+#define _LIBCUDACXX_ALIGNOF(_Tp) alignof(_Tp)
+#define _LIBCUDACXX_PREFERRED_ALIGNOF(_Tp) __alignof(_Tp)
+
+#if defined(_LIBCUDACXX_COMPILER_MSVC)
+#  define _ALIGNAS_TYPE(x) alignas(x)
+#  define _ALIGNAS(x) __declspec(align(x))
+#elif __has_feature(cxx_alignas)
+#  define _ALIGNAS_TYPE(x) alignas(x)
+#  define _ALIGNAS(x) alignas(x)
+#else
+#  define _ALIGNAS_TYPE(x) __attribute__((__aligned__(_LIBCUDACXX_ALIGNOF(x))))
+#  define _ALIGNAS(x) __attribute__((__aligned__(x)))
+#endif // !_LIBCUDACXX_COMPILER_MSVC && !__has_feature(cxx_alignas)
+
+// This is wrapped in __CUDA_ARCH__ to prevent error: "ignoring '#pragma unroll'
+// [-Werror=unknown-pragmas]"
+#if defined(__CUDA_ARCH__)
+#if defined(_LIBCUDACXX_COMPILER_MSVC)
+#  define _LIBCUDACXX_PRAGMA_UNROLL(_N) __pragma(_LIBCUDACXX_TOSTRING(unroll _N))
+#else // ^^^ _LIBCUDACXX_COMPILER_MSVC ^^^ / vvv !_LIBCUDACXX_COMPILER_MSVC vvv
+#  define _LIBCUDACXX_PRAGMA_UNROLL(_N) _Pragma(_LIBCUDACXX_TOSTRING(unroll _N))
+#endif // !_LIBCUDACXX_COMPILER_MSVC
+#else // ^^^ _LIBCUDACXX_CUDACC ^^^ / vvv !_LIBCUDACXX_CUDACCvvv
+#  define _LIBCUDACXX_PRAGMA_UNROLL(_N)
+#endif // !__CUDA_ARCH__
+
+#if defined(_LIBCUDACXX_COMPILER_MSVC)
+#define _LIBCUDACXX_ALWAYS_INLINE __forceinline
+#else
+#define _LIBCUDACXX_ALWAYS_INLINE __attribute__ ((__always_inline__))
+#endif // !_LIBCUDACXX_COMPILER_MSVC
+
+#if defined(__cuda_std__)
+#define _LIBCUDACXX_ATOMIC_ALWAYS_LOCK_FREE(size, ptr) (size <= 8)
+#elif defined(_LIBCUDACXX_COMPILER_CLANG) || defined(_LIBCUDACXX_COMPILER_GCC)
+#define _LIBCUDACXX_ATOMIC_ALWAYS_LOCK_FREE(...) __atomic_always_lock_free(__VA_ARGS__)
+#endif // __cuda_std__
+
+// https://bugs.llvm.org/show_bug.cgi?id=44517
+#define __check_builtin(__x) (__has_builtin(__##__x) || \
+                              __has_keyword(__##__x) || \
+                              __has_feature(__x))
+
+// We work around old clang versions (before clang-10) not supporting __has_builtin via __check_builtin
+// We work around old intel versions (before 2021.3)   not supporting __has_builtin via __check_builtin
+// We work around old nvhpc versions (before 2022.11)  not supporting __has_builtin via __check_builtin
+// MSVC needs manual handling, has no real way of checking builtins so all is manual
+// GCC  needs manual handling, before gcc-10 as that finally supports __has_builtin
+
+#if __check_builtin(array_rank)
+#define _LIBCUDACXX_ARRAY_RANK(...) __array_rank(__VA_ARGS__)
+#endif // __check_builtin(array_rank)
+
+// nvhpc has a bug where it supports __builtin_addressof but does not mark it via __check_builtin
+#if __check_builtin(builtin_addressof)                       \
+ || (defined(_LIBCUDACXX_COMPILER_GCC)  && _GNUC_VER >= 700) \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)                       \
+ || defined(_LIBCUDACXX_COMPILER_NVHPC)
+#define _LIBCUDACXX_ADDRESSOF(...) __builtin_addressof(__VA_ARGS__)
+#endif // __check_builtin(builtin_addressof)
+
+#if __check_builtin(builtin_bit_cast) \
+ || (defined(_LIBCUDACXX_COMPILER_MSVC) && _MSC_VER  > 1925)
+#define _LIBCUDACXX_BIT_CAST(...) __builtin_bit_cast(__VA_ARGS__)
+#endif // __check_builtin(builtin_bit_cast)
+
+#if __check_builtin(builtin_is_constant_evaluated)           \
+ || (defined(_LIBCUDACXX_COMPILER_GCC)  && _GNUC_VER >= 900) \
+ || (defined(_LIBCUDACXX_COMPILER_MSVC) && _MSC_VER  > 1924 && !defined(_LIBCUDACXX_CUDACC_BELOW_11_3))
+#define _LIBCUDACXX_IS_CONSTANT_EVALUATED(...) __builtin_is_constant_evaluated(__VA_ARGS__)
+#endif // __check_builtin(builtin_is_constant_evaluated)
+
+// NVCC and NVRTC in C++11 mode freaks out about `__builtin_is_constant_evaluated`.
+#if _LIBCUDACXX_STD_VER < 14              \
+ && (defined(_LIBCUDACXX_COMPILER_NVCC)   \
+ ||  defined(_LIBCUDACXX_COMPILER_NVRTC)  \
+ ||  defined(_LIBCUDACXX_COMPILER_NVHPC))
+#undef _LIBCUDACXX_IS_CONSTANT_EVALUATED
+#endif // _LIBCUDACXX_STD_VER < 14 && defined(_LIBCUDACXX_COMPILER_NVCC)
+
+#if __check_builtin(builtin_launder)                         \
+ || (defined(_LIBCUDACXX_COMPILER_GCC)  && _GNUC_VER >= 700)
+#define _LIBCUDACXX_LAUNDER(...) __builtin_launder(__VA_ARGS__)
+#endif // __check_builtin(builtin_launder)
+
+// Disabled due to libstdc++ conflict
+#if 0 // __check_builtin(decay)
+#define _LIBCUDACXX_DECAY(...) __decay(__VA_ARGS__)
+#endif // __check_builtin(decay)
+
+#if __check_builtin(has_nothrow_assign)                      \
+ || (defined(_LIBCUDACXX_COMPILER_GCC)  && _GNUC_VER >= 403) \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)                       \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)
+#define _LIBCUDACXX_HAS_NOTHROW_ASSIGN(...) __has_nothrow_assign(__VA_ARGS__)
+#endif // __check_builtin(has_nothrow_assign)
+
+#if __check_builtin(has_nothrow_constructor)                 \
+ || (defined(_LIBCUDACXX_COMPILER_GCC)  && _GNUC_VER >= 403) \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)                       \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)
+#define _LIBCUDACXX_HAS_NOTHROW_CONSTRUCTOR(...) __has_nothrow_constructor(__VA_ARGS__)
+#endif // __check_builtin(has_nothrow_constructor)
+
+#if __check_builtin(has_nothrow_copy)                        \
+ || (defined(_LIBCUDACXX_COMPILER_GCC)  && _GNUC_VER >= 403) \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)                       \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)
+#define _LIBCUDACXX_HAS_NOTHROW_COPY(...) __has_nothrow_copy(__VA_ARGS__)
+#endif // __check_builtin(has_nothrow_copy)
+
+#if __check_builtin(has_trivial_constructor)                 \
+ || (defined(_LIBCUDACXX_COMPILER_GCC)  && _GNUC_VER >= 403) \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)                       \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)
+#define _LIBCUDACXX_HAS_TRIVIAL_CONSTRUCTOR(...) __has_trivial_constructor(__VA_ARGS__)
+#endif // __check_builtin(has_trivial_constructor)
+
+#if __check_builtin(has_trivial_destructor)                  \
+ || (defined(_LIBCUDACXX_COMPILER_GCC)  && _GNUC_VER >= 403) \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)                       \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)
+#define _LIBCUDACXX_HAS_TRIVIAL_DESTRUCTOR(...) __has_trivial_destructor(__VA_ARGS__)
+#endif // __check_builtin(has_trivial_destructor)
+
+#if __check_builtin(has_unique_object_representations)       \
+ || (defined(_LIBCUDACXX_COMPILER_GCC)  && _GNUC_VER >= 700)
+#define _LIBCUDACXX_HAS_UNIQUE_OBJECT_REPRESENTATIONS(...) __has_unique_object_representations(__VA_ARGS__)
+#endif // __check_builtin(has_unique_object_representations)
+
+#if __check_builtin(has_virtual_destructor)                  \
+ || (defined(_LIBCUDACXX_COMPILER_GCC)  && _GNUC_VER >= 403) \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)                       \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)
+#define _LIBCUDACXX_HAS_VIRTUAL_DESTRUCTOR(...) __has_virtual_destructor(__VA_ARGS__)
+#endif // __check_builtin(has_virtual_destructor)
+
+#if __check_builtin(is_aggregate)                            \
+ || (defined(_LIBCUDACXX_COMPILER_GCC)  && _GNUC_VER >= 700) \
+ || (defined(_LIBCUDACXX_COMPILER_MSVC) && _MSC_VER  > 1914) \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)
+#define _LIBCUDACXX_IS_AGGREGATE(...) __is_aggregate(__VA_ARGS__)
+#endif // __check_builtin(is_aggregate)
+
+#if __check_builtin(is_array)
+#define _LIBCUDACXX_IS_ARRAY(...) __is_array(__VA_ARGS__)
+#endif // __check_builtin(is_array)
+
+// TODO: Clang incorrectly reports that __is_array is true for T[0].
+//       Re-enable the branch once https://llvm.org/PR54705 is fixed.
+#ifndef _LIBCUDACXX_USE_IS_ARRAY_FALLBACK
+#if defined(_LIBCUDACXX_COMPILER_CLANG)
+#define _LIBCUDACXX_USE_IS_ARRAY_FALLBACK
+#endif // _LIBCUDACXX_COMPILER_CLANG
+#endif // !_LIBCUDACXX_USE_IS_ARRAY_FALLBACK
+
+#if __check_builtin(is_assignable)     \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)
+#define _LIBCUDACXX_IS_ASSIGNABLE(...) __is_assignable(__VA_ARGS__)
+#endif // __check_builtin(is_assignable)
+
+#if __check_builtin(is_base_of)                              \
+ || (defined(_LIBCUDACXX_COMPILER_GCC)  && _GNUC_VER >= 403) \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)                       \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)
+#define _LIBCUDACXX_IS_BASE_OF(...) __is_base_of(__VA_ARGS__)
+#endif // __check_builtin(is_base_of)
+
+#if __check_builtin(is_class)                                \
+ || (defined(_LIBCUDACXX_COMPILER_GCC)  && _GNUC_VER >= 403) \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)                       \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)
+#define _LIBCUDACXX_IS_CLASS(...) __is_class(__VA_ARGS__)
+#endif // __check_builtin(is_class)
+
+#if __check_builtin(is_constructible)                       \
+ || (defined(_LIBCUDACXX_COMPILER_GCC) && _GNUC_VER >= 800) \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)                      \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)
+#define _LIBCUDACXX_IS_CONSTRUCTIBLE(...) __is_constructible(__VA_ARGS__)
+#endif // __check_builtin(is_constructible)
+
+#if __check_builtin(is_convertible_to) \
+ || defined(_LIBCUDACXX_COMPILER_MSVC) \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)
+#define _LIBCUDACXX_IS_CONVERTIBLE_TO(...) __is_convertible_to(__VA_ARGS__)
+#endif // __check_builtin(is_convertible_to)
+
+#if __check_builtin(is_destructible)   \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)
+#define _LIBCUDACXX_IS_DESTRUCTIBLE(...) __is_destructible(__VA_ARGS__)
+#endif // __check_builtin(is_destructible)
+
+#if __check_builtin(is_empty)                                \
+ || (defined(_LIBCUDACXX_COMPILER_GCC)  && _GNUC_VER >= 403) \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)                       \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)
+#define _LIBCUDACXX_IS_EMPTY(...) __is_empty(__VA_ARGS__)
+#endif // __check_builtin(is_empty)
+
+#if __check_builtin(is_enum)                                 \
+ || (defined(_LIBCUDACXX_COMPILER_GCC)  && _GNUC_VER >= 403) \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)                       \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)
+#define _LIBCUDACXX_IS_ENUM(...) __is_enum(__VA_ARGS__)
+#endif // __check_builtin(is_enum)
+
+#if __check_builtin(is_final)                                \
+ || (defined(_LIBCUDACXX_COMPILER_GCC)  && _GNUC_VER >= 407) \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)                       \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)
+#define _LIBCUDACXX_IS_FINAL(...) __is_final(__VA_ARGS__)
+#endif // __check_builtin(is_final)
+
+#if __check_builtin(is_function)       \
+ && !defined(_LIBCUDACXX_COMPILER_NVCC)
+#define _LIBCUDACXX_IS_FUNCTION(...) __is_function(__VA_ARGS__)
+#endif // __check_builtin(is_function)
+
+#if __check_builtin(is_literal_type)                         \
+ || (defined(_LIBCUDACXX_COMPILER_GCC)  && _GNUC_VER >= 406) \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)                       \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)
+#define _LIBCUDACXX_IS_LITERAL(...) __is_literal_type(__VA_ARGS__)
+#endif // __check_builtin(is_literal_type)
+
+#if __check_builtin(is_lvalue_reference)
+#define _LIBCUDACXX_IS_LVALUE_REFERENCE(...) __is_lvalue_reference(__VA_ARGS__)
+#endif // __check_builtin(is_lvalue_reference)
+
+#ifndef _LIBCUDACXX_USE_IS_LVALUE_REFERENCE_FALLBACK
+#if defined(_LIBCUDACXX_CUDACC_BELOW_11_3)
+#define _LIBCUDACXX_USE_IS_LVALUE_REFERENCE_FALLBACK
+#endif // nvcc < 11.3
+#endif // !_LIBCUDACXX_USE_IS_LVALUE_REFERENCE_FALLBACK
+
+#if __check_builtin(is_nothrow_assignable) \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)     \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)
+#define _LIBCUDACXX_IS_NOTHROW_ASSIGNABLE(...) __is_nothrow_assignable(__VA_ARGS__)
+#endif // __check_builtin(is_nothrow_assignable)
+
+#if __check_builtin(is_nothrow_constructible) \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)        \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)
+#define _LIBCUDACXX_IS_NOTHROW_CONSTRUCTIBLE(...) __is_nothrow_constructible(__VA_ARGS__)
+#endif // __check_builtin(is_nothrow_constructible)
+
+#if __check_builtin(is_nothrow_destructible) \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)       \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)
+#define _LIBCUDACXX_IS_NOTHROW_DESTRUCTIBLE(...) __is_nothrow_destructible(__VA_ARGS__)
+#endif // __check_builtin(is_nothrow_destructible)
+
+#if __check_builtin(is_object)
+#define _LIBCUDACXX_IS_OBJECT(...) __is_object(__VA_ARGS__)
+#endif // __check_builtin(is_object)
+
+#ifndef _LIBCUDACXX_USE_IS_OBJECT_FALLBACK
+#if defined(_LIBCUDACXX_CUDACC_BELOW_11_3)
+#define _LIBCUDACXX_USE_IS_OBJECT_FALLBACK
+#endif // nvcc < 11.3
+#endif // !_LIBCUDACXX_USE_IS_OBJECT_FALLBACK
+
+#if __check_builtin(is_pod)                                  \
+ || (defined(_LIBCUDACXX_COMPILER_GCC)  && _GNUC_VER >= 403) \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)                       \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)
+#define _LIBCUDACXX_IS_POD(...) __is_pod(__VA_ARGS__)
+#endif // __check_builtin(is_pod)
+
+// libstdc++ defines this as a function, breaking functionality
+#if 0 // __check_builtin(is_pointer)
+#define _LIBCUDACXX_IS_POINTER(...) __is_pointer(__VA_ARGS__)
+#endif // __check_builtin(is_pointer)
+
+#if __check_builtin(is_polymorphic)                          \
+ || (defined(_LIBCUDACXX_COMPILER_GCC)  && _GNUC_VER >= 403) \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)                       \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)
+#define _LIBCUDACXX_IS_POLYMORPHIC(...) __is_polymorphic(__VA_ARGS__)
+#endif // __check_builtin(is_polymorphic)
+
+#if __check_builtin(is_reference)
+#define _LIBCUDACXX_IS_REFERENCE(...) __is_reference(__VA_ARGS__)
+#endif // __check_builtin(is_reference)
+
+// Disabled due to libstdc++ conflict
+#if 0 // __check_builtin(is_referenceable)
+#define _LIBCUDACXX_IS_REFERENCEABLE(...) __is_referenceable(__VA_ARGS__)
+#endif // __check_builtin(is_referenceable)
+
+#if __check_builtin(is_rvalue_reference)
+#define _LIBCUDACXX_IS_RVALUE_REFERENCE(...) __is_rvalue_reference(__VA_ARGS__)
+#endif // __check_builtin(is_rvalue_reference)
+
+#if __check_builtin(is_same)            \
+ && !defined(_LIBCUDACXX_COMPILER_NVCC)
+#define _LIBCUDACXX_IS_SAME(...) __is_same(__VA_ARGS__)
+#endif // __check_builtin(is_same)
+
+// libstdc++ defines this as a function, breaking functionality
+#if 0 // __check_builtin(is_scalar)
+#define _LIBCUDACXX_IS_SCALAR(...) __is_scalar(__VA_ARGS__)
+#endif // __check_builtin(is_scalar)
+
+// libstdc++ defines this as a function, breaking functionality
+#if 0 // __check_builtin(is_signed)
+#define _LIBCUDACXX_IS_SIGNED(...) __is_signed(__VA_ARGS__)
+#endif // __check_builtin(is_signed)
+
+#if __check_builtin(is_standard_layout)                      \
+ || (defined(_LIBCUDACXX_COMPILER_GCC)  && _GNUC_VER >= 407) \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)                       \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)
+#define _LIBCUDACXX_IS_STANDARD_LAYOUT(...) __is_standard_layout(__VA_ARGS__)
+#endif // __check_builtin(is_standard_layout)
+
+#if __check_builtin(is_trivial)                              \
+ || (defined(_LIBCUDACXX_COMPILER_GCC)  && _GNUC_VER >= 405) \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)                       \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)
+#define _LIBCUDACXX_IS_TRIVIAL(...) __is_trivial(__VA_ARGS__)
+#endif // __check_builtin(is_trivial)
+
+#if __check_builtin(is_trivially_assignable)                 \
+ || (defined(_LIBCUDACXX_COMPILER_GCC)  && _GNUC_VER >= 501) \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)                       \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)
+#define _LIBCUDACXX_IS_TRIVIALLY_ASSIGNABLE(...) __is_trivially_assignable(__VA_ARGS__)
+#endif // __check_builtin(is_trivially_assignable)
+
+#if __check_builtin(is_trivially_constructible)              \
+ || (defined(_LIBCUDACXX_COMPILER_GCC)  && _GNUC_VER >= 501) \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)                       \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)
+#define _LIBCUDACXX_IS_TRIVIALLY_CONSTRUCTIBLE(...) __is_trivially_constructible(__VA_ARGS__)
+#endif // __check_builtin(is_trivially_constructible)
+
+#if __check_builtin(is_trivially_copyable)                   \
+ || (defined(_LIBCUDACXX_COMPILER_GCC)  && _GNUC_VER >= 501) \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)                       \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)
+#define _LIBCUDACXX_IS_TRIVIALLY_COPYABLE(...) __is_trivially_copyable(__VA_ARGS__)
+#endif // __check_builtin(is_trivially_copyable)
+
+#if __check_builtin(is_trivially_destructible) \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)
+#define _LIBCUDACXX_IS_TRIVIALLY_DESTRUCTIBLE(...) __is_trivially_destructible(__VA_ARGS__)
+#endif // __check_builtin(is_trivially_destructible)
+
+#if __check_builtin(is_union)                                \
+ || (defined(_LIBCUDACXX_COMPILER_GCC)  && _GNUC_VER >= 403) \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)                       \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)
+#define _LIBCUDACXX_IS_UNION(...) __is_union(__VA_ARGS__)
+#endif // __check_builtin(is_union)
+
+#if __check_builtin(is_unsigned)
+#define _LIBCUDACXX_IS_UNSIGNED(...) __is_unsigned(__VA_ARGS__)
+#endif // __check_builtin(is_unsigned)
+
+#ifndef _LIBCUDACXX_USE_IS_UNSIGNED_FALLBACK
+#if defined(_LIBCUDACXX_CUDACC_BELOW_11_3)
+#define _LIBCUDACXX_USE_IS_UNSIGNED_FALLBACK
+#endif // nvcc < 11.3
+#endif // !_LIBCUDACXX_USE_IS_UNSIGNED_FALLBACK
+
+// libstdc++ defines this as a function, breaking functionality
+#if 0 // __check_builtin(is_void)
+#define _LIBCUDACXX_IS_VOID(...) __is_void(__VA_ARGS__)
+#endif // __check_builtin(is_void)
+
+// Disabled due to libstdc++ conflict
+#if 0 // __check_builtin(make_signed)
+#define _LIBCUDACXX_MAKE_SIGNED(...) __make_signed(__VA_ARGS__)
+#endif // __check_builtin(make_signed)
+
+// Disabled due to libstdc++ conflict
+#if 0 // __check_builtin(make_unsigned)
+#define _LIBCUDACXX_MAKE_UNSIGNED(...) __make_unsigned(__VA_ARGS__)
+#endif // __check_builtin(make_unsigned)
+
+// Disabled due to libstdc++ conflict
+#if 0 // __check_builtin(remove_all_extents)
+#define _LIBCUDACXX_REMOVE_ALL_EXTENTS(...) __remove_all_extents(__VA_ARGS__)
+#endif // __check_builtin(remove_all_extents)
+
+// Disabled due to libstdc++ conflict
+#if 0 // __check_builtin(remove_const)
+#define _LIBCUDACXX_REMOVE_CONST(...) __remove_const(__VA_ARGS__)
+#endif // __check_builtin(remove_const)
+
+// Disabled due to libstdc++ conflict
+#if 0 // __check_builtin(remove_cv)
+#define _LIBCUDACXX_REMOVE_CV(...) __remove_cv(__VA_ARGS__)
+#endif // __check_builtin(remove_cv)
+
+// Disabled due to libstdc++ conflict
+#if 0 // __check_builtin(remove_cvref)
+#define _LIBCUDACXX_REMOVE_CVREF(...) __remove_cvref(__VA_ARGS__)
+#endif // __check_builtin(remove_cvref)
+
+// Disabled due to libstdc++ conflict
+#if 0 // __check_builtin(remove_extent)
+#define _LIBCUDACXX_REMOVE_EXTENT(...) __remove_extent(__VA_ARGS__)
+#endif // __check_builtin(remove_extent)
+
+// Disabled due to libstdc++ conflict
+#if 0 // __check_builtin(remove_pointer)
+#define _LIBCUDACXX_REMOVE_POINTER(...) __remove_pointer(__VA_ARGS__)
+#endif // __check_builtin(remove_pointer)
+
+// Disabled due to libstdc++ conflict
+#if 0 // __check_builtin(remove_reference_t)
+#define _LIBCUDACXX_REMOVE_REFERENCE_T(...) __remove_reference_t(__VA_ARGS__)
+#endif // __check_builtin(remove_reference_t)
+
+// Disabled due to libstdc++ conflict
+#if 0 // __check_builtin(remove_volatile)
+#define _LIBCUDACXX_REMOVE_VOLATILE(...) __remove_volatile(__VA_ARGS__)
+#endif // __check_builtin(remove_volatile)
+
+#if __check_builtin(underlying_type)                         \
+ || (defined(_LIBCUDACXX_COMPILER_GCC)  && _GNUC_VER >= 407) \
+ || defined(_LIBCUDACXX_COMPILER_MSVC)                       \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)
+#define _LIBCUDACXX_UNDERLYING_TYPE(...) __underlying_type(__VA_ARGS__)
+#endif // __check_builtin(underlying_type)
+
+#define _LIBCUDACXX_TOSTRING2(_STR) #_STR
+#define _LIBCUDACXX_TOSTRING(_STR) _LIBCUDACXX_TOSTRING2(_STR)
+#if defined(_LIBCUDACXX_CUDACC) && !defined(_LIBCUDACXX_COMPILER_CLANG_CUDA)
+#  if defined(__NVCC_DIAG_PRAGMA_SUPPORT__)
+#    if defined(_LIBCUDACXX_COMPILER_MSVC)
+#      define _LIBCUDACXX_NV_DIAG_SUPPRESS(_WARNING) __pragma(_LIBCUDACXX_TOSTRING(nv_diag_suppress _WARNING))
+#      define _LIBCUDACXX_NV_DIAG_DEFAULT(_WARNING)  __pragma(_LIBCUDACXX_TOSTRING(nv_diag_default _WARNING))
+#    else // ^^^ MSVC ^^^ / vvv not MSVC
+#      define _LIBCUDACXX_NV_DIAG_SUPPRESS(_WARNING)     \
+         _Pragma(_LIBCUDACXX_TOSTRING(nv_diagnostic push)) \
+         _Pragma(_LIBCUDACXX_TOSTRING(nv_diag_suppress _WARNING))
+#      define _LIBCUDACXX_NV_DIAG_DEFAULT(_WARNING) _Pragma(_LIBCUDACXX_TOSTRING(nv_diagnostic pop))
+#    endif // not MSVC
+#  elif defined(_LIBCUDACXX_COMPILER_NVHPC)
+#    define _LIBCUDACXX_NV_DIAG_SUPPRESS(_WARNING)  \
+       _Pragma(_LIBCUDACXX_TOSTRING(diagnostic push)) \
+       _Pragma(_LIBCUDACXX_TOSTRING(diag_suppress _WARNING))
+#    define _LIBCUDACXX_NV_DIAG_DEFAULT(_WARNING) _Pragma(_LIBCUDACXX_TOSTRING(diagnostic pop))
+#  else // _LIBCUDACXX_CUDACC_BELOW_11_3
+#    if defined(_LIBCUDACXX_COMPILER_MSVC_2017) // MSVC 2017 has issues with restoring the warning
+#      define _LIBCUDACXX_NV_DIAG_SUPPRESS(_WARNING) __pragma(_LIBCUDACXX_TOSTRING(diag_suppress _WARNING))
+#      define _LIBCUDACXX_NV_DIAG_DEFAULT(_WARNING)
+#    elif defined(_LIBCUDACXX_COMPILER_MSVC)
+#      define _LIBCUDACXX_NV_DIAG_SUPPRESS(_WARNING) __pragma(_LIBCUDACXX_TOSTRING(diag_suppress _WARNING))
+#      define _LIBCUDACXX_NV_DIAG_DEFAULT(_WARNING)  __pragma(_LIBCUDACXX_TOSTRING(diag_default _WARNING))
+#    else // ^^^ MSVC ^^^ / vvv not MSVC
+#      define _LIBCUDACXX_NV_DIAG_SUPPRESS(_WARNING) _Pragma(_LIBCUDACXX_TOSTRING(diag_suppress _WARNING))
+#      define _LIBCUDACXX_NV_DIAG_DEFAULT(_WARNING)  _Pragma(_LIBCUDACXX_TOSTRING(diag_default _WARNING))
+#    endif // not MSVC
+#  endif // !__NVCC_DIAG_PRAGMA_SUPPORT__
+#else // ^^^ _LIBCUDACXX_CUDACC ^^^ / vvv other compiler vvv
+#  define _LIBCUDACXX_NV_DIAG_SUPPRESS(_WARNING)
+#  define _LIBCUDACXX_NV_DIAG_DEFAULT(_WARNING)
+#endif // other compilers
+
+#if defined(_LIBCUDACXX_COMPILER_CLANG)
+
+// _LIBCUDACXX_ALTERNATE_STRING_LAYOUT is an old name for
+// _LIBCUDACXX_ABI_ALTERNATE_STRING_LAYOUT left here for backward compatibility.
+#if defined(_LIBCUDACXX_ALTERNATE_STRING_LAYOUT)
+#define _LIBCUDACXX_ABI_ALTERNATE_STRING_LAYOUT
+#endif
+
+#if __cplusplus < 201103L
+typedef __char16_t char16_t;
+typedef __char32_t char32_t;
+#endif
+
+#if !(__has_feature(cxx_strong_enums))
+#define _LIBCUDACXX_HAS_NO_STRONG_ENUMS
+#endif
+
+#if !(__has_feature(cxx_lambdas))
+#define _LIBCUDACXX_HAS_NO_LAMBDAS
+#endif
+
+#if !(__has_feature(cxx_nullptr))
+#  if (__has_extension(cxx_nullptr) || __has_keyword(__nullptr)) && defined(_LIBCUDACXX_ABI_ALWAYS_USE_CXX11_NULLPTR)
+#    define nullptr __nullptr
+#  else
+#    define _LIBCUDACXX_HAS_NO_NULLPTR
+#  endif
+#endif
+
+#if !(__has_feature(cxx_rvalue_references))
+#define _LIBCUDACXX_HAS_NO_RVALUE_REFERENCES
+#endif
+
+#if !(__has_feature(cxx_auto_type))
+#define _LIBCUDACXX_HAS_NO_AUTO_TYPE
+#endif
+
+#if !(__has_feature(cxx_variadic_templates))
+#define _LIBCUDACXX_HAS_NO_VARIADICS
+#endif
+
+#if !(__has_feature(cxx_generalized_initializers))
+#define _LIBCUDACXX_HAS_NO_GENERALIZED_INITIALIZERS
+#endif
+
+// Objective-C++ features (opt-in)
+#if __has_feature(objc_arc)
+#define _LIBCUDACXX_HAS_OBJC_ARC
+#endif
+
+#if __has_feature(objc_arc_weak)
+#define _LIBCUDACXX_HAS_OBJC_ARC_WEAK
+#endif
+
+#if !(__has_feature(cxx_relaxed_constexpr))
+#define _LIBCUDACXX_HAS_NO_CXX14_CONSTEXPR
+#endif
+
+#if !(__has_feature(cxx_variable_templates))
+#define _LIBCUDACXX_HAS_NO_VARIABLE_TEMPLATES
+#endif
+
+#if !(__has_feature(cxx_noexcept))
+#define _LIBCUDACXX_HAS_NO_NOEXCEPT
+#endif
+
+// Allow for build-time disabling of unsigned integer sanitization
+#if !defined(_LIBCUDACXX_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK) && __has_attribute(no_sanitize)
+#define _LIBCUDACXX_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK __attribute__((__no_sanitize__("unsigned-integer-overflow")))
+#endif
+
+#define _LIBCUDACXX_DISABLE_EXTENSION_WARNING __extension__
+
+#elif defined(_LIBCUDACXX_COMPILER_GCC)
+
+#ifndef _LIBCUDACXX_USE_IS_ASSIGNABLE_FALLBACK
+// FIXME: GCC 8.0 supports this trait, but it has a bug.
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=91592
+// https://godbolt.org/z/IljfIw
+#define _LIBCUDACXX_USE_IS_ASSIGNABLE_FALLBACK
+#endif // _LIBCUDACXX_USE_IS_ASSIGNABLE_FALLBACK
+
+// Determine if GCC supports relaxed constexpr
+#if !defined(__cpp_constexpr) || __cpp_constexpr < 201304L
+#define _LIBCUDACXX_HAS_NO_CXX14_CONSTEXPR
+#endif
+
+// GCC 5 supports variable templates
+#if !defined(__cpp_variable_templates) || __cpp_variable_templates < 201304L
+#define _LIBCUDACXX_HAS_NO_VARIABLE_TEMPLATES
+#endif
+
+#if _GNUC_VER < 600
+#define _LIBCUDACXX_GCC_MATH_IN_STD
+#endif
+
+// NVCC cannot properly handle some deductions occuring within NOEXCEPT
+// C++17 mode causes reference instatiation errors in tuple
+#if (_GNUC_VER >= 702 && _GNUC_VER <= 805)
+#if defined(_LIBCUDACXX_COMPILER_NVCC) && _LIBCUDACXX_STD_VER == 17
+#define _LIBCUDACXX_NO_TUPLE_NOEXCEPT
+#endif
+#endif
+
+#define _LIBCUDACXX_DISABLE_EXTENSION_WARNING __extension__
+
+#elif defined(_LIBCUDACXX_COMPILER_MSVC)
+
+#define _LIBCUDACXX_WARNING(x) __pragma(message(__FILE__ "(" _LIBCUDACXX_TOSTRING(__LINE__) ") : warning note: " x))
+
+// https://github.com/microsoft/STL/blob/master/stl/inc/yvals_core.h#L353
+// warning C4100: 'quack': unreferenced formal parameter
+// warning C4127: conditional expression is constant
+// warning C4180: qualifier applied to function type has no meaning; ignored
+// warning C4197: 'purr': top-level volatile in cast is ignored
+// warning C4324: 'roar': structure was padded due to alignment specifier
+// warning C4455: literal suffix identifiers that do not start with an underscore are reserved
+// warning C4503: 'hum': decorated name length exceeded, name was truncated
+// warning C4522: 'woof' : multiple assignment operators specified
+// warning C4668: 'meow' is not defined as a preprocessor macro, replacing with '0' for '#if/#elif'
+// warning C4800: 'boo': forcing value to bool 'true' or 'false' (performance warning)
+// warning C4996: 'meow': was declared deprecated
+#define _LIBCUDACXX_MSVC_DISABLED_WARNINGS \
+  4100 \
+  4127 \
+  4180 \
+  4197 \
+  4296 \
+  4324 \
+  4455 \
+  4503 \
+  4522 \
+  4668 \
+  4800 \
+  4996 \
+  /**/
+
+#if _MSC_VER < 1900
+#error "MSVC versions prior to Visual Studio 2015 are not supported"
+#endif
+
+// MSVC implemented P0030R1 in 15.7, only available under C++17
+#if _MSC_VER < 1914
+#define _LIBCUDACXX_NO_HOST_CPP17_HYPOT
+#endif
+
+#if _MSC_VER < 1920
+#define _LIBCUDACXX_HAS_NO_NOEXCEPT_SFINAE
+#define _LIBCUDACXX_HAS_NO_LOGICAL_METAFUNCTION_ALIASES
+#endif
+
+// MSVC exposed __iso_volatile intrinsics beginning on 1924 for x86
+#if _MSC_VER < 1924
+    #define _LIBCUDACXX_MSVC_HAS_NO_ISO_INTRIN
+#endif
+
+#if _LIBCUDACXX_STD_VER < 14
+#define _LIBCUDACXX_HAS_NO_CXX14_CONSTEXPR
+#define _LIBCUDACXX_HAS_NO_VARIABLE_TEMPLATES
+#endif
+
+#define _LIBCUDACXX_WEAK
+
+#define _LIBCUDACXX_HAS_NO_VECTOR_EXTENSION
+
+#define _LIBCUDACXX_DISABLE_EXTENSION_WARNING
+
+#elif defined(_LIBCUDACXX_COMPILER_IBM)
+
+#define _ATTRIBUTE(x) __attribute__((x))
+
+#define _LIBCUDACXX_HAS_NO_UNICODE_CHARS
+#define _LIBCUDACXX_HAS_NO_VARIABLE_TEMPLATES
+
+#if defined(_AIX)
+#define __MULTILOCALE_API
+#endif
+
+#define _LIBCUDACXX_HAS_NO_VECTOR_EXTENSION
+
+#elif defined(_LIBCUDACXX_COMPILER_NVRTC) || defined(_LIBCUDACXX_COMPILER_NVHPC)
+
+#if !defined(__cpp_constexpr) || __cpp_constexpr < 201304L
+#define _LIBCUDACXX_HAS_NO_CXX14_CONSTEXPR
+#endif
+
+#if !defined(__cpp_variable_templates) || __cpp_variable_templates < 201304L
+#define _LIBCUDACXX_HAS_NO_VARIABLE_TEMPLATES
+#endif
+
+#define _LIBCUDACXX_DISABLE_EXTENSION_WARNING
+
+#endif // _LIBCUDACXX_COMPILER_[CLANG|GCC|MSVC|IBM|NVRTC]
+
+#if defined(_LIBCUDACXX_COMPILER_NVHPC) && !defined(__cuda_std__)
+// Forcefully disable visibility controls when used as the standard library with NVC++.
+// TODO: reevaluate.
+#define _LIBCUDACXX_HIDE_FROM_ABI
+#ifndef _LIBCUDACXX_DISABLE_EXTERN_TEMPLATE
+#define _LIBCUDACXX_DISABLE_EXTERN_TEMPLATE
+#endif
+#endif
+
+#ifndef _LIBCUDACXX_FREESTANDING
+#if defined(__cuda_std__)     \
+ || !defined(__STDC_HOSTED__)
+#  define _LIBCUDACXX_FREESTANDING
+#endif
+#endif // !_LIBCUDACXX_FREESTANDING
+
+#ifndef _LIBCUDACXX_DISABLE_VISIBILITY_ANNOTATIONS
+#if defined(_LIBCUDACXX_COMPILER_NVRTC) \
+ || (defined(_LIBCUDACXX_COMPILER_NVHPC) && !defined(__cuda_std__))
+#  define _LIBCUDACXX_DISABLE_VISIBILITY_ANNOTATIONS
+#endif
+#endif // _LIBCUDACXX_DISABLE_VISIBILITY_ANNOTATIONS
+
+#ifndef _LIBCUDACXX_HAS_CUDA_ATOMIC_EXT
+#if defined(__cuda_std__)
+#  define _LIBCUDACXX_HAS_CUDA_ATOMIC_EXT
+#endif
+#endif // _LIBCUDACXX_HAS_CUDA_ATOMIC_EXT
+
+#ifndef _LIBCUDACXX_HAS_EXTERNAL_ATOMIC_IMP
+#if defined(__cuda_std__)
+#  define _LIBCUDACXX_HAS_EXTERNAL_ATOMIC_IMP
+#endif
+#endif // _LIBCUDACXX_HAS_EXTERNAL_ATOMIC_IMP
+
+#ifndef _LIBCUDACXX_HAS_NO_ASAN
+#if defined(_LIBCUDACXX_COMPILER_GCC)
+#  if !defined(__SANITIZE_ADDRESS__)
+#    define _LIBCUDACXX_HAS_NO_ASAN
+#  endif // !__SANITIZE_ADDRESS__
+#elif defined(_LIBCUDACXX_COMPILER_CLANG)
+#  if !__has_feature(address_sanitizer)
+#    define _LIBCUDACXX_HAS_NO_ASAN
+#  endif // !__has_feature(address_sanitizer)
+#else
+#  define _LIBCUDACXX_HAS_NO_ASAN
+#endif // _LIBCUDACXX_COMPILER[MSVC|IBM|NVHPC|NVRTC]
+#endif // _LIBCUDACXX_HAS_NO_ASAN
+
+#ifndef _LIBCUDACXX_HAS_NO_CXX20_CHRONO_LITERALS
+#if defined(__cuda_std__) \
+ || (defined(_LIBCUDACXX_COMPILER_CLANG) && _LIBCUDACXX_CLANG_VER < 800)
+#  define _LIBCUDACXX_HAS_NO_CXX20_CHRONO_LITERALS
+#endif // __cuda_std__
+#endif // _LIBCUDACXX_HAS_NO_CXX20_CHRONO_LITERALS
+
+#ifndef _LIBCUDACXX_HAS_NO_INT128
+#if defined(_LIBCUDACXX_COMPILER_MSVC)                                          \
+ || (defined(_LIBCUDACXX_COMPILER_NVRTC) && !defined(__CUDACC_RTC_INT128__))    \
+ || (defined(_LIBCUDACXX_COMPILER_NVCC)  && (_LIBCUDACXX_CUDACC_VER < 1105000)) \
+ || !defined(__SIZEOF_INT128__)
+#  define _LIBCUDACXX_HAS_NO_INT128
+#endif
+#endif // !_LIBCUDACXX_HAS_NO_INT128
+
+#ifndef _LIBCUDACXX_HAS_NO_LONG_DOUBLE
+#if defined(_LIBCUDACXX_CUDACC)
+#  define _LIBCUDACXX_HAS_NO_LONG_DOUBLE
+#endif
+#endif // _LIBCUDACXX_HAS_NO_LONG_DOUBLE
+
+#ifndef _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+#if __has_cpp_attribute(msvc::no_unique_address)
+// MSVC implements [[no_unique_address]] as a silent no-op currently.
+// (If/when MSVC breaks its C++ ABI, it will be changed to work as intended.)
+// However, MSVC implements [[msvc::no_unique_address]] which does what
+// [[no_unique_address]] is supposed to do, in general.
+
+// Clang-cl does not yet (14.0) implement either [[no_unique_address]] or
+// [[msvc::no_unique_address]] though. If/when it does implement
+// [[msvc::no_unique_address]], this should be preferred though.
+#  define _LIBCUDACXX_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]]
+#elif defined(_LIBCUDACXX_CUDACC_BELOW_11_3) \
+ || (__has_cpp_attribute(no_unique_address) < 201803L)
+#  define _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+#  define _LIBCUDACXX_NO_UNIQUE_ADDRESS
+#elif __has_cpp_attribute(no_unique_address)
+#  define _LIBCUDACXX_NO_UNIQUE_ADDRESS [[no_unique_address]]
+#else
+#  define _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+#  define _LIBCUDACXX_NO_UNIQUE_ADDRESS
+// Note that this can be replaced by #error as soon as clang-cl
+// implements msvc::no_unique_address, since there should be no C++20
+// compiler that doesn't support one of the two attributes at that point.
+// We generally don't want to use this macro outside of C++20-only code,
+// because using it conditionally in one language version only would make
+// the ABI inconsistent.
+#endif
+#endif // _LIBCUDACXX_HAS_NO_ATTRIBUTE_NO_UNIQUE_ADDRESS
+
+#ifndef _LIBCUDACXX_HAS_NO_MONOTONIC_CLOCK
+#if defined(__cuda_std__)
+#  define _LIBCUDACXX_HAS_NO_MONOTONIC_CLOCK
+#endif
+#endif // _LIBCUDACXX_HAS_NO_MONOTONIC_CLOCK
+
+#ifndef _LIBCUDACXX_HAS_NO_PLATFORM_WAIT
+#if defined(__cuda_std__)
+#  define _LIBCUDACXX_HAS_NO_PLATFORM_WAIT
+#endif
+#endif // _LIBCUDACXX_HAS_NO_PLATFORM_WAIT
+
+#ifndef _LIBCUDACXX_HAS_NO_PRAGMA_PUSH_POP_MACRO
+#if (defined(_LIBCUDACXX_COMPILER_MSVC) && _MSC_VER < 1920) \
+ || defined(_LIBCUDACXX_COMPILER_NVRTC)                     \
+ || defined(_LIBCUDACXX_COMPILER_IBM)
+#define _LIBCUDACXX_HAS_NO_PRAGMA_PUSH_POP_MACRO
+#endif
+#endif // _LIBCUDACXX_HAS_NO_PRAGMA_PUSH_POP_MACRO
+
+#ifndef _LIBCUDACXX_HAS_NO_THREAD_CONTENTION_TABLE
+#if defined(__cuda_std__)
+#  define _LIBCUDACXX_HAS_NO_THREAD_CONTENTION_TABLE
+#endif
+#endif // _LIBCUDACXX_HAS_NO_THREAD_CONTENTION_TABLE
+
+#ifndef _LIBCUDACXX_HAS_NO_TREE_BARRIER
+#if defined(__cuda_std__)
+#  define _LIBCUDACXX_HAS_NO_TREE_BARRIER
+#endif
+#endif // _LIBCUDACXX_HAS_NO_TREE_BARRIER
+
+#ifndef _LIBCUDACXX_HAS_NO_WCHAR_H
+#if defined(__cuda_std__)
+#  define _LIBCUDACXX_HAS_NO_WCHAR_H
+#endif
+#endif // _LIBCUDACXX_HAS_NO_WCHAR_H
+
+#ifndef _LIBCUDACXX_NO_EXCEPTIONS
+#if defined(__cuda_std__)                                                     \
+ || (defined(_LIBCUDACXX_COMPILER_CLANG) && !(__has_feature(cxx_exceptions))) \
+ || (defined(_LIBCUDACXX_COMPILER_GCC) && !__EXCEPTIONS)
+#  define _LIBCUDACXX_NO_EXCEPTIONS
+#endif
+#endif // !_LIBCUDACXX_NO_EXCEPTIONS
+
+// Try to find out if RTTI is disabled.
+// g++ and cl.exe have RTTI on by default and define a macro when it is.
+#ifndef _LIBCUDACXX_NO_RTTI
+#if defined(__cuda_std__)                                               \
+ || (defined(_LIBCUDACXX_COMPILER_CLANG) && !(__has_feature(cxx_rtti))) \
+ || (defined(_LIBCUDACXX_COMPILER_GCC)   && !defined(__GXX_RTTI))       \
+ || (defined(_LIBCUDACXX_COMPILER_MSVC)  && !defined(_CPPRTTI))
+#  define _LIBCUDACXX_NO_RTTI
+#endif
+#endif // !_LIBCUDACXX_NO_RTTI
+
+#ifndef _LIBCUDACXX_NODEBUG_TYPE
+#if defined(__cuda_std__)
+#  define _LIBCUDACXX_NODEBUG_TYPE
+#elif __has_attribute(__nodebug__)                                         \
+ && (defined(_LIBCUDACXX_COMPILER_CLANG) && _LIBCUDACXX_CLANG_VER >= 1210)
+#  define _LIBCUDACXX_NODEBUG_TYPE __attribute__((nodebug))
+#else
+#  define _LIBCUDACXX_NODEBUG_TYPE
+#endif
+#endif // !_LIBCUDACXX_NODEBUG_TYPE
+
+#if defined(_LIBCUDACXX_COMPILER_MSVC)
+#  define _LIBCUDACXX_NORETURN __declspec(noreturn)
+#elif __has_feature(cxx_attributes)
+#  define _LIBCUDACXX_NORETURN [[noreturn]]
+#else
+#  define _LIBCUDACXX_NORETURN __attribute__ ((noreturn))
+#endif
+
+#if defined(_LIBCUDACXX_OBJECT_FORMAT_COFF)
+
+#ifdef _DLL
+#  define _LIBCUDACXX_CRT_FUNC __declspec(dllimport)
+#else
+#  define _LIBCUDACXX_CRT_FUNC
+#endif
+
+#if defined(_LIBCUDACXX_DISABLE_VISIBILITY_ANNOTATIONS)
+#  define _LIBCUDACXX_DLL_VIS
+#  define _LIBCUDACXX_EXTERN_TEMPLATE_TYPE_VIS
+#  define _LIBCUDACXX_CLASS_TEMPLATE_INSTANTIATION_VIS
+#  define _LIBCUDACXX_OVERRIDABLE_FUNC_VIS
+#  define _LIBCUDACXX_EXPORTED_FROM_ABI
+#elif defined(_LIBCUDACXX_BUILDING_LIBRARY)
+#  define _LIBCUDACXX_DLL_VIS __declspec(dllexport)
+#  if defined(__MINGW32__)
+#    define _LIBCUDACXX_EXTERN_TEMPLATE_TYPE_VIS _LIBCUDACXX_DLL_VIS
+#    define _LIBCUDACXX_CLASS_TEMPLATE_INSTANTIATION_VIS
+#  else
+#    define _LIBCUDACXX_EXTERN_TEMPLATE_TYPE_VIS
+#    define _LIBCUDACXX_CLASS_TEMPLATE_INSTANTIATION_VIS _LIBCUDACXX_DLL_VIS
+#  endif
+#  define _LIBCUDACXX_OVERRIDABLE_FUNC_VIS _LIBCUDACXX_DLL_VIS
+#  define _LIBCUDACXX_EXPORTED_FROM_ABI __declspec(dllexport)
+#else
+#  define _LIBCUDACXX_DLL_VIS __declspec(dllimport)
+#  define _LIBCUDACXX_EXTERN_TEMPLATE_TYPE_VIS _LIBCUDACXX_DLL_VIS
+#  define _LIBCUDACXX_CLASS_TEMPLATE_INSTANTIATION_VIS
+#  define _LIBCUDACXX_OVERRIDABLE_FUNC_VIS
+#  define _LIBCUDACXX_EXPORTED_FROM_ABI __declspec(dllimport)
+#endif
+
+#define _LIBCUDACXX_TYPE_VIS            _LIBCUDACXX_DLL_VIS
+#define _LIBCUDACXX_FUNC_VIS            _LIBCUDACXX_DLL_VIS
+#define _LIBCUDACXX_EXCEPTION_ABI       _LIBCUDACXX_DLL_VIS
+#define _LIBCUDACXX_HIDDEN
+#define _LIBCUDACXX_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+#define _LIBCUDACXX_TEMPLATE_VIS
+#define _LIBCUDACXX_ENUM_VIS
+
+#endif // defined(_LIBCUDACXX_OBJECT_FORMAT_COFF)
+
+#ifndef _LIBCUDACXX_HIDDEN
+#  if !defined(_LIBCUDACXX_DISABLE_VISIBILITY_ANNOTATIONS)
+#    define _LIBCUDACXX_HIDDEN __attribute__ ((__visibility__("hidden")))
+#  else
+#    define _LIBCUDACXX_HIDDEN
+#  endif
+#endif
+
+#ifndef _LIBCUDACXX_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+#  if !defined(_LIBCUDACXX_DISABLE_VISIBILITY_ANNOTATIONS)
+// The inline should be removed once PR32114 is resolved
+#    define _LIBCUDACXX_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS inline _LIBCUDACXX_HIDDEN
+#  else
+#    define _LIBCUDACXX_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+#  endif
+#endif
+
+#ifndef _LIBCUDACXX_FUNC_VIS
+#  if !defined(_LIBCUDACXX_DISABLE_VISIBILITY_ANNOTATIONS)
+#    define _LIBCUDACXX_FUNC_VIS __attribute__ ((__visibility__("default")))
+#  else
+#    define _LIBCUDACXX_FUNC_VIS
+#  endif
+#endif
+
+#ifndef _LIBCUDACXX_TYPE_VIS
+#  if !defined(_LIBCUDACXX_DISABLE_VISIBILITY_ANNOTATIONS)
+#    define _LIBCUDACXX_TYPE_VIS __attribute__ ((__visibility__("default")))
+#  else
+#    define _LIBCUDACXX_TYPE_VIS
+#  endif
+#endif
+
+#ifndef _LIBCUDACXX_TEMPLATE_VIS
+#  if !defined(_LIBCUDACXX_DISABLE_VISIBILITY_ANNOTATIONS)
+#    if __has_attribute(__type_visibility__)
+#      define _LIBCUDACXX_TEMPLATE_VIS __attribute__ ((__type_visibility__("default")))
+#    else
+#      define _LIBCUDACXX_TEMPLATE_VIS __attribute__ ((__visibility__("default")))
+#    endif
+#  else
+#    define _LIBCUDACXX_TEMPLATE_VIS
+#  endif
+#endif
+
+#ifndef _LIBCUDACXX_EXPORTED_FROM_ABI
+#  if !defined(_LIBCUDACXX_DISABLE_VISIBILITY_ANNOTATIONS)
+#    define _LIBCUDACXX_EXPORTED_FROM_ABI __attribute__((__visibility__("default")))
+#  else
+#    define _LIBCUDACXX_EXPORTED_FROM_ABI
+#  endif
+#endif
+
+#ifndef _LIBCUDACXX_OVERRIDABLE_FUNC_VIS
+#define _LIBCUDACXX_OVERRIDABLE_FUNC_VIS _LIBCUDACXX_FUNC_VIS
+#endif
+
+#ifndef _LIBCUDACXX_EXCEPTION_ABI
+#  if !defined(_LIBCUDACXX_DISABLE_VISIBILITY_ANNOTATIONS)
+#    define _LIBCUDACXX_EXCEPTION_ABI __attribute__ ((__visibility__("default")))
+#  else
+#    define _LIBCUDACXX_EXCEPTION_ABI
+#  endif
+#endif
+
+#ifndef _LIBCUDACXX_ENUM_VIS
+#  if !defined(_LIBCUDACXX_DISABLE_VISIBILITY_ANNOTATIONS) && __has_attribute(__type_visibility__)
+#    define _LIBCUDACXX_ENUM_VIS __attribute__ ((__type_visibility__("default")))
+#  else
+#    define _LIBCUDACXX_ENUM_VIS
+#  endif
+#endif
+
+#ifndef _LIBCUDACXX_EXTERN_TEMPLATE_TYPE_VIS
+#  if !defined(_LIBCUDACXX_DISABLE_VISIBILITY_ANNOTATIONS) && __has_attribute(__type_visibility__)
+#    define _LIBCUDACXX_EXTERN_TEMPLATE_TYPE_VIS __attribute__ ((__visibility__("default")))
+#  else
+#    define _LIBCUDACXX_EXTERN_TEMPLATE_TYPE_VIS
+#  endif
+#endif
+
+#ifndef _LIBCUDACXX_CLASS_TEMPLATE_INSTANTIATION_VIS
+#define _LIBCUDACXX_CLASS_TEMPLATE_INSTANTIATION_VIS
+#endif
+
+#if __has_attribute(internal_linkage)
+#  define _LIBCUDACXX_INTERNAL_LINKAGE __attribute__ ((internal_linkage))
+#else
+#  define _LIBCUDACXX_INTERNAL_LINKAGE _LIBCUDACXX_ALWAYS_INLINE
+#endif
+
+#if __has_attribute(exclude_from_explicit_instantiation)
+#  define _LIBCUDACXX_EXCLUDE_FROM_EXPLICIT_INSTANTIATION __attribute__ ((__exclude_from_explicit_instantiation__))
+#else
+   // Try to approximate the effect of exclude_from_explicit_instantiation
+   // (which is that entities are not assumed to be provided by explicit
+   // template instantiations in the dylib) by always inlining those entities.
+#  define _LIBCUDACXX_EXCLUDE_FROM_EXPLICIT_INSTANTIATION _LIBCUDACXX_ALWAYS_INLINE
+#endif
+
+#ifndef _LIBCUDACXX_HIDE_FROM_ABI_PER_TU
+#  ifndef _LIBCUDACXX_HIDE_FROM_ABI_PER_TU_BY_DEFAULT
+#    define _LIBCUDACXX_HIDE_FROM_ABI_PER_TU 0
+#  else
+#    define _LIBCUDACXX_HIDE_FROM_ABI_PER_TU 1
+#  endif
+#endif
+
+#ifndef _LIBCUDACXX_HAS_MERGED_TYPEINFO_NAMES_DEFAULT
+# ifdef _LIBCUDACXX_OBJECT_FORMAT_COFF // Windows binaries can't merge typeinfos.
+# define _LIBCUDACXX_HAS_MERGED_TYPEINFO_NAMES_DEFAULT 0
+#else
+// TODO: This isn't strictly correct on ELF platforms due to llvm.org/PR37398
+// And we should consider defaulting to OFF.
+# define _LIBCUDACXX_HAS_MERGED_TYPEINFO_NAMES_DEFAULT 1
+#endif
+#endif
+
+#ifndef _LIBCUDACXX_HIDE_FROM_ABI
+#  if _LIBCUDACXX_HIDE_FROM_ABI_PER_TU
+#    define _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_HIDDEN _LIBCUDACXX_INTERNAL_LINKAGE
+#  else
+#    define _LIBCUDACXX_HIDE_FROM_ABI _LIBCUDACXX_HIDDEN _LIBCUDACXX_EXCLUDE_FROM_EXPLICIT_INSTANTIATION
+#  endif
+#endif
+
+#ifdef _LIBCUDACXX_BUILDING_LIBRARY
+#  if _LIBCUDACXX_ABI_VERSION > 1
+#    define _LIBCUDACXX_HIDE_FROM_ABI_AFTER_V1 _LIBCUDACXX_HIDE_FROM_ABI
+#  else
+#    define _LIBCUDACXX_HIDE_FROM_ABI_AFTER_V1
+#  endif
+#else
+#  define _LIBCUDACXX_HIDE_FROM_ABI_AFTER_V1 _LIBCUDACXX_HIDE_FROM_ABI
+#endif
+
+#ifdef _LIBCUDACXX_CUDACC
+#  define _LIBCUDACXX_HOST __host__
+#  define _LIBCUDACXX_DEVICE __device__
+#  define _LIBCUDACXX_HOST_DEVICE __host__ __device__
+#  define _LIBCUDACXX_FORCE_INLINE __forceinline__
+#else // ^^^ _LIBCUDACXX_CUDACC ^^^ / vvv !_LIBCUDACXX_CUDACC
+#  define _LIBCUDACXX_HOST
+#  define _LIBCUDACXX_DEVICE
+#  define _LIBCUDACXX_HOST_DEVICE
+#  define _LIBCUDACXX_FORCE_INLINE
+#endif // !_LIBCUDACXX_CUDACC
+
+// Just so we can migrate to the new macros gradually.
+
+#ifdef __cuda_std__
+#  define _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_HOST_DEVICE
+#else
+#  define _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_HIDE_FROM_ABI
+#endif // __cuda_std__
+
+#define _LIBCUDACXX_CONCAT1(_LIBCUDACXX_X,_LIBCUDACXX_Y) _LIBCUDACXX_X##_LIBCUDACXX_Y
+#define _LIBCUDACXX_CONCAT(_LIBCUDACXX_X,_LIBCUDACXX_Y) _LIBCUDACXX_CONCAT1(_LIBCUDACXX_X,_LIBCUDACXX_Y)
+
+#ifndef _LIBCUDACXX_ABI_NAMESPACE
+#ifdef __cuda_std__
+# define _LIBCUDACXX_ABI_NAMESPACE _LIBCUDACXX_CONCAT(__,_LIBCUDACXX_CUDA_ABI_VERSION)
+#else
+# define _LIBCUDACXX_ABI_NAMESPACE _LIBCUDACXX_CONCAT(__,_LIBCUDACXX_ABI_VERSION)
+#endif // __cuda_std__
+#endif // _LIBCUDACXX_ABI_NAMESPACE
+
+#ifdef __cuda_std__
+#  define _LIBCUDACXX_BEGIN_NAMESPACE_STD_NOVERSION namespace cuda { namespace std {
+#  define _LIBCUDACXX_END_NAMESPACE_STD_NOVERSION } }
+#  define _CUDA_VSTD ::cuda::std::_LIBCUDACXX_ABI_NAMESPACE
+#  define _CUDA_VRANGES ::cuda::std::ranges::_LIBCUDACXX_ABI_NAMESPACE
+#else
+#  define _LIBCUDACXX_BEGIN_NAMESPACE_STD_NOVERSION namespace std {
+#  define _LIBCUDACXX_END_NAMESPACE_STD_NOVERSION }
+#  define _CUDA_VSTD ::std::_LIBCUDACXX_ABI_NAMESPACE
+#  define _CUDA_VRANGES ::std::ranges::_LIBCUDACXX_ABI_NAMESPACE
+#endif
+
+#ifdef __cuda_std__
+#define _LIBCUDACXX_BEGIN_NAMESPACE_CUDA namespace cuda { inline namespace _LIBCUDACXX_ABI_NAMESPACE {
+#define _LIBCUDACXX_END_NAMESPACE_CUDA  } }
+#define _LIBCUDACXX_BEGIN_NAMESPACE_CUDA_DEVICE namespace cuda { namespace device { inline namespace _LIBCUDACXX_ABI_NAMESPACE {
+#define _LIBCUDACXX_END_NAMESPACE_CUDA_DEVICE  } } }
+#define _LIBCUDACXX_BEGIN_NAMESPACE_CUDA_PTX namespace cuda { namespace ptx { inline namespace _LIBCUDACXX_ABI_NAMESPACE {
+#define _LIBCUDACXX_END_NAMESPACE_CUDA_PTX  } } }
+#define _CUDA_VPTX ::cuda::ptx::_LIBCUDACXX_ABI_NAMESPACE
+#define _LIBCUDACXX_BEGIN_NAMESPACE_CUDA_DEVICE_EXPERIMENTAL namespace cuda { namespace device { namespace experimental { inline namespace _LIBCUDACXX_ABI_NAMESPACE {
+#define _LIBCUDACXX_END_NAMESPACE_CUDA_DEVICE_EXPERIMENTAL  } } } }
+#endif
+
+// Inline namespaces are available in Clang/GCC/MSVC regardless of C++ dialect.
+#define _LIBCUDACXX_BEGIN_NAMESPACE_STD _LIBCUDACXX_BEGIN_NAMESPACE_STD_NOVERSION inline namespace _LIBCUDACXX_ABI_NAMESPACE {
+#define _LIBCUDACXX_END_NAMESPACE_STD   } _LIBCUDACXX_END_NAMESPACE_STD_NOVERSION
+
+#ifndef __cuda_std__
+_LIBCUDACXX_BEGIN_NAMESPACE_STD _LIBCUDACXX_END_NAMESPACE_STD
+#endif
+
+#define _LIBCUDACXX_BEGIN_NAMESPACE_RANGES _LIBCUDACXX_BEGIN_NAMESPACE_STD_NOVERSION namespace ranges { inline namespace _LIBCUDACXX_ABI_NAMESPACE {
+#define _LIBCUDACXX_END_NAMESPACE_RANGES   } } _LIBCUDACXX_END_NAMESPACE_STD_NOVERSION
+
+#if !defined(__cuda_std__)
+_LIBCUDACXX_BEGIN_NAMESPACE_RANGES _LIBCUDACXX_END_NAMESPACE_RANGES
+#endif
+
+#if _LIBCUDACXX_STD_VER > 17
+#define _LIBCUDACXX_BEGIN_NAMESPACE_RANGES_ABI inline namespace __cxx20 {
+#else
+#define _LIBCUDACXX_BEGIN_NAMESPACE_RANGES_ABI inline namespace __cxx17 {
+#endif
+#define _LIBCUDACXX_END_NAMESPACE_RANGES_ABI }
+
+#define _LIBCUDACXX_BEGIN_NAMESPACE_CPO(_CPO) namespace _CPO { _LIBCUDACXX_BEGIN_NAMESPACE_RANGES_ABI
+#define _LIBCUDACXX_END_NAMESPACE_CPO } }
+
+#if _LIBCUDACXX_STD_VER >= 17
+#define _LIBCUDACXX_BEGIN_NAMESPACE_FILESYSTEM \
+  _LIBCUDACXX_BEGIN_NAMESPACE_STD inline namespace __fs { namespace filesystem {
+#else
+#define _LIBCUDACXX_BEGIN_NAMESPACE_FILESYSTEM \
+  _LIBCUDACXX_BEGIN_NAMESPACE_STD namespace __fs { namespace filesystem {
+#endif
+
+#define _LIBCUDACXX_END_NAMESPACE_FILESYSTEM \
+  _LIBCUDACXX_END_NAMESPACE_STD } }
+
+#define _CUDA_VSTD_FS _CUDA_VSTD::__fs::filesystem
+
+#ifndef _LIBCUDACXX_PREFERRED_OVERLOAD
+#  if __has_attribute(__enable_if__)
+#    define _LIBCUDACXX_PREFERRED_OVERLOAD __attribute__ ((__enable_if__(true, "")))
+#  endif
+#endif
+
+#ifdef _LIBCUDACXX_HAS_NO_UNICODE_CHARS
+typedef unsigned short char16_t;
+typedef unsigned int   char32_t;
+#endif  // _LIBCUDACXX_HAS_NO_UNICODE_CHARS
+
+#if defined(_LIBCUDACXX_COMPILER_GCC)   \
+ || defined(_LIBCUDACXX_COMPILER_CLANG)
+#  define _LIBCUDACXX_NOALIAS __attribute__((__malloc__))
+#else
+#  define _LIBCUDACXX_NOALIAS
+#endif
+
+#if __has_feature(cxx_explicit_conversions) \
+ || defined(_LIBCUDACXX_COMPILER_IBM)       \
+ || defined(_LIBCUDACXX_COMPILER_GCC)       \
+ || defined(_LIBCUDACXX_COMPILER_CLANG)
+#  define _LIBCUDACXX_EXPLICIT explicit
+#else
+#  define _LIBCUDACXX_EXPLICIT
+#endif
+
+#if !__has_builtin(__builtin_operator_new) || !__has_builtin(__builtin_operator_delete)
+#define _LIBCUDACXX_HAS_NO_BUILTIN_OPERATOR_NEW_DELETE
+#endif
+
+#ifdef _LIBCUDACXX_HAS_NO_STRONG_ENUMS
+#  define _LIBCUDACXX_DECLARE_STRONG_ENUM(x) struct _LIBCUDACXX_TYPE_VIS x { enum __lx
+#  define _LIBCUDACXX_DECLARE_STRONG_ENUM_EPILOG(x) \
+     __lx __v_; \
+     _LIBCUDACXX_INLINE_VISIBILITY x(__lx __v) : __v_(__v) {} \
+     _LIBCUDACXX_INLINE_VISIBILITY explicit x(int __v) : __v_(static_cast<__lx>(__v)) {} \
+     _LIBCUDACXX_INLINE_VISIBILITY operator int() const {return __v_;} \
+     };
+#else  // _LIBCUDACXX_HAS_NO_STRONG_ENUMS
+#  define _LIBCUDACXX_DECLARE_STRONG_ENUM(x) enum class _LIBCUDACXX_ENUM_VIS x
+#  define _LIBCUDACXX_DECLARE_STRONG_ENUM_EPILOG(x)
+#endif  // _LIBCUDACXX_HAS_NO_STRONG_ENUMS
+
+#ifdef _LIBCUDACXX_DEBUG
+#  if _LIBCUDACXX_DEBUG == 0
+#    define _LIBCUDACXX_DEBUG_LEVEL 1
+#  elif _LIBCUDACXX_DEBUG == 1
+#    define _LIBCUDACXX_DEBUG_LEVEL 2
+#  else
+#    error Supported values for _LIBCUDACXX_DEBUG are 0 and 1
+#  endif
+#  if !defined(_LIBCUDACXX_BUILDING_LIBRARY)
+#    define _LIBCUDACXX_EXTERN_TEMPLATE(...)
+#  endif
+#endif
+
+#ifdef _LIBCUDACXX_DISABLE_EXTERN_TEMPLATE
+#define _LIBCUDACXX_EXTERN_TEMPLATE(...)
+#define _LIBCUDACXX_EXTERN_TEMPLATE2(...)
+#endif
+
+#ifndef _LIBCUDACXX_EXTERN_TEMPLATE
+#define _LIBCUDACXX_EXTERN_TEMPLATE(...) extern template __VA_ARGS__;
+#endif
+
+#ifndef _LIBCUDACXX_EXTERN_TEMPLATE2
+#define _LIBCUDACXX_EXTERN_TEMPLATE2(...) extern template __VA_ARGS__;
+#endif
+
+#if defined(__APPLE__) || defined(__FreeBSD__) || defined(_LIBCUDACXX_MSVCRT_LIKE) || \
+    defined(__sun__) || defined(__NetBSD__) || defined(__CloudABI__)
+#define _LIBCUDACXX_LOCALE__L_EXTENSIONS 1
+#endif
+
+#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
+// Most unix variants have catopen.  These are the specific ones that don't.
+#  if !defined(__BIONIC__) && !defined(_NEWLIB_VERSION)
+#    define _LIBCUDACXX_HAS_CATOPEN 1
+#  endif
+#endif
+
+#ifdef __FreeBSD__
+#define _DECLARE_C99_LDBL_MATH 1
+#endif
+
+#if defined(_LIBCUDACXX_ABI_MICROSOFT) && !defined(_LIBCUDACXX_NO_VCRUNTIME)
+#  define _LIBCUDACXX_DEFER_NEW_TO_VCRUNTIME
+#endif
+
+// If we are getting operator new from the MSVC CRT, then allocation overloads
+// for align_val_t were added in 19.12, aka VS 2017 version 15.3.
+#if defined(_LIBCUDACXX_MSVCRT) && defined(_LIBCUDACXX_COMPILER_MSVC) && _MSC_VER < 1912
+#  define _LIBCUDACXX_HAS_NO_LIBRARY_ALIGNED_ALLOCATION
+#elif defined(_LIBCUDACXX_ABI_VCRUNTIME) && !defined(__cpp_aligned_new)
+   // We're deferring to Microsoft's STL to provide aligned new et al. We don't
+   // have it unless the language feature test macro is defined.
+#  define _LIBCUDACXX_HAS_NO_LIBRARY_ALIGNED_ALLOCATION
+#endif
+
+#if defined(__APPLE__)
+#  if !defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && \
+      defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
+#    define __MAC_OS_X_VERSION_MIN_REQUIRED __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__
+#  endif
+#endif // defined(__APPLE__)
+
+#if !defined(_LIBCUDACXX_HAS_NO_ALIGNED_ALLOCATION) && \
+    (defined(_LIBCUDACXX_HAS_NO_LIBRARY_ALIGNED_ALLOCATION) || \
+    (!defined(__cpp_aligned_new) || __cpp_aligned_new < 201606))
+#  define _LIBCUDACXX_HAS_NO_ALIGNED_ALLOCATION
+#endif
+
+#if defined(__APPLE__) || defined(__FreeBSD__)
+#define _LIBCUDACXX_HAS_DEFAULTRUNELOCALE
+#endif
+
+#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__sun__)
+#define _LIBCUDACXX_WCTYPE_IS_MASK
+#endif
+
+#if _LIBCUDACXX_STD_VER <= 17 || !defined(__cpp_char8_t)
+#define _LIBCUDACXX_NO_HAS_CHAR8_T
+#endif
+
+// Deprecation macros.
+//
+// Deprecations warnings are always enabled, except when users explicitly opt-out
+// by defining _LIBCUDACXX_DISABLE_DEPRECATION_WARNINGS.
+// NVCC 11.1 and 11.2 are broken with the deprecated attribute, so disable it
+#if !defined(_LIBCUDACXX_DISABLE_DEPRECATION_WARNINGS) \
+ && !defined(_LIBCUDACXX_CUDACC_BELOW_11_3)
+#  if __has_attribute(deprecated)
+#    define _LIBCUDACXX_DEPRECATED __attribute__ ((deprecated))
+#  elif _LIBCUDACXX_STD_VER > 11
+#    define _LIBCUDACXX_DEPRECATED [[deprecated]]
+#  else
+#    define _LIBCUDACXX_DEPRECATED
+#  endif
+#else
+#  define _LIBCUDACXX_DEPRECATED
+#endif
+
+#define _LIBCUDACXX_DEPRECATED_IN_CXX11 _LIBCUDACXX_DEPRECATED
+
+#if _LIBCUDACXX_STD_VER >= 14
+#  define _LIBCUDACXX_DEPRECATED_IN_CXX14 _LIBCUDACXX_DEPRECATED
+#else
+#  define _LIBCUDACXX_DEPRECATED_IN_CXX14
+#endif
+
+#if _LIBCUDACXX_STD_VER >= 17
+#  define _LIBCUDACXX_DEPRECATED_IN_CXX17 _LIBCUDACXX_DEPRECATED
+#else
+#  define _LIBCUDACXX_DEPRECATED_IN_CXX17
+#endif
+
+#if _LIBCUDACXX_STD_VER <= 11
+#  define _LIBCUDACXX_EXPLICIT_AFTER_CXX11
+#else
+#  define _LIBCUDACXX_EXPLICIT_AFTER_CXX11 explicit
+#endif
+
+#if _LIBCUDACXX_STD_VER > 11 && !defined(_LIBCUDACXX_HAS_NO_CXX14_CONSTEXPR)
+#  define _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 constexpr
+#else
+#  define _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+#endif
+
+#if _LIBCUDACXX_STD_VER > 14 && !defined(_LIBCUDACXX_HAS_NO_CXX14_CONSTEXPR)
+#  define _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 constexpr
+#else
+#  define _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+#endif
+
+#if _LIBCUDACXX_STD_VER > 17 && !defined(_LIBCUDACXX_HAS_NO_CXX14_CONSTEXPR)
+#  define _LIBCUDACXX_CONSTEXPR_AFTER_CXX17 constexpr
+#else
+#  define _LIBCUDACXX_CONSTEXPR_AFTER_CXX17
+#endif
+
+// Macros to enter and leave a state where deprecation warnings are suppressed.
+#if defined(_LIBCUDACXX_COMPILER_CLANG) || defined(_LIBCUDACXX_COMPILER_GCC)
+#   define _LIBCUDACXX_SUPPRESS_DEPRECATED_PUSH \
+        _Pragma("GCC diagnostic push") \
+        _Pragma("GCC diagnostic ignored \"-Wdeprecated\"") \
+        _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
+#   define _LIBCUDACXX_SUPPRESS_DEPRECATED_POP \
+        _Pragma("GCC diagnostic pop")
+#else
+#   define _LIBCUDACXX_SUPPRESS_DEPRECATED_PUSH
+#   define _LIBCUDACXX_SUPPRESS_DEPRECATED_POP
+#endif
+
+// The _LIBCUDACXX_NODISCARD_ATTRIBUTE should only be used to define other
+// NODISCARD macros to the correct attribute.
+#if __has_cpp_attribute(nodiscard) || (defined(_LIBCUDACXX_COMPILER_MSVC) && _LIBCUDACXX_STD_VER > 14)
+#  define _LIBCUDACXX_NODISCARD_ATTRIBUTE [[nodiscard]]
+#elif defined(_LIBCUDACXX_COMPILER_CLANG)
+#  define _LIBCUDACXX_NODISCARD_ATTRIBUTE [[clang::warn_unused_result]]
+#else
+// We can't use GCC's [[gnu::warn_unused_result]] and
+// __attribute__((warn_unused_result)), because GCC does not silence them via
+// (void) cast.
+#  define _LIBCUDACXX_NODISCARD_ATTRIBUTE
+#endif
+
+// NVCC below 11.3 does not support nodiscard on friend functions
+// It always fails with clang
+#if defined(_LIBCUDACXX_CUDACC_BELOW_11_3) \
+ || defined(_LIBCUDACXX_COMPILER_CLANG)
+#  define _LIBCUDACXX_NODISCARD_FRIEND friend
+#else // ^^^ _LIBCUDACXX_CUDACC_BELOW_11_3 ^^^ / vvv !_LIBCUDACXX_CUDACC_BELOW_11_3 vvv
+#  define _LIBCUDACXX_NODISCARD_FRIEND _LIBCUDACXX_NODISCARD_ATTRIBUTE friend
+#endif // !_LIBCUDACXX_CUDACC_BELOW_11_3 && !_LIBCUDACXX_COMPILER_CLANG
+
+// _LIBCUDACXX_NODISCARD_EXT may be used to apply [[nodiscard]] to entities not
+// specified as such as an extension.
+#if defined(_LIBCUDACXX_ENABLE_NODISCARD) && !defined(_LIBCUDACXX_DISABLE_NODISCARD_EXT)
+#  define _LIBCUDACXX_NODISCARD_EXT _LIBCUDACXX_NODISCARD_ATTRIBUTE
+#else
+#  define _LIBCUDACXX_NODISCARD_EXT
+#endif
+
+#if !defined(_LIBCUDACXX_DISABLE_NODISCARD_AFTER_CXX17) && \
+    (_LIBCUDACXX_STD_VER > 17 || defined(_LIBCUDACXX_ENABLE_NODISCARD))
+#  define _LIBCUDACXX_NODISCARD_AFTER_CXX17 _LIBCUDACXX_NODISCARD_ATTRIBUTE
+#else
+#  define _LIBCUDACXX_NODISCARD_AFTER_CXX17
+#endif
+
+#if _LIBCUDACXX_STD_VER > 14 && defined(__cpp_inline_variables) && (__cpp_inline_variables >= 201606L)
+#  define _LIBCUDACXX_INLINE_VAR inline
+#else
+#  define _LIBCUDACXX_INLINE_VAR
+#endif
+
+#ifdef _LIBCUDACXX_HAS_NO_RVALUE_REFERENCES
+#  define _LIBCUDACXX_EXPLICIT_MOVE(x) _CUDA_VSTD::move(x)
+#else
+#  define _LIBCUDACXX_EXPLICIT_MOVE(x) (x)
+#endif
+
+#ifndef _LIBCUDACXX_CONSTEXPR_IF_NODEBUG
+#if defined(_LIBCUDACXX_DEBUG) || defined(_LIBCUDACXX_HAS_NO_CXX14_CONSTEXPR)
+#define _LIBCUDACXX_CONSTEXPR_IF_NODEBUG
+#else
+#define _LIBCUDACXX_CONSTEXPR_IF_NODEBUG _LIBCUDACXX_CONSTEXPR_AFTER_CXX11
+#endif
+#endif
+
+#if __has_attribute(no_destroy)
+#  define _LIBCUDACXX_NO_DESTROY __attribute__((__no_destroy__))
+#else
+#  define _LIBCUDACXX_NO_DESTROY
+#endif
+
+#ifndef _LIBCUDACXX_HAS_NO_ASAN
+extern "C" _LIBCUDACXX_FUNC_VIS void __sanitizer_annotate_contiguous_container(
+  const void *, const void *, const void *, const void *);
+#endif
+
+#ifndef _LIBCUDACXX_WEAK
+#define _LIBCUDACXX_WEAK __attribute__((__weak__))
+#endif
+
+// Redefine some macros for internal use
+#if defined(__cuda_std__)
+#  undef _LIBCUDACXX_FUNC_VIS
+#  define _LIBCUDACXX_FUNC_VIS _LIBCUDACXX_INLINE_VISIBILITY
+#  undef _LIBCUDACXX_TYPE_VIS
+#  define _LIBCUDACXX_TYPE_VIS
+#endif // __cuda_std__
+
+// Thread API
+#ifndef _LIBCUDACXX_HAS_THREAD_API_EXTERNAL
+#if defined(_LIBCUDACXX_COMPILER_NVRTC) \
+ || defined(__EMSCRIPTEN__)
+#  define _LIBCUDACXX_HAS_THREAD_API_EXTERNAL
+#endif
+#endif // _LIBCUDACXX_HAS_THREAD_API_EXTERNAL
+
+#ifndef _LIBCUDACXX_HAS_THREAD_API_CUDA
+#if defined(__cuda_std__)                               \
+ && (defined(__CUDA_ARCH__) || defined(__EMSCRIPTEN__))
+#  define _LIBCUDACXX_HAS_THREAD_API_CUDA
+#endif // __cuda_std__
+#endif // _LIBCUDACXX_HAS_THREAD_API_CUDA
+
+#ifndef _LIBCUDACXX_HAS_THREAD_API_WIN32
+#if defined(_LIBCUDACXX_COMPILER_MSVC)        \
+ && !defined(_LIBCUDACXX_HAS_THREAD_API_CUDA)
+#  define _LIBCUDACXX_HAS_THREAD_API_WIN32
+#endif
+#endif // _LIBCUDACXX_HAS_THREAD_API_WIN32
+
+#if !defined(_LIBCUDACXX_HAS_NO_THREADS)          \
+ && !defined(_LIBCUDACXX_HAS_THREAD_API_PTHREAD)  \
+ && !defined(_LIBCUDACXX_HAS_THREAD_API_WIN32)    \
+ && !defined(_LIBCUDACXX_HAS_THREAD_API_EXTERNAL)
+#  if defined(__FreeBSD__) || \
+      defined(__Fuchsia__) || \
+      defined(__wasi__) || \
+      defined(__NetBSD__) || \
+      defined(__linux__) || \
+      defined(__GNU__) || \
+      defined(__APPLE__) || \
+      defined(__CloudABI__) || \
+      defined(__sun__) || \
+      (defined(__MINGW32__) && __has_include(<pthread.h>))
+#    define _LIBCUDACXX_HAS_THREAD_API_PTHREAD
+#  elif defined(_LIBCUDACXX_WIN32API)
+#    define _LIBCUDACXX_HAS_THREAD_API_WIN32
+#  else
+#    define _LIBCUDACXX_UNSUPPORTED_THREAD_API
+#  endif // _LIBCUDACXX_HAS_THREAD_API
+#endif // _LIBCUDACXX_HAS_NO_THREADS
+
+#if defined(_LIBCUDACXX_HAS_THREAD_API_PTHREAD)
+#if defined(__ANDROID__) && __ANDROID_API__ >= 30
+#define _LIBCUDACXX_HAS_COND_CLOCKWAIT
+#elif defined(_LIBCUDACXX_GLIBC_PREREQ)
+#if _LIBCUDACXX_GLIBC_PREREQ(2, 30)
+#define _LIBCUDACXX_HAS_COND_CLOCKWAIT
+#endif
+#endif
+#endif
+
+#if defined(_LIBCUDACXX_HAS_NO_THREADS) && defined(_LIBCUDACXX_HAS_THREAD_API_PTHREAD)
+#error _LIBCUDACXX_HAS_THREAD_API_PTHREAD may only be defined when \
+       _LIBCUDACXX_HAS_NO_THREADS is not defined.
+#endif
+
+#if defined(_LIBCUDACXX_HAS_NO_THREADS) && defined(_LIBCUDACXX_HAS_THREAD_API_EXTERNAL)
+#error _LIBCUDACXX_HAS_THREAD_API_EXTERNAL may not be defined when \
+       _LIBCUDACXX_HAS_NO_THREADS is defined.
+#endif
+
+#if defined(__STDCPP_THREADS__) && defined(_LIBCUDACXX_HAS_NO_THREADS)
+#error _LIBCUDACXX_HAS_NO_THREADS cannot be set when __STDCPP_THREADS__ is set.
+#endif
+
+#if !defined(_LIBCUDACXX_HAS_NO_THREADS) && !defined(__STDCPP_THREADS__)
+#define __STDCPP_THREADS__ 1
+#endif
+
+// The glibc and Bionic implementation of pthreads implements
+// pthread_mutex_destroy as nop for regular mutexes. Additionally, Win32
+// mutexes have no destroy mechanism.
+//
+// This optimization can't be performed on Apple platforms, where
+// pthread_mutex_destroy can allow the kernel to release resources.
+// See https://llvm.org/D64298 for details.
+//
+// TODO(EricWF): Enable this optimization on Bionic after speaking to their
+//               respective stakeholders.
+#if (defined(_LIBCUDACXX_HAS_THREAD_API_PTHREAD) && defined(__GLIBC__)) \
+  || defined(_LIBCUDACXX_HAS_THREAD_API_WIN32)
+# define _LIBCUDACXX_HAS_TRIVIAL_MUTEX_DESTRUCTION
+#endif
+
+// Destroying a condvar is a nop on Windows.
+//
+// This optimization can't be performed on Apple platforms, where
+// pthread_cond_destroy can allow the kernel to release resources.
+// See https://llvm.org/D64298 for details.
+//
+// TODO(EricWF): This is potentially true for some pthread implementations
+// as well.
+#if defined(_LIBCUDACXX_HAS_THREAD_API_WIN32)
+# define _LIBCUDACXX_HAS_TRIVIAL_CONDVAR_DESTRUCTION
+#endif
+
+// Systems that use capability-based security (FreeBSD with Capsicum,
+// Nuxi CloudABI) may only provide local filesystem access (using *at()).
+// Functions like open(), rename(), unlink() and stat() should not be
+// used, as they attempt to access the global filesystem namespace.
+#ifdef __CloudABI__
+#define _LIBCUDACXX_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
+#endif
+
+// CloudABI is intended for running networked services. Processes do not
+// have standard input and output channels.
+#ifdef __CloudABI__
+#define _LIBCUDACXX_HAS_NO_STDIN
+#define _LIBCUDACXX_HAS_NO_STDOUT
+#endif
+
+// Some systems do not provide gets() in their C library, for security reasons.
+#ifndef _LIBCUDACXX_C_HAS_NO_GETS
+#  if defined(_LIBCUDACXX_MSVCRT) || (defined(__FreeBSD__) && __FreeBSD__ >= 13)
+#    define _LIBCUDACXX_C_HAS_NO_GETS
+#  endif
+#endif
+
+#if defined(__BIONIC__) || defined(__CloudABI__) ||                            \
+    defined(__Fuchsia__) || defined(__wasi__) || defined(_LIBCUDACXX_HAS_MUSL_LIBC)
+#define _LIBCUDACXX_PROVIDES_DEFAULT_RUNE_TABLE
+#endif
+
+// Thread-unsafe functions such as strtok() and localtime()
+// are not available.
+#ifdef __CloudABI__
+#define _LIBCUDACXX_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
+#endif
+
+// TODO: Support C11 Atomics?
+// #if __has_feature(cxx_atomic) || __has_extension(c_atomic) || __has_keyword(_Atomic)
+// #  define _LIBCUDACXX_HAS_C_ATOMIC_IMP
+#if defined(_LIBCUDACXX_COMPILER_ICC)
+#  define _LIBCUDACXX_HAS_GCC_ATOMIC_IMP
+#elif defined(_LIBCUDACXX_COMPILER_CLANG)
+#  define _LIBCUDACXX_HAS_GCC_ATOMIC_IMP
+#elif defined(_LIBCUDACXX_COMPILER_GCC)
+#  define _LIBCUDACXX_HAS_GCC_ATOMIC_IMP
+#elif defined(_LIBCUDACXX_COMPILER_NVHPC)
+#  define _LIBCUDACXX_HAS_GCC_ATOMIC_IMP
+#elif defined(_LIBCUDACXX_COMPILER_MSVC)
+#  define _LIBCUDACXX_HAS_MSVC_ATOMIC_IMPL
+#endif
+
+// CUDA Atomics supersede host atomics in order to insert the host/device dispatch layer
+#if defined(_LIBCUDACXX_COMPILER_NVCC) || defined(_LIBCUDACXX_COMPILER_NVRTC) || defined(_LIBCUDACXX_COMPILER_NVHPC) || defined(_LIBCUDACXX_CUDACC)
+#  define _LIBCUDACXX_HAS_CUDA_ATOMIC_IMPL
+#endif
+
+#if (!defined(_LIBCUDACXX_HAS_C_ATOMIC_IMP) && \
+     !defined(_LIBCUDACXX_HAS_GCC_ATOMIC_IMP) && \
+     !defined(_LIBCUDACXX_HAS_EXTERNAL_ATOMIC_IMP)) \
+     || defined(_LIBCUDACXX_HAS_NO_THREADS)
+#  define _LIBCUDACXX_HAS_NO_ATOMIC_HEADER
+#else
+#  ifdef __cuda_std__
+#    undef _LIBCUDACXX_ATOMIC_FLAG_TYPE
+#    define _LIBCUDACXX_ATOMIC_FLAG_TYPE int
+#  endif
+#  ifndef _LIBCUDACXX_ATOMIC_FLAG_TYPE
+#    define _LIBCUDACXX_ATOMIC_FLAG_TYPE bool
+#  endif
+#  ifdef _LIBCUDACXX_FREESTANDING
+#    define _LIBCUDACXX_ATOMIC_ONLY_USE_BUILTINS
+#  endif
+#endif
+
+#ifndef _LIBCUDACXX_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
+#define _LIBCUDACXX_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
+#endif
+
+#if defined(_LIBCUDACXX_ENABLE_THREAD_SAFETY_ANNOTATIONS)
+#  if defined(_LIBCUDACXX_COMPILER_CLANG) && __has_attribute(acquire_capability)
+// Work around the attribute handling in clang.  When both __declspec and
+// __attribute__ are present, the processing goes awry preventing the definition
+// of the types.
+#    if !defined(_LIBCUDACXX_OBJECT_FORMAT_COFF)
+#      define _LIBCUDACXX_HAS_THREAD_SAFETY_ANNOTATIONS
+#    endif
+#  endif
+#endif
+
+#if __has_attribute(require_constant_initialization)
+#  define _LIBCUDACXX_SAFE_STATIC __attribute__((__require_constant_initialization__))
+#else
+#  define _LIBCUDACXX_SAFE_STATIC
+#endif
+
+#if !defined(_LIBCUDACXX_HAS_NO_OFF_T_FUNCTIONS)
+#  if defined(_LIBCUDACXX_MSVCRT) || defined(_NEWLIB_VERSION)
+#    define _LIBCUDACXX_HAS_NO_OFF_T_FUNCTIONS
+#  endif
+#endif
+
+#if __has_attribute(diagnose_if) && !defined(_LIBCUDACXX_DISABLE_ADDITIONAL_DIAGNOSTICS)
+#  define _LIBCUDACXX_DIAGNOSE_WARNING(...) \
+     __attribute__((diagnose_if(__VA_ARGS__, "warning")))
+#  define _LIBCUDACXX_DIAGNOSE_ERROR(...) \
+     __attribute__((diagnose_if(__VA_ARGS__, "error")))
+#else
+#  define _LIBCUDACXX_DIAGNOSE_WARNING(...)
+#  define _LIBCUDACXX_DIAGNOSE_ERROR(...)
+#endif
+
+// Use a function like macro to imply that it must be followed by a semicolon
+#if __cplusplus > 201402L && __has_cpp_attribute(fallthrough)
+#  define _LIBCUDACXX_FALLTHROUGH() [[fallthrough]]
+#elif defined(_LIBCUDACXX_COMPILER_NVRTC)
+#  define _LIBCUDACXX_FALLTHROUGH() ((void)0)
+#elif __has_cpp_attribute(clang::fallthrough)
+#  define _LIBCUDACXX_FALLTHROUGH() [[clang::fallthrough]]
+#elif defined(_LIBCUDACXX_COMPILER_NVHPC)
+#  define _LIBCUDACXX_FALLTHROUGH()
+#elif __has_attribute(fallthough) || _GNUC_VER >= 700
+#  define _LIBCUDACXX_FALLTHROUGH() __attribute__((__fallthrough__))
+#else
+#  define _LIBCUDACXX_FALLTHROUGH() ((void)0)
+#endif
+
+#if __has_attribute(__nodebug__)
+#define _LIBCUDACXX_NODEBUG __attribute__((__nodebug__))
+#else
+#define _LIBCUDACXX_NODEBUG
+#endif
+
+#  if __has_attribute(__preferred_name__)
+#    define _LIBCUDACXX_PREFERRED_NAME(x) __attribute__((__preferred_name__(x)))
+#  else
+#    define _LIBCUDACXX_PREFERRED_NAME(x)
+#  endif
+
+#if defined(_LIBCUDACXX_ABI_MICROSOFT) && \
+    (defined(_LIBCUDACXX_COMPILER_MSVC) || __has_declspec_attribute(empty_bases))
+#  define _LIBCUDACXX_DECLSPEC_EMPTY_BASES __declspec(empty_bases)
+#else
+#  define _LIBCUDACXX_DECLSPEC_EMPTY_BASES
+#endif
+
+#if defined(_LIBCUDACXX_ENABLE_CXX17_REMOVED_FEATURES)
+#define _LIBCUDACXX_ENABLE_CXX17_REMOVED_AUTO_PTR
+#define _LIBCUDACXX_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS
+#define _LIBCUDACXX_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE
+#define _LIBCUDACXX_ENABLE_CXX17_REMOVED_BINDERS
+#endif // _LIBCUDACXX_ENABLE_CXX17_REMOVED_FEATURES
+
+#if !defined(__cpp_deduction_guides) || __cpp_deduction_guides < 201611
+#define _LIBCUDACXX_HAS_NO_DEDUCTION_GUIDES
+#endif
+
+#if !defined(__cpp_coroutines) || __cpp_coroutines < 201703L
+#define _LIBCUDACXX_HAS_NO_COROUTINES
+#endif
+
+// We need `is_constant_evaluated` for clang and gcc. MSVC also needs extensive rework
+#if !defined(_LIBCUDACXX_IS_CONSTANT_EVALUATED)
+#define _LIBCUDACXX_HAS_NO_CONSTEXPR_COMPLEX_OPERATIONS
+#elif defined(__CUDACC_RTC__)
+#define _LIBCUDACXX_HAS_NO_CONSTEXPR_COMPLEX_OPERATIONS
+#elif defined(_MSC_VER)
+#define _LIBCUDACXX_HAS_NO_CONSTEXPR_COMPLEX_OPERATIONS
+#elif defined(_LIBCUDACXX_CUDACC_BELOW_11_8)
+#define _LIBCUDACXX_HAS_NO_CONSTEXPR_COMPLEX_OPERATIONS
+#endif
+
+// FIXME: Correct this macro when either (A) a feature test macro for the
+// spaceship operator is provided, or (B) a compiler provides a complete
+// implementation.
+#define _LIBCUDACXX_HAS_NO_SPACESHIP_OPERATOR
+
+#define _LIBCUDACXX_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS
+
+// The stream API was dropped and re-added in the dylib shipped on macOS
+// and iOS. We can only assume the dylib to provide these definitions for
+// macosx >= 10.9 and ios >= 7.0. Otherwise, the definitions are available
+// from the headers, but not from the dylib. Explicit instantiation
+// declarations for streams exist conditionally to this; if we provide
+// an explicit instantiation declaration and we try to deploy to a dylib
+// that does not provide those symbols, we'll get a load-time error.
+#if !defined(_LIBCUDACXX_BUILDING_LIBRARY) &&                                      \
+    ((defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) &&                \
+      __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 1090) ||                 \
+     (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) &&               \
+      __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 70000))
+#  define _LIBCUDACXX_DO_NOT_ASSUME_STREAMS_EXPLICIT_INSTANTIATION_IN_DYLIB
+#endif
+
+#if defined(_LIBCUDACXX_HAS_NO_PRAGMA_PUSH_POP_MACRO)
+#  define _LIBCUDACXX_PUSH_MACROS
+#  define _LIBCUDACXX_POP_MACROS
+#else
+  // Don't warn about macro conflicts when we can restore them at the
+  // end of the header.
+#  ifndef _LIBCUDACXX_DISABLE_MACRO_CONFLICT_WARNINGS
+#    define _LIBCUDACXX_DISABLE_MACRO_CONFLICT_WARNINGS
+#  endif
+#  if defined(_LIBCUDACXX_COMPILER_MSVC)
+#    define _LIBCUDACXX_PUSH_MACROS    \
+       __pragma(push_macro("min")) \
+       __pragma(push_macro("max"))
+#    define _LIBCUDACXX_POP_MACROS     \
+       __pragma(pop_macro("min"))  \
+       __pragma(pop_macro("max"))
+#  else
+#    define _LIBCUDACXX_PUSH_MACROS        \
+       _Pragma("push_macro(\"min\")")  \
+       _Pragma("push_macro(\"max\")")
+#    define _LIBCUDACXX_POP_MACROS         \
+       _Pragma("pop_macro(\"min\")")   \
+       _Pragma("pop_macro(\"max\")")
+#  endif
+#endif // defined(_LIBCUDACXX_HAS_NO_PRAGMA_PUSH_POP_MACRO)
+
+#if !defined(_LIBCUDACXX_NO_AUTO_LINK) && !defined(__cuda_std__)
+#  if defined(_LIBCUDACXX_ABI_MICROSOFT) && !defined(_LIBCUDACXX_BUILDING_LIBRARY)
+#    if defined(_DLL)
+#      pragma comment(lib, "c++.lib")
+#    else
+#      pragma comment(lib, "libc++.lib")
+#    endif
+#  endif // defined(_LIBCUDACXX_ABI_MICROSOFT) && !defined(_LIBCUDACXX_BUILDING_LIBRARY)
+#endif // !defined(_LIBCUDACXX_NO_AUTO_LINK)
+
+#define _LIBCUDACXX_UNUSED_VAR(x) ((void)(x))
+
+// Configures the fopen close-on-exec mode character, if any. This string will
+// be appended to any mode string used by fstream for fopen/fdopen.
+//
+// Not all platforms support this, but it helps avoid fd-leaks on platforms that
+// do.
+#if defined(__BIONIC__)
+#  define _LIBCUDACXX_FOPEN_CLOEXEC_MODE "e"
+#else
+#  define _LIBCUDACXX_FOPEN_CLOEXEC_MODE
+#endif
+
+#  if __has_attribute(__format__)
+// The attribute uses 1-based indices for ordinary and static member functions.
+// The attribute uses 2-based indices for non-static member functions.
+#    define _LIBCUDACXX_ATTRIBUTE_FORMAT(archetype, format_string_index, first_format_arg_index)                           \
+      __attribute__((__format__(archetype, format_string_index, first_format_arg_index)))
+#  else
+#    define _LIBCUDACXX_ATTRIBUTE_FORMAT(archetype, format_string_index, first_format_arg_index) /* nothing */
+#  endif
+
+#ifndef _LIBCUDACXX_SYS_CLOCK_DURATION
+#if defined(__cuda_std__)
+#  define _LIBCUDACXX_SYS_CLOCK_DURATION nanoseconds
+#else
+#  define _LIBCUDACXX_SYS_CLOCK_DURATION microseconds
+#endif
+#endif // _LIBCUDACXX_SYS_CLOCK_DURATION
+
+// There are a handful of public standard library types that are intended to
+// support CTAD but don't need any explicit deduction guides to do so. This
+// macro is used to mark them as such, which suppresses the
+// '-Wctad-maybe-unsupported' compiler warning when CTAD is used in user code
+// with these classes.
+#if (!defined(_LIBCUDACXX_COMPILER_GCC) || __GNUC__ > 6) \
+ && _LIBCUDACXX_STD_VER >= 17
+#  define _LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(_ClassName)                                                                \
+      template <class ..._Tag>                                                                                         \
+      _ClassName(typename _Tag::__allow_ctad...) -> _ClassName<_Tag...>
+#else
+#  define _LIBCUDACXX_CTAD_SUPPORTED_FOR_TYPE(_ClassName) static_assert(true, "")
+#endif
+
+#if (defined(__CUDACC_VER_MAJOR__) && __CUDACC_VER_MAJOR__ <= 11) \
+ && (defined(__CUDACC_VER_MINOR__) && __CUDACC_VER_MINOR__ <= 2)
+#  define _LIBCUDACXX_CONSTEXPR_GLOBAL const
+#else
+#  define _LIBCUDACXX_CONSTEXPR_GLOBAL constexpr
+#endif
+
+#if defined(__CUDA_ARCH__)
+#  define _LIBCUDACXX_CPO_ACCESSIBILITY _LIBCUDACXX_DEVICE _LIBCUDACXX_CONSTEXPR_GLOBAL
+#else
+#  define _LIBCUDACXX_CPO_ACCESSIBILITY _LIBCUDACXX_INLINE_VAR constexpr
+#endif
+
+#if _LIBCUDACXX_STD_VER > 14
+#  define _LIBCUDACXX_TRAIT(__TRAIT, ...) __TRAIT##_v<__VA_ARGS__>
+#else
+#  define _LIBCUDACXX_TRAIT(__TRAIT, ...) __TRAIT<__VA_ARGS__>::value
+#endif
+
+// Older nvcc do not handle the constraint of `construct_at` in earlier std modes
+// So to preserve our performance optimization we default to the unconstrained
+// `__construct_at` and only in C++20 use `construct_at`
+#if _LIBCUDACXX_STD_VER > 17
+#  define _LIBCUDACXX_CONSTRUCT_AT(_LOCATION, ...) \
+  _CUDA_VSTD::construct_at(_CUDA_VSTD::addressof(_LOCATION), __VA_ARGS__)
+#else
+#  define _LIBCUDACXX_CONSTRUCT_AT(_LOCATION, ...) \
+  _CUDA_VSTD::__construct_at(_CUDA_VSTD::addressof(_LOCATION), __VA_ARGS__)
+#endif
+
+#if !defined(_LIBCUDACXX_DISABLE_EXEC_CHECK)
+#if defined(_LIBCUDACXX_CUDACC)               \
+ && !defined(_LIBCUDACXX_COMPILER_NVRTC)      \
+ && !defined(_LIBCUDACXX_COMPILER_NVHPC_CUDA) \
+ && !defined(_LIBCUDACXX_COMPILER_CLANG_CUDA)
+#  if defined(_LIBCUDACXX_COMPILER_MSVC)
+#    define _LIBCUDACXX_DISABLE_EXEC_CHECK __pragma("nv_exec_check_disable")
+#  else // ^^^ _LIBCUDACXX_COMPILER_MSVC ^^^ / vvv !_LIBCUDACXX_COMPILER_MSVC vvv
+#    define _LIBCUDACXX_DISABLE_EXEC_CHECK _Pragma("nv_exec_check_disable")
+#  endif // !_LIBCUDACXX_COMPILER_MSVC
+#else // ^^^ !NVRTC && !NVHPC-cuda && !clang-cuda ^^^ / vvv NVRTC || NVHPC-cuda || clang-cuda vvv
+#  define _LIBCUDACXX_DISABLE_EXEC_CHECK
+#endif // NVRTC || NVHPC-cuda || clang-cuda
+#endif // !_LIBCUDACXX_DISABLE_EXEC_CHECK
+
+#define _LIBCUDACXX_HAS_NO_INCOMPLETE_RANGES
+
+#endif // __cplusplus
+
+#endif // _LIBCUDACXX_CONFIG

cuda_toolkit/include/__config_site.in

@@ -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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX_CONFIG_SITE
+#define _LIBCUDACXX_CONFIG_SITE
+
+#cmakedefine _LIBCUDACXX_ABI_VERSION @_LIBCUDACXX_ABI_VERSION@
+#cmakedefine _LIBCUDACXX_ABI_UNSTABLE
+#cmakedefine _LIBCUDACXX_ABI_FORCE_ITANIUM
+#cmakedefine _LIBCUDACXX_ABI_FORCE_MICROSOFT
+#cmakedefine _LIBCUDACXX_HIDE_FROM_ABI_PER_TU_BY_DEFAULT
+#cmakedefine _LIBCUDACXX_HAS_NO_GLOBAL_FILESYSTEM_NAMESPACE
+#cmakedefine _LIBCUDACXX_HAS_NO_STDIN
+#cmakedefine _LIBCUDACXX_HAS_NO_STDOUT
+#cmakedefine _LIBCUDACXX_HAS_NO_THREADS
+#cmakedefine _LIBCUDACXX_HAS_NO_MONOTONIC_CLOCK
+#cmakedefine _LIBCUDACXX_HAS_NO_THREAD_UNSAFE_C_FUNCTIONS
+#cmakedefine _LIBCUDACXX_HAS_MUSL_LIBC
+#cmakedefine _LIBCUDACXX_HAS_THREAD_API_PTHREAD
+#cmakedefine _LIBCUDACXX_HAS_THREAD_API_EXTERNAL
+#cmakedefine _LIBCUDACXX_HAS_THREAD_API_WIN32
+#cmakedefine _LIBCUDACXX_HAS_THREAD_LIBRARY_EXTERNAL
+#cmakedefine _LIBCUDACXX_DISABLE_VISIBILITY_ANNOTATIONS
+#cmakedefine _LIBCUDACXX_NO_VCRUNTIME
+#cmakedefine01 _LIBCUDACXX_HAS_MERGED_TYPEINFO_NAMES_DEFAULT
+#cmakedefine _LIBCUDACXX_ABI_NAMESPACE @_LIBCUDACXX_ABI_NAMESPACE@
+#cmakedefine _LIBCUDACXX_HAS_PARALLEL_ALGORITHMS
+
+@_LIBCUDACXX_ABI_DEFINES@
+
+#endif // _LIBCUDACXX_CONFIG_SITE

cuda_toolkit/include/__debug

@@ -0,0 +1,279 @@
+// -*- 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___DEBUG
+#define _LIBCUDACXX___DEBUG
+
+#ifndef __cuda_std__
+#include <__config>
+#endif //__cuda_std__
+
+#include "__assert"
+#include "__type_traits/is_constant_evaluated.h"
+#include "cstddef"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#if defined(_LIBCUDACXX_ENABLE_DEBUG_MODE) && !defined(_LIBCUDACXX_DEBUG_RANDOMIZE_UNSPECIFIED_STABILITY)
+# define _LIBCUDACXX_DEBUG_RANDOMIZE_UNSPECIFIED_STABILITY
+#endif
+
+#if defined(_LIBCUDACXX_ENABLE_DEBUG_MODE) && !defined(_LIBCUDACXX_DEBUG_ITERATOR_BOUNDS_CHECKING)
+# define _LIBCUDACXX_DEBUG_ITERATOR_BOUNDS_CHECKING
+#endif
+
+#ifdef _LIBCUDACXX_ENABLE_DEBUG_MODE
+#   define _LIBCUDACXX_DEBUG_ASSERT(x, m) _LIBCUDACXX_ASSERT(::std::__libcpp_is_constant_evaluated() || (x), m)
+#else
+#   define _LIBCUDACXX_DEBUG_ASSERT(x, m) ((void)0)
+#endif
+
+#if defined(_LIBCUDACXX_ENABLE_DEBUG_MODE) || defined(_LIBCUDACXX_BUILDING_LIBRARY)
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+struct _LIBCUDACXX_TYPE_VIS __c_node;
+
+struct _LIBCUDACXX_TYPE_VIS __i_node
+{
+    void* __i_;
+    __i_node* __next_;
+    __c_node* __c_;
+
+    __i_node(const __i_node&) = delete;
+    __i_node& operator=(const __i_node&) = delete;
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __i_node(void* __i, __i_node* __next, __c_node* __c)
+        : __i_(__i), __next_(__next), __c_(__c) {}
+    ~__i_node();
+};
+
+struct _LIBCUDACXX_TYPE_VIS __c_node
+{
+    void* __c_;
+    __c_node* __next_;
+    __i_node** beg_;
+    __i_node** end_;
+    __i_node** cap_;
+
+    __c_node(const __c_node&) = delete;
+    __c_node& operator=(const __c_node&) = delete;
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit __c_node(void* __c, __c_node* __next)
+        : __c_(__c), __next_(__next), beg_(nullptr), end_(nullptr), cap_(nullptr) {}
+    virtual ~__c_node();
+
+    virtual bool __dereferenceable(const void*) const = 0;
+    virtual bool __decrementable(const void*) const = 0;
+    virtual bool __addable(const void*, ptrdiff_t) const = 0;
+    virtual bool __subscriptable(const void*, ptrdiff_t) const = 0;
+
+    void __add(__i_node* __i);
+    _LIBCUDACXX_HIDDEN void __remove(__i_node* __i);
+};
+
+template <class _Cont>
+struct _C_node
+    : public __c_node
+{
+    explicit _C_node(void* __c, __c_node* __n)
+        : __c_node(__c, __n) {}
+
+    bool __dereferenceable(const void*) const override;
+    bool __decrementable(const void*) const override;
+    bool __addable(const void*, ptrdiff_t) const override;
+    bool __subscriptable(const void*, ptrdiff_t) const override;
+};
+
+template <class _Cont>
+inline bool
+_C_node<_Cont>::__dereferenceable(const void* __i) const
+{
+    typedef typename _Cont::const_iterator iterator;
+    const iterator* __j = static_cast<const iterator*>(__i);
+    _Cont* _Cp = static_cast<_Cont*>(__c_);
+    return _Cp->__dereferenceable(__j);
+}
+
+template <class _Cont>
+inline bool
+_C_node<_Cont>::__decrementable(const void* __i) const
+{
+    typedef typename _Cont::const_iterator iterator;
+    const iterator* __j = static_cast<const iterator*>(__i);
+    _Cont* _Cp = static_cast<_Cont*>(__c_);
+    return _Cp->__decrementable(__j);
+}
+
+template <class _Cont>
+inline bool
+_C_node<_Cont>::__addable(const void* __i, ptrdiff_t __n) const
+{
+    typedef typename _Cont::const_iterator iterator;
+    const iterator* __j = static_cast<const iterator*>(__i);
+    _Cont* _Cp = static_cast<_Cont*>(__c_);
+    return _Cp->__addable(__j, __n);
+}
+
+template <class _Cont>
+inline bool
+_C_node<_Cont>::__subscriptable(const void* __i, ptrdiff_t __n) const
+{
+    typedef typename _Cont::const_iterator iterator;
+    const iterator* __j = static_cast<const iterator*>(__i);
+    _Cont* _Cp = static_cast<_Cont*>(__c_);
+    return _Cp->__subscriptable(__j, __n);
+}
+
+class _LIBCUDACXX_TYPE_VIS __libcpp_db
+{
+    __c_node** __cbeg_;
+    __c_node** __cend_;
+    size_t   __csz_;
+    __i_node** __ibeg_;
+    __i_node** __iend_;
+    size_t   __isz_;
+
+    explicit __libcpp_db();
+public:
+    __libcpp_db(const __libcpp_db&) = delete;
+    __libcpp_db& operator=(const __libcpp_db&) = delete;
+
+    ~__libcpp_db();
+
+    class __db_c_iterator;
+    class __db_c_const_iterator;
+    class __db_i_iterator;
+    class __db_i_const_iterator;
+
+    __db_c_const_iterator __c_end() const;
+    __db_i_const_iterator __i_end() const;
+
+    typedef __c_node*(_InsertConstruct)(void*, void*, __c_node*);
+
+    template <class _Cont>
+    _LIBCUDACXX_INLINE_VISIBILITY static __c_node* __create_C_node(void *__mem, void *__c, __c_node *__next) {
+        return ::new (__mem) _C_node<_Cont>(__c, __next);
+    }
+
+    template <class _Cont>
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void __insert_c(_Cont* __c)
+    {
+        __insert_c(static_cast<void*>(__c), &__create_C_node<_Cont>);
+    }
+
+    void __insert_i(void* __i);
+    void __insert_c(void* __c, _InsertConstruct* __fn);
+    void __erase_c(void* __c);
+
+    void __insert_ic(void* __i, const void* __c);
+    void __iterator_copy(void* __i, const void* __i0);
+    void __erase_i(void* __i);
+
+    void* __find_c_from_i(void* __i) const;
+    void __invalidate_all(void* __c);
+    __c_node* __find_c_and_lock(void* __c) const;
+    __c_node* __find_c(void* __c) const;
+    void unlock() const;
+
+    void swap(void* __c1, void* __c2);
+
+
+    bool __dereferenceable(const void* __i) const;
+    bool __decrementable(const void* __i) const;
+    bool __addable(const void* __i, ptrdiff_t __n) const;
+    bool __subscriptable(const void* __i, ptrdiff_t __n) const;
+    bool __less_than_comparable(const void* __i, const void* __j) const;
+private:
+    _LIBCUDACXX_HIDDEN
+    __i_node* __insert_iterator(void* __i);
+    _LIBCUDACXX_HIDDEN
+    __i_node* __find_iterator(const void* __i) const;
+
+    friend _LIBCUDACXX_FUNC_VIS __libcpp_db* __get_db();
+};
+
+_LIBCUDACXX_FUNC_VIS __libcpp_db* __get_db();
+_LIBCUDACXX_FUNC_VIS const __libcpp_db* __get_const_db();
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // defined(_LIBCUDACXX_ENABLE_DEBUG_MODE) || defined(_LIBCUDACXX_BUILDING_LIBRARY)
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+_LIBCUDACXX_CONSTEXPR_AFTER_CXX11 inline void __debug_db_insert_c(_Tp* __c) {
+#ifdef _LIBCUDACXX_ENABLE_DEBUG_MODE
+    if (!__libcpp_is_constant_evaluated())
+        __get_db()->__insert_c(__c);
+#else
+    (void)(__c);
+#endif
+}
+
+template <class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+_LIBCUDACXX_CONSTEXPR_AFTER_CXX11 inline void __debug_db_insert_i(_Tp* __i) {
+#ifdef _LIBCUDACXX_ENABLE_DEBUG_MODE
+    if (!__libcpp_is_constant_evaluated())
+        __get_db()->__insert_i(__i);
+#else
+    (void)(__i);
+#endif
+}
+
+template <class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+_LIBCUDACXX_CONSTEXPR_AFTER_CXX11 inline void __debug_db_erase_c(_Tp* __c) {
+#ifdef _LIBCUDACXX_ENABLE_DEBUG_MODE
+    if (!__libcpp_is_constant_evaluated())
+        __get_db()->__erase_c(__c);
+#else
+    (void)(__c);
+#endif
+}
+
+template <class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+_LIBCUDACXX_CONSTEXPR_AFTER_CXX11 inline void __debug_db_swap(_Tp* __lhs, _Tp* __rhs) {
+#ifdef _LIBCUDACXX_ENABLE_DEBUG_MODE
+    if (!__libcpp_is_constant_evaluated())
+        __get_db()->swap(__lhs, __rhs);
+#else
+    (void)(__lhs);
+    (void)(__rhs);
+#endif
+}
+
+template <class _Tp>
+_LIBCUDACXX_INLINE_VISIBILITY
+_LIBCUDACXX_CONSTEXPR_AFTER_CXX11 inline void __debug_db_invalidate_all(_Tp* __c) {
+#ifdef _LIBCUDACXX_ENABLE_DEBUG_MODE
+    if (!__libcpp_is_constant_evaluated())
+        __get_db()->__invalidate_all(__c);
+#else
+    (void)(__c);
+#endif
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___DEBUG

cuda_toolkit/include/__errc

@@ -0,0 +1,221 @@
+// -*- C++ -*-
+//===---------------------------- __errc ----------------------------------===//
+//
+// 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___ERRC
+#define _LIBCUDACXX___ERRC
+
+/*
+    system_error synopsis
+
+namespace std
+{
+
+enum class errc
+{
+    address_family_not_supported,       // EAFNOSUPPORT
+    address_in_use,                     // EADDRINUSE
+    address_not_available,              // EADDRNOTAVAIL
+    already_connected,                  // EISCONN
+    argument_list_too_long,             // E2BIG
+    argument_out_of_domain,             // EDOM
+    bad_address,                        // EFAULT
+    bad_file_descriptor,                // EBADF
+    bad_message,                        // EBADMSG
+    broken_pipe,                        // EPIPE
+    connection_aborted,                 // ECONNABORTED
+    connection_already_in_progress,     // EALREADY
+    connection_refused,                 // ECONNREFUSED
+    connection_reset,                   // ECONNRESET
+    cross_device_link,                  // EXDEV
+    destination_address_required,       // EDESTADDRREQ
+    device_or_resource_busy,            // EBUSY
+    directory_not_empty,                // ENOTEMPTY
+    executable_format_error,            // ENOEXEC
+    file_exists,                        // EEXIST
+    file_too_large,                     // EFBIG
+    filename_too_long,                  // ENAMETOOLONG
+    function_not_supported,             // ENOSYS
+    host_unreachable,                   // EHOSTUNREACH
+    identifier_removed,                 // EIDRM
+    illegal_byte_sequence,              // EILSEQ
+    inappropriate_io_control_operation, // ENOTTY
+    interrupted,                        // EINTR
+    invalid_argument,                   // EINVAL
+    invalid_seek,                       // ESPIPE
+    io_error,                           // EIO
+    is_a_directory,                     // EISDIR
+    message_size,                       // EMSGSIZE
+    network_down,                       // ENETDOWN
+    network_reset,                      // ENETRESET
+    network_unreachable,                // ENETUNREACH
+    no_buffer_space,                    // ENOBUFS
+    no_child_process,                   // ECHILD
+    no_link,                            // ENOLINK
+    no_lock_available,                  // ENOLCK
+    no_message_available,               // ENODATA
+    no_message,                         // ENOMSG
+    no_protocol_option,                 // ENOPROTOOPT
+    no_space_on_device,                 // ENOSPC
+    no_stream_resources,                // ENOSR
+    no_such_device_or_address,          // ENXIO
+    no_such_device,                     // ENODEV
+    no_such_file_or_directory,          // ENOENT
+    no_such_process,                    // ESRCH
+    not_a_directory,                    // ENOTDIR
+    not_a_socket,                       // ENOTSOCK
+    not_a_stream,                       // ENOSTR
+    not_connected,                      // ENOTCONN
+    not_enough_memory,                  // ENOMEM
+    not_supported,                      // ENOTSUP
+    operation_canceled,                 // ECANCELED
+    operation_in_progress,              // EINPROGRESS
+    operation_not_permitted,            // EPERM
+    operation_not_supported,            // EOPNOTSUPP
+    operation_would_block,              // EWOULDBLOCK
+    owner_dead,                         // EOWNERDEAD
+    permission_denied,                  // EACCES
+    protocol_error,                     // EPROTO
+    protocol_not_supported,             // EPROTONOSUPPORT
+    read_only_file_system,              // EROFS
+    resource_deadlock_would_occur,      // EDEADLK
+    resource_unavailable_try_again,     // EAGAIN
+    result_out_of_range,                // ERANGE
+    state_not_recoverable,              // ENOTRECOVERABLE
+    stream_timeout,                     // ETIME
+    text_file_busy,                     // ETXTBSY
+    timed_out,                          // ETIMEDOUT
+    too_many_files_open_in_system,      // ENFILE
+    too_many_files_open,                // EMFILE
+    too_many_links,                     // EMLINK
+    too_many_symbolic_link_levels,      // ELOOP
+    value_too_large,                    // EOVERFLOW
+    wrong_protocol_type                 // EPROTOTYPE
+};
+
+*/
+
+#include <__config>
+#include <cerrno>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// Some error codes are not present on all platforms, so we provide equivalents
+// for them:
+
+//enum class errc
+_LIBCUDACXX_DECLARE_STRONG_ENUM(errc)
+{
+    address_family_not_supported        = EAFNOSUPPORT,
+    address_in_use                      = EADDRINUSE,
+    address_not_available               = EADDRNOTAVAIL,
+    already_connected                   = EISCONN,
+    argument_list_too_long              = E2BIG,
+    argument_out_of_domain              = EDOM,
+    bad_address                         = EFAULT,
+    bad_file_descriptor                 = EBADF,
+    bad_message                         = EBADMSG,
+    broken_pipe                         = EPIPE,
+    connection_aborted                  = ECONNABORTED,
+    connection_already_in_progress      = EALREADY,
+    connection_refused                  = ECONNREFUSED,
+    connection_reset                    = ECONNRESET,
+    cross_device_link                   = EXDEV,
+    destination_address_required        = EDESTADDRREQ,
+    device_or_resource_busy             = EBUSY,
+    directory_not_empty                 = ENOTEMPTY,
+    executable_format_error             = ENOEXEC,
+    file_exists                         = EEXIST,
+    file_too_large                      = EFBIG,
+    filename_too_long                   = ENAMETOOLONG,
+    function_not_supported              = ENOSYS,
+    host_unreachable                    = EHOSTUNREACH,
+    identifier_removed                  = EIDRM,
+    illegal_byte_sequence               = EILSEQ,
+    inappropriate_io_control_operation  = ENOTTY,
+    interrupted                         = EINTR,
+    invalid_argument                    = EINVAL,
+    invalid_seek                        = ESPIPE,
+    io_error                            = EIO,
+    is_a_directory                      = EISDIR,
+    message_size                        = EMSGSIZE,
+    network_down                        = ENETDOWN,
+    network_reset                       = ENETRESET,
+    network_unreachable                 = ENETUNREACH,
+    no_buffer_space                     = ENOBUFS,
+    no_child_process                    = ECHILD,
+    no_link                             = ENOLINK,
+    no_lock_available                   = ENOLCK,
+#ifdef ENODATA
+    no_message_available                = ENODATA,
+#else
+    no_message_available                = ENOMSG,
+#endif
+    no_message                          = ENOMSG,
+    no_protocol_option                  = ENOPROTOOPT,
+    no_space_on_device                  = ENOSPC,
+#ifdef ENOSR
+    no_stream_resources                 = ENOSR,
+#else
+    no_stream_resources                 = ENOMEM,
+#endif
+    no_such_device_or_address           = ENXIO,
+    no_such_device                      = ENODEV,
+    no_such_file_or_directory           = ENOENT,
+    no_such_process                     = ESRCH,
+    not_a_directory                     = ENOTDIR,
+    not_a_socket                        = ENOTSOCK,
+#ifdef ENOSTR
+    not_a_stream                        = ENOSTR,
+#else
+    not_a_stream                        = EINVAL,
+#endif
+    not_connected                       = ENOTCONN,
+    not_enough_memory                   = ENOMEM,
+    not_supported                       = ENOTSUP,
+    operation_canceled                  = ECANCELED,
+    operation_in_progress               = EINPROGRESS,
+    operation_not_permitted             = EPERM,
+    operation_not_supported             = EOPNOTSUPP,
+    operation_would_block               = EWOULDBLOCK,
+    owner_dead                          = EOWNERDEAD,
+    permission_denied                   = EACCES,
+    protocol_error                      = EPROTO,
+    protocol_not_supported              = EPROTONOSUPPORT,
+    read_only_file_system               = EROFS,
+    resource_deadlock_would_occur       = EDEADLK,
+    resource_unavailable_try_again      = EAGAIN,
+    result_out_of_range                 = ERANGE,
+    state_not_recoverable               = ENOTRECOVERABLE,
+#ifdef ETIME
+    stream_timeout                      = ETIME,
+#else
+    stream_timeout                      = ETIMEDOUT,
+#endif
+    text_file_busy                      = ETXTBSY,
+    timed_out                           = ETIMEDOUT,
+    too_many_files_open_in_system       = ENFILE,
+    too_many_files_open                 = EMFILE,
+    too_many_links                      = EMLINK,
+    too_many_symbolic_link_levels       = ELOOP,
+    value_too_large                     = EOVERFLOW,
+    wrong_protocol_type                 = EPROTOTYPE
+};
+_LIBCUDACXX_DECLARE_STRONG_ENUM_EPILOG(errc)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif  // _LIBCUDACXX___ERRC

cuda_toolkit/include/__functional_base

@@ -0,0 +1,138 @@
+// -*- 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_BASE
+#define _LIBCUDACXX_FUNCTIONAL_BASE
+
+#ifndef __cuda_std__
+#include <__config>
+#include <typeinfo>
+#include <exception>
+#include <new>
+#endif // __cuda_std__
+
+#include "__functional/binary_function.h"
+#include "__functional/operations.h"
+#include "__functional/reference_wrapper.h"
+#include "__functional/unary_function.h"
+#include "__functional/weak_result_type.h"
+#include "__type_traits/integral_constant.h"
+#include "__type_traits/is_constructible.h"
+#include "__type_traits/is_convertible.h"
+#include "__type_traits/remove_cvref.h"
+#include "__utility/forward.h"
+
+#ifndef __cuda_std__
+#include <__pragma_push>
+#endif // __cuda_std__
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// allocator_arg_t
+
+struct _LIBCUDACXX_TEMPLATE_VIS allocator_arg_t { explicit allocator_arg_t() = default; };
+
+#if defined(_LIBCUDACXX_BUILDING_LIBRARY)
+extern _LIBCUDACXX_EXPORTED_FROM_ABI const allocator_arg_t allocator_arg;
+#else
+/* _LIBCUDACXX_INLINE_VAR */ constexpr allocator_arg_t allocator_arg = allocator_arg_t();
+#endif
+
+// uses_allocator
+
+template <class _Tp>
+struct __has_allocator_type
+{
+private:
+    struct __two {char __lx; char __lxx;};
+    template <class _Up> _LIBCUDACXX_INLINE_VISIBILITY static __two __test(...);
+    template <class _Up> _LIBCUDACXX_INLINE_VISIBILITY static char __test(typename _Up::allocator_type* = 0);
+public:
+    static const bool value = sizeof(__test<_Tp>(0)) == 1;
+};
+
+template <class _Tp, class _Alloc, bool = __has_allocator_type<_Tp>::value>
+struct __uses_allocator
+    : public integral_constant<bool,
+        is_convertible<_Alloc, typename _Tp::allocator_type>::value>
+{
+};
+
+template <class _Tp, class _Alloc>
+struct __uses_allocator<_Tp, _Alloc, false>
+    : public false_type
+{
+};
+
+template <class _Tp, class _Alloc>
+struct _LIBCUDACXX_TEMPLATE_VIS uses_allocator
+    : public __uses_allocator<_Tp, _Alloc>
+{
+};
+
+#if _LIBCUDACXX_STD_VER > 14
+template <class _Tp, class _Alloc>
+_LIBCUDACXX_INLINE_VAR constexpr size_t uses_allocator_v = uses_allocator<_Tp, _Alloc>::value;
+#endif
+
+// allocator construction
+
+template <class _Tp, class _Alloc, class ..._Args>
+struct __uses_alloc_ctor_imp
+{
+    typedef _LIBCUDACXX_NODEBUG_TYPE __remove_cvref_t<_Alloc> _RawAlloc;
+    static const bool __ua = uses_allocator<_Tp, _RawAlloc>::value;
+    static const bool __ic =
+        is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value;
+    static const int value = __ua ? 2 - __ic : 0;
+};
+
+template <class _Tp, class _Alloc, class ..._Args>
+struct __uses_alloc_ctor
+    : integral_constant<int, __uses_alloc_ctor_imp<_Tp, _Alloc, _Args...>::value>
+    {};
+
+template <class _Tp, class _Allocator, class... _Args>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+void __user_alloc_construct_impl (integral_constant<int, 0>, _Tp *__storage, const _Allocator &, _Args &&... __args )
+{
+    new (__storage) _Tp (_CUDA_VSTD::forward<_Args>(__args)...);
+}
+
+// FIXME: This should have a version which takes a non-const alloc.
+template <class _Tp, class _Allocator, class... _Args>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+void __user_alloc_construct_impl (integral_constant<int, 1>, _Tp *__storage, const _Allocator &__a, _Args &&... __args )
+{
+    new (__storage) _Tp (allocator_arg, __a, _CUDA_VSTD::forward<_Args>(__args)...);
+}
+
+// FIXME: This should have a version which takes a non-const alloc.
+template <class _Tp, class _Allocator, class... _Args>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+void __user_alloc_construct_impl (integral_constant<int, 2>, _Tp *__storage, const _Allocator &__a, _Args &&... __args )
+{
+    new (__storage) _Tp (_CUDA_VSTD::forward<_Args>(__args)..., __a);
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#ifndef __cuda_std__
+#include <__pragma_pop>
+#endif // __cuda_std__
+
+#endif  // _LIBCUDACXX_FUNCTIONAL_BASE

cuda_toolkit/include/__libcpp_version

@@ -0,0 +1 @@
+10000

cuda_toolkit/include/__locale

@@ -0,0 +1,1557 @@
+// -*- 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___LOCALE
+#define _LIBCUDACXX___LOCALE
+
+#include <__config>
+#include <string>
+#include <memory>
+#include <utility>
+#include <mutex>
+#include <cstdint>
+#include <cctype>
+#include <locale.h>
+#if defined(_LIBCUDACXX_MSVCRT_LIKE)
+# include <cstring>
+# include <support/win32/locale_win32.h>
+#elif defined(_AIX)
+# include <support/ibm/xlocale.h>
+#elif defined(__ANDROID__)
+# include <support/android/locale_bionic.h>
+#elif defined(__sun__)
+# include <xlocale.h>
+# include <support/solaris/xlocale.h>
+#elif defined(_NEWLIB_VERSION)
+# include <support/newlib/xlocale.h>
+#elif (defined(__APPLE__)      || defined(__FreeBSD__) \
+    || defined(__EMSCRIPTEN__) || defined(__IBMCPP__))
+# include <xlocale.h>
+#elif defined(__Fuchsia__)
+# include <support/fuchsia/xlocale.h>
+#elif defined(__wasi__)
+// WASI libc uses musl's locales support.
+# include <support/musl/xlocale.h>
+#elif defined(_LIBCUDACXX_HAS_MUSL_LIBC)
+# include <support/musl/xlocale.h>
+#endif
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if !defined(_LIBCUDACXX_LOCALE__L_EXTENSIONS)
+struct __libcpp_locale_guard {
+  _LIBCUDACXX_INLINE_VISIBILITY
+  __libcpp_locale_guard(locale_t& __loc) : __old_loc_(uselocale(__loc)) {}
+
+  _LIBCUDACXX_INLINE_VISIBILITY
+  ~__libcpp_locale_guard() {
+    if (__old_loc_)
+      uselocale(__old_loc_);
+  }
+
+  locale_t __old_loc_;
+private:
+  __libcpp_locale_guard(__libcpp_locale_guard const&);
+  __libcpp_locale_guard& operator=(__libcpp_locale_guard const&);
+};
+#elif defined(_LIBCUDACXX_MSVCRT_LIKE)
+struct __libcpp_locale_guard {
+    __libcpp_locale_guard(locale_t __l) :
+        __status(_configthreadlocale(_ENABLE_PER_THREAD_LOCALE)) {
+      // Setting the locale can be expensive even when the locale given is
+      // already the current locale, so do an explicit check to see if the
+      // current locale is already the one we want.
+      const char* __lc = __setlocale(nullptr);
+      // If every category is the same, the locale string will simply be the
+      // locale name, otherwise it will be a semicolon-separated string listing
+      // each category.  In the second case, we know at least one category won't
+      // be what we want, so we only have to check the first case.
+      if (strcmp(__l.__get_locale(), __lc) != 0) {
+        __locale_all = _strdup(__lc);
+        if (__locale_all == nullptr)
+          __throw_bad_alloc();
+        __setlocale(__l.__get_locale());
+      }
+    }
+    ~__libcpp_locale_guard() {
+      // The CRT documentation doesn't explicitly say, but setlocale() does the
+      // right thing when given a semicolon-separated list of locale settings
+      // for the different categories in the same format as returned by
+      // setlocale(LC_ALL, nullptr).
+      if (__locale_all != nullptr) {
+        __setlocale(__locale_all);
+        free(__locale_all);
+      }
+      _configthreadlocale(__status);
+    }
+    static const char* __setlocale(const char* __locale) {
+      const char* __new_locale = setlocale(LC_ALL, __locale);
+      if (__new_locale == nullptr)
+        __throw_bad_alloc();
+      return __new_locale;
+    }
+    int __status;
+    char* __locale_all = nullptr;
+};
+#endif
+
+
+class _LIBCUDACXX_TYPE_VIS locale;
+
+template <class _Facet>
+_LIBCUDACXX_INLINE_VISIBILITY
+bool
+has_facet(const locale&) noexcept;
+
+template <class _Facet>
+_LIBCUDACXX_INLINE_VISIBILITY
+const _Facet&
+use_facet(const locale&);
+
+class _LIBCUDACXX_TYPE_VIS locale
+{
+public:
+    // types:
+    class _LIBCUDACXX_TYPE_VIS facet;
+    class _LIBCUDACXX_TYPE_VIS id;
+
+    typedef int category;
+    _LIBCUDACXX_AVAILABILITY_LOCALE_CATEGORY
+    static const category // values assigned here are for exposition only
+        none     = 0,
+        collate  = LC_COLLATE_MASK,
+        ctype    = LC_CTYPE_MASK,
+        monetary = LC_MONETARY_MASK,
+        numeric  = LC_NUMERIC_MASK,
+        time     = LC_TIME_MASK,
+        messages = LC_MESSAGES_MASK,
+        all = collate | ctype | monetary | numeric | time | messages;
+
+    // construct/copy/destroy:
+    locale()  noexcept;
+    locale(const locale&)  noexcept;
+    explicit locale(const char*);
+    explicit locale(const string&);
+    locale(const locale&, const char*, category);
+    locale(const locale&, const string&, category);
+    template <class _Facet>
+        _LIBCUDACXX_INLINE_VISIBILITY locale(const locale&, _Facet*);
+    locale(const locale&, const locale&, category);
+
+    ~locale();
+
+    const locale& operator=(const locale&)  noexcept;
+
+    template <class _Facet>
+      _LIBCUDACXX_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+      locale combine(const locale&) const;
+
+    // locale operations:
+    string name() const;
+    bool operator==(const locale&) const;
+    bool operator!=(const locale& __y) const {return !(*this == __y);}
+    template <class _CharT, class _Traits, class _Allocator>
+      _LIBCUDACXX_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+      bool operator()(const basic_string<_CharT, _Traits, _Allocator>&,
+                      const basic_string<_CharT, _Traits, _Allocator>&) const;
+
+    // global locale objects:
+    static locale global(const locale&);
+    static const locale& classic();
+
+private:
+    class __imp;
+    __imp* __locale_;
+
+    void __install_ctor(const locale&, facet*, long);
+    static locale& __global();
+    bool has_facet(id&) const;
+    const facet* use_facet(id&) const;
+
+    template <class _Facet> friend bool has_facet(const locale&)  noexcept;
+    template <class _Facet> friend const _Facet& use_facet(const locale&);
+};
+
+class _LIBCUDACXX_TYPE_VIS locale::facet
+    : public __shared_count
+{
+protected:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit facet(size_t __refs = 0)
+        : __shared_count(static_cast<long>(__refs)-1) {}
+
+    virtual ~facet();
+
+//    facet(const facet&) = delete;     // effectively done in __shared_count
+//    void operator=(const facet&) = delete;
+private:
+    virtual void __on_zero_shared() noexcept;
+};
+
+class _LIBCUDACXX_TYPE_VIS locale::id
+{
+    once_flag      __flag_;
+    int32_t        __id_;
+
+    static int32_t __next_id;
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY constexpr id() :__id_(0) {}
+private:
+    void __init();
+    void operator=(const id&); // = delete;
+    id(const id&); // = delete;
+public:  // only needed for tests
+    long __get();
+
+    friend class locale;
+    friend class locale::__imp;
+};
+
+template <class _Facet>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+locale::locale(const locale& __other, _Facet* __f)
+{
+    __install_ctor(__other, __f, __f ? __f->id.__get() : 0);
+}
+
+template <class _Facet>
+locale
+locale::combine(const locale& __other) const
+{
+    if (!_CUDA_VSTD::has_facet<_Facet>(__other))
+        __throw_runtime_error("locale::combine: locale missing facet");
+
+    return locale(*this, &const_cast<_Facet&>(_CUDA_VSTD::use_facet<_Facet>(__other)));
+}
+
+template <class _Facet>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool
+has_facet(const locale& __l)  noexcept
+{
+    return __l.has_facet(_Facet::id);
+}
+
+template <class _Facet>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+const _Facet&
+use_facet(const locale& __l)
+{
+    return static_cast<const _Facet&>(*__l.use_facet(_Facet::id));
+}
+
+// template <class _CharT> class collate;
+
+template <class _CharT>
+class _LIBCUDACXX_TEMPLATE_VIS collate
+    : public locale::facet
+{
+public:
+    typedef _CharT char_type;
+    typedef basic_string<char_type> string_type;
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit collate(size_t __refs = 0)
+        : locale::facet(__refs) {}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    int compare(const char_type* __lo1, const char_type* __hi1,
+                const char_type* __lo2, const char_type* __hi2) const
+    {
+        return do_compare(__lo1, __hi1, __lo2, __hi2);
+    }
+
+    // FIXME(EricWF): The _LIBCUDACXX_ALWAYS_INLINE is needed on Windows to work
+    // around a dllimport bug that expects an external instantiation.
+    _LIBCUDACXX_INLINE_VISIBILITY
+    _LIBCUDACXX_ALWAYS_INLINE
+    string_type transform(const char_type* __lo, const char_type* __hi) const
+    {
+        return do_transform(__lo, __hi);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    long hash(const char_type* __lo, const char_type* __hi) const
+    {
+        return do_hash(__lo, __hi);
+    }
+
+    static locale::id id;
+
+protected:
+    ~collate();
+    virtual int do_compare(const char_type* __lo1, const char_type* __hi1,
+                           const char_type* __lo2, const char_type* __hi2) const;
+    virtual string_type do_transform(const char_type* __lo, const char_type* __hi) const
+        {return string_type(__lo, __hi);}
+    virtual long do_hash(const char_type* __lo, const char_type* __hi) const;
+};
+
+template <class _CharT> locale::id collate<_CharT>::id;
+
+template <class _CharT>
+collate<_CharT>::~collate()
+{
+}
+
+template <class _CharT>
+int
+collate<_CharT>::do_compare(const char_type* __lo1, const char_type* __hi1,
+                            const char_type* __lo2, const char_type* __hi2) const
+{
+    for (; __lo2 != __hi2; ++__lo1, ++__lo2)
+    {
+        if (__lo1 == __hi1 || *__lo1 < *__lo2)
+            return -1;
+        if (*__lo2 < *__lo1)
+            return 1;
+    }
+    return __lo1 != __hi1;
+}
+
+template <class _CharT>
+long
+collate<_CharT>::do_hash(const char_type* __lo, const char_type* __hi) const
+{
+    size_t __h = 0;
+    const size_t __sr = __CHAR_BIT__ * sizeof(size_t) - 8;
+    const size_t __mask = size_t(0xF) << (__sr + 4);
+    for(const char_type* __p = __lo; __p != __hi; ++__p)
+    {
+        __h = (__h << 4) + static_cast<size_t>(*__p);
+        size_t __g = __h & __mask;
+        __h ^= __g | (__g >> __sr);
+    }
+    return static_cast<long>(__h);
+}
+
+_LIBCUDACXX_EXTERN_TEMPLATE2(class _LIBCUDACXX_EXTERN_TEMPLATE_TYPE_VIS collate<char>)
+_LIBCUDACXX_EXTERN_TEMPLATE2(class _LIBCUDACXX_EXTERN_TEMPLATE_TYPE_VIS collate<wchar_t>)
+
+// template <class CharT> class collate_byname;
+
+template <class _CharT> class _LIBCUDACXX_TEMPLATE_VIS collate_byname;
+
+template <>
+class _LIBCUDACXX_TYPE_VIS collate_byname<char>
+    : public collate<char>
+{
+    locale_t __l;
+public:
+    typedef char char_type;
+    typedef basic_string<char_type> string_type;
+
+    explicit collate_byname(const char* __n, size_t __refs = 0);
+    explicit collate_byname(const string& __n, size_t __refs = 0);
+
+protected:
+    ~collate_byname();
+    virtual int do_compare(const char_type* __lo1, const char_type* __hi1,
+                           const char_type* __lo2, const char_type* __hi2) const;
+    virtual string_type do_transform(const char_type* __lo, const char_type* __hi) const;
+};
+
+template <>
+class _LIBCUDACXX_TYPE_VIS collate_byname<wchar_t>
+    : public collate<wchar_t>
+{
+    locale_t __l;
+public:
+    typedef wchar_t char_type;
+    typedef basic_string<char_type> string_type;
+
+    explicit collate_byname(const char* __n, size_t __refs = 0);
+    explicit collate_byname(const string& __n, size_t __refs = 0);
+
+protected:
+    ~collate_byname();
+
+    virtual int do_compare(const char_type* __lo1, const char_type* __hi1,
+                           const char_type* __lo2, const char_type* __hi2) const;
+    virtual string_type do_transform(const char_type* __lo, const char_type* __hi) const;
+};
+
+template <class _CharT, class _Traits, class _Allocator>
+bool
+locale::operator()(const basic_string<_CharT, _Traits, _Allocator>& __x,
+                   const basic_string<_CharT, _Traits, _Allocator>& __y) const
+{
+    return _CUDA_VSTD::use_facet<_CUDA_VSTD::collate<_CharT> >(*this).compare(
+                                       __x.data(), __x.data() + __x.size(),
+                                       __y.data(), __y.data() + __y.size()) < 0;
+}
+
+// template <class charT> class ctype
+
+class _LIBCUDACXX_TYPE_VIS ctype_base
+{
+public:
+#if defined(__GLIBC__)
+    typedef unsigned short mask;
+    static const mask space  = _ISspace;
+    static const mask print  = _ISprint;
+    static const mask cntrl  = _IScntrl;
+    static const mask upper  = _ISupper;
+    static const mask lower  = _ISlower;
+    static const mask alpha  = _ISalpha;
+    static const mask digit  = _ISdigit;
+    static const mask punct  = _ISpunct;
+    static const mask xdigit = _ISxdigit;
+    static const mask blank  = _ISblank;
+#if defined(__mips__)
+    static const mask __regex_word = static_cast<mask>(_ISbit(15));
+#else
+    static const mask __regex_word = 0x80;
+#endif
+#elif defined(_LIBCUDACXX_MSVCRT_LIKE)
+    typedef unsigned short mask;
+    static const mask space  = _SPACE;
+    static const mask print  = _BLANK|_PUNCT|_ALPHA|_DIGIT;
+    static const mask cntrl  = _CONTROL;
+    static const mask upper  = _UPPER;
+    static const mask lower  = _LOWER;
+    static const mask alpha  = _ALPHA;
+    static const mask digit  = _DIGIT;
+    static const mask punct  = _PUNCT;
+    static const mask xdigit = _HEX;
+    static const mask blank  = _BLANK;
+    static const mask __regex_word = 0x80;
+# define _LIBCUDACXX_CTYPE_MASK_IS_COMPOSITE_PRINT
+#elif defined(__APPLE__) || defined(__FreeBSD__) || defined(__EMSCRIPTEN__) || defined(__NetBSD__)
+# ifdef __APPLE__
+    typedef __uint32_t mask;
+# elif defined(__FreeBSD__)
+    typedef unsigned long mask;
+# elif defined(__EMSCRIPTEN__) || defined(__NetBSD__)
+    typedef unsigned short mask;
+# endif
+    static const mask space  = _CTYPE_S;
+    static const mask print  = _CTYPE_R;
+    static const mask cntrl  = _CTYPE_C;
+    static const mask upper  = _CTYPE_U;
+    static const mask lower  = _CTYPE_L;
+    static const mask alpha  = _CTYPE_A;
+    static const mask digit  = _CTYPE_D;
+    static const mask punct  = _CTYPE_P;
+    static const mask xdigit = _CTYPE_X;
+
+# if defined(__NetBSD__)
+    static const mask blank  = _CTYPE_BL;
+    // NetBSD defines classes up to 0x2000
+    // see sys/ctype_bits.h, _CTYPE_Q
+    static const mask __regex_word = 0x8000;
+# else
+    static const mask blank  = _CTYPE_B;
+    static const mask __regex_word = 0x80;
+# endif
+#elif defined(__sun__) || defined(_AIX)
+    typedef unsigned int mask;
+    static const mask space  = _ISSPACE;
+    static const mask print  = _ISPRINT;
+    static const mask cntrl  = _ISCNTRL;
+    static const mask upper  = _ISUPPER;
+    static const mask lower  = _ISLOWER;
+    static const mask alpha  = _ISALPHA;
+    static const mask digit  = _ISDIGIT;
+    static const mask punct  = _ISPUNCT;
+    static const mask xdigit = _ISXDIGIT;
+    static const mask blank  = _ISBLANK;
+    static const mask __regex_word = 0x80;
+#elif defined(_NEWLIB_VERSION)
+    // Same type as Newlib's _ctype_ array in newlib/libc/include/ctype.h.
+    typedef char mask;
+    static const mask space  = _S;
+    static const mask print  = _P | _U | _L | _N | _B;
+    static const mask cntrl  = _C;
+    static const mask upper  = _U;
+    static const mask lower  = _L;
+    static const mask alpha  = _U | _L;
+    static const mask digit  = _N;
+    static const mask punct  = _P;
+    static const mask xdigit = _X | _N;
+    static const mask blank  = _B;
+    static const mask __regex_word = 0x80;
+# define _LIBCUDACXX_CTYPE_MASK_IS_COMPOSITE_PRINT
+# define _LIBCUDACXX_CTYPE_MASK_IS_COMPOSITE_ALPHA
+# define _LIBCUDACXX_CTYPE_MASK_IS_COMPOSITE_XDIGIT
+#else
+    typedef unsigned long mask;
+    static const mask space  = 1<<0;
+    static const mask print  = 1<<1;
+    static const mask cntrl  = 1<<2;
+    static const mask upper  = 1<<3;
+    static const mask lower  = 1<<4;
+    static const mask alpha  = 1<<5;
+    static const mask digit  = 1<<6;
+    static const mask punct  = 1<<7;
+    static const mask xdigit = 1<<8;
+    static const mask blank  = 1<<9;
+    static const mask __regex_word = 1<<10;
+#endif
+    static const mask alnum  = alpha | digit;
+    static const mask graph  = alnum | punct;
+
+    _LIBCUDACXX_INLINE_VISIBILITY ctype_base() {}
+};
+
+template <class _CharT> class _LIBCUDACXX_TEMPLATE_VIS ctype;
+
+template <>
+class _LIBCUDACXX_TYPE_VIS ctype<wchar_t>
+    : public locale::facet,
+      public ctype_base
+{
+public:
+    typedef wchar_t char_type;
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit ctype(size_t __refs = 0)
+        : locale::facet(__refs) {}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    bool is(mask __m, char_type __c) const
+    {
+        return do_is(__m, __c);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const char_type* is(const char_type* __low, const char_type* __high, mask* __vec) const
+    {
+        return do_is(__low, __high, __vec);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const char_type* scan_is(mask __m, const char_type* __low, const char_type* __high) const
+    {
+        return do_scan_is(__m, __low, __high);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const char_type* scan_not(mask __m, const char_type* __low, const char_type* __high) const
+    {
+        return do_scan_not(__m, __low, __high);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    char_type toupper(char_type __c) const
+    {
+        return do_toupper(__c);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const char_type* toupper(char_type* __low, const char_type* __high) const
+    {
+        return do_toupper(__low, __high);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    char_type tolower(char_type __c) const
+    {
+        return do_tolower(__c);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const char_type* tolower(char_type* __low, const char_type* __high) const
+    {
+        return do_tolower(__low, __high);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    char_type widen(char __c) const
+    {
+        return do_widen(__c);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const char* widen(const char* __low, const char* __high, char_type* __to) const
+    {
+        return do_widen(__low, __high, __to);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    char narrow(char_type __c, char __dfault) const
+    {
+        return do_narrow(__c, __dfault);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const char_type* narrow(const char_type* __low, const char_type* __high, char __dfault, char* __to) const
+    {
+        return do_narrow(__low, __high, __dfault, __to);
+    }
+
+    static locale::id id;
+
+protected:
+    ~ctype();
+    virtual bool do_is(mask __m, char_type __c) const;
+    virtual const char_type* do_is(const char_type* __low, const char_type* __high, mask* __vec) const;
+    virtual const char_type* do_scan_is(mask __m, const char_type* __low, const char_type* __high) const;
+    virtual const char_type* do_scan_not(mask __m, const char_type* __low, const char_type* __high) const;
+    virtual char_type do_toupper(char_type) const;
+    virtual const char_type* do_toupper(char_type* __low, const char_type* __high) const;
+    virtual char_type do_tolower(char_type) const;
+    virtual const char_type* do_tolower(char_type* __low, const char_type* __high) const;
+    virtual char_type do_widen(char) const;
+    virtual const char* do_widen(const char* __low, const char* __high, char_type* __dest) const;
+    virtual char do_narrow(char_type, char __dfault) const;
+    virtual const char_type* do_narrow(const char_type* __low, const char_type* __high, char __dfault, char* __dest) const;
+};
+
+template <>
+class _LIBCUDACXX_TYPE_VIS ctype<char>
+    : public locale::facet, public ctype_base
+{
+    const mask* __tab_;
+    bool        __del_;
+public:
+    typedef char char_type;
+
+    explicit ctype(const mask* __tab = 0, bool __del = false, size_t __refs = 0);
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    bool is(mask __m, char_type __c) const
+    {
+        return isascii(__c) ? (__tab_[static_cast<int>(__c)] & __m) !=0 : false;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const char_type* is(const char_type* __low, const char_type* __high, mask* __vec) const
+    {
+        for (; __low != __high; ++__low, ++__vec)
+            *__vec = isascii(*__low) ? __tab_[static_cast<int>(*__low)] : 0;
+        return __low;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const char_type* scan_is (mask __m, const char_type* __low, const char_type* __high) const
+    {
+        for (; __low != __high; ++__low)
+            if (isascii(*__low) && (__tab_[static_cast<int>(*__low)] & __m))
+                break;
+        return __low;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const char_type* scan_not(mask __m, const char_type* __low, const char_type* __high) const
+    {
+        for (; __low != __high; ++__low)
+            if (!(isascii(*__low) && (__tab_[static_cast<int>(*__low)] & __m)))
+                break;
+        return __low;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    char_type toupper(char_type __c) const
+    {
+        return do_toupper(__c);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const char_type* toupper(char_type* __low, const char_type* __high) const
+    {
+        return do_toupper(__low, __high);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    char_type tolower(char_type __c) const
+    {
+        return do_tolower(__c);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const char_type* tolower(char_type* __low, const char_type* __high) const
+    {
+        return do_tolower(__low, __high);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    char_type widen(char __c) const
+    {
+        return do_widen(__c);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const char* widen(const char* __low, const char* __high, char_type* __to) const
+    {
+        return do_widen(__low, __high, __to);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    char narrow(char_type __c, char __dfault) const
+    {
+        return do_narrow(__c, __dfault);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    const char* narrow(const char_type* __low, const char_type* __high, char __dfault, char* __to) const
+    {
+        return do_narrow(__low, __high, __dfault, __to);
+    }
+
+    static locale::id id;
+
+#ifdef _CACHED_RUNES
+    static const size_t table_size = _CACHED_RUNES;
+#else
+    static const size_t table_size = 256;  // FIXME: Don't hardcode this.
+#endif
+    _LIBCUDACXX_INLINE_VISIBILITY const mask* table() const  noexcept {return __tab_;}
+    static const mask* classic_table()  noexcept;
+#if defined(__GLIBC__) || defined(__EMSCRIPTEN__)
+    static const int* __classic_upper_table() noexcept;
+    static const int* __classic_lower_table() noexcept;
+#endif
+#if defined(__NetBSD__)
+    static const short* __classic_upper_table() noexcept;
+    static const short* __classic_lower_table() noexcept;
+#endif
+
+protected:
+    ~ctype();
+    virtual char_type do_toupper(char_type __c) const;
+    virtual const char_type* do_toupper(char_type* __low, const char_type* __high) const;
+    virtual char_type do_tolower(char_type __c) const;
+    virtual const char_type* do_tolower(char_type* __low, const char_type* __high) const;
+    virtual char_type do_widen(char __c) const;
+    virtual const char* do_widen(const char* __low, const char* __high, char_type* __to) const;
+    virtual char do_narrow(char_type __c, char __dfault) const;
+    virtual const char* do_narrow(const char_type* __low, const char_type* __high, char __dfault, char* __to) const;
+};
+
+// template <class CharT> class ctype_byname;
+
+template <class _CharT> class _LIBCUDACXX_TEMPLATE_VIS ctype_byname;
+
+template <>
+class _LIBCUDACXX_TYPE_VIS ctype_byname<char>
+    : public ctype<char>
+{
+    locale_t __l;
+
+public:
+    explicit ctype_byname(const char*, size_t = 0);
+    explicit ctype_byname(const string&, size_t = 0);
+
+protected:
+    ~ctype_byname();
+    virtual char_type do_toupper(char_type) const;
+    virtual const char_type* do_toupper(char_type* __low, const char_type* __high) const;
+    virtual char_type do_tolower(char_type) const;
+    virtual const char_type* do_tolower(char_type* __low, const char_type* __high) const;
+};
+
+template <>
+class _LIBCUDACXX_TYPE_VIS ctype_byname<wchar_t>
+    : public ctype<wchar_t>
+{
+    locale_t __l;
+
+public:
+    explicit ctype_byname(const char*, size_t = 0);
+    explicit ctype_byname(const string&, size_t = 0);
+
+protected:
+    ~ctype_byname();
+    virtual bool do_is(mask __m, char_type __c) const;
+    virtual const char_type* do_is(const char_type* __low, const char_type* __high, mask* __vec) const;
+    virtual const char_type* do_scan_is(mask __m, const char_type* __low, const char_type* __high) const;
+    virtual const char_type* do_scan_not(mask __m, const char_type* __low, const char_type* __high) const;
+    virtual char_type do_toupper(char_type) const;
+    virtual const char_type* do_toupper(char_type* __low, const char_type* __high) const;
+    virtual char_type do_tolower(char_type) const;
+    virtual const char_type* do_tolower(char_type* __low, const char_type* __high) const;
+    virtual char_type do_widen(char) const;
+    virtual const char* do_widen(const char* __low, const char* __high, char_type* __dest) const;
+    virtual char do_narrow(char_type, char __dfault) const;
+    virtual const char_type* do_narrow(const char_type* __low, const char_type* __high, char __dfault, char* __dest) const;
+};
+
+template <class _CharT>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool
+isspace(_CharT __c, const locale& __loc)
+{
+    return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c);
+}
+
+template <class _CharT>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool
+isprint(_CharT __c, const locale& __loc)
+{
+    return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c);
+}
+
+template <class _CharT>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool
+iscntrl(_CharT __c, const locale& __loc)
+{
+    return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c);
+}
+
+template <class _CharT>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool
+isupper(_CharT __c, const locale& __loc)
+{
+    return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c);
+}
+
+template <class _CharT>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool
+islower(_CharT __c, const locale& __loc)
+{
+    return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c);
+}
+
+template <class _CharT>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool
+isalpha(_CharT __c, const locale& __loc)
+{
+    return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c);
+}
+
+template <class _CharT>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool
+isdigit(_CharT __c, const locale& __loc)
+{
+    return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c);
+}
+
+template <class _CharT>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool
+ispunct(_CharT __c, const locale& __loc)
+{
+    return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c);
+}
+
+template <class _CharT>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool
+isxdigit(_CharT __c, const locale& __loc)
+{
+    return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c);
+}
+
+template <class _CharT>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool
+isalnum(_CharT __c, const locale& __loc)
+{
+    return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c);
+}
+
+template <class _CharT>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+bool
+isgraph(_CharT __c, const locale& __loc)
+{
+    return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c);
+}
+
+template <class _CharT>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+_CharT
+toupper(_CharT __c, const locale& __loc)
+{
+    return use_facet<ctype<_CharT> >(__loc).toupper(__c);
+}
+
+template <class _CharT>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+_CharT
+tolower(_CharT __c, const locale& __loc)
+{
+    return use_facet<ctype<_CharT> >(__loc).tolower(__c);
+}
+
+// codecvt_base
+
+class _LIBCUDACXX_TYPE_VIS codecvt_base
+{
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY codecvt_base() {}
+    enum result {ok, partial, error, noconv};
+};
+
+// template <class internT, class externT, class stateT> class codecvt;
+
+template <class _InternT, class _ExternT, class _StateT> class _LIBCUDACXX_TEMPLATE_VIS codecvt;
+
+// template <> class codecvt<char, char, mbstate_t>
+
+template <>
+class _LIBCUDACXX_TYPE_VIS codecvt<char, char, mbstate_t>
+    : public locale::facet,
+      public codecvt_base
+{
+public:
+    typedef char      intern_type;
+    typedef char      extern_type;
+    typedef mbstate_t state_type;
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit codecvt(size_t __refs = 0)
+        : locale::facet(__refs) {}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    result out(state_type& __st,
+               const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
+               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
+    {
+        return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    result unshift(state_type& __st,
+                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
+    {
+        return do_unshift(__st, __to, __to_end, __to_nxt);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    result in(state_type& __st,
+              const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
+              intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const
+    {
+        return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    int encoding() const  noexcept
+    {
+        return do_encoding();
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    bool always_noconv() const  noexcept
+    {
+        return do_always_noconv();
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    int length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const
+    {
+        return do_length(__st, __frm, __end, __mx);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    int max_length() const  noexcept
+    {
+        return do_max_length();
+    }
+
+    static locale::id id;
+
+protected:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit codecvt(const char*, size_t __refs = 0)
+        : locale::facet(__refs) {}
+
+    ~codecvt();
+
+    virtual result do_out(state_type& __st,
+                          const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
+                          extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
+    virtual result do_in(state_type& __st,
+                         const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
+                         intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
+    virtual result do_unshift(state_type& __st,
+                              extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
+    virtual int do_encoding() const  noexcept;
+    virtual bool do_always_noconv() const  noexcept;
+    virtual int do_length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
+    virtual int do_max_length() const  noexcept;
+};
+
+// template <> class codecvt<wchar_t, char, mbstate_t>
+
+template <>
+class _LIBCUDACXX_TYPE_VIS codecvt<wchar_t, char, mbstate_t>
+    : public locale::facet,
+      public codecvt_base
+{
+    locale_t __l;
+public:
+    typedef wchar_t   intern_type;
+    typedef char      extern_type;
+    typedef mbstate_t state_type;
+
+    explicit codecvt(size_t __refs = 0);
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    result out(state_type& __st,
+               const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
+               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
+    {
+        return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    result unshift(state_type& __st,
+                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
+    {
+        return do_unshift(__st, __to, __to_end, __to_nxt);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    result in(state_type& __st,
+              const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
+              intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const
+    {
+        return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    int encoding() const  noexcept
+    {
+        return do_encoding();
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    bool always_noconv() const  noexcept
+    {
+        return do_always_noconv();
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    int length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const
+    {
+        return do_length(__st, __frm, __end, __mx);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    int max_length() const  noexcept
+    {
+        return do_max_length();
+    }
+
+    static locale::id id;
+
+protected:
+    explicit codecvt(const char*, size_t __refs = 0);
+
+    ~codecvt();
+
+    virtual result do_out(state_type& __st,
+                          const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
+                          extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
+    virtual result do_in(state_type& __st,
+                         const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
+                         intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
+    virtual result do_unshift(state_type& __st,
+                              extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
+    virtual int do_encoding() const  noexcept;
+    virtual bool do_always_noconv() const  noexcept;
+    virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
+    virtual int do_max_length() const  noexcept;
+};
+
+// template <> class codecvt<char16_t, char, mbstate_t>
+
+template <>
+class _LIBCUDACXX_TYPE_VIS codecvt<char16_t, char, mbstate_t>
+    : public locale::facet,
+      public codecvt_base
+{
+public:
+    typedef char16_t  intern_type;
+    typedef char      extern_type;
+    typedef mbstate_t state_type;
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit codecvt(size_t __refs = 0)
+        : locale::facet(__refs) {}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    result out(state_type& __st,
+               const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
+               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
+    {
+        return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    result unshift(state_type& __st,
+                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
+    {
+        return do_unshift(__st, __to, __to_end, __to_nxt);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    result in(state_type& __st,
+              const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
+              intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const
+    {
+        return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    int encoding() const  noexcept
+    {
+        return do_encoding();
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    bool always_noconv() const  noexcept
+    {
+        return do_always_noconv();
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    int length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const
+    {
+        return do_length(__st, __frm, __end, __mx);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    int max_length() const  noexcept
+    {
+        return do_max_length();
+    }
+
+    static locale::id id;
+
+protected:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit codecvt(const char*, size_t __refs = 0)
+        : locale::facet(__refs) {}
+
+    ~codecvt();
+
+    virtual result do_out(state_type& __st,
+                          const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
+                          extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
+    virtual result do_in(state_type& __st,
+                         const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
+                         intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
+    virtual result do_unshift(state_type& __st,
+                              extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
+    virtual int do_encoding() const  noexcept;
+    virtual bool do_always_noconv() const  noexcept;
+    virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
+    virtual int do_max_length() const  noexcept;
+};
+
+// template <> class codecvt<char32_t, char, mbstate_t>
+
+template <>
+class _LIBCUDACXX_TYPE_VIS codecvt<char32_t, char, mbstate_t>
+    : public locale::facet,
+      public codecvt_base
+{
+public:
+    typedef char32_t  intern_type;
+    typedef char      extern_type;
+    typedef mbstate_t state_type;
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit codecvt(size_t __refs = 0)
+        : locale::facet(__refs) {}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    result out(state_type& __st,
+               const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
+               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
+    {
+        return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    result unshift(state_type& __st,
+                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
+    {
+        return do_unshift(__st, __to, __to_end, __to_nxt);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    result in(state_type& __st,
+              const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
+              intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const
+    {
+        return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    int encoding() const  noexcept
+    {
+        return do_encoding();
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    bool always_noconv() const  noexcept
+    {
+        return do_always_noconv();
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    int length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const
+    {
+        return do_length(__st, __frm, __end, __mx);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    int max_length() const  noexcept
+    {
+        return do_max_length();
+    }
+
+    static locale::id id;
+
+protected:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit codecvt(const char*, size_t __refs = 0)
+        : locale::facet(__refs) {}
+
+    ~codecvt();
+
+    virtual result do_out(state_type& __st,
+                          const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
+                          extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
+    virtual result do_in(state_type& __st,
+                         const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
+                         intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
+    virtual result do_unshift(state_type& __st,
+                              extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
+    virtual int do_encoding() const  noexcept;
+    virtual bool do_always_noconv() const  noexcept;
+    virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
+    virtual int do_max_length() const  noexcept;
+};
+
+// template <class _InternT, class _ExternT, class _StateT> class codecvt_byname
+
+template <class _InternT, class _ExternT, class _StateT>
+class _LIBCUDACXX_TEMPLATE_VIS codecvt_byname
+    : public codecvt<_InternT, _ExternT, _StateT>
+{
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit codecvt_byname(const char* __nm, size_t __refs = 0)
+        : codecvt<_InternT, _ExternT, _StateT>(__nm, __refs) {}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit codecvt_byname(const string& __nm, size_t __refs = 0)
+        : codecvt<_InternT, _ExternT, _StateT>(__nm.c_str(), __refs) {}
+protected:
+    ~codecvt_byname();
+};
+
+template <class _InternT, class _ExternT, class _StateT>
+codecvt_byname<_InternT, _ExternT, _StateT>::~codecvt_byname()
+{
+}
+
+_LIBCUDACXX_EXTERN_TEMPLATE2(class _LIBCUDACXX_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char, char, mbstate_t>)
+_LIBCUDACXX_EXTERN_TEMPLATE2(class _LIBCUDACXX_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<wchar_t, char, mbstate_t>)
+_LIBCUDACXX_EXTERN_TEMPLATE2(class _LIBCUDACXX_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char16_t, char, mbstate_t>)
+_LIBCUDACXX_EXTERN_TEMPLATE2(class _LIBCUDACXX_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char32_t, char, mbstate_t>)
+
+template <size_t _Np>
+struct __narrow_to_utf8
+{
+    template <class _OutputIterator, class _CharT>
+    _OutputIterator
+    operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const;
+};
+
+template <>
+struct __narrow_to_utf8<8>
+{
+    template <class _OutputIterator, class _CharT>
+    _LIBCUDACXX_INLINE_VISIBILITY
+    _OutputIterator
+    operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const
+    {
+        for (; __wb < __we; ++__wb, ++__s)
+            *__s = *__wb;
+        return __s;
+    }
+};
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS __narrow_to_utf8<16>
+    : public codecvt<char16_t, char, mbstate_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __narrow_to_utf8() : codecvt<char16_t, char, mbstate_t>(1) {}
+
+    _LIBCUDACXX_EXPORTED_FROM_ABI ~__narrow_to_utf8();
+
+    template <class _OutputIterator, class _CharT>
+    _LIBCUDACXX_INLINE_VISIBILITY
+    _OutputIterator
+    operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const
+    {
+        result __r = ok;
+        mbstate_t __mb;
+        while (__wb < __we && __r != error)
+        {
+            const int __sz = 32;
+            char __buf[__sz];
+            char* __bn;
+            const char16_t* __wn = (const char16_t*)__wb;
+            __r = do_out(__mb, (const char16_t*)__wb, (const char16_t*)__we, __wn,
+                         __buf, __buf+__sz, __bn);
+            if (__r == codecvt_base::error || __wn == (const char16_t*)__wb)
+                __throw_runtime_error("locale not supported");
+            for (const char* __p = __buf; __p < __bn; ++__p, ++__s)
+                *__s = *__p;
+            __wb = (const _CharT*)__wn;
+        }
+        return __s;
+    }
+};
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS __narrow_to_utf8<32>
+    : public codecvt<char32_t, char, mbstate_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __narrow_to_utf8() : codecvt<char32_t, char, mbstate_t>(1) {}
+
+    _LIBCUDACXX_EXPORTED_FROM_ABI ~__narrow_to_utf8();
+
+    template <class _OutputIterator, class _CharT>
+    _LIBCUDACXX_INLINE_VISIBILITY
+    _OutputIterator
+    operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const
+    {
+        result __r = ok;
+        mbstate_t __mb;
+        while (__wb < __we && __r != error)
+        {
+            const int __sz = 32;
+            char __buf[__sz];
+            char* __bn;
+            const char32_t* __wn = (const char32_t*)__wb;
+            __r = do_out(__mb, (const char32_t*)__wb, (const char32_t*)__we, __wn,
+                         __buf, __buf+__sz, __bn);
+            if (__r == codecvt_base::error || __wn == (const char32_t*)__wb)
+                __throw_runtime_error("locale not supported");
+            for (const char* __p = __buf; __p < __bn; ++__p, ++__s)
+                *__s = *__p;
+            __wb = (const _CharT*)__wn;
+        }
+        return __s;
+    }
+};
+
+template <size_t _Np>
+struct __widen_from_utf8
+{
+    template <class _OutputIterator>
+    _OutputIterator
+    operator()(_OutputIterator __s, const char* __nb, const char* __ne) const;
+};
+
+template <>
+struct __widen_from_utf8<8>
+{
+    template <class _OutputIterator>
+    _LIBCUDACXX_INLINE_VISIBILITY
+    _OutputIterator
+    operator()(_OutputIterator __s, const char* __nb, const char* __ne) const
+    {
+        for (; __nb < __ne; ++__nb, ++__s)
+            *__s = *__nb;
+        return __s;
+    }
+};
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS __widen_from_utf8<16>
+    : public codecvt<char16_t, char, mbstate_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __widen_from_utf8() : codecvt<char16_t, char, mbstate_t>(1) {}
+
+    _LIBCUDACXX_EXPORTED_FROM_ABI ~__widen_from_utf8();
+
+    template <class _OutputIterator>
+    _LIBCUDACXX_INLINE_VISIBILITY
+    _OutputIterator
+    operator()(_OutputIterator __s, const char* __nb, const char* __ne) const
+    {
+        result __r = ok;
+        mbstate_t __mb;
+        while (__nb < __ne && __r != error)
+        {
+            const int __sz = 32;
+            char16_t __buf[__sz];
+            char16_t* __bn;
+            const char* __nn = __nb;
+            __r = do_in(__mb, __nb, __ne - __nb > __sz ? __nb+__sz : __ne, __nn,
+                        __buf, __buf+__sz, __bn);
+            if (__r == codecvt_base::error || __nn == __nb)
+                __throw_runtime_error("locale not supported");
+            for (const char16_t* __p = __buf; __p < __bn; ++__p, ++__s)
+                *__s = (wchar_t)*__p;
+            __nb = __nn;
+        }
+        return __s;
+    }
+};
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS __widen_from_utf8<32>
+    : public codecvt<char32_t, char, mbstate_t>
+{
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __widen_from_utf8() : codecvt<char32_t, char, mbstate_t>(1) {}
+
+    _LIBCUDACXX_EXPORTED_FROM_ABI ~__widen_from_utf8();
+
+    template <class _OutputIterator>
+    _LIBCUDACXX_INLINE_VISIBILITY
+    _OutputIterator
+    operator()(_OutputIterator __s, const char* __nb, const char* __ne) const
+    {
+        result __r = ok;
+        mbstate_t __mb;
+        while (__nb < __ne && __r != error)
+        {
+            const int __sz = 32;
+            char32_t __buf[__sz];
+            char32_t* __bn;
+            const char* __nn = __nb;
+            __r = do_in(__mb, __nb, __ne - __nb > __sz ? __nb+__sz : __ne, __nn,
+                        __buf, __buf+__sz, __bn);
+            if (__r == codecvt_base::error || __nn == __nb)
+                __throw_runtime_error("locale not supported");
+            for (const char32_t* __p = __buf; __p < __bn; ++__p, ++__s)
+                *__s = (wchar_t)*__p;
+            __nb = __nn;
+        }
+        return __s;
+    }
+};
+
+// template <class charT> class numpunct
+
+template <class _CharT> class _LIBCUDACXX_TEMPLATE_VIS numpunct;
+
+template <>
+class _LIBCUDACXX_TYPE_VIS numpunct<char>
+    : public locale::facet
+{
+public:
+    typedef char char_type;
+    typedef basic_string<char_type> string_type;
+
+    explicit numpunct(size_t __refs = 0);
+
+    _LIBCUDACXX_INLINE_VISIBILITY char_type decimal_point() const {return do_decimal_point();}
+    _LIBCUDACXX_INLINE_VISIBILITY char_type thousands_sep() const {return do_thousands_sep();}
+    _LIBCUDACXX_INLINE_VISIBILITY string grouping() const         {return do_grouping();}
+    _LIBCUDACXX_INLINE_VISIBILITY string_type truename() const    {return do_truename();}
+    _LIBCUDACXX_INLINE_VISIBILITY string_type falsename() const   {return do_falsename();}
+
+    static locale::id id;
+
+protected:
+    ~numpunct();
+    virtual char_type do_decimal_point() const;
+    virtual char_type do_thousands_sep() const;
+    virtual string do_grouping() const;
+    virtual string_type do_truename() const;
+    virtual string_type do_falsename() const;
+
+    char_type __decimal_point_;
+    char_type __thousands_sep_;
+    string __grouping_;
+};
+
+template <>
+class _LIBCUDACXX_TYPE_VIS numpunct<wchar_t>
+    : public locale::facet
+{
+public:
+    typedef wchar_t char_type;
+    typedef basic_string<char_type> string_type;
+
+    explicit numpunct(size_t __refs = 0);
+
+    _LIBCUDACXX_INLINE_VISIBILITY char_type decimal_point() const {return do_decimal_point();}
+    _LIBCUDACXX_INLINE_VISIBILITY char_type thousands_sep() const {return do_thousands_sep();}
+    _LIBCUDACXX_INLINE_VISIBILITY string grouping() const         {return do_grouping();}
+    _LIBCUDACXX_INLINE_VISIBILITY string_type truename() const    {return do_truename();}
+    _LIBCUDACXX_INLINE_VISIBILITY string_type falsename() const   {return do_falsename();}
+
+    static locale::id id;
+
+protected:
+    ~numpunct();
+    virtual char_type do_decimal_point() const;
+    virtual char_type do_thousands_sep() const;
+    virtual string do_grouping() const;
+    virtual string_type do_truename() const;
+    virtual string_type do_falsename() const;
+
+    char_type __decimal_point_;
+    char_type __thousands_sep_;
+    string __grouping_;
+};
+
+// template <class charT> class numpunct_byname
+
+template <class _CharT> class _LIBCUDACXX_TEMPLATE_VIS numpunct_byname;
+
+template <>
+class _LIBCUDACXX_TYPE_VIS numpunct_byname<char>
+: public numpunct<char>
+{
+public:
+    typedef char char_type;
+    typedef basic_string<char_type> string_type;
+
+    explicit numpunct_byname(const char* __nm, size_t __refs = 0);
+    explicit numpunct_byname(const string& __nm, size_t __refs = 0);
+
+protected:
+    ~numpunct_byname();
+
+private:
+    void __init(const char*);
+};
+
+template <>
+class _LIBCUDACXX_TYPE_VIS numpunct_byname<wchar_t>
+: public numpunct<wchar_t>
+{
+public:
+    typedef wchar_t char_type;
+    typedef basic_string<char_type> string_type;
+
+    explicit numpunct_byname(const char* __nm, size_t __refs = 0);
+    explicit numpunct_byname(const string& __nm, size_t __refs = 0);
+
+protected:
+    ~numpunct_byname();
+
+private:
+    void __init(const char*);
+};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif  // _LIBCUDACXX___LOCALE

cuda_toolkit/include/__mutex_base

@@ -0,0 +1,542 @@
+// -*- 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___MUTEX_BASE
+#define _LIBCUDACXX___MUTEX_BASE
+
+#include <__config>
+#include <chrono>
+#include <system_error>
+#include <__threading_support>
+
+#include <time.h>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_PUSH_MACROS
+#include <__undef_macros>
+
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#ifndef _LIBCUDACXX_HAS_NO_THREADS
+
+#ifndef _LIBCUDACXX_THREAD_SAFETY_ANNOTATION
+#  ifdef _LIBCUDACXX_HAS_THREAD_SAFETY_ANNOTATIONS
+#    define _LIBCUDACXX_THREAD_SAFETY_ANNOTATION(x) __attribute__((x))
+#  else
+#    define _LIBCUDACXX_THREAD_SAFETY_ANNOTATION(x)
+#  endif
+#endif  // _LIBCUDACXX_THREAD_SAFETY_ANNOTATION
+
+
+class _LIBCUDACXX_TYPE_VIS _LIBCUDACXX_THREAD_SAFETY_ANNOTATION(capability("mutex")) mutex
+{
+    __libcpp_mutex_t __m_ = _LIBCUDACXX_MUTEX_INITIALIZER;
+
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    constexpr mutex() = default;
+
+    mutex(const mutex&) = delete;
+    mutex& operator=(const mutex&) = delete;
+
+#if defined(_LIBCUDACXX_HAS_TRIVIAL_MUTEX_DESTRUCTION)
+    ~mutex() = default;
+#else
+    ~mutex() noexcept;
+#endif
+
+    void lock() _LIBCUDACXX_THREAD_SAFETY_ANNOTATION(acquire_capability());
+    bool try_lock() noexcept _LIBCUDACXX_THREAD_SAFETY_ANNOTATION(try_acquire_capability(true));
+    void unlock() noexcept _LIBCUDACXX_THREAD_SAFETY_ANNOTATION(release_capability());
+
+    typedef __libcpp_mutex_t* native_handle_type;
+    _LIBCUDACXX_INLINE_VISIBILITY native_handle_type native_handle() {return &__m_;}
+};
+
+static_assert(is_nothrow_default_constructible<mutex>::value,
+              "the default constructor for std::mutex must be nothrow");
+
+struct _LIBCUDACXX_TYPE_VIS defer_lock_t { explicit defer_lock_t() = default; };
+struct _LIBCUDACXX_TYPE_VIS try_to_lock_t { explicit try_to_lock_t() = default; };
+struct _LIBCUDACXX_TYPE_VIS adopt_lock_t { explicit adopt_lock_t() = default; };
+
+#if defined(_LIBCUDACXX_BUILDING_LIBRARY)
+
+extern _LIBCUDACXX_EXPORTED_FROM_ABI const defer_lock_t  defer_lock;
+extern _LIBCUDACXX_EXPORTED_FROM_ABI const try_to_lock_t try_to_lock;
+extern _LIBCUDACXX_EXPORTED_FROM_ABI const adopt_lock_t  adopt_lock;
+
+#else
+
+/* _LIBCUDACXX_INLINE_VAR */ constexpr defer_lock_t  defer_lock  = defer_lock_t();
+/* _LIBCUDACXX_INLINE_VAR */ constexpr try_to_lock_t try_to_lock = try_to_lock_t();
+/* _LIBCUDACXX_INLINE_VAR */ constexpr adopt_lock_t  adopt_lock  = adopt_lock_t();
+
+#endif
+
+template <class _Mutex>
+class _LIBCUDACXX_TEMPLATE_VIS _LIBCUDACXX_THREAD_SAFETY_ANNOTATION(scoped_lockable)
+lock_guard
+{
+public:
+    typedef _Mutex mutex_type;
+
+private:
+    mutex_type& __m_;
+public:
+
+    _LIBCUDACXX_NODISCARD_EXT _LIBCUDACXX_INLINE_VISIBILITY
+    explicit lock_guard(mutex_type& __m) _LIBCUDACXX_THREAD_SAFETY_ANNOTATION(acquire_capability(__m))
+        : __m_(__m) {__m_.lock();}
+
+    _LIBCUDACXX_NODISCARD_EXT _LIBCUDACXX_INLINE_VISIBILITY
+    lock_guard(mutex_type& __m, adopt_lock_t) _LIBCUDACXX_THREAD_SAFETY_ANNOTATION(requires_capability(__m))
+        : __m_(__m) {}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    ~lock_guard() _LIBCUDACXX_THREAD_SAFETY_ANNOTATION(release_capability()) {__m_.unlock();}
+
+private:
+    lock_guard(lock_guard const&) = delete;
+    lock_guard& operator=(lock_guard const&) = delete;
+};
+
+template <class _Mutex>
+class _LIBCUDACXX_TEMPLATE_VIS unique_lock
+{
+public:
+    typedef _Mutex mutex_type;
+
+private:
+    mutex_type* __m_;
+    bool __owns_;
+
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    unique_lock() noexcept : __m_(nullptr), __owns_(false) {}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit unique_lock(mutex_type& __m)
+        : __m_(_CUDA_VSTD::addressof(__m)), __owns_(true) {__m_->lock();}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    unique_lock(mutex_type& __m, defer_lock_t) noexcept
+        : __m_(_CUDA_VSTD::addressof(__m)), __owns_(false) {}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    unique_lock(mutex_type& __m, try_to_lock_t)
+        : __m_(_CUDA_VSTD::addressof(__m)), __owns_(__m.try_lock()) {}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    unique_lock(mutex_type& __m, adopt_lock_t)
+        : __m_(_CUDA_VSTD::addressof(__m)), __owns_(true) {}
+    template <class _Clock, class _Duration>
+    _LIBCUDACXX_INLINE_VISIBILITY
+        unique_lock(mutex_type& __m, const chrono::time_point<_Clock, _Duration>& __t)
+            : __m_(_CUDA_VSTD::addressof(__m)), __owns_(__m.try_lock_until(__t)) {}
+    template <class _Rep, class _Period>
+    _LIBCUDACXX_INLINE_VISIBILITY
+        unique_lock(mutex_type& __m, const chrono::duration<_Rep, _Period>& __d)
+            : __m_(_CUDA_VSTD::addressof(__m)), __owns_(__m.try_lock_for(__d)) {}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    ~unique_lock()
+    {
+        if (__owns_)
+            __m_->unlock();
+    }
+
+private:
+    unique_lock(unique_lock const&); // = delete;
+    unique_lock& operator=(unique_lock const&); // = delete;
+
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    unique_lock(unique_lock&& __u) noexcept
+        : __m_(__u.__m_), __owns_(__u.__owns_)
+        {__u.__m_ = nullptr; __u.__owns_ = false;}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    unique_lock& operator=(unique_lock&& __u) noexcept
+        {
+            if (__owns_)
+                __m_->unlock();
+            __m_ = __u.__m_;
+            __owns_ = __u.__owns_;
+            __u.__m_ = nullptr;
+            __u.__owns_ = false;
+            return *this;
+        }
+
+    void lock();
+    bool try_lock();
+
+    template <class _Rep, class _Period>
+        bool try_lock_for(const chrono::duration<_Rep, _Period>& __d);
+    template <class _Clock, class _Duration>
+        bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
+
+    void unlock();
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void swap(unique_lock& __u) noexcept
+    {
+        _CUDA_VSTD::swap(__m_, __u.__m_);
+        _CUDA_VSTD::swap(__owns_, __u.__owns_);
+    }
+    _LIBCUDACXX_INLINE_VISIBILITY
+    mutex_type* release() noexcept
+    {
+        mutex_type* __m = __m_;
+        __m_ = nullptr;
+        __owns_ = false;
+        return __m;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    bool owns_lock() const noexcept {return __owns_;}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    _LIBCUDACXX_EXPLICIT
+        operator bool () const noexcept {return __owns_;}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    mutex_type* mutex() const noexcept {return __m_;}
+};
+
+template <class _Mutex>
+void
+unique_lock<_Mutex>::lock()
+{
+    if (__m_ == nullptr)
+        __throw_system_error(EPERM, "unique_lock::lock: references null mutex");
+    if (__owns_)
+        __throw_system_error(EDEADLK, "unique_lock::lock: already locked");
+    __m_->lock();
+    __owns_ = true;
+}
+
+template <class _Mutex>
+bool
+unique_lock<_Mutex>::try_lock()
+{
+    if (__m_ == nullptr)
+        __throw_system_error(EPERM, "unique_lock::try_lock: references null mutex");
+    if (__owns_)
+        __throw_system_error(EDEADLK, "unique_lock::try_lock: already locked");
+    __owns_ = __m_->try_lock();
+    return __owns_;
+}
+
+template <class _Mutex>
+template <class _Rep, class _Period>
+bool
+unique_lock<_Mutex>::try_lock_for(const chrono::duration<_Rep, _Period>& __d)
+{
+    if (__m_ == nullptr)
+        __throw_system_error(EPERM, "unique_lock::try_lock_for: references null mutex");
+    if (__owns_)
+        __throw_system_error(EDEADLK, "unique_lock::try_lock_for: already locked");
+    __owns_ = __m_->try_lock_for(__d);
+    return __owns_;
+}
+
+template <class _Mutex>
+template <class _Clock, class _Duration>
+bool
+unique_lock<_Mutex>::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t)
+{
+    if (__m_ == nullptr)
+        __throw_system_error(EPERM, "unique_lock::try_lock_until: references null mutex");
+    if (__owns_)
+        __throw_system_error(EDEADLK, "unique_lock::try_lock_until: already locked");
+    __owns_ = __m_->try_lock_until(__t);
+    return __owns_;
+}
+
+template <class _Mutex>
+void
+unique_lock<_Mutex>::unlock()
+{
+    if (!__owns_)
+        __throw_system_error(EPERM, "unique_lock::unlock: not locked");
+    __m_->unlock();
+    __owns_ = false;
+}
+
+template <class _Mutex>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+void
+swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) noexcept
+    {__x.swap(__y);}
+
+//enum class cv_status
+_LIBCUDACXX_DECLARE_STRONG_ENUM(cv_status)
+{
+    no_timeout,
+    timeout
+};
+_LIBCUDACXX_DECLARE_STRONG_ENUM_EPILOG(cv_status)
+
+class _LIBCUDACXX_TYPE_VIS condition_variable
+{
+    __libcpp_condvar_t __cv_ = _LIBCUDACXX_CONDVAR_INITIALIZER;
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    constexpr condition_variable() noexcept = default;
+
+#ifdef _LIBCUDACXX_HAS_TRIVIAL_CONDVAR_DESTRUCTION
+    ~condition_variable() = default;
+#else
+    ~condition_variable();
+#endif
+
+    condition_variable(const condition_variable&) = delete;
+    condition_variable& operator=(const condition_variable&) = delete;
+
+    void notify_one() noexcept;
+    void notify_all() noexcept;
+
+    void wait(unique_lock<mutex>& __lk) noexcept;
+    template <class _Predicate>
+        _LIBCUDACXX_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+        void wait(unique_lock<mutex>& __lk, _Predicate __pred);
+
+    template <class _Clock, class _Duration>
+        _LIBCUDACXX_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+        cv_status
+        wait_until(unique_lock<mutex>& __lk,
+                   const chrono::time_point<_Clock, _Duration>& __t);
+
+    template <class _Clock, class _Duration, class _Predicate>
+        _LIBCUDACXX_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+        bool
+        wait_until(unique_lock<mutex>& __lk,
+                   const chrono::time_point<_Clock, _Duration>& __t,
+                   _Predicate __pred);
+
+    template <class _Rep, class _Period>
+        _LIBCUDACXX_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+        cv_status
+        wait_for(unique_lock<mutex>& __lk,
+                 const chrono::duration<_Rep, _Period>& __d);
+
+    template <class _Rep, class _Period, class _Predicate>
+        bool
+        _LIBCUDACXX_INLINE_VISIBILITY
+        wait_for(unique_lock<mutex>& __lk,
+                 const chrono::duration<_Rep, _Period>& __d,
+                 _Predicate __pred);
+
+    typedef __libcpp_condvar_t* native_handle_type;
+    _LIBCUDACXX_INLINE_VISIBILITY native_handle_type native_handle() {return &__cv_;}
+
+private:
+    void __do_timed_wait(unique_lock<mutex>& __lk,
+       chrono::time_point<chrono::system_clock, chrono::nanoseconds>) noexcept;
+#if defined(_LIBCUDACXX_HAS_COND_CLOCKWAIT)
+    void __do_timed_wait(unique_lock<mutex>& __lk,
+       chrono::time_point<chrono::steady_clock, chrono::nanoseconds>) noexcept;
+#endif
+    template <class _Clock>
+    void __do_timed_wait(unique_lock<mutex>& __lk,
+       chrono::time_point<_Clock, chrono::nanoseconds>) noexcept;
+};
+#endif // !_LIBCUDACXX_HAS_NO_THREADS
+
+template <class _Rep, class _Period>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+typename enable_if
+<
+    is_floating_point<_Rep>::value,
+    chrono::nanoseconds
+>::type
+__safe_nanosecond_cast(chrono::duration<_Rep, _Period> __d)
+{
+    using namespace chrono;
+    using __ratio = ratio_divide<_Period, nano>;
+    using __ns_rep = nanoseconds::rep;
+    _Rep __result_float = __d.count() * __ratio::num / __ratio::den;
+
+    _Rep __result_max = numeric_limits<__ns_rep>::max();
+    if (__result_float >= __result_max) {
+        return nanoseconds::max();
+    }
+
+    _Rep __result_min = numeric_limits<__ns_rep>::min();
+    if (__result_float <= __result_min) {
+        return nanoseconds::min();
+    }
+
+    return nanoseconds(static_cast<__ns_rep>(__result_float));
+}
+
+template <class _Rep, class _Period>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+typename enable_if
+<
+    !is_floating_point<_Rep>::value,
+    chrono::nanoseconds
+>::type
+__safe_nanosecond_cast(chrono::duration<_Rep, _Period> __d)
+{
+    using namespace chrono;
+    if (__d.count() == 0) {
+        return nanoseconds(0);
+    }
+
+    using __ratio = ratio_divide<_Period, nano>;
+    using __ns_rep = nanoseconds::rep;
+    __ns_rep __result_max = std::numeric_limits<__ns_rep>::max();
+    if (__d.count() > 0 && __d.count() > __result_max / __ratio::num) {
+        return nanoseconds::max();
+    }
+
+    __ns_rep __result_min = std::numeric_limits<__ns_rep>::min();
+    if (__d.count() < 0 && __d.count() < __result_min / __ratio::num) {
+        return nanoseconds::min();
+    }
+
+    __ns_rep __result = __d.count() * __ratio::num / __ratio::den;
+    if (__result == 0) {
+        return nanoseconds(1);
+    }
+
+    return nanoseconds(__result);
+}
+
+#ifndef _LIBCUDACXX_HAS_NO_THREADS
+template <class _Predicate>
+void
+condition_variable::wait(unique_lock<mutex>& __lk, _Predicate __pred)
+{
+    while (!__pred())
+        wait(__lk);
+}
+
+template <class _Clock, class _Duration>
+cv_status
+condition_variable::wait_until(unique_lock<mutex>& __lk,
+                               const chrono::time_point<_Clock, _Duration>& __t)
+{
+    using namespace chrono;
+    using __clock_tp_ns = time_point<_Clock, nanoseconds>;
+
+    typename _Clock::time_point __now = _Clock::now();
+    if (__t <= __now)
+        return cv_status::timeout;
+
+    __clock_tp_ns __t_ns = __clock_tp_ns(__safe_nanosecond_cast(__t.time_since_epoch()));
+
+    __do_timed_wait(__lk, __t_ns);
+    return _Clock::now() < __t ? cv_status::no_timeout : cv_status::timeout;
+}
+
+template <class _Clock, class _Duration, class _Predicate>
+bool
+condition_variable::wait_until(unique_lock<mutex>& __lk,
+                   const chrono::time_point<_Clock, _Duration>& __t,
+                   _Predicate __pred)
+{
+    while (!__pred())
+    {
+        if (wait_until(__lk, __t) == cv_status::timeout)
+            return __pred();
+    }
+    return true;
+}
+
+template <class _Rep, class _Period>
+cv_status
+condition_variable::wait_for(unique_lock<mutex>& __lk,
+                             const chrono::duration<_Rep, _Period>& __d)
+{
+    using namespace chrono;
+    if (__d <= __d.zero())
+        return cv_status::timeout;
+    using __ns_rep = nanoseconds::rep;
+    steady_clock::time_point __c_now = steady_clock::now();
+
+#if defined(_LIBCUDACXX_HAS_COND_CLOCKWAIT)
+    using __clock_tp_ns = time_point<steady_clock, nanoseconds>;
+    __ns_rep __now_count_ns = __safe_nanosecond_cast(__c_now.time_since_epoch()).count();
+#else
+    using __clock_tp_ns = time_point<system_clock, nanoseconds>;
+    __ns_rep __now_count_ns = __safe_nanosecond_cast(system_clock::now().time_since_epoch()).count();
+#endif
+
+    __ns_rep __d_ns_count = __safe_nanosecond_cast(__d).count();
+
+    if (__now_count_ns > numeric_limits<__ns_rep>::max() - __d_ns_count) {
+        __do_timed_wait(__lk, __clock_tp_ns::max());
+    } else {
+        __do_timed_wait(__lk, __clock_tp_ns(nanoseconds(__now_count_ns + __d_ns_count)));
+    }
+
+    return steady_clock::now() - __c_now < __d ? cv_status::no_timeout :
+                                                 cv_status::timeout;
+}
+
+template <class _Rep, class _Period, class _Predicate>
+inline
+bool
+condition_variable::wait_for(unique_lock<mutex>& __lk,
+                             const chrono::duration<_Rep, _Period>& __d,
+                             _Predicate __pred)
+{
+    return wait_until(__lk, chrono::steady_clock::now() + __d,
+                      _CUDA_VSTD::move(__pred));
+}
+
+#if defined(_LIBCUDACXX_HAS_COND_CLOCKWAIT)
+inline
+void
+condition_variable::__do_timed_wait(unique_lock<mutex>& __lk,
+     chrono::time_point<chrono::steady_clock, chrono::nanoseconds> __tp) noexcept
+{
+    using namespace chrono;
+    if (!__lk.owns_lock())
+        __throw_system_error(EPERM,
+                            "condition_variable::timed wait: mutex not locked");
+    nanoseconds __d = __tp.time_since_epoch();
+    timespec __ts;
+    seconds __s = duration_cast<seconds>(__d);
+    using __ts_sec = decltype(__ts.tv_sec);
+    const __ts_sec __ts_sec_max = numeric_limits<__ts_sec>::max();
+    if (__s.count() < __ts_sec_max)
+    {
+        __ts.tv_sec = static_cast<__ts_sec>(__s.count());
+        __ts.tv_nsec = (__d - __s).count();
+    }
+    else
+    {
+        __ts.tv_sec = __ts_sec_max;
+        __ts.tv_nsec = giga::num - 1;
+    }
+    int __ec = pthread_cond_clockwait(&__cv_, __lk.mutex()->native_handle(), CLOCK_MONOTONIC, &__ts);
+    if (__ec != 0 && __ec != ETIMEDOUT)
+        __throw_system_error(__ec, "condition_variable timed_wait failed");
+}
+#endif // _LIBCUDACXX_HAS_COND_CLOCKWAIT
+
+template <class _Clock>
+inline
+void
+condition_variable::__do_timed_wait(unique_lock<mutex>& __lk,
+     chrono::time_point<_Clock, chrono::nanoseconds> __tp) noexcept
+{
+    wait_for(__lk, __tp - _Clock::now());
+}
+
+#endif // !_LIBCUDACXX_HAS_NO_THREADS
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+_LIBCUDACXX_POP_MACROS
+
+#endif  // _LIBCUDACXX___MUTEX_BASE

cuda_toolkit/include/__node_handle

@@ -0,0 +1,213 @@
+// -*- 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___NODE_HANDLE
+#define _LIBCUDACXX___NODE_HANDLE
+
+#include <__config>
+#include "__assert" // all public C++ headers provide the assertion handler
+#include <memory>
+#include <optional>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _LIBCUDACXX_STD_VER > 14
+
+// Specialized in __tree & __hash_table for their _NodeType.
+template <class _NodeType, class _Alloc>
+struct __generic_container_node_destructor;
+
+template <class _NodeType, class _Alloc,
+          template <class, class> class _MapOrSetSpecifics>
+class _LIBCUDACXX_TEMPLATE_VIS __basic_node_handle
+    : public _MapOrSetSpecifics<
+          _NodeType,
+          __basic_node_handle<_NodeType, _Alloc, _MapOrSetSpecifics>>
+{
+    template <class _Tp, class _Compare, class _Allocator>
+        friend class __tree;
+    template <class _Tp, class _Hash, class _Equal, class _Allocator>
+        friend class __hash_table;
+    friend struct _MapOrSetSpecifics<
+        _NodeType, __basic_node_handle<_NodeType, _Alloc, _MapOrSetSpecifics>>;
+
+    typedef allocator_traits<_Alloc> __alloc_traits;
+    typedef typename __rebind_pointer<typename __alloc_traits::void_pointer,
+                                      _NodeType>::type
+        __node_pointer_type;
+
+public:
+    typedef _Alloc allocator_type;
+
+private:
+    __node_pointer_type __ptr_ = nullptr;
+    optional<allocator_type> __alloc_;
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void __release_ptr()
+    {
+        __ptr_ = nullptr;
+        __alloc_ = _CUDA_VSTD::nullopt;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void __destroy_node_pointer()
+    {
+        if (__ptr_ != nullptr)
+        {
+            typedef typename __allocator_traits_rebind<
+                allocator_type, _NodeType>::type __node_alloc_type;
+            __node_alloc_type __alloc(*__alloc_);
+            __generic_container_node_destructor<_NodeType, __node_alloc_type>(
+                __alloc, true)(__ptr_);
+            __ptr_ = nullptr;
+        }
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __basic_node_handle(__node_pointer_type __ptr,
+                        allocator_type const& __alloc)
+            : __ptr_(__ptr), __alloc_(__alloc)
+    {
+    }
+
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __basic_node_handle() = default;
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __basic_node_handle(__basic_node_handle&& __other) noexcept
+            : __ptr_(__other.__ptr_),
+              __alloc_(_CUDA_VSTD::move(__other.__alloc_))
+    {
+        __other.__ptr_ = nullptr;
+        __other.__alloc_ = _CUDA_VSTD::nullopt;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __basic_node_handle& operator=(__basic_node_handle&& __other)
+    {
+        _LIBCUDACXX_ASSERT(
+            __alloc_ == _CUDA_VSTD::nullopt ||
+            __alloc_traits::propagate_on_container_move_assignment::value ||
+            __alloc_ == __other.__alloc_,
+            "node_type with incompatible allocator passed to "
+            "node_type::operator=(node_type&&)");
+
+        __destroy_node_pointer();
+        __ptr_ = __other.__ptr_;
+
+        if (__alloc_traits::propagate_on_container_move_assignment::value ||
+            __alloc_ == _CUDA_VSTD::nullopt)
+            __alloc_ = _CUDA_VSTD::move(__other.__alloc_);
+
+        __other.__ptr_ = nullptr;
+        __other.__alloc_ = _CUDA_VSTD::nullopt;
+
+        return *this;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    allocator_type get_allocator() const { return *__alloc_; }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit operator bool() const { return __ptr_ != nullptr; }
+
+    _LIBCUDACXX_NODISCARD_AFTER_CXX17 _LIBCUDACXX_INLINE_VISIBILITY
+    bool empty() const { return __ptr_ == nullptr; }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void swap(__basic_node_handle& __other) noexcept(
+        __alloc_traits::propagate_on_container_swap::value ||
+        __alloc_traits::is_always_equal::value)
+    {
+        using _CUDA_VSTD::swap;
+        swap(__ptr_, __other.__ptr_);
+        if (__alloc_traits::propagate_on_container_swap::value ||
+            __alloc_ == _CUDA_VSTD::nullopt || __other.__alloc_ == _CUDA_VSTD::nullopt)
+            swap(__alloc_, __other.__alloc_);
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    friend void swap(__basic_node_handle& __a, __basic_node_handle& __b)
+        noexcept(noexcept(__a.swap(__b))) { __a.swap(__b); }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    ~__basic_node_handle()
+    {
+        __destroy_node_pointer();
+    }
+};
+
+template <class _NodeType, class _Derived>
+struct __set_node_handle_specifics
+{
+    typedef typename _NodeType::__node_value_type value_type;
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    value_type& value() const
+    {
+        return static_cast<_Derived const*>(this)->__ptr_->__value_;
+    }
+};
+
+template <class _NodeType, class _Derived>
+struct __map_node_handle_specifics
+{
+    typedef typename _NodeType::__node_value_type::key_type key_type;
+    typedef typename _NodeType::__node_value_type::mapped_type mapped_type;
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    key_type& key() const
+    {
+        return static_cast<_Derived const*>(this)->
+            __ptr_->__value_.__ref().first;
+    }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    mapped_type& mapped() const
+    {
+        return static_cast<_Derived const*>(this)->
+            __ptr_->__value_.__ref().second;
+    }
+};
+
+template <class _NodeType, class _Alloc>
+using __set_node_handle =
+    __basic_node_handle< _NodeType, _Alloc, __set_node_handle_specifics>;
+
+template <class _NodeType, class _Alloc>
+using __map_node_handle =
+    __basic_node_handle< _NodeType, _Alloc, __map_node_handle_specifics>;
+
+template <class _Iterator, class _NodeType>
+struct _LIBCUDACXX_TEMPLATE_VIS __insert_return_type
+{
+    _Iterator position;
+    bool inserted;
+    _NodeType node;
+};
+
+#endif // _LIBCUDACXX_STD_VER > 14
+
+_LIBCUDACXX_END_NAMESPACE_STD
+_LIBCUDACXX_POP_MACROS
+
+#endif

cuda_toolkit/include/__nullptr

@@ -0,0 +1,65 @@
+// -*- C++ -*-
+//===--------------------------- __nullptr --------------------------------===//
+//
+// 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_NULLPTR
+#define _LIBCUDACXX_NULLPTR
+
+#include <__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#ifdef _LIBCUDACXX_HAS_NO_NULLPTR
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+struct _LIBCUDACXX_TEMPLATE_VIS nullptr_t
+{
+    void* __lx;
+
+    struct __nat {int __for_bool_;};
+
+    _LIBCUDACXX_INLINE_VISIBILITY constexpr nullptr_t() : __lx(0) {}
+    _LIBCUDACXX_INLINE_VISIBILITY constexpr nullptr_t(int __nat::*) : __lx(0) {}
+
+    _LIBCUDACXX_INLINE_VISIBILITY constexpr operator int __nat::*() const {return 0;}
+
+    template <class _Tp>
+        _LIBCUDACXX_INLINE_VISIBILITY constexpr
+        operator _Tp* () const {return 0;}
+
+    template <class _Tp, class _Up>
+        _LIBCUDACXX_INLINE_VISIBILITY
+        operator _Tp _Up::* () const {return 0;}
+
+    friend _LIBCUDACXX_INLINE_VISIBILITY constexpr bool operator==(nullptr_t, nullptr_t) {return true;}
+    friend _LIBCUDACXX_INLINE_VISIBILITY constexpr bool operator!=(nullptr_t, nullptr_t) {return false;}
+};
+
+inline _LIBCUDACXX_INLINE_VISIBILITY constexpr nullptr_t __get_nullptr_t() {return nullptr_t(0);}
+
+#define nullptr _CUDA_VSTD::__get_nullptr_t()
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#else  // _LIBCUDACXX_HAS_NO_NULLPTR
+
+namespace std
+{
+    typedef decltype(nullptr) nullptr_t;
+}
+
+#endif  // _LIBCUDACXX_HAS_NO_NULLPTR
+
+#endif  // _LIBCUDACXX_NULLPTR

cuda_toolkit/include/__pragma_pop

@@ -0,0 +1,16 @@
+// -*- C++ -*-
+//===---------------------------- chrono ----------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_MSVC_WARNING)
+  #pragma warning(pop)
+#endif
+
+#if defined(_LIBCUDACXX_POP_MACROS)
+  _LIBCUDACXX_POP_MACROS
+#endif

cuda_toolkit/include/__pragma_push

@@ -0,0 +1,25 @@
+// -*- C++ -*-
+//===---------------------------- chrono ----------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifdef _LIBCUDACXX_IMPLICIT_SYSTEM_HEADER
+  #pragma GCC system_header
+#endif
+
+#if defined(_LIBCUDACXX_USE_PRAGMA_MSVC_WARNING)
+  #pragma warning(push)
+  #pragma warning(disable : _LIBCUDACXX_MSVC_DISABLED_WARNINGS)
+#endif
+
+#if defined(_LIBCUDACXX_PUSH_MACROS)
+  _LIBCUDACXX_PUSH_MACROS
+#endif
+
+#ifndef __cuda_std__
+#include <__undef_macros>
+#endif

cuda_toolkit/include/__split_buffer

@@ -0,0 +1,632 @@
+// -*- C++ -*-
+#ifndef _LIBCUDACXX_SPLIT_BUFFER
+#define _LIBCUDACXX_SPLIT_BUFFER
+
+#include <__config>
+#include <type_traits>
+#include <algorithm>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_PUSH_MACROS
+#include <__undef_macros>
+
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <bool>
+class __split_buffer_common
+{
+protected:
+    void __throw_length_error() const;
+    void __throw_out_of_range() const;
+};
+
+template <class _Tp, class _Allocator = allocator<_Tp> >
+struct __split_buffer
+    : private __split_buffer_common<true>
+{
+private:
+    __split_buffer(const __split_buffer&);
+    __split_buffer& operator=(const __split_buffer&);
+public:
+    typedef _Tp                                             value_type;
+    typedef _Allocator                                      allocator_type;
+    typedef __libcpp_remove_reference_t<allocator_type>     __alloc_rr;
+    typedef allocator_traits<__alloc_rr>                    __alloc_traits;
+    typedef value_type&                                     reference;
+    typedef const value_type&                               const_reference;
+    typedef typename __alloc_traits::size_type              size_type;
+    typedef typename __alloc_traits::difference_type        difference_type;
+    typedef typename __alloc_traits::pointer                pointer;
+    typedef typename __alloc_traits::const_pointer          const_pointer;
+    typedef pointer                                         iterator;
+    typedef const_pointer                                   const_iterator;
+
+    pointer                                         __first_;
+    pointer                                         __begin_;
+    pointer                                         __end_;
+    __compressed_pair<pointer, allocator_type> __end_cap_;
+
+    typedef __add_lvalue_reference_t<allocator_type> __alloc_ref;
+    typedef __add_lvalue_reference_t<allocator_type> __alloc_const_ref;
+
+    _LIBCUDACXX_INLINE_VISIBILITY __alloc_rr&           __alloc() noexcept         {return __end_cap_.second();}
+    _LIBCUDACXX_INLINE_VISIBILITY const __alloc_rr&     __alloc() const noexcept   {return __end_cap_.second();}
+    _LIBCUDACXX_INLINE_VISIBILITY pointer&              __end_cap() noexcept       {return __end_cap_.first();}
+    _LIBCUDACXX_INLINE_VISIBILITY const pointer&        __end_cap() const noexcept {return __end_cap_.first();}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __split_buffer()
+        noexcept(is_nothrow_default_constructible<allocator_type>::value);
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit __split_buffer(__alloc_rr& __a);
+    _LIBCUDACXX_INLINE_VISIBILITY
+    explicit __split_buffer(const __alloc_rr& __a);
+    __split_buffer(size_type __cap, size_type __start, __alloc_rr& __a);
+    ~__split_buffer();
+
+    __split_buffer(__split_buffer&& __c)
+        noexcept(is_nothrow_move_constructible<allocator_type>::value);
+    __split_buffer(__split_buffer&& __c, const __alloc_rr& __a);
+    __split_buffer& operator=(__split_buffer&& __c)
+        noexcept((__alloc_traits::propagate_on_container_move_assignment::value &&
+                is_nothrow_move_assignable<allocator_type>::value) ||
+               !__alloc_traits::propagate_on_container_move_assignment::value);
+
+    _LIBCUDACXX_INLINE_VISIBILITY       iterator begin() noexcept       {return __begin_;}
+    _LIBCUDACXX_INLINE_VISIBILITY const_iterator begin() const noexcept {return __begin_;}
+    _LIBCUDACXX_INLINE_VISIBILITY       iterator end() noexcept         {return __end_;}
+    _LIBCUDACXX_INLINE_VISIBILITY const_iterator end() const noexcept   {return __end_;}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void clear() noexcept
+        {__destruct_at_end(__begin_);}
+    _LIBCUDACXX_INLINE_VISIBILITY size_type size() const {return static_cast<size_type>(__end_ - __begin_);}
+    _LIBCUDACXX_INLINE_VISIBILITY bool empty()     const {return __end_ == __begin_;}
+    _LIBCUDACXX_INLINE_VISIBILITY size_type capacity() const {return static_cast<size_type>(__end_cap() - __first_);}
+    _LIBCUDACXX_INLINE_VISIBILITY size_type __front_spare() const {return static_cast<size_type>(__begin_ - __first_);}
+    _LIBCUDACXX_INLINE_VISIBILITY size_type __back_spare() const {return static_cast<size_type>(__end_cap() - __end_);}
+
+    _LIBCUDACXX_INLINE_VISIBILITY       reference front()       {return *__begin_;}
+    _LIBCUDACXX_INLINE_VISIBILITY const_reference front() const {return *__begin_;}
+    _LIBCUDACXX_INLINE_VISIBILITY       reference back()        {return *(__end_ - 1);}
+    _LIBCUDACXX_INLINE_VISIBILITY const_reference back() const  {return *(__end_ - 1);}
+
+    void reserve(size_type __n);
+    void shrink_to_fit() noexcept;
+    void push_front(const_reference __x);
+    _LIBCUDACXX_INLINE_VISIBILITY void push_back(const_reference __x);
+    void push_front(value_type&& __x);
+    void push_back(value_type&& __x);
+    template <class... _Args>
+        void emplace_back(_Args&&... __args);
+
+    _LIBCUDACXX_INLINE_VISIBILITY void pop_front() {__destruct_at_begin(__begin_+1);}
+    _LIBCUDACXX_INLINE_VISIBILITY void pop_back() {__destruct_at_end(__end_-1);}
+
+    void __construct_at_end(size_type __n);
+    void __construct_at_end(size_type __n, const_reference __x);
+    template <class _InputIter>
+        typename enable_if
+        <
+            __is_cpp17_input_iterator<_InputIter>::value &&
+           !__is_cpp17_forward_iterator<_InputIter>::value,
+            void
+        >::type
+        __construct_at_end(_InputIter __first, _InputIter __last);
+    template <class _ForwardIterator>
+        typename enable_if
+        <
+            __is_cpp17_forward_iterator<_ForwardIterator>::value,
+            void
+        >::type
+        __construct_at_end(_ForwardIterator __first, _ForwardIterator __last);
+
+    _LIBCUDACXX_INLINE_VISIBILITY void __destruct_at_begin(pointer __new_begin)
+        {__destruct_at_begin(__new_begin, is_trivially_destructible<value_type>());}
+        _LIBCUDACXX_INLINE_VISIBILITY
+        void __destruct_at_begin(pointer __new_begin, false_type);
+        _LIBCUDACXX_INLINE_VISIBILITY
+        void __destruct_at_begin(pointer __new_begin, true_type);
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void __destruct_at_end(pointer __new_last) noexcept
+        {__destruct_at_end(__new_last, false_type());}
+    _LIBCUDACXX_INLINE_VISIBILITY
+        void __destruct_at_end(pointer __new_last, false_type) noexcept;
+    _LIBCUDACXX_INLINE_VISIBILITY
+        void __destruct_at_end(pointer __new_last, true_type) noexcept;
+
+    void swap(__split_buffer& __x)
+        noexcept(!__alloc_traits::propagate_on_container_swap::value||
+                   __is_nothrow_swappable<__alloc_rr>::value);
+
+    bool __invariants() const;
+
+private:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void __move_assign_alloc(__split_buffer& __c, true_type)
+        noexcept(is_nothrow_move_assignable<allocator_type>::value)
+        {
+            __alloc() = _CUDA_VSTD::move(__c.__alloc());
+        }
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void __move_assign_alloc(__split_buffer&, false_type) noexcept
+        {}
+
+    struct _ConstructTransaction {
+      explicit _ConstructTransaction(pointer* __p, size_type __n) noexcept
+      : __pos_(*__p), __end_(*__p + __n), __dest_(__p) {
+      }
+      ~_ConstructTransaction() {
+        *__dest_ = __pos_;
+      }
+      pointer __pos_;
+     const pointer __end_;
+    private:
+     pointer *__dest_;
+    };
+};
+
+template <class _Tp, class _Allocator>
+bool
+__split_buffer<_Tp, _Allocator>::__invariants() const
+{
+    if (__first_ == nullptr)
+    {
+        if (__begin_ != nullptr)
+            return false;
+        if (__end_ != nullptr)
+            return false;
+        if (__end_cap() != nullptr)
+            return false;
+    }
+    else
+    {
+        if (__begin_ < __first_)
+            return false;
+        if (__end_ < __begin_)
+            return false;
+        if (__end_cap() < __end_)
+            return false;
+    }
+    return true;
+}
+
+//  Default constructs __n objects starting at __end_
+//  throws if construction throws
+//  Precondition:  __n > 0
+//  Precondition:  size() + __n <= capacity()
+//  Postcondition:  size() == size() + __n
+template <class _Tp, class _Allocator>
+void
+__split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n)
+{
+    _ConstructTransaction __tx(&this->__end_, __n);
+    for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {
+        __alloc_traits::construct(this->__alloc(), _CUDA_VSTD::__to_raw_pointer(__tx.__pos_));
+    }
+}
+
+//  Copy constructs __n objects starting at __end_ from __x
+//  throws if construction throws
+//  Precondition:  __n > 0
+//  Precondition:  size() + __n <= capacity()
+//  Postcondition:  size() == old size() + __n
+//  Postcondition:  [i] == __x for all i in [size() - __n, __n)
+template <class _Tp, class _Allocator>
+void
+__split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x)
+{
+    _ConstructTransaction __tx(&this->__end_, __n);
+    for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {
+        __alloc_traits::construct(this->__alloc(),
+            _CUDA_VSTD::__to_raw_pointer(__tx.__pos_), __x);
+    }
+}
+
+template <class _Tp, class _Allocator>
+template <class _InputIter>
+typename enable_if
+<
+     __is_cpp17_input_iterator<_InputIter>::value &&
+    !__is_cpp17_forward_iterator<_InputIter>::value,
+    void
+>::type
+__split_buffer<_Tp, _Allocator>::__construct_at_end(_InputIter __first, _InputIter __last)
+{
+    __alloc_rr& __a = this->__alloc();
+    for (; __first != __last; ++__first)
+    {
+        if (__end_ == __end_cap())
+        {
+            size_type __old_cap = __end_cap() - __first_;
+            size_type __new_cap = _CUDA_VSTD::max<size_type>(2 * __old_cap, 8);
+            __split_buffer __buf(__new_cap, 0, __a);
+            for (pointer __p = __begin_; __p != __end_; ++__p, (void)++__buf.__end_)
+                __alloc_traits::construct(__buf.__alloc(),
+                        _CUDA_VSTD::__to_raw_pointer(__buf.__end_), _CUDA_VSTD::move(*__p));
+            swap(__buf);
+        }
+        __alloc_traits::construct(__a, _CUDA_VSTD::__to_raw_pointer(this->__end_), *__first);
+        ++this->__end_;
+    }
+}
+
+template <class _Tp, class _Allocator>
+template <class _ForwardIterator>
+typename enable_if
+<
+    __is_cpp17_forward_iterator<_ForwardIterator>::value,
+    void
+>::type
+__split_buffer<_Tp, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last)
+{
+    _ConstructTransaction __tx(&this->__end_, std::distance(__first, __last));
+    for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_, (void)++__first) {
+        __alloc_traits::construct(this->__alloc(),
+            _CUDA_VSTD::__to_raw_pointer(__tx.__pos_), *__first);
+    }
+}
+
+template <class _Tp, class _Allocator>
+inline
+void
+__split_buffer<_Tp, _Allocator>::__destruct_at_begin(pointer __new_begin, false_type)
+{
+    while (__begin_ != __new_begin)
+        __alloc_traits::destroy(__alloc(), __to_raw_pointer(__begin_++));
+}
+
+template <class _Tp, class _Allocator>
+inline
+void
+__split_buffer<_Tp, _Allocator>::__destruct_at_begin(pointer __new_begin, true_type)
+{
+    __begin_ = __new_begin;
+}
+
+template <class _Tp, class _Allocator>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+void
+__split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, false_type) noexcept
+{
+    while (__new_last != __end_)
+        __alloc_traits::destroy(__alloc(), __to_raw_pointer(--__end_));
+}
+
+template <class _Tp, class _Allocator>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+void
+__split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, true_type) noexcept
+{
+    __end_ = __new_last;
+}
+
+template <class _Tp, class _Allocator>
+__split_buffer<_Tp, _Allocator>::__split_buffer(size_type __cap, size_type __start, __alloc_rr& __a)
+    : __end_cap_(nullptr, __a)
+{
+    __first_ = __cap != 0 ? __alloc_traits::allocate(__alloc(), __cap) : nullptr;
+    __begin_ = __end_ = __first_ + __start;
+    __end_cap() = __first_ + __cap;
+}
+
+template <class _Tp, class _Allocator>
+inline
+__split_buffer<_Tp, _Allocator>::__split_buffer()
+    noexcept(is_nothrow_default_constructible<allocator_type>::value)
+    : __first_(nullptr), __begin_(nullptr), __end_(nullptr), __end_cap_(nullptr)
+{
+}
+
+template <class _Tp, class _Allocator>
+inline
+__split_buffer<_Tp, _Allocator>::__split_buffer(__alloc_rr& __a)
+    : __first_(nullptr), __begin_(nullptr), __end_(nullptr), __end_cap_(nullptr, __a)
+{
+}
+
+template <class _Tp, class _Allocator>
+inline
+__split_buffer<_Tp, _Allocator>::__split_buffer(const __alloc_rr& __a)
+    : __first_(nullptr), __begin_(nullptr), __end_(nullptr), __end_cap_(nullptr, __a)
+{
+}
+
+template <class _Tp, class _Allocator>
+__split_buffer<_Tp, _Allocator>::~__split_buffer()
+{
+    clear();
+    if (__first_)
+        __alloc_traits::deallocate(__alloc(), __first_, capacity());
+}
+
+template <class _Tp, class _Allocator>
+__split_buffer<_Tp, _Allocator>::__split_buffer(__split_buffer&& __c)
+    noexcept(is_nothrow_move_constructible<allocator_type>::value)
+    : __first_(_CUDA_VSTD::move(__c.__first_)),
+      __begin_(_CUDA_VSTD::move(__c.__begin_)),
+      __end_(_CUDA_VSTD::move(__c.__end_)),
+      __end_cap_(_CUDA_VSTD::move(__c.__end_cap_))
+{
+    __c.__first_ = nullptr;
+    __c.__begin_ = nullptr;
+    __c.__end_ = nullptr;
+    __c.__end_cap() = nullptr;
+}
+
+template <class _Tp, class _Allocator>
+__split_buffer<_Tp, _Allocator>::__split_buffer(__split_buffer&& __c, const __alloc_rr& __a)
+    : __end_cap_(__second_tag(), __a)
+{
+    if (__a == __c.__alloc())
+    {
+        __first_ = __c.__first_;
+        __begin_ = __c.__begin_;
+        __end_ = __c.__end_;
+        __end_cap() = __c.__end_cap();
+        __c.__first_ = nullptr;
+        __c.__begin_ = nullptr;
+        __c.__end_ = nullptr;
+        __c.__end_cap() = nullptr;
+    }
+    else
+    {
+        size_type __cap = __c.size();
+        __first_ = __alloc_traits::allocate(__alloc(), __cap);
+        __begin_ = __end_ = __first_;
+        __end_cap() = __first_ + __cap;
+        typedef move_iterator<iterator> _Ip;
+        __construct_at_end(_Ip(__c.begin()), _Ip(__c.end()));
+    }
+}
+
+template <class _Tp, class _Allocator>
+__split_buffer<_Tp, _Allocator>&
+__split_buffer<_Tp, _Allocator>::operator=(__split_buffer&& __c)
+    noexcept((__alloc_traits::propagate_on_container_move_assignment::value &&
+                is_nothrow_move_assignable<allocator_type>::value) ||
+               !__alloc_traits::propagate_on_container_move_assignment::value)
+{
+    clear();
+    shrink_to_fit();
+    __first_ = __c.__first_;
+    __begin_ = __c.__begin_;
+    __end_ = __c.__end_;
+    __end_cap() = __c.__end_cap();
+    __move_assign_alloc(__c,
+        integral_constant<bool,
+                          __alloc_traits::propagate_on_container_move_assignment::value>());
+    __c.__first_ = __c.__begin_ = __c.__end_ = __c.__end_cap() = nullptr;
+    return *this;
+}
+
+template <class _Tp, class _Allocator>
+void
+__split_buffer<_Tp, _Allocator>::swap(__split_buffer& __x)
+        noexcept(!__alloc_traits::propagate_on_container_swap::value||
+                   __is_nothrow_swappable<__alloc_rr>::value)
+{
+    _CUDA_VSTD::swap(__first_, __x.__first_);
+    _CUDA_VSTD::swap(__begin_, __x.__begin_);
+    _CUDA_VSTD::swap(__end_, __x.__end_);
+    _CUDA_VSTD::swap(__end_cap(), __x.__end_cap());
+    __swap_allocator(__alloc(), __x.__alloc());
+}
+
+template <class _Tp, class _Allocator>
+void
+__split_buffer<_Tp, _Allocator>::reserve(size_type __n)
+{
+    if (__n < capacity())
+    {
+        __split_buffer<value_type, __alloc_rr&> __t(__n, 0, __alloc());
+        __t.__construct_at_end(move_iterator<pointer>(__begin_),
+                               move_iterator<pointer>(__end_));
+        _CUDA_VSTD::swap(__first_, __t.__first_);
+        _CUDA_VSTD::swap(__begin_, __t.__begin_);
+        _CUDA_VSTD::swap(__end_, __t.__end_);
+        _CUDA_VSTD::swap(__end_cap(), __t.__end_cap());
+    }
+}
+
+template <class _Tp, class _Allocator>
+void
+__split_buffer<_Tp, _Allocator>::shrink_to_fit() noexcept
+{
+    if (capacity() > size())
+    {
+#ifndef _LIBCUDACXX_NO_EXCEPTIONS
+        try
+        {
+#endif  // _LIBCUDACXX_NO_EXCEPTIONS
+            __split_buffer<value_type, __alloc_rr&> __t(size(), 0, __alloc());
+            __t.__construct_at_end(move_iterator<pointer>(__begin_),
+                                   move_iterator<pointer>(__end_));
+            __t.__end_ = __t.__begin_ + (__end_ - __begin_);
+            _CUDA_VSTD::swap(__first_, __t.__first_);
+            _CUDA_VSTD::swap(__begin_, __t.__begin_);
+            _CUDA_VSTD::swap(__end_, __t.__end_);
+            _CUDA_VSTD::swap(__end_cap(), __t.__end_cap());
+#ifndef _LIBCUDACXX_NO_EXCEPTIONS
+        }
+        catch (...)
+        {
+        }
+#endif  // _LIBCUDACXX_NO_EXCEPTIONS
+    }
+}
+
+template <class _Tp, class _Allocator>
+void
+__split_buffer<_Tp, _Allocator>::push_front(const_reference __x)
+{
+    if (__begin_ == __first_)
+    {
+        if (__end_ < __end_cap())
+        {
+            difference_type __d = __end_cap() - __end_;
+            __d = (__d + 1) / 2;
+            __begin_ = _CUDA_VSTD::move_backward(__begin_, __end_, __end_ + __d);
+            __end_ += __d;
+        }
+        else
+        {
+            size_type __c = max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
+            __split_buffer<value_type, __alloc_rr&> __t(__c, (__c + 3) / 4, __alloc());
+            __t.__construct_at_end(move_iterator<pointer>(__begin_),
+                                   move_iterator<pointer>(__end_));
+            _CUDA_VSTD::swap(__first_, __t.__first_);
+            _CUDA_VSTD::swap(__begin_, __t.__begin_);
+            _CUDA_VSTD::swap(__end_, __t.__end_);
+            _CUDA_VSTD::swap(__end_cap(), __t.__end_cap());
+        }
+    }
+    __alloc_traits::construct(__alloc(), _CUDA_VSTD::__to_raw_pointer(__begin_-1), __x);
+    --__begin_;
+}
+
+template <class _Tp, class _Allocator>
+void
+__split_buffer<_Tp, _Allocator>::push_front(value_type&& __x)
+{
+    if (__begin_ == __first_)
+    {
+        if (__end_ < __end_cap())
+        {
+            difference_type __d = __end_cap() - __end_;
+            __d = (__d + 1) / 2;
+            __begin_ = _CUDA_VSTD::move_backward(__begin_, __end_, __end_ + __d);
+            __end_ += __d;
+        }
+        else
+        {
+            size_type __c = max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
+            __split_buffer<value_type, __alloc_rr&> __t(__c, (__c + 3) / 4, __alloc());
+            __t.__construct_at_end(move_iterator<pointer>(__begin_),
+                                   move_iterator<pointer>(__end_));
+            _CUDA_VSTD::swap(__first_, __t.__first_);
+            _CUDA_VSTD::swap(__begin_, __t.__begin_);
+            _CUDA_VSTD::swap(__end_, __t.__end_);
+            _CUDA_VSTD::swap(__end_cap(), __t.__end_cap());
+        }
+    }
+    __alloc_traits::construct(__alloc(), _CUDA_VSTD::__to_raw_pointer(__begin_-1),
+            _CUDA_VSTD::move(__x));
+    --__begin_;
+}
+
+template <class _Tp, class _Allocator>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+void
+__split_buffer<_Tp, _Allocator>::push_back(const_reference __x)
+{
+    if (__end_ == __end_cap())
+    {
+        if (__begin_ > __first_)
+        {
+            difference_type __d = __begin_ - __first_;
+            __d = (__d + 1) / 2;
+            __end_ = _CUDA_VSTD::move(__begin_, __end_, __begin_ - __d);
+            __begin_ -= __d;
+        }
+        else
+        {
+            size_type __c = max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
+            __split_buffer<value_type, __alloc_rr&> __t(__c, __c / 4, __alloc());
+            __t.__construct_at_end(move_iterator<pointer>(__begin_),
+                                   move_iterator<pointer>(__end_));
+            _CUDA_VSTD::swap(__first_, __t.__first_);
+            _CUDA_VSTD::swap(__begin_, __t.__begin_);
+            _CUDA_VSTD::swap(__end_, __t.__end_);
+            _CUDA_VSTD::swap(__end_cap(), __t.__end_cap());
+        }
+    }
+    __alloc_traits::construct(__alloc(), _CUDA_VSTD::__to_raw_pointer(__end_), __x);
+    ++__end_;
+}
+
+template <class _Tp, class _Allocator>
+void
+__split_buffer<_Tp, _Allocator>::push_back(value_type&& __x)
+{
+    if (__end_ == __end_cap())
+    {
+        if (__begin_ > __first_)
+        {
+            difference_type __d = __begin_ - __first_;
+            __d = (__d + 1) / 2;
+            __end_ = _CUDA_VSTD::move(__begin_, __end_, __begin_ - __d);
+            __begin_ -= __d;
+        }
+        else
+        {
+            size_type __c = max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
+            __split_buffer<value_type, __alloc_rr&> __t(__c, __c / 4, __alloc());
+            __t.__construct_at_end(move_iterator<pointer>(__begin_),
+                                   move_iterator<pointer>(__end_));
+            _CUDA_VSTD::swap(__first_, __t.__first_);
+            _CUDA_VSTD::swap(__begin_, __t.__begin_);
+            _CUDA_VSTD::swap(__end_, __t.__end_);
+            _CUDA_VSTD::swap(__end_cap(), __t.__end_cap());
+        }
+    }
+    __alloc_traits::construct(__alloc(), _CUDA_VSTD::__to_raw_pointer(__end_),
+            _CUDA_VSTD::move(__x));
+    ++__end_;
+}
+
+template <class _Tp, class _Allocator>
+template <class... _Args>
+void
+__split_buffer<_Tp, _Allocator>::emplace_back(_Args&&... __args)
+{
+    if (__end_ == __end_cap())
+    {
+        if (__begin_ > __first_)
+        {
+            difference_type __d = __begin_ - __first_;
+            __d = (__d + 1) / 2;
+            __end_ = _CUDA_VSTD::move(__begin_, __end_, __begin_ - __d);
+            __begin_ -= __d;
+        }
+        else
+        {
+            size_type __c = max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
+            __split_buffer<value_type, __alloc_rr&> __t(__c, __c / 4, __alloc());
+            __t.__construct_at_end(move_iterator<pointer>(__begin_),
+                                   move_iterator<pointer>(__end_));
+            _CUDA_VSTD::swap(__first_, __t.__first_);
+            _CUDA_VSTD::swap(__begin_, __t.__begin_);
+            _CUDA_VSTD::swap(__end_, __t.__end_);
+            _CUDA_VSTD::swap(__end_cap(), __t.__end_cap());
+        }
+    }
+    __alloc_traits::construct(__alloc(), _CUDA_VSTD::__to_raw_pointer(__end_),
+                              _CUDA_VSTD::forward<_Args>(__args)...);
+    ++__end_;
+}
+
+template <class _Tp, class _Allocator>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+void
+swap(__split_buffer<_Tp, _Allocator>& __x, __split_buffer<_Tp, _Allocator>& __y)
+        noexcept(noexcept(__x.swap(__y)))
+{
+    __x.swap(__y);
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+_LIBCUDACXX_POP_MACROS
+
+#endif  // _LIBCUDACXX_SPLIT_BUFFER

cuda_toolkit/include/__sso_allocator

@@ -0,0 +1,80 @@
+// -*- 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___SSO_ALLOCATOR
+#define _LIBCUDACXX___SSO_ALLOCATOR
+
+#include <__config>
+#include <type_traits>
+#include <new>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp, size_t _Np> class _LIBCUDACXX_HIDDEN __sso_allocator;
+
+template <size_t _Np>
+class _LIBCUDACXX_HIDDEN __sso_allocator<void, _Np>
+{
+public:
+    typedef const void*       const_pointer;
+    typedef void              value_type;
+};
+
+template <class _Tp, size_t _Np>
+class _LIBCUDACXX_HIDDEN __sso_allocator
+{
+    typename aligned_storage<sizeof(_Tp) * _Np>::type buf_;
+    bool __allocated_;
+public:
+    typedef size_t            size_type;
+    typedef _Tp*              pointer;
+    typedef _Tp               value_type;
+
+    _LIBCUDACXX_INLINE_VISIBILITY __sso_allocator() throw() : __allocated_(false) {}
+    _LIBCUDACXX_INLINE_VISIBILITY __sso_allocator(const __sso_allocator&) throw() : __allocated_(false) {}
+    template <class _Up> _LIBCUDACXX_INLINE_VISIBILITY __sso_allocator(const __sso_allocator<_Up, _Np>&) throw()
+         : __allocated_(false) {}
+private:
+    __sso_allocator& operator=(const __sso_allocator&);
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY pointer allocate(size_type __n, typename __sso_allocator<void, _Np>::const_pointer = 0)
+    {
+        if (!__allocated_ && __n <= _Np)
+        {
+            __allocated_ = true;
+            return (pointer)&buf_;
+        }
+        return static_cast<pointer>(_CUDA_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCUDACXX_ALIGNOF(_Tp)));
+    }
+    _LIBCUDACXX_INLINE_VISIBILITY void deallocate(pointer __p, size_type __n)
+    {
+        if (__p == (pointer)&buf_)
+            __allocated_ = false;
+        else
+            _CUDA_VSTD::__libcpp_deallocate(__p, __n * sizeof(_Tp), _LIBCUDACXX_ALIGNOF(_Tp));
+    }
+    _LIBCUDACXX_INLINE_VISIBILITY size_type max_size() const throw() {return size_type(~0) / sizeof(_Tp);}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    bool operator==(__sso_allocator& __a) const {return &buf_ == &__a.buf_;}
+    _LIBCUDACXX_INLINE_VISIBILITY
+    bool operator!=(__sso_allocator& __a) const {return &buf_ != &__a.buf_;}
+};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif  // _LIBCUDACXX___SSO_ALLOCATOR

cuda_toolkit/include/__std_stream

@@ -0,0 +1,365 @@
+// -*- 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___STD_STREAM
+#define _LIBCUDACXX___STD_STREAM
+
+#include <__config>
+#include <ostream>
+#include <istream>
+#include <__locale>
+#include <cstdio>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_PUSH_MACROS
+#include <__undef_macros>
+
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+static const int __limit = 8;
+
+// __stdinbuf
+
+template <class _CharT>
+class _LIBCUDACXX_HIDDEN __stdinbuf
+    : public basic_streambuf<_CharT, char_traits<_CharT> >
+{
+public:
+    typedef _CharT                           char_type;
+    typedef char_traits<char_type>           traits_type;
+    typedef typename traits_type::int_type   int_type;
+    typedef typename traits_type::pos_type   pos_type;
+    typedef typename traits_type::off_type   off_type;
+    typedef typename traits_type::state_type state_type;
+
+    __stdinbuf(FILE* __fp, state_type* __st);
+
+protected:
+    virtual int_type underflow();
+    virtual int_type uflow();
+    virtual int_type pbackfail(int_type __c = traits_type::eof());
+    virtual void imbue(const locale& __loc);
+
+private:
+
+    FILE* __file_;
+    const codecvt<char_type, char, state_type>* __cv_;
+    state_type* __st_;
+    int __encoding_;
+    int_type __last_consumed_;
+    bool __last_consumed_is_next_;
+    bool __always_noconv_;
+
+    __stdinbuf(const __stdinbuf&);
+    __stdinbuf& operator=(const __stdinbuf&);
+
+    int_type __getchar(bool __consume);
+};
+
+template <class _CharT>
+__stdinbuf<_CharT>::__stdinbuf(FILE* __fp, state_type* __st)
+    : __file_(__fp),
+      __st_(__st),
+      __last_consumed_(traits_type::eof()),
+      __last_consumed_is_next_(false)
+{
+    imbue(this->getloc());
+}
+
+template <class _CharT>
+void
+__stdinbuf<_CharT>::imbue(const locale& __loc)
+{
+    __cv_ = &use_facet<codecvt<char_type, char, state_type> >(__loc);
+    __encoding_ = __cv_->encoding();
+    __always_noconv_ = __cv_->always_noconv();
+    if (__encoding_ > __limit)
+        __throw_runtime_error("unsupported locale for standard input");
+}
+
+template <class _CharT>
+typename __stdinbuf<_CharT>::int_type
+__stdinbuf<_CharT>::underflow()
+{
+    return __getchar(false);
+}
+
+template <class _CharT>
+typename __stdinbuf<_CharT>::int_type
+__stdinbuf<_CharT>::uflow()
+{
+    return __getchar(true);
+}
+
+template <class _CharT>
+typename __stdinbuf<_CharT>::int_type
+__stdinbuf<_CharT>::__getchar(bool __consume)
+{
+    if (__last_consumed_is_next_)
+    {
+        int_type __result = __last_consumed_;
+        if (__consume)
+        {
+            __last_consumed_ = traits_type::eof();
+            __last_consumed_is_next_ = false;
+        }
+        return __result;
+    }
+    char __extbuf[__limit];
+    int __nread = _CUDA_VSTD::max(1, __encoding_);
+    for (int __i = 0; __i < __nread; ++__i)
+    {
+        int __c = getc(__file_);
+        if (__c == EOF)
+            return traits_type::eof();
+        __extbuf[__i] = static_cast<char>(__c);
+    }
+    char_type __1buf;
+    if (__always_noconv_)
+        __1buf = static_cast<char_type>(__extbuf[0]);
+    else
+    {
+        const char* __enxt;
+        char_type* __inxt;
+        codecvt_base::result __r;
+        do
+        {
+            state_type __sv_st = *__st_;
+            __r = __cv_->in(*__st_, __extbuf, __extbuf + __nread, __enxt,
+                                   &__1buf, &__1buf + 1, __inxt);
+            switch (__r)
+            {
+            case _CUDA_VSTD::codecvt_base::ok:
+                break;
+            case codecvt_base::partial:
+                *__st_ = __sv_st;
+                if (__nread == sizeof(__extbuf))
+                    return traits_type::eof();
+                {
+                    int __c = getc(__file_);
+                    if (__c == EOF)
+                        return traits_type::eof();
+                    __extbuf[__nread] = static_cast<char>(__c);
+                }
+                ++__nread;
+                break;
+            case codecvt_base::error:
+                return traits_type::eof();
+            case _CUDA_VSTD::codecvt_base::noconv:
+                __1buf = static_cast<char_type>(__extbuf[0]);
+                break;
+            }
+        } while (__r == _CUDA_VSTD::codecvt_base::partial);
+    }
+    if (!__consume)
+    {
+        for (int __i = __nread; __i > 0;)
+        {
+            if (ungetc(traits_type::to_int_type(__extbuf[--__i]), __file_) == EOF)
+                return traits_type::eof();
+        }
+    }
+    else
+        __last_consumed_ = traits_type::to_int_type(__1buf);
+    return traits_type::to_int_type(__1buf);
+}
+
+template <class _CharT>
+typename __stdinbuf<_CharT>::int_type
+__stdinbuf<_CharT>::pbackfail(int_type __c)
+{
+    if (traits_type::eq_int_type(__c, traits_type::eof()))
+    {
+        if (!__last_consumed_is_next_)
+        {
+            __c = __last_consumed_;
+            __last_consumed_is_next_ = !traits_type::eq_int_type(__last_consumed_,
+                                                                 traits_type::eof());
+        }
+        return __c;
+    }
+    if (__last_consumed_is_next_)
+    {
+        char __extbuf[__limit];
+        char* __enxt;
+        const char_type __ci = traits_type::to_char_type(__last_consumed_);
+        const char_type* __inxt;
+        switch (__cv_->out(*__st_, &__ci, &__ci + 1, __inxt,
+                                  __extbuf, __extbuf + sizeof(__extbuf), __enxt))
+        {
+        case _CUDA_VSTD::codecvt_base::ok:
+            break;
+        case _CUDA_VSTD::codecvt_base::noconv:
+            __extbuf[0] = static_cast<char>(__last_consumed_);
+            __enxt = __extbuf + 1;
+            break;
+        case codecvt_base::partial:
+        case codecvt_base::error:
+            return traits_type::eof();
+        }
+        while (__enxt > __extbuf)
+            if (ungetc(*--__enxt, __file_) == EOF)
+                return traits_type::eof();
+    }
+    __last_consumed_ = __c;
+    __last_consumed_is_next_ = true;
+    return __c;
+}
+
+// __stdoutbuf
+
+template <class _CharT>
+class _LIBCUDACXX_HIDDEN __stdoutbuf
+    : public basic_streambuf<_CharT, char_traits<_CharT> >
+{
+public:
+    typedef _CharT                           char_type;
+    typedef char_traits<char_type>           traits_type;
+    typedef typename traits_type::int_type   int_type;
+    typedef typename traits_type::pos_type   pos_type;
+    typedef typename traits_type::off_type   off_type;
+    typedef typename traits_type::state_type state_type;
+
+    __stdoutbuf(FILE* __fp, state_type* __st);
+
+protected:
+    virtual int_type overflow (int_type __c = traits_type::eof());
+    virtual streamsize xsputn(const char_type* __s, streamsize __n);
+    virtual int sync();
+    virtual void imbue(const locale& __loc);
+
+private:
+    FILE* __file_;
+    const codecvt<char_type, char, state_type>* __cv_;
+    state_type* __st_;
+    bool __always_noconv_;
+
+    __stdoutbuf(const __stdoutbuf&);
+    __stdoutbuf& operator=(const __stdoutbuf&);
+};
+
+template <class _CharT>
+__stdoutbuf<_CharT>::__stdoutbuf(FILE* __fp, state_type* __st)
+    : __file_(__fp),
+      __cv_(&use_facet<codecvt<char_type, char, state_type> >(this->getloc())),
+      __st_(__st),
+      __always_noconv_(__cv_->always_noconv())
+{
+}
+
+template <class _CharT>
+typename __stdoutbuf<_CharT>::int_type
+__stdoutbuf<_CharT>::overflow(int_type __c)
+{
+    char __extbuf[__limit];
+    char_type __1buf;
+    if (!traits_type::eq_int_type(__c, traits_type::eof()))
+    {
+        __1buf = traits_type::to_char_type(__c);
+        if (__always_noconv_)
+        {
+            if (fwrite(&__1buf, sizeof(char_type), 1, __file_) != 1)
+                return traits_type::eof();
+        }
+        else
+        {
+            char* __extbe = __extbuf;
+            codecvt_base::result __r;
+            char_type* pbase = &__1buf;
+            char_type* pptr = pbase + 1;
+            do
+            {
+                const char_type* __e;
+                __r = __cv_->out(*__st_, pbase, pptr, __e,
+                                        __extbuf,
+                                        __extbuf + sizeof(__extbuf),
+                                        __extbe);
+                if (__e == pbase)
+                    return traits_type::eof();
+                if (__r == codecvt_base::noconv)
+                {
+                    if (fwrite(pbase, 1, 1, __file_) != 1)
+                        return traits_type::eof();
+                }
+                else if (__r == codecvt_base::ok || __r == codecvt_base::partial)
+                {
+                    size_t __nmemb = static_cast<size_t>(__extbe - __extbuf);
+                    if (fwrite(__extbuf, 1, __nmemb, __file_) != __nmemb)
+                        return traits_type::eof();
+                    if (__r == codecvt_base::partial)
+                    {
+                        pbase = const_cast<char_type*>(__e);
+                    }
+                }
+                else
+                    return traits_type::eof();
+            } while (__r == codecvt_base::partial);
+        }
+    }
+    return traits_type::not_eof(__c);
+}
+
+template <class _CharT>
+streamsize
+__stdoutbuf<_CharT>::xsputn(const char_type* __s, streamsize __n)
+{
+    if (__always_noconv_)
+        return fwrite(__s, sizeof(char_type), __n, __file_);
+    streamsize __i = 0;
+    for (; __i < __n; ++__i, ++__s)
+        if (overflow(traits_type::to_int_type(*__s)) == traits_type::eof())
+            break;
+    return __i;
+}
+
+template <class _CharT>
+int
+__stdoutbuf<_CharT>::sync()
+{
+    char __extbuf[__limit];
+    codecvt_base::result __r;
+    do
+    {
+        char* __extbe;
+        __r = __cv_->unshift(*__st_, __extbuf,
+                                    __extbuf + sizeof(__extbuf),
+                                    __extbe);
+        size_t __nmemb = static_cast<size_t>(__extbe - __extbuf);
+        if (fwrite(__extbuf, 1, __nmemb, __file_) != __nmemb)
+            return -1;
+    } while (__r == codecvt_base::partial);
+    if (__r == codecvt_base::error)
+        return -1;
+    if (fflush(__file_))
+        return -1;
+    return 0;
+}
+
+template <class _CharT>
+void
+__stdoutbuf<_CharT>::imbue(const locale& __loc)
+{
+    sync();
+    __cv_ = &use_facet<codecvt<char_type, char, state_type> >(__loc);
+    __always_noconv_ = __cv_->always_noconv();
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+_LIBCUDACXX_POP_MACROS
+
+#endif  // _LIBCUDACXX___STD_STREAM

cuda_toolkit/include/__string

@@ -0,0 +1,990 @@
+// -*- C++ -*-
+//===-------------------------- __string ----------------------------------===//
+//
+// 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___STRING
+#define _LIBCUDACXX___STRING
+
+/*
+    string synopsis
+
+namespace std
+{
+
+template <class charT>
+struct char_traits
+{
+    typedef charT     char_type;
+    typedef ...       int_type;
+    typedef streamoff off_type;
+    typedef streampos pos_type;
+    typedef mbstate_t state_type;
+
+    static constexpr void assign(char_type& c1, const char_type& c2) noexcept;
+    static constexpr bool eq(char_type c1, char_type c2) noexcept;
+    static constexpr bool lt(char_type c1, char_type c2) noexcept;
+
+    static constexpr int    compare(const char_type* s1, const char_type* s2, size_t n);
+    static constexpr size_t length(const char_type* s);
+    static constexpr const char_type*
+                            find(const char_type* s, size_t n, const char_type& a);
+    static char_type*       move(char_type* s1, const char_type* s2, size_t n);
+    static char_type*       copy(char_type* s1, const char_type* s2, size_t n);
+    static char_type*       assign(char_type* s, size_t n, char_type a);
+
+    static constexpr int_type  not_eof(int_type c) noexcept;
+    static constexpr char_type to_char_type(int_type c) noexcept;
+    static constexpr int_type  to_int_type(char_type c) noexcept;
+    static constexpr bool      eq_int_type(int_type c1, int_type c2) noexcept;
+    static constexpr int_type  eof() noexcept;
+};
+
+template <> struct char_traits<char>;
+template <> struct char_traits<wchar_t>;
+template <> struct char_traits<char8_t>;  // c++20
+
+}  // std
+
+*/
+
+#include <__config>
+#include <algorithm>  // for search and min
+#include <cstdio>     // For EOF.
+#include <memory>     // for __murmur2_or_cityhash
+
+#include "__assert" // all public C++ headers provide the assertion handler
+#include <__debug>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_PUSH_MACROS
+#include <__undef_macros>
+
+#include "__fwd/string.h"
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// char_traits
+
+template <class _CharT>
+struct _LIBCUDACXX_TEMPLATE_VIS char_traits
+{
+    typedef _CharT    char_type;
+    typedef int       int_type;
+    typedef streamoff off_type;
+    typedef streampos pos_type;
+    typedef mbstate_t state_type;
+
+    static inline void _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+        assign(char_type& __c1, const char_type& __c2) noexcept {__c1 = __c2;}
+    static inline constexpr bool eq(char_type __c1, char_type __c2) noexcept
+        {return __c1 == __c2;}
+    static inline constexpr bool lt(char_type __c1, char_type __c2) noexcept
+        {return __c1 < __c2;}
+
+    static _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    int compare(const char_type* __s1, const char_type* __s2, size_t __n);
+    _LIBCUDACXX_INLINE_VISIBILITY static _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    size_t length(const char_type* __s);
+    _LIBCUDACXX_INLINE_VISIBILITY static _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    const char_type* find(const char_type* __s, size_t __n, const char_type& __a);
+    static char_type*       move(char_type* __s1, const char_type* __s2, size_t __n);
+    _LIBCUDACXX_INLINE_VISIBILITY
+    static char_type*       copy(char_type* __s1, const char_type* __s2, size_t __n);
+    _LIBCUDACXX_INLINE_VISIBILITY
+    static char_type*       assign(char_type* __s, size_t __n, char_type __a);
+
+    static inline constexpr int_type  not_eof(int_type __c) noexcept
+        {return eq_int_type(__c, eof()) ? ~eof() : __c;}
+    static inline constexpr char_type to_char_type(int_type __c) noexcept
+        {return char_type(__c);}
+    static inline constexpr int_type  to_int_type(char_type __c) noexcept
+        {return int_type(__c);}
+    static inline constexpr bool      eq_int_type(int_type __c1, int_type __c2) noexcept
+        {return __c1 == __c2;}
+    static inline constexpr int_type  eof() noexcept
+        {return int_type(EOF);}
+};
+
+template <class _CharT>
+_LIBCUDACXX_CONSTEXPR_AFTER_CXX14 int
+char_traits<_CharT>::compare(const char_type* __s1, const char_type* __s2, size_t __n)
+{
+    for (; __n; --__n, ++__s1, ++__s2)
+    {
+        if (lt(*__s1, *__s2))
+            return -1;
+        if (lt(*__s2, *__s1))
+            return 1;
+    }
+    return 0;
+}
+
+template <class _CharT>
+inline
+_LIBCUDACXX_CONSTEXPR_AFTER_CXX14 size_t
+char_traits<_CharT>::length(const char_type* __s)
+{
+    size_t __len = 0;
+    for (; !eq(*__s, char_type(0)); ++__s)
+        ++__len;
+    return __len;
+}
+
+template <class _CharT>
+inline
+_LIBCUDACXX_CONSTEXPR_AFTER_CXX14 const _CharT*
+char_traits<_CharT>::find(const char_type* __s, size_t __n, const char_type& __a)
+{
+    for (; __n; --__n)
+    {
+        if (eq(*__s, __a))
+            return __s;
+        ++__s;
+    }
+    return 0;
+}
+
+template <class _CharT>
+_CharT*
+char_traits<_CharT>::move(char_type* __s1, const char_type* __s2, size_t __n)
+{
+    char_type* __r = __s1;
+    if (__s1 < __s2)
+    {
+        for (; __n; --__n, ++__s1, ++__s2)
+            assign(*__s1, *__s2);
+    }
+    else if (__s2 < __s1)
+    {
+        __s1 += __n;
+        __s2 += __n;
+        for (; __n; --__n)
+            assign(*--__s1, *--__s2);
+    }
+    return __r;
+}
+
+template <class _CharT>
+inline
+_CharT*
+char_traits<_CharT>::copy(char_type* __s1, const char_type* __s2, size_t __n)
+{
+    _LIBCUDACXX_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
+    char_type* __r = __s1;
+    for (; __n; --__n, ++__s1, ++__s2)
+        assign(*__s1, *__s2);
+    return __r;
+}
+
+template <class _CharT>
+inline
+_CharT*
+char_traits<_CharT>::assign(char_type* __s, size_t __n, char_type __a)
+{
+    char_type* __r = __s;
+    for (; __n; --__n, ++__s)
+        assign(*__s, __a);
+    return __r;
+}
+
+// char_traits<char>
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS char_traits<char>
+{
+    typedef char      char_type;
+    typedef int       int_type;
+    typedef streamoff off_type;
+    typedef streampos pos_type;
+    typedef mbstate_t state_type;
+
+    static inline _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    void assign(char_type& __c1, const char_type& __c2) noexcept {__c1 = __c2;}
+    static inline constexpr bool eq(char_type __c1, char_type __c2) noexcept
+            {return __c1 == __c2;}
+    static inline constexpr bool lt(char_type __c1, char_type __c2) noexcept
+        {return (unsigned char)__c1 < (unsigned char)__c2;}
+
+    static _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    int compare(const char_type* __s1, const char_type* __s2, size_t __n) noexcept;
+    static inline size_t _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    length(const char_type* __s)  noexcept {return __builtin_strlen(__s);}
+    static _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    const char_type* find(const char_type* __s, size_t __n, const char_type& __a) noexcept;
+    static inline char_type* move(char_type* __s1, const char_type* __s2, size_t __n) noexcept
+        {return __n == 0 ? __s1 : (char_type*) memmove(__s1, __s2, __n);}
+    static inline char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) noexcept
+        {
+            _LIBCUDACXX_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
+            return __n == 0 ? __s1 : (char_type*)memcpy(__s1, __s2, __n);
+        }
+    static inline char_type* assign(char_type* __s, size_t __n, char_type __a) noexcept
+        {return __n == 0 ? __s : (char_type*)memset(__s, to_int_type(__a), __n);}
+
+    static inline constexpr int_type  not_eof(int_type __c) noexcept
+        {return eq_int_type(__c, eof()) ? ~eof() : __c;}
+    static inline constexpr char_type to_char_type(int_type __c) noexcept
+        {return char_type(__c);}
+    static inline constexpr int_type to_int_type(char_type __c) noexcept
+        {return int_type((unsigned char)__c);}
+    static inline constexpr bool eq_int_type(int_type __c1, int_type __c2) noexcept
+        {return __c1 == __c2;}
+    static inline constexpr int_type  eof() noexcept
+        {return int_type(EOF);}
+};
+
+inline _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+int
+char_traits<char>::compare(const char_type* __s1, const char_type* __s2, size_t __n) noexcept
+{
+    if (__n == 0)
+        return 0;
+#if __has_feature(cxx_constexpr_string_builtins)
+    return __builtin_memcmp(__s1, __s2, __n);
+#elif _LIBCUDACXX_STD_VER <= 14
+    return memcmp(__s1, __s2, __n);
+#else
+    for (; __n; --__n, ++__s1, ++__s2)
+    {
+        if (lt(*__s1, *__s2))
+            return -1;
+        if (lt(*__s2, *__s1))
+            return 1;
+    }
+    return 0;
+#endif
+}
+
+inline _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+const char*
+char_traits<char>::find(const char_type* __s, size_t __n, const char_type& __a) noexcept
+{
+    if (__n == 0)
+        return nullptr;
+#if __has_feature(cxx_constexpr_string_builtins)
+    return __builtin_char_memchr(__s, to_int_type(__a), __n);
+#elif _LIBCUDACXX_STD_VER <= 14
+    return (const char_type*) memchr(__s, to_int_type(__a), __n);
+#else
+    for (; __n; --__n)
+    {
+        if (eq(*__s, __a))
+            return __s;
+        ++__s;
+    }
+    return nullptr;
+#endif
+}
+
+
+// char_traits<wchar_t>
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS char_traits<wchar_t>
+{
+    typedef wchar_t   char_type;
+    typedef wint_t    int_type;
+    typedef streamoff off_type;
+    typedef streampos pos_type;
+    typedef mbstate_t state_type;
+
+    static inline _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    void assign(char_type& __c1, const char_type& __c2) noexcept {__c1 = __c2;}
+    static inline constexpr bool eq(char_type __c1, char_type __c2) noexcept
+        {return __c1 == __c2;}
+    static inline constexpr bool lt(char_type __c1, char_type __c2) noexcept
+        {return __c1 < __c2;}
+
+    static _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    int compare(const char_type* __s1, const char_type* __s2, size_t __n) noexcept;
+    static _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    size_t length(const char_type* __s) noexcept;
+    static _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    const char_type* find(const char_type* __s, size_t __n, const char_type& __a) noexcept;
+    static inline char_type* move(char_type* __s1, const char_type* __s2, size_t __n) noexcept
+        {return __n == 0 ? __s1 : (char_type*)wmemmove(__s1, __s2, __n);}
+    static inline char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) noexcept
+        {
+            _LIBCUDACXX_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
+            return __n == 0 ? __s1 : (char_type*)wmemcpy(__s1, __s2, __n);
+        }
+    static inline char_type* assign(char_type* __s, size_t __n, char_type __a) noexcept
+        {return __n == 0 ? __s : (char_type*)wmemset(__s, __a, __n);}
+
+    static inline constexpr int_type  not_eof(int_type __c) noexcept
+        {return eq_int_type(__c, eof()) ? ~eof() : __c;}
+    static inline constexpr char_type to_char_type(int_type __c) noexcept
+        {return char_type(__c);}
+    static inline constexpr int_type to_int_type(char_type __c) noexcept
+        {return int_type(__c);}
+    static inline constexpr bool eq_int_type(int_type __c1, int_type __c2) noexcept
+        {return __c1 == __c2;}
+    static inline constexpr int_type eof() noexcept
+        {return int_type(WEOF);}
+};
+
+inline _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+int
+char_traits<wchar_t>::compare(const char_type* __s1, const char_type* __s2, size_t __n) noexcept
+{
+    if (__n == 0)
+        return 0;
+#if __has_feature(cxx_constexpr_string_builtins)
+    return __builtin_wmemcmp(__s1, __s2, __n);
+#elif _LIBCUDACXX_STD_VER <= 14
+    return wmemcmp(__s1, __s2, __n);
+#else
+    for (; __n; --__n, ++__s1, ++__s2)
+    {
+        if (lt(*__s1, *__s2))
+            return -1;
+        if (lt(*__s2, *__s1))
+            return 1;
+    }
+    return 0;
+#endif
+}
+
+
+template <class _Traits>
+_LIBCUDACXX_INLINE_VISIBILITY
+inline constexpr size_t __char_traits_length_checked(const typename _Traits::char_type* __s) noexcept {
+#if _LIBCUDACXX_DEBUG_LEVEL >= 1
+  return __s ? _Traits::length(__s) : (_CUDA_VSTD::__libcpp_debug_function(_CUDA_VSTD::__libcpp_debug_info(__FILE__, __LINE__, "p == nullptr", "null pointer pass to non-null argument of char_traits<...>::length")), 0);
+#else
+  return _Traits::length(__s);
+#endif
+}
+
+inline _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+size_t
+char_traits<wchar_t>::length(const char_type* __s) noexcept
+{
+#if __has_feature(cxx_constexpr_string_builtins)
+    return __builtin_wcslen(__s);
+#elif _LIBCUDACXX_STD_VER <= 14
+    return wcslen(__s);
+#else
+    size_t __len = 0;
+    for (; !eq(*__s, char_type(0)); ++__s)
+        ++__len;
+    return __len;
+#endif
+}
+
+inline _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+const wchar_t*
+char_traits<wchar_t>::find(const char_type* __s, size_t __n, const char_type& __a) noexcept
+{
+    if (__n == 0)
+        return nullptr;
+#if __has_feature(cxx_constexpr_string_builtins)
+    return __builtin_wmemchr(__s, __a, __n);
+#elif _LIBCUDACXX_STD_VER <= 14
+    return wmemchr(__s, __a, __n);
+#else
+    for (; __n; --__n)
+    {
+        if (eq(*__s, __a))
+            return __s;
+        ++__s;
+    }
+    return nullptr;
+#endif
+}
+
+
+#ifndef _LIBCUDACXX_NO_HAS_CHAR8_T
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS char_traits<char8_t>
+{
+    typedef char8_t        char_type;
+    typedef unsigned int   int_type;
+    typedef streamoff      off_type;
+    typedef u8streampos    pos_type;
+    typedef mbstate_t      state_type;
+
+    static inline constexpr void assign(char_type& __c1, const char_type& __c2) noexcept
+        {__c1 = __c2;}
+    static inline constexpr bool eq(char_type __c1, char_type __c2) noexcept
+        {return __c1 == __c2;}
+    static inline constexpr bool lt(char_type __c1, char_type __c2) noexcept
+        {return __c1 < __c2;}
+
+    static constexpr
+    int              compare(const char_type* __s1, const char_type* __s2, size_t __n) noexcept;
+
+    static constexpr
+    size_t           length(const char_type* __s) noexcept;
+
+    _LIBCUDACXX_INLINE_VISIBILITY static constexpr
+    const char_type* find(const char_type* __s, size_t __n, const char_type& __a) noexcept;
+
+    static char_type*       move(char_type* __s1, const char_type* __s2, size_t __n) noexcept
+        {return __n == 0 ? __s1 : (char_type*) memmove(__s1, __s2, __n);}
+
+    static char_type*       copy(char_type* __s1, const char_type* __s2, size_t __n) noexcept
+       {
+            _LIBCUDACXX_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
+            return __n == 0 ? __s1 : (char_type*)memcpy(__s1, __s2, __n);
+       }
+
+    static char_type*       assign(char_type* __s, size_t __n, char_type __a) noexcept
+        {return __n == 0 ? __s : (char_type*)memset(__s, to_int_type(__a), __n);}
+
+    static inline constexpr int_type  not_eof(int_type __c) noexcept
+        {return eq_int_type(__c, eof()) ? ~eof() : __c;}
+    static inline constexpr char_type to_char_type(int_type __c) noexcept
+        {return char_type(__c);}
+    static inline constexpr int_type to_int_type(char_type __c) noexcept
+        {return int_type(__c);}
+    static inline constexpr bool eq_int_type(int_type __c1, int_type __c2) noexcept
+        {return __c1 == __c2;}
+    static inline constexpr int_type eof() noexcept
+        {return int_type(EOF);}
+};
+
+// TODO use '__builtin_strlen' if it ever supports char8_t ??
+inline constexpr
+size_t
+char_traits<char8_t>::length(const char_type* __s) noexcept
+{
+    size_t __len = 0;
+    for (; !eq(*__s, char_type(0)); ++__s)
+        ++__len;
+    return __len;
+}
+
+inline constexpr
+int
+char_traits<char8_t>::compare(const char_type* __s1, const char_type* __s2, size_t __n) noexcept
+{
+#if __has_feature(cxx_constexpr_string_builtins)
+    return __builtin_memcmp(__s1, __s2, __n);
+#else
+    for (; __n; --__n, ++__s1, ++__s2)
+    {
+        if (lt(*__s1, *__s2))
+            return -1;
+        if (lt(*__s2, *__s1))
+            return 1;
+    }
+    return 0;
+#endif
+}
+
+// TODO use '__builtin_char_memchr' if it ever supports char8_t ??
+inline constexpr
+const char8_t*
+char_traits<char8_t>::find(const char_type* __s, size_t __n, const char_type& __a) noexcept
+{
+    for (; __n; --__n)
+    {
+        if (eq(*__s, __a))
+            return __s;
+        ++__s;
+    }
+    return 0;
+}
+
+#endif // #_LIBCUDACXX_NO_HAS_CHAR8_T
+
+#ifndef _LIBCUDACXX_HAS_NO_UNICODE_CHARS
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS char_traits<char16_t>
+{
+    typedef char16_t       char_type;
+    typedef uint_least16_t int_type;
+    typedef streamoff      off_type;
+    typedef u16streampos   pos_type;
+    typedef mbstate_t      state_type;
+
+    static inline _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    void assign(char_type& __c1, const char_type& __c2) noexcept {__c1 = __c2;}
+    static inline constexpr bool eq(char_type __c1, char_type __c2) noexcept
+        {return __c1 == __c2;}
+    static inline constexpr bool lt(char_type __c1, char_type __c2) noexcept
+        {return __c1 < __c2;}
+
+    _LIBCUDACXX_INLINE_VISIBILITY static _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    int              compare(const char_type* __s1, const char_type* __s2, size_t __n) noexcept;
+    _LIBCUDACXX_INLINE_VISIBILITY static _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    size_t           length(const char_type* __s) noexcept;
+    _LIBCUDACXX_INLINE_VISIBILITY static _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    const char_type* find(const char_type* __s, size_t __n, const char_type& __a) noexcept;
+    _LIBCUDACXX_INLINE_VISIBILITY
+    static char_type*       move(char_type* __s1, const char_type* __s2, size_t __n) noexcept;
+    _LIBCUDACXX_INLINE_VISIBILITY
+    static char_type*       copy(char_type* __s1, const char_type* __s2, size_t __n) noexcept;
+    _LIBCUDACXX_INLINE_VISIBILITY
+    static char_type*       assign(char_type* __s, size_t __n, char_type __a) noexcept;
+
+    static inline constexpr int_type  not_eof(int_type __c) noexcept
+        {return eq_int_type(__c, eof()) ? ~eof() : __c;}
+    static inline constexpr char_type to_char_type(int_type __c) noexcept
+        {return char_type(__c);}
+    static inline constexpr int_type to_int_type(char_type __c) noexcept
+        {return int_type(__c);}
+    static inline constexpr bool eq_int_type(int_type __c1, int_type __c2) noexcept
+        {return __c1 == __c2;}
+    static inline constexpr int_type eof() noexcept
+        {return int_type(0xFFFF);}
+};
+
+inline _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+int
+char_traits<char16_t>::compare(const char_type* __s1, const char_type* __s2, size_t __n) noexcept
+{
+    for (; __n; --__n, ++__s1, ++__s2)
+    {
+        if (lt(*__s1, *__s2))
+            return -1;
+        if (lt(*__s2, *__s1))
+            return 1;
+    }
+    return 0;
+}
+
+inline _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+size_t
+char_traits<char16_t>::length(const char_type* __s) noexcept
+{
+    size_t __len = 0;
+    for (; !eq(*__s, char_type(0)); ++__s)
+        ++__len;
+    return __len;
+}
+
+inline _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+const char16_t*
+char_traits<char16_t>::find(const char_type* __s, size_t __n, const char_type& __a) noexcept
+{
+    for (; __n; --__n)
+    {
+        if (eq(*__s, __a))
+            return __s;
+        ++__s;
+    }
+    return 0;
+}
+
+inline
+char16_t*
+char_traits<char16_t>::move(char_type* __s1, const char_type* __s2, size_t __n) noexcept
+{
+    char_type* __r = __s1;
+    if (__s1 < __s2)
+    {
+        for (; __n; --__n, ++__s1, ++__s2)
+            assign(*__s1, *__s2);
+    }
+    else if (__s2 < __s1)
+    {
+        __s1 += __n;
+        __s2 += __n;
+        for (; __n; --__n)
+            assign(*--__s1, *--__s2);
+    }
+    return __r;
+}
+
+inline
+char16_t*
+char_traits<char16_t>::copy(char_type* __s1, const char_type* __s2, size_t __n) noexcept
+{
+    _LIBCUDACXX_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
+    char_type* __r = __s1;
+    for (; __n; --__n, ++__s1, ++__s2)
+        assign(*__s1, *__s2);
+    return __r;
+}
+
+inline
+char16_t*
+char_traits<char16_t>::assign(char_type* __s, size_t __n, char_type __a) noexcept
+{
+    char_type* __r = __s;
+    for (; __n; --__n, ++__s)
+        assign(*__s, __a);
+    return __r;
+}
+
+template <>
+struct _LIBCUDACXX_TEMPLATE_VIS char_traits<char32_t>
+{
+    typedef char32_t       char_type;
+    typedef uint_least32_t int_type;
+    typedef streamoff      off_type;
+    typedef u32streampos   pos_type;
+    typedef mbstate_t      state_type;
+
+    static inline _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    void assign(char_type& __c1, const char_type& __c2) noexcept {__c1 = __c2;}
+    static inline constexpr bool eq(char_type __c1, char_type __c2) noexcept
+        {return __c1 == __c2;}
+    static inline constexpr bool lt(char_type __c1, char_type __c2) noexcept
+        {return __c1 < __c2;}
+
+    _LIBCUDACXX_INLINE_VISIBILITY static _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    int              compare(const char_type* __s1, const char_type* __s2, size_t __n) noexcept;
+    _LIBCUDACXX_INLINE_VISIBILITY static _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    size_t           length(const char_type* __s) noexcept;
+    _LIBCUDACXX_INLINE_VISIBILITY static _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+    const char_type* find(const char_type* __s, size_t __n, const char_type& __a) noexcept;
+    _LIBCUDACXX_INLINE_VISIBILITY
+    static char_type*       move(char_type* __s1, const char_type* __s2, size_t __n) noexcept;
+    _LIBCUDACXX_INLINE_VISIBILITY
+    static char_type*       copy(char_type* __s1, const char_type* __s2, size_t __n) noexcept;
+    _LIBCUDACXX_INLINE_VISIBILITY
+    static char_type*       assign(char_type* __s, size_t __n, char_type __a) noexcept;
+
+    static inline constexpr int_type  not_eof(int_type __c) noexcept
+        {return eq_int_type(__c, eof()) ? ~eof() : __c;}
+    static inline constexpr char_type to_char_type(int_type __c) noexcept
+        {return char_type(__c);}
+    static inline constexpr int_type to_int_type(char_type __c) noexcept
+        {return int_type(__c);}
+    static inline constexpr bool eq_int_type(int_type __c1, int_type __c2) noexcept
+        {return __c1 == __c2;}
+    static inline constexpr int_type eof() noexcept
+        {return int_type(0xFFFFFFFF);}
+};
+
+inline _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+int
+char_traits<char32_t>::compare(const char_type* __s1, const char_type* __s2, size_t __n) noexcept
+{
+    for (; __n; --__n, ++__s1, ++__s2)
+    {
+        if (lt(*__s1, *__s2))
+            return -1;
+        if (lt(*__s2, *__s1))
+            return 1;
+    }
+    return 0;
+}
+
+inline _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+size_t
+char_traits<char32_t>::length(const char_type* __s) noexcept
+{
+    size_t __len = 0;
+    for (; !eq(*__s, char_type(0)); ++__s)
+        ++__len;
+    return __len;
+}
+
+inline _LIBCUDACXX_CONSTEXPR_AFTER_CXX14
+const char32_t*
+char_traits<char32_t>::find(const char_type* __s, size_t __n, const char_type& __a) noexcept
+{
+    for (; __n; --__n)
+    {
+        if (eq(*__s, __a))
+            return __s;
+        ++__s;
+    }
+    return 0;
+}
+
+inline
+char32_t*
+char_traits<char32_t>::move(char_type* __s1, const char_type* __s2, size_t __n) noexcept
+{
+    char_type* __r = __s1;
+    if (__s1 < __s2)
+    {
+        for (; __n; --__n, ++__s1, ++__s2)
+            assign(*__s1, *__s2);
+    }
+    else if (__s2 < __s1)
+    {
+        __s1 += __n;
+        __s2 += __n;
+        for (; __n; --__n)
+            assign(*--__s1, *--__s2);
+    }
+    return __r;
+}
+
+inline
+char32_t*
+char_traits<char32_t>::copy(char_type* __s1, const char_type* __s2, size_t __n) noexcept
+{
+    _LIBCUDACXX_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
+    char_type* __r = __s1;
+    for (; __n; --__n, ++__s1, ++__s2)
+        assign(*__s1, *__s2);
+    return __r;
+}
+
+inline
+char32_t*
+char_traits<char32_t>::assign(char_type* __s, size_t __n, char_type __a) noexcept
+{
+    char_type* __r = __s;
+    for (; __n; --__n, ++__s)
+        assign(*__s, __a);
+    return __r;
+}
+
+#endif  // _LIBCUDACXX_HAS_NO_UNICODE_CHARS
+
+// helper fns for basic_string and string_view
+
+// __str_find
+template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
+inline _SizeT _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+__str_find(const _CharT *__p, _SizeT __sz,
+             _CharT __c, _SizeT __pos) noexcept
+{
+    if (__pos >= __sz)
+        return __npos;
+    const _CharT* __r = _Traits::find(__p + __pos, __sz - __pos, __c);
+    if (__r == 0)
+        return __npos;
+    return static_cast<_SizeT>(__r - __p);
+}
+
+template <class _CharT, class _Traits>
+inline _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 const _CharT *
+__search_substring(const _CharT *__first1, const _CharT *__last1,
+                   const _CharT *__first2, const _CharT *__last2) {
+  // Take advantage of knowing source and pattern lengths.
+  // Stop short when source is smaller than pattern.
+  const ptrdiff_t __len2 = __last2 - __first2;
+  if (__len2 == 0)
+    return __first1;
+
+  ptrdiff_t __len1 = __last1 - __first1;
+  if (__len1 < __len2)
+    return __last1;
+
+  // First element of __first2 is loop invariant.
+  _CharT __f2 = *__first2;
+  while (true) {
+    __len1 = __last1 - __first1;
+    // Check whether __first1 still has at least __len2 bytes.
+    if (__len1 < __len2)
+      return __last1;
+
+    // Find __f2 the first byte matching in __first1.
+    __first1 = _Traits::find(__first1, __len1 - __len2 + 1, __f2);
+    if (__first1 == 0)
+      return __last1;
+
+    // It is faster to compare from the first byte of __first1 even if we
+    // already know that it matches the first byte of __first2: this is because
+    // __first2 is most likely aligned, as it is user's "pattern" string, and
+    // __first1 + 1 is most likely not aligned, as the match is in the middle of
+    // the string.
+    if (_Traits::compare(__first1, __first2, __len2) == 0)
+      return __first1;
+
+    ++__first1;
+  }
+}
+
+template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
+inline _SizeT _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+__str_find(const _CharT *__p, _SizeT __sz,
+       const _CharT* __s, _SizeT __pos, _SizeT __n) noexcept
+{
+    if (__pos > __sz)
+        return __npos;
+
+    if (__n == 0) // There is nothing to search, just return __pos.
+        return __pos;
+
+    const _CharT *__r = __search_substring<_CharT, _Traits>(
+        __p + __pos, __p + __sz, __s, __s + __n);
+
+    if (__r == __p + __sz)
+        return __npos;
+    return static_cast<_SizeT>(__r - __p);
+}
+
+
+// __str_rfind
+
+template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
+inline _SizeT _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+__str_rfind(const _CharT *__p, _SizeT __sz,
+              _CharT __c, _SizeT __pos) noexcept
+{
+    if (__sz < 1)
+        return __npos;
+    if (__pos < __sz)
+        ++__pos;
+    else
+        __pos = __sz;
+    for (const _CharT* __ps = __p + __pos; __ps != __p;)
+    {
+        if (_Traits::eq(*--__ps, __c))
+            return static_cast<_SizeT>(__ps - __p);
+    }
+    return __npos;
+}
+
+template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
+inline _SizeT _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+__str_rfind(const _CharT *__p, _SizeT __sz,
+        const _CharT* __s, _SizeT __pos, _SizeT __n) noexcept
+{
+    __pos = _CUDA_VSTD::min(__pos, __sz);
+    if (__n < __sz - __pos)
+        __pos += __n;
+    else
+        __pos = __sz;
+    const _CharT* __r = _CUDA_VSTD::__find_end(
+                  __p, __p + __pos, __s, __s + __n, _Traits::eq,
+                        random_access_iterator_tag(), random_access_iterator_tag());
+    if (__n > 0 && __r == __p + __pos)
+        return __npos;
+    return static_cast<_SizeT>(__r - __p);
+}
+
+// __str_find_first_of
+template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
+inline _SizeT _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+__str_find_first_of(const _CharT *__p, _SizeT __sz,
+                const _CharT* __s, _SizeT __pos, _SizeT __n) noexcept
+{
+    if (__pos >= __sz || __n == 0)
+        return __npos;
+    const _CharT* __r = _CUDA_VSTD::__find_first_of_ce
+        (__p + __pos, __p + __sz, __s, __s + __n, _Traits::eq );
+    if (__r == __p + __sz)
+        return __npos;
+    return static_cast<_SizeT>(__r - __p);
+}
+
+
+// __str_find_last_of
+template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
+inline _SizeT _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+__str_find_last_of(const _CharT *__p, _SizeT __sz,
+               const _CharT* __s, _SizeT __pos, _SizeT __n) noexcept
+    {
+    if (__n != 0)
+    {
+        if (__pos < __sz)
+            ++__pos;
+        else
+            __pos = __sz;
+        for (const _CharT* __ps = __p + __pos; __ps != __p;)
+        {
+            const _CharT* __r = _Traits::find(__s, __n, *--__ps);
+            if (__r)
+                return static_cast<_SizeT>(__ps - __p);
+        }
+    }
+    return __npos;
+}
+
+
+// __str_find_first_not_of
+template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
+inline _SizeT _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+__str_find_first_not_of(const _CharT *__p, _SizeT __sz,
+                    const _CharT* __s, _SizeT __pos, _SizeT __n) noexcept
+{
+    if (__pos < __sz)
+    {
+        const _CharT* __pe = __p + __sz;
+        for (const _CharT* __ps = __p + __pos; __ps != __pe; ++__ps)
+            if (_Traits::find(__s, __n, *__ps) == 0)
+                return static_cast<_SizeT>(__ps - __p);
+    }
+    return __npos;
+}
+
+
+template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
+inline _SizeT _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+__str_find_first_not_of(const _CharT *__p, _SizeT __sz,
+                          _CharT __c, _SizeT __pos) noexcept
+{
+    if (__pos < __sz)
+    {
+        const _CharT* __pe = __p + __sz;
+        for (const _CharT* __ps = __p + __pos; __ps != __pe; ++__ps)
+            if (!_Traits::eq(*__ps, __c))
+                return static_cast<_SizeT>(__ps - __p);
+    }
+    return __npos;
+}
+
+
+// __str_find_last_not_of
+template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
+inline _SizeT _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+__str_find_last_not_of(const _CharT *__p, _SizeT __sz,
+                   const _CharT* __s, _SizeT __pos, _SizeT __n) noexcept
+{
+    if (__pos < __sz)
+        ++__pos;
+    else
+        __pos = __sz;
+    for (const _CharT* __ps = __p + __pos; __ps != __p;)
+        if (_Traits::find(__s, __n, *--__ps) == 0)
+            return static_cast<_SizeT>(__ps - __p);
+    return __npos;
+}
+
+
+template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
+inline _SizeT _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 _LIBCUDACXX_INLINE_VISIBILITY
+__str_find_last_not_of(const _CharT *__p, _SizeT __sz,
+                         _CharT __c, _SizeT __pos) noexcept
+{
+    if (__pos < __sz)
+        ++__pos;
+    else
+        __pos = __sz;
+    for (const _CharT* __ps = __p + __pos; __ps != __p;)
+        if (!_Traits::eq(*--__ps, __c))
+            return static_cast<_SizeT>(__ps - __p);
+    return __npos;
+}
+
+template<class _Ptr>
+inline _LIBCUDACXX_INLINE_VISIBILITY
+size_t __do_string_hash(_Ptr __p, _Ptr __e)
+{
+    typedef typename iterator_traits<_Ptr>::value_type value_type;
+    return __murmur2_or_cityhash<size_t>()(__p, (__e-__p)*sizeof(value_type));
+}
+
+template <class _CharT, class _Iter, class _Traits=char_traits<_CharT> >
+struct __quoted_output_proxy
+{
+    _Iter  __first;
+    _Iter  __last;
+    _CharT  __delim;
+    _CharT  __escape;
+
+    __quoted_output_proxy(_Iter __f, _Iter __l, _CharT __d, _CharT __e)
+    : __first(__f), __last(__l), __delim(__d), __escape(__e) {}
+    //  This would be a nice place for a string_ref
+};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+_LIBCUDACXX_POP_MACROS
+
+#endif  // _LIBCUDACXX___STRING

cuda_toolkit/include/__threading_support

@@ -0,0 +1,795 @@
+// -*- 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_THREADING_SUPPORT
+#define _LIBCUDACXX_THREADING_SUPPORT
+
+#ifndef __cuda_std__
+#include <__config>
+#include <errno.h>
+#else
+#include "__cuda/atomic_prelude.h"
+#endif // __cuda_std__
+
+#include "__assert" // all public C++ headers provide the assertion handler
+#include "__functional/hash.h"
+#include "chrono"
+#include "climits"
+#include "iosfwd"
+
+#ifndef __cuda_std__
+#include <__pragma_push>
+#endif // __cuda_std__
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#if defined(_LIBCUDACXX_HAS_THREAD_API_EXTERNAL)
+# ifndef __cuda_std__
+#  include <__external_threading>
+# else
+#  define _LIBCUDACXX_THREAD_ABI_VISIBILITY inline _LIBCUDACXX_INLINE_VISIBILITY
+# endif
+#elif !defined(_LIBCUDACXX_HAS_NO_THREADS)
+
+#if defined(_LIBCUDACXX_HAS_THREAD_API_PTHREAD)
+# include <pthread.h>
+# include <sched.h>
+# include <semaphore.h>
+# if defined(__APPLE__)
+#  include <dispatch/dispatch.h>
+# endif
+# if defined(__linux__)
+#  include <unistd.h>
+#  include <linux/futex.h>
+#  include <sys/syscall.h>
+# endif
+#endif
+
+#if defined(_LIBCUDACXX_HAS_THREAD_API_WIN32)
+# include <process.h>
+# include <windows.h>
+#endif
+
+#if defined(_LIBCUDACXX_HAS_THREAD_LIBRARY_EXTERNAL) || \
+    defined(_LIBCUDACXX_BUILDING_THREAD_LIBRARY_EXTERNAL)
+#define _LIBCUDACXX_THREAD_ABI_VISIBILITY _LIBCUDACXX_FUNC_VIS
+#else
+#define _LIBCUDACXX_THREAD_ABI_VISIBILITY inline _LIBCUDACXX_INLINE_VISIBILITY
+#endif
+
+#if defined(__FreeBSD__) && defined(_LIBCUDACXX_COMPILER_CLANG) && __has_attribute(no_thread_safety_analysis)
+#define _LIBCUDACXX_NO_THREAD_SAFETY_ANALYSIS __attribute__((no_thread_safety_analysis))
+#else
+#define _LIBCUDACXX_NO_THREAD_SAFETY_ANALYSIS
+#endif
+
+typedef ::timespec __libcpp_timespec_t;
+#endif // !defined(_LIBCUDACXX_HAS_NO_THREADS)
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if !defined(_LIBCUDACXX_HAS_NO_THREADS)
+
+#define _LIBCUDACXX_POLLING_COUNT 16
+
+_LIBCUDACXX_INLINE_VISIBILITY
+inline void __libcpp_thread_yield_processor()
+{
+#if defined(__aarch64__)
+# define __LIBCUDACXX_ASM_THREAD_YIELD (asm volatile ("yield" :::);)
+#elif defined(__x86_64__)
+# define __LIBCUDACXX_ASM_THREAD_YIELD (asm volatile ("pause" :::);)
+#elif defined (__powerpc__)
+# define __LIBCUDACXX_ASM_THREAD_YIELD (asm volatile ("or 27,27,27":::);)
+#else
+# define __LIBCUDACXX_ASM_THREAD_YIELD (;)
+#endif
+    NV_IF_TARGET(
+        NV_IS_HOST,
+            __LIBCUDACXX_ASM_THREAD_YIELD
+    )
+}
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+void __libcpp_thread_yield();
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+void __libcpp_thread_sleep_for(chrono::nanoseconds __ns);
+
+template<class _Fn>
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+bool __libcpp_thread_poll_with_backoff(_Fn && __f, chrono::nanoseconds __max = chrono::nanoseconds::zero());
+
+#if defined(_LIBCUDACXX_HAS_THREAD_API_PTHREAD)
+// Mutex
+typedef pthread_mutex_t __libcpp_mutex_t;
+#define _LIBCUDACXX_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
+
+typedef pthread_mutex_t __libcpp_recursive_mutex_t;
+
+// Condition Variable
+typedef pthread_cond_t __libcpp_condvar_t;
+#define _LIBCUDACXX_CONDVAR_INITIALIZER PTHREAD_COND_INITIALIZER
+
+// Semaphore
+#if defined(__APPLE__)
+typedef dispatch_semaphore_t __libcpp_semaphore_t;
+# define _LIBCUDACXX_SEMAPHORE_MAX numeric_limits<long>::max()
+#else
+typedef sem_t __libcpp_semaphore_t;
+# define _LIBCUDACXX_SEMAPHORE_MAX SEM_VALUE_MAX
+#endif
+
+// Execute once
+typedef pthread_once_t __libcpp_exec_once_flag;
+#define _LIBCUDACXX_EXEC_ONCE_INITIALIZER PTHREAD_ONCE_INIT
+
+// Thread id
+typedef pthread_t __libcpp_thread_id;
+
+// Thread
+#define _LIBCUDACXX_NULL_THREAD 0U
+
+typedef pthread_t __libcpp_thread_t;
+
+// Thread Local Storage
+typedef pthread_key_t __libcpp_tls_key;
+
+#define _LIBCUDACXX_TLS_DESTRUCTOR_CC
+#elif !defined(_LIBCUDACXX_HAS_THREAD_API_EXTERNAL)
+// Mutex
+typedef void* __libcpp_mutex_t;
+#define _LIBCUDACXX_MUTEX_INITIALIZER 0
+
+#if defined(_M_IX86) || defined(__i386__) || defined(_M_ARM) || defined(__arm__)
+typedef void* __libcpp_recursive_mutex_t[6];
+#elif defined(_M_AMD64) || defined(__x86_64__) || defined(_M_ARM64) || defined(__aarch64__)
+typedef void* __libcpp_recursive_mutex_t[5];
+#else
+# error Unsupported architecture
+#endif
+
+// Condition Variable
+typedef void* __libcpp_condvar_t;
+#define _LIBCUDACXX_CONDVAR_INITIALIZER 0
+
+// Semaphore
+typedef void* __libcpp_semaphore_t;
+
+// Execute Once
+typedef void* __libcpp_exec_once_flag;
+#define _LIBCUDACXX_EXEC_ONCE_INITIALIZER 0
+
+// Thread ID
+typedef long __libcpp_thread_id;
+
+// Thread
+#define _LIBCUDACXX_NULL_THREAD 0U
+
+typedef void* __libcpp_thread_t;
+
+// Thread Local Storage
+typedef long __libcpp_tls_key;
+
+#define _LIBCUDACXX_TLS_DESTRUCTOR_CC __stdcall
+#endif // !defined(_LIBCUDACXX_HAS_THREAD_API_PTHREAD) && !defined(_LIBCUDACXX_HAS_THREAD_API_EXTERNAL)
+
+#if !defined(_LIBCUDACXX_HAS_THREAD_API_EXTERNAL)
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+__libcpp_timespec_t __libcpp_to_timespec(const chrono::nanoseconds& __ns);
+
+// Mutex
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m);
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY _LIBCUDACXX_NO_THREAD_SAFETY_ANALYSIS
+int __libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t *__m);
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY _LIBCUDACXX_NO_THREAD_SAFETY_ANALYSIS
+bool __libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t *__m);
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY _LIBCUDACXX_NO_THREAD_SAFETY_ANALYSIS
+int __libcpp_recursive_mutex_unlock(__libcpp_recursive_mutex_t *__m);
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t *__m);
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY _LIBCUDACXX_NO_THREAD_SAFETY_ANALYSIS
+int __libcpp_mutex_lock(__libcpp_mutex_t *__m);
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY _LIBCUDACXX_NO_THREAD_SAFETY_ANALYSIS
+bool __libcpp_mutex_trylock(__libcpp_mutex_t *__m);
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY _LIBCUDACXX_NO_THREAD_SAFETY_ANALYSIS
+int __libcpp_mutex_unlock(__libcpp_mutex_t *__m);
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_mutex_destroy(__libcpp_mutex_t *__m);
+
+// Condition variable
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_condvar_signal(__libcpp_condvar_t* __cv);
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_condvar_broadcast(__libcpp_condvar_t* __cv);
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY _LIBCUDACXX_NO_THREAD_SAFETY_ANALYSIS
+int __libcpp_condvar_wait(__libcpp_condvar_t* __cv, __libcpp_mutex_t* __m);
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY _LIBCUDACXX_NO_THREAD_SAFETY_ANALYSIS
+int __libcpp_condvar_timedwait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m,
+                               __libcpp_timespec_t *__ts);
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_condvar_destroy(__libcpp_condvar_t* __cv);
+
+// Semaphore
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+bool __libcpp_semaphore_init(__libcpp_semaphore_t* __sem, int __init);
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+bool __libcpp_semaphore_destroy(__libcpp_semaphore_t* __sem);
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+bool __libcpp_semaphore_post(__libcpp_semaphore_t* __sem);
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+bool __libcpp_semaphore_wait(__libcpp_semaphore_t* __sem);
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+bool __libcpp_semaphore_wait_timed(__libcpp_semaphore_t* __sem, chrono::nanoseconds const& __ns);
+
+// Execute once
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_execute_once(__libcpp_exec_once_flag *flag,
+                          void (*init_routine)());
+
+// Thread id
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+bool __libcpp_thread_id_equal(__libcpp_thread_id t1, __libcpp_thread_id t2);
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+bool __libcpp_thread_id_less(__libcpp_thread_id t1, __libcpp_thread_id t2);
+
+// Thread
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+bool __libcpp_thread_isnull(const __libcpp_thread_t *__t);
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_thread_create(__libcpp_thread_t *__t, void *(*__func)(void *),
+                           void *__arg);
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+__libcpp_thread_id __libcpp_thread_get_current_id();
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+__libcpp_thread_id __libcpp_thread_get_id(const __libcpp_thread_t *__t);
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_thread_join(__libcpp_thread_t *__t);
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_thread_detach(__libcpp_thread_t *__t);
+
+// Thread local storage
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_tls_create(__libcpp_tls_key* __key,
+                        void(_LIBCUDACXX_TLS_DESTRUCTOR_CC* __at_exit)(void*));
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+void *__libcpp_tls_get(__libcpp_tls_key __key);
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_tls_set(__libcpp_tls_key __key, void *__p);
+
+#endif // !defined(_LIBCUDACXX_HAS_THREAD_API_EXTERNAL)
+
+#if !defined(_LIBCUDACXX_HAS_THREAD_LIBRARY_EXTERNAL) || defined(_LIBCUDACXX_BUILDING_THREAD_LIBRARY_EXTERNAL)
+
+#if defined(_LIBCUDACXX_HAS_THREAD_API_CUDA)
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+void __libcpp_thread_yield() {}
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+void __libcpp_thread_sleep_for(chrono::nanoseconds __ns)
+{
+    NV_IF_TARGET(
+        NV_IS_DEVICE, (
+            auto const __step = __ns.count();
+            assert(__step < numeric_limits<unsigned>::max());
+            asm volatile("nanosleep.u32 %0;"::"r"((unsigned)__step):);
+        )
+    )
+}
+
+#elif defined(_LIBCUDACXX_HAS_THREAD_API_PTHREAD)
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+__libcpp_timespec_t __libcpp_to_timespec(const chrono::nanoseconds& __ns)
+{
+     using namespace chrono;
+     seconds __s = duration_cast<seconds>(__ns);
+     __libcpp_timespec_t __ts;
+     typedef decltype(__ts.tv_sec) ts_sec;
+     constexpr ts_sec __ts_sec_max = numeric_limits<ts_sec>::max();
+
+     if (__s.count() < __ts_sec_max)
+     {
+         __ts.tv_sec = static_cast<ts_sec>(__s.count());
+         __ts.tv_nsec = static_cast<decltype(__ts.tv_nsec)>((__ns - __s).count());
+     }
+     else
+     {
+         __ts.tv_sec = __ts_sec_max;
+         __ts.tv_nsec = 999999999; // (10^9 - 1)
+     }
+     return __ts;
+}
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m)
+{
+    pthread_mutexattr_t attr;
+    int __ec = pthread_mutexattr_init(&attr);
+    if (__ec)
+        return __ec;
+    __ec = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+    if (__ec) {
+        pthread_mutexattr_destroy(&attr);
+        return __ec;
+    }
+    __ec = pthread_mutex_init(__m, &attr);
+    if (__ec) {
+        pthread_mutexattr_destroy(&attr);
+        return __ec;
+    }
+    __ec = pthread_mutexattr_destroy(&attr);
+    if (__ec) {
+        pthread_mutex_destroy(__m);
+        return __ec;
+    }
+    return 0;
+}
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t *__m)
+{
+    return pthread_mutex_lock(__m);
+}
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+bool __libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t *__m)
+{
+    return pthread_mutex_trylock(__m) == 0;
+}
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_recursive_mutex_unlock(__libcpp_mutex_t *__m)
+{
+    return pthread_mutex_unlock(__m);
+}
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t *__m)
+{
+    return pthread_mutex_destroy(__m);
+}
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_mutex_lock(__libcpp_mutex_t *__m)
+{
+    return pthread_mutex_lock(__m);
+}
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+bool __libcpp_mutex_trylock(__libcpp_mutex_t *__m)
+{
+    return pthread_mutex_trylock(__m) == 0;
+}
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_mutex_unlock(__libcpp_mutex_t *__m)
+{
+    return pthread_mutex_unlock(__m);
+}
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_mutex_destroy(__libcpp_mutex_t *__m)
+{
+  return pthread_mutex_destroy(__m);
+}
+
+// Condition Variable
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_condvar_signal(__libcpp_condvar_t *__cv)
+{
+    return pthread_cond_signal(__cv);
+}
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_condvar_broadcast(__libcpp_condvar_t *__cv)
+{
+    return pthread_cond_broadcast(__cv);
+}
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_condvar_wait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m)
+{
+    return pthread_cond_wait(__cv, __m);
+}
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_condvar_timedwait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m,
+                               __libcpp_timespec_t *__ts)
+{
+    return pthread_cond_timedwait(__cv, __m, __ts);
+}
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_condvar_destroy(__libcpp_condvar_t *__cv)
+{
+    return pthread_cond_destroy(__cv);
+}
+
+// Semaphore
+#if defined(__APPLE__)
+
+bool __libcpp_semaphore_init(__libcpp_semaphore_t* __sem, int __init)
+{
+    return (*__sem = dispatch_semaphore_create(__init)) != NULL;
+}
+
+bool __libcpp_semaphore_destroy(__libcpp_semaphore_t* __sem)
+{
+    dispatch_release(*__sem);
+    return true;
+}
+
+bool __libcpp_semaphore_post(__libcpp_semaphore_t* __sem)
+{
+    dispatch_semaphore_signal(*__sem);
+    return true;
+}
+
+bool __libcpp_semaphore_wait(__libcpp_semaphore_t* __sem)
+{
+    return dispatch_semaphore_wait(*__sem, DISPATCH_TIME_FOREVER) == 0;
+}
+
+bool __libcpp_semaphore_wait_timed(__libcpp_semaphore_t* __sem, chrono::nanoseconds const& __ns)
+{
+    return dispatch_semaphore_wait(*__sem, dispatch_time(DISPATCH_TIME_NOW, __ns.count())) == 0;
+}
+
+#else
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+bool __libcpp_semaphore_init(__libcpp_semaphore_t* __sem, int __init)
+{
+    return sem_init(__sem, 0, __init) == 0;
+}
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+bool __libcpp_semaphore_destroy(__libcpp_semaphore_t* __sem)
+{
+    return sem_destroy(__sem) == 0;
+}
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+bool __libcpp_semaphore_post(__libcpp_semaphore_t* __sem)
+{
+    return sem_post(__sem) == 0;
+}
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+bool __libcpp_semaphore_wait(__libcpp_semaphore_t* __sem)
+{
+    return sem_wait(__sem) == 0;
+}
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+bool __libcpp_semaphore_wait_timed(__libcpp_semaphore_t* __sem, chrono::nanoseconds const& __ns)
+{
+    __libcpp_timespec_t __ts = __libcpp_to_timespec(__ns);
+    return sem_timedwait(__sem, &__ts) == 0;
+}
+
+#endif //__APPLE__
+
+// Execute once
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_execute_once(__libcpp_exec_once_flag *flag, void (*init_routine)())
+{
+    return pthread_once(flag, init_routine);
+}
+
+// Thread id
+// Returns non-zero if the thread ids are equal, otherwise 0
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+bool __libcpp_thread_id_equal(__libcpp_thread_id t1, __libcpp_thread_id t2)
+{
+    return pthread_equal(t1, t2) != 0;
+}
+
+// Returns non-zero if t1 < t2, otherwise 0
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+bool __libcpp_thread_id_less(__libcpp_thread_id t1, __libcpp_thread_id t2)
+{
+    return t1 < t2;
+}
+
+// Thread
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+bool __libcpp_thread_isnull(const __libcpp_thread_t *__t)
+{
+    return *__t == 0;
+}
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_thread_create(__libcpp_thread_t *__t, void *(*__func)(void *),
+                           void *__arg)
+{
+    return pthread_create(__t, 0, __func, __arg);
+}
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+__libcpp_thread_id __libcpp_thread_get_current_id()
+{
+    return pthread_self();
+}
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+__libcpp_thread_id __libcpp_thread_get_id(const __libcpp_thread_t *__t)
+{
+    return *__t;
+}
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_thread_join(__libcpp_thread_t *__t)
+{
+    return pthread_join(*__t, 0);
+}
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_thread_detach(__libcpp_thread_t *__t)
+{
+    return pthread_detach(*__t);
+}
+
+// Thread local storage
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_tls_create(__libcpp_tls_key *__key, void (*__at_exit)(void *))
+{
+    return pthread_key_create(__key, __at_exit);
+}
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+void *__libcpp_tls_get(__libcpp_tls_key __key)
+{
+    return pthread_getspecific(__key);
+}
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+int __libcpp_tls_set(__libcpp_tls_key __key, void *__p)
+{
+    return pthread_setspecific(__key, __p);
+}
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+void __libcpp_thread_yield()
+{
+    sched_yield();
+}
+
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+void __libcpp_thread_sleep_for(chrono::nanoseconds __ns)
+{
+    __libcpp_timespec_t __ts = __libcpp_to_timespec(__ns);
+    while (nanosleep(&__ts, &__ts) == -1 && errno == EINTR);
+}
+
+#if defined(__linux__) && !defined(_LIBCUDACXX_HAS_NO_PLATFORM_WAIT)
+
+#define _LIBCUDACXX_HAS_PLATFORM_WAIT
+
+typedef int __libcpp_platform_wait_t;
+
+template<typename _Tp>
+struct __libcpp_platform_wait_uses_type {
+    enum { __value = is_same<__remove_cv_t<_Tp>, __libcpp_platform_wait_t>::value };
+};
+
+template <class _Tp, typename enable_if<__libcpp_platform_wait_uses_type<_Tp>::__value, int>::type = 1>
+void __libcpp_platform_wait(_Tp const* ptr, _Tp val, void const* timeout) {
+    syscall(SYS_futex, ptr, FUTEX_WAIT_PRIVATE, val, timeout, 0, 0);
+}
+
+template <class _Tp, typename enable_if<__libcpp_platform_wait_uses_type<_Tp>::__value, int>::type = 1>
+void __libcpp_platform_wake(_Tp const* ptr, bool all) {
+    syscall(SYS_futex, ptr, FUTEX_WAKE_PRIVATE, all ? INT_MAX : 1, 0, 0, 0);
+}
+
+#endif // defined(__linux__) && !defined(_LIBCUDACXX_HAS_NO_PLATFORM_WAIT)
+
+#elif defined(_LIBCUDACXX_HAS_THREAD_API_WIN32)
+
+void __libcpp_thread_yield()
+{
+    SwitchToThread();
+}
+
+void __libcpp_thread_sleep_for(chrono::nanoseconds __ns)
+{
+    using namespace chrono;
+    // round-up to the nearest milisecond
+    milliseconds __ms =
+        duration_cast<milliseconds>(__ns + chrono::nanoseconds(999999));
+    Sleep(static_cast<DWORD>(__ms.count()));
+}
+
+#endif // defined(_LIBCUDACXX_HAS_THREAD_API_WIN32)
+
+#endif // !defined(_LIBCUDACXX_HAS_THREAD_LIBRARY_EXTERNAL) || defined(_LIBCUDACXX_BUILDING_THREAD_LIBRARY_EXTERNAL)
+
+template<class _Fn>
+_LIBCUDACXX_THREAD_ABI_VISIBILITY
+bool __libcpp_thread_poll_with_backoff(_Fn && __f, chrono::nanoseconds __max)
+{
+    chrono::high_resolution_clock::time_point const __start = chrono::high_resolution_clock::now();
+    for(int __count = 0;;) {
+      if(__f())
+        return true;
+      if(__count < _LIBCUDACXX_POLLING_COUNT) {
+        if(__count > (_LIBCUDACXX_POLLING_COUNT >> 1))
+          __libcpp_thread_yield_processor();
+        __count += 1;
+        continue;
+      }
+      chrono::high_resolution_clock::duration const __elapsed = chrono::high_resolution_clock::now() - __start;
+      if(__max != chrono::nanoseconds::zero() &&
+         __max < __elapsed)
+         return false;
+      chrono::nanoseconds const __step = __elapsed / 4;
+      if(__step >= chrono::milliseconds(1))
+        __libcpp_thread_sleep_for(chrono::milliseconds(1));
+      else if(__step >= chrono::microseconds(10))
+        __libcpp_thread_sleep_for(__step);
+      else
+        __libcpp_thread_yield();
+    }
+}
+
+#ifndef _LIBCUDACXX_HAS_NO_THREAD_CONTENTION_TABLE
+
+struct alignas(64) __libcpp_contention_t {
+#if defined(_LIBCUDACXX_HAS_PLATFORM_WAIT)
+    ptrdiff_t                __waiters = 0;
+    __libcpp_platform_wait_t __version = 0;
+#else
+    ptrdiff_t                __credit = 0;
+    __libcpp_mutex_t         __mutex = _LIBCUDACXX_MUTEX_INITIALIZER;
+    __libcpp_condvar_t       __condvar = _LIBCUDACXX_CONDVAR_INITIALIZER;
+#endif
+};
+
+_LIBCUDACXX_FUNC_VIS
+__libcpp_contention_t * __libcpp_contention_state(void const volatile * p) noexcept;
+
+#endif // _LIBCUDACXX_HAS_NO_THREAD_CONTENTION_TABLE
+
+#if !defined(_LIBCUDACXX_HAS_NO_TREE_BARRIER) && !defined(_LIBCUDACXX_HAS_NO_THREAD_FAVORITE_BARRIER_INDEX)
+
+_LIBCUDACXX_EXPORTED_FROM_ABI
+extern thread_local ptrdiff_t __libcpp_thread_favorite_barrier_index;
+
+#endif
+
+#ifndef __cuda_std__
+
+class _LIBCUDACXX_TYPE_VIS thread;
+class _LIBCUDACXX_TYPE_VIS __thread_id;
+
+namespace this_thread
+{
+
+_LIBCUDACXX_INLINE_VISIBILITY __thread_id get_id() noexcept;
+
+}  // this_thread
+
+template<> struct hash<__thread_id>;
+
+class _LIBCUDACXX_TEMPLATE_VIS __thread_id
+{
+    // FIXME: pthread_t is a pointer on Darwin but a long on Linux.
+    // NULL is the no-thread value on Darwin.  Someone needs to check
+    // on other platforms.  We assume 0 works everywhere for now.
+    __libcpp_thread_id __id_;
+
+public:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __thread_id() noexcept : __id_(0) {}
+
+    friend _LIBCUDACXX_INLINE_VISIBILITY
+        bool operator==(__thread_id __x, __thread_id __y) noexcept
+        { // don't pass id==0 to underlying routines
+        if (__x.__id_ == 0) return __y.__id_ == 0;
+        if (__y.__id_ == 0) return false;
+        return __libcpp_thread_id_equal(__x.__id_, __y.__id_);
+        }
+    friend _LIBCUDACXX_INLINE_VISIBILITY
+        bool operator!=(__thread_id __x, __thread_id __y) noexcept
+        {return !(__x == __y);}
+    friend _LIBCUDACXX_INLINE_VISIBILITY
+        bool operator< (__thread_id __x, __thread_id __y) noexcept
+        { // id==0 is always less than any other thread_id
+        if (__x.__id_ == 0) return __y.__id_ != 0;
+        if (__y.__id_ == 0) return false;
+        return  __libcpp_thread_id_less(__x.__id_, __y.__id_);
+        }
+    friend _LIBCUDACXX_INLINE_VISIBILITY
+        bool operator<=(__thread_id __x, __thread_id __y) noexcept
+        {return !(__y < __x);}
+    friend _LIBCUDACXX_INLINE_VISIBILITY
+        bool operator> (__thread_id __x, __thread_id __y) noexcept
+        {return   __y < __x ;}
+    friend _LIBCUDACXX_INLINE_VISIBILITY
+        bool operator>=(__thread_id __x, __thread_id __y) noexcept
+        {return !(__x < __y);}
+
+    _LIBCUDACXX_INLINE_VISIBILITY
+    void __reset() { __id_ = 0; }
+
+#ifndef __cuda_std__
+    template<class _CharT, class _Traits>
+    friend
+    _LIBCUDACXX_INLINE_VISIBILITY
+    basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id);
+#endif
+
+private:
+    _LIBCUDACXX_INLINE_VISIBILITY
+    __thread_id(__libcpp_thread_id __id) : __id_(__id) {}
+
+    friend __thread_id this_thread::get_id() noexcept;
+    friend class _LIBCUDACXX_TYPE_VIS thread;
+    friend struct _LIBCUDACXX_TEMPLATE_VIS hash<__thread_id>;
+};
+
+namespace this_thread
+{
+
+inline _LIBCUDACXX_INLINE_VISIBILITY
+__thread_id
+get_id() noexcept
+{
+    return __libcpp_thread_get_current_id();
+}
+
+}  // this_thread
+
+#endif // __cuda_std__
+
+#endif // !_LIBCUDACXX_HAS_NO_THREADS
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#ifndef __cuda_std__
+#include <__pragma_pop>
+#endif
+
+#endif // _LIBCUDACXX_THREADING_SUPPORT

cuda_toolkit/include/__undef_macros

@@ -0,0 +1,33 @@
+// -*- C++ -*-
+//===------------------------ __undef_macros ------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+
+#ifdef min
+#if !defined(_LIBCUDACXX_DISABLE_MACRO_CONFLICT_WARNINGS)
+#if defined(_LIBCUDACXX_WARNING)
+_LIBCUDACXX_WARNING("macro min is incompatible with C++.  Try #define NOMINMAX "
+                "before any Windows header. #undefing min")
+#else
+#warning: macro min is incompatible with C++.  #undefing min
+#endif
+#endif
+#undef min
+#endif
+
+#ifdef max
+#if !defined(_LIBCUDACXX_DISABLE_MACRO_CONFLICT_WARNINGS)
+#if defined(_LIBCUDACXX_WARNING)
+_LIBCUDACXX_WARNING("macro max is incompatible with C++.  Try #define NOMINMAX "
+                "before any Windows header. #undefing max")
+#else
+#warning: macro max is incompatible with C++.  #undefing max
+#endif
+#endif
+#undef max
+#endif

cuda_toolkit/include/__verbose_abort

@@ -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___VERBOSE_ABORT
+#define _LIBCUDACXX___VERBOSE_ABORT
+
+#ifndef __cuda_std__
+#include <__config>
+#endif // __cuda_std__
+
+#include "__availability"
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+// Provide a default implementation of __libcpp_verbose_abort if we know that neither the built
+// library nor the user is providing one. Otherwise, just declare it and use the one from the
+// built library or the one provided by the user.
+//
+// We can't provide a great implementation because it needs to be pretty much
+// dependency-free (this is included everywhere else in the library).
+#if defined(_LIBCUDACXX_HAS_NO_VERBOSE_ABORT_IN_LIBRARY) && !defined(_LIBCUDACXX_AVAILABILITY_CUSTOM_VERBOSE_ABORT_PROVIDED)
+
+extern "C" void abort();
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+_LIBCUDACXX_NORETURN _LIBCUDACXX_ATTRIBUTE_FORMAT(__printf__, 1, 2) _LIBCUDACXX_HIDE_FROM_ABI inline
+void __libcpp_verbose_abort(const char *, ...) {
+  ::abort();
+  __builtin_unreachable(); // never reached, but needed to tell the compiler that the function never returns
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#else
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+_LIBCUDACXX_NORETURN _LIBCUDACXX_OVERRIDABLE_FUNC_VIS _LIBCUDACXX_ATTRIBUTE_FORMAT(__printf__, 1, 2)
+void __libcpp_verbose_abort(const char *__format, ...);
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif
+
+#endif // _LIBCUDACXX___VERBOSE_ABORT