Path: blob/main/contrib/llvm-project/clang/lib/Tooling/Inclusions/Stdlib/StdSymbolMap.inc
35294 views
//===-- gen_std.py generated file -------------------------------*- C++ -*-===// // // Used to build a lookup table (qualified names => include headers) for CPP // Standard Library symbols. // // This file was generated automatically by // clang/tools/include-mapping/gen_std.py, DO NOT EDIT! // // Generated from cppreference offline HTML book (modified on 2022-07-30). //===----------------------------------------------------------------------===// SYMBOL(ATOMIC_BOOL_LOCK_FREE, None, <atomic>) SYMBOL(ATOMIC_CHAR16_T_LOCK_FREE, None, <atomic>) SYMBOL(ATOMIC_CHAR32_T_LOCK_FREE, None, <atomic>) SYMBOL(ATOMIC_CHAR8_T_LOCK_FREE, None, <atomic>) SYMBOL(ATOMIC_CHAR_LOCK_FREE, None, <atomic>) SYMBOL(ATOMIC_FLAG_INIT, None, <atomic>) SYMBOL(ATOMIC_INT_LOCK_FREE, None, <atomic>) SYMBOL(ATOMIC_LLONG_LOCK_FREE, None, <atomic>) SYMBOL(ATOMIC_LONG_LOCK_FREE, None, <atomic>) SYMBOL(ATOMIC_POINTER_LOCK_FREE, None, <atomic>) SYMBOL(ATOMIC_SHORT_LOCK_FREE, None, <atomic>) SYMBOL(ATOMIC_VAR_INIT, None, <atomic>) SYMBOL(ATOMIC_WCHAR_T_LOCK_FREE, None, <atomic>) SYMBOL(BUFSIZ, None, <cstdio>) SYMBOL(BUFSIZ, None, <stdio.h>) SYMBOL(CHAR_BIT, None, <climits>) SYMBOL(CHAR_BIT, None, <limits.h>) SYMBOL(CHAR_MAX, None, <climits>) SYMBOL(CHAR_MAX, None, <limits.h>) SYMBOL(CHAR_MIN, None, <climits>) SYMBOL(CHAR_MIN, None, <limits.h>) SYMBOL(CLOCKS_PER_SEC, None, <ctime>) SYMBOL(CLOCKS_PER_SEC, None, <time.h>) SYMBOL(DBL_DECIMAL_DIG, None, <cfloat>) SYMBOL(DBL_DECIMAL_DIG, None, <float.h>) SYMBOL(DBL_DIG, None, <cfloat>) SYMBOL(DBL_DIG, None, <float.h>) SYMBOL(DBL_EPSILON, None, <cfloat>) SYMBOL(DBL_EPSILON, None, <float.h>) SYMBOL(DBL_HAS_SUBNORM, None, <cfloat>) SYMBOL(DBL_HAS_SUBNORM, None, <float.h>) SYMBOL(DBL_MANT_DIG, None, <cfloat>) SYMBOL(DBL_MANT_DIG, None, <float.h>) SYMBOL(DBL_MAX, None, <cfloat>) SYMBOL(DBL_MAX, None, <float.h>) SYMBOL(DBL_MAX_10_EXP, None, <cfloat>) SYMBOL(DBL_MAX_10_EXP, None, <float.h>) SYMBOL(DBL_MAX_EXP, None, <cfloat>) SYMBOL(DBL_MAX_EXP, None, <float.h>) SYMBOL(DBL_MIN, None, <cfloat>) SYMBOL(DBL_MIN, None, <float.h>) SYMBOL(DBL_MIN_10_EXP, None, <cfloat>) SYMBOL(DBL_MIN_10_EXP, None, <float.h>) SYMBOL(DBL_MIN_EXP, None, <cfloat>) SYMBOL(DBL_MIN_EXP, None, <float.h>) SYMBOL(DBL_TRUE_MIN, None, <cfloat>) SYMBOL(DBL_TRUE_MIN, None, <float.h>) SYMBOL(DECIMAL_DIG, None, <cfloat>) SYMBOL(DECIMAL_DIG, None, <float.h>) SYMBOL(E2BIG, None, <cerrno>) SYMBOL(E2BIG, None, <errno.h>) SYMBOL(EACCES, None, <cerrno>) SYMBOL(EACCES, None, <errno.h>) SYMBOL(EADDRINUSE, None, <cerrno>) SYMBOL(EADDRINUSE, None, <errno.h>) SYMBOL(EADDRNOTAVAIL, None, <cerrno>) SYMBOL(EADDRNOTAVAIL, None, <errno.h>) SYMBOL(EAFNOSUPPORT, None, <cerrno>) SYMBOL(EAFNOSUPPORT, None, <errno.h>) SYMBOL(EAGAIN, None, <cerrno>) SYMBOL(EAGAIN, None, <errno.h>) SYMBOL(EALREADY, None, <cerrno>) SYMBOL(EALREADY, None, <errno.h>) SYMBOL(EBADF, None, <cerrno>) SYMBOL(EBADF, None, <errno.h>) SYMBOL(EBADMSG, None, <cerrno>) SYMBOL(EBADMSG, None, <errno.h>) SYMBOL(EBUSY, None, <cerrno>) SYMBOL(EBUSY, None, <errno.h>) SYMBOL(ECANCELED, None, <cerrno>) SYMBOL(ECANCELED, None, <errno.h>) SYMBOL(ECHILD, None, <cerrno>) SYMBOL(ECHILD, None, <errno.h>) SYMBOL(ECONNABORTED, None, <cerrno>) SYMBOL(ECONNABORTED, None, <errno.h>) SYMBOL(ECONNREFUSED, None, <cerrno>) SYMBOL(ECONNREFUSED, None, <errno.h>) SYMBOL(ECONNRESET, None, <cerrno>) SYMBOL(ECONNRESET, None, <errno.h>) SYMBOL(EDEADLK, None, <cerrno>) SYMBOL(EDEADLK, None, <errno.h>) SYMBOL(EDESTADDRREQ, None, <cerrno>) SYMBOL(EDESTADDRREQ, None, <errno.h>) SYMBOL(EDOM, None, <cerrno>) SYMBOL(EDOM, None, <errno.h>) SYMBOL(EEXIST, None, <cerrno>) SYMBOL(EEXIST, None, <errno.h>) SYMBOL(EFAULT, None, <cerrno>) SYMBOL(EFAULT, None, <errno.h>) SYMBOL(EFBIG, None, <cerrno>) SYMBOL(EFBIG, None, <errno.h>) SYMBOL(EHOSTUNREACH, None, <cerrno>) SYMBOL(EHOSTUNREACH, None, <errno.h>) SYMBOL(EIDRM, None, <cerrno>) SYMBOL(EIDRM, None, <errno.h>) SYMBOL(EILSEQ, None, <cerrno>) SYMBOL(EILSEQ, None, <errno.h>) SYMBOL(EINPROGRESS, None, <cerrno>) SYMBOL(EINPROGRESS, None, <errno.h>) SYMBOL(EINTR, None, <cerrno>) SYMBOL(EINTR, None, <errno.h>) SYMBOL(EINVAL, None, <cerrno>) SYMBOL(EINVAL, None, <errno.h>) SYMBOL(EIO, None, <cerrno>) SYMBOL(EIO, None, <errno.h>) SYMBOL(EISCONN, None, <cerrno>) SYMBOL(EISCONN, None, <errno.h>) SYMBOL(EISDIR, None, <cerrno>) SYMBOL(EISDIR, None, <errno.h>) SYMBOL(ELOOP, None, <cerrno>) SYMBOL(ELOOP, None, <errno.h>) SYMBOL(EMFILE, None, <cerrno>) SYMBOL(EMFILE, None, <errno.h>) SYMBOL(EMLINK, None, <cerrno>) SYMBOL(EMLINK, None, <errno.h>) SYMBOL(EMSGSIZE, None, <cerrno>) SYMBOL(EMSGSIZE, None, <errno.h>) SYMBOL(ENAMETOOLONG, None, <cerrno>) SYMBOL(ENAMETOOLONG, None, <errno.h>) SYMBOL(ENETDOWN, None, <cerrno>) SYMBOL(ENETDOWN, None, <errno.h>) SYMBOL(ENETRESET, None, <cerrno>) SYMBOL(ENETRESET, None, <errno.h>) SYMBOL(ENETUNREACH, None, <cerrno>) SYMBOL(ENETUNREACH, None, <errno.h>) SYMBOL(ENFILE, None, <cerrno>) SYMBOL(ENFILE, None, <errno.h>) SYMBOL(ENOBUFS, None, <cerrno>) SYMBOL(ENOBUFS, None, <errno.h>) SYMBOL(ENODATA, None, <cerrno>) SYMBOL(ENODATA, None, <errno.h>) SYMBOL(ENODEV, None, <cerrno>) SYMBOL(ENODEV, None, <errno.h>) SYMBOL(ENOENT, None, <cerrno>) SYMBOL(ENOENT, None, <errno.h>) SYMBOL(ENOEXEC, None, <cerrno>) SYMBOL(ENOEXEC, None, <errno.h>) SYMBOL(ENOLCK, None, <cerrno>) SYMBOL(ENOLCK, None, <errno.h>) SYMBOL(ENOLINK, None, <cerrno>) SYMBOL(ENOLINK, None, <errno.h>) SYMBOL(ENOMEM, None, <cerrno>) SYMBOL(ENOMEM, None, <errno.h>) SYMBOL(ENOMSG, None, <cerrno>) SYMBOL(ENOMSG, None, <errno.h>) SYMBOL(ENOPROTOOPT, None, <cerrno>) SYMBOL(ENOPROTOOPT, None, <errno.h>) SYMBOL(ENOSPC, None, <cerrno>) SYMBOL(ENOSPC, None, <errno.h>) SYMBOL(ENOSR, None, <cerrno>) SYMBOL(ENOSR, None, <errno.h>) SYMBOL(ENOSTR, None, <cerrno>) SYMBOL(ENOSTR, None, <errno.h>) SYMBOL(ENOSYS, None, <cerrno>) SYMBOL(ENOSYS, None, <errno.h>) SYMBOL(ENOTCONN, None, <cerrno>) SYMBOL(ENOTCONN, None, <errno.h>) SYMBOL(ENOTDIR, None, <cerrno>) SYMBOL(ENOTDIR, None, <errno.h>) SYMBOL(ENOTEMPTY, None, <cerrno>) SYMBOL(ENOTEMPTY, None, <errno.h>) SYMBOL(ENOTRECOVERABLE, None, <cerrno>) SYMBOL(ENOTRECOVERABLE, None, <errno.h>) SYMBOL(ENOTSOCK, None, <cerrno>) SYMBOL(ENOTSOCK, None, <errno.h>) SYMBOL(ENOTSUP, None, <cerrno>) SYMBOL(ENOTSUP, None, <errno.h>) SYMBOL(ENOTTY, None, <cerrno>) SYMBOL(ENOTTY, None, <errno.h>) SYMBOL(ENXIO, None, <cerrno>) SYMBOL(ENXIO, None, <errno.h>) SYMBOL(EOF, None, <cstdio>) SYMBOL(EOF, None, <stdio.h>) SYMBOL(EOPNOTSUPP, None, <cerrno>) SYMBOL(EOPNOTSUPP, None, <errno.h>) SYMBOL(EOVERFLOW, None, <cerrno>) SYMBOL(EOVERFLOW, None, <errno.h>) SYMBOL(EOWNERDEAD, None, <cerrno>) SYMBOL(EOWNERDEAD, None, <errno.h>) SYMBOL(EPERM, None, <cerrno>) SYMBOL(EPERM, None, <errno.h>) SYMBOL(EPIPE, None, <cerrno>) SYMBOL(EPIPE, None, <errno.h>) SYMBOL(EPROTO, None, <cerrno>) SYMBOL(EPROTO, None, <errno.h>) SYMBOL(EPROTONOSUPPORT, None, <cerrno>) SYMBOL(EPROTONOSUPPORT, None, <errno.h>) SYMBOL(EPROTOTYPE, None, <cerrno>) SYMBOL(EPROTOTYPE, None, <errno.h>) SYMBOL(ERANGE, None, <cerrno>) SYMBOL(ERANGE, None, <errno.h>) SYMBOL(EROFS, None, <cerrno>) SYMBOL(EROFS, None, <errno.h>) SYMBOL(ESPIPE, None, <cerrno>) SYMBOL(ESPIPE, None, <errno.h>) SYMBOL(ESRCH, None, <cerrno>) SYMBOL(ESRCH, None, <errno.h>) SYMBOL(ETIME, None, <cerrno>) SYMBOL(ETIME, None, <errno.h>) SYMBOL(ETIMEDOUT, None, <cerrno>) SYMBOL(ETIMEDOUT, None, <errno.h>) SYMBOL(ETXTBSY, None, <cerrno>) SYMBOL(ETXTBSY, None, <errno.h>) SYMBOL(EWOULDBLOCK, None, <cerrno>) SYMBOL(EWOULDBLOCK, None, <errno.h>) SYMBOL(EXDEV, None, <cerrno>) SYMBOL(EXDEV, None, <errno.h>) SYMBOL(EXIT_FAILURE, None, <cstdlib>) SYMBOL(EXIT_FAILURE, None, <stdlib.h>) SYMBOL(EXIT_SUCCESS, None, <cstdlib>) SYMBOL(EXIT_SUCCESS, None, <stdlib.h>) SYMBOL(FE_ALL_EXCEPT, None, <cfenv>) SYMBOL(FE_ALL_EXCEPT, None, <fenv.h>) SYMBOL(FE_DFL_ENV, None, <cfenv>) SYMBOL(FE_DFL_ENV, None, <fenv.h>) SYMBOL(FE_DIVBYZERO, None, <cfenv>) SYMBOL(FE_DIVBYZERO, None, <fenv.h>) SYMBOL(FE_DOWNWARD, None, <cfenv>) SYMBOL(FE_DOWNWARD, None, <fenv.h>) SYMBOL(FE_INEXACT, None, <cfenv>) SYMBOL(FE_INEXACT, None, <fenv.h>) SYMBOL(FE_INVALID, None, <cfenv>) SYMBOL(FE_INVALID, None, <fenv.h>) SYMBOL(FE_OVERFLOW, None, <cfenv>) SYMBOL(FE_OVERFLOW, None, <fenv.h>) SYMBOL(FE_TONEAREST, None, <cfenv>) SYMBOL(FE_TONEAREST, None, <fenv.h>) SYMBOL(FE_TOWARDZERO, None, <cfenv>) SYMBOL(FE_TOWARDZERO, None, <fenv.h>) SYMBOL(FE_UNDERFLOW, None, <cfenv>) SYMBOL(FE_UNDERFLOW, None, <fenv.h>) SYMBOL(FE_UPWARD, None, <cfenv>) SYMBOL(FE_UPWARD, None, <fenv.h>) SYMBOL(FILENAME_MAX, None, <cstdio>) SYMBOL(FILENAME_MAX, None, <stdio.h>) SYMBOL(FLT_DECIMAL_DIG, None, <cfloat>) SYMBOL(FLT_DECIMAL_DIG, None, <float.h>) SYMBOL(FLT_DIG, None, <cfloat>) SYMBOL(FLT_DIG, None, <float.h>) SYMBOL(FLT_EPSILON, None, <cfloat>) SYMBOL(FLT_EPSILON, None, <float.h>) SYMBOL(FLT_EVAL_METHOD, None, <cfloat>) SYMBOL(FLT_EVAL_METHOD, None, <float.h>) SYMBOL(FLT_HAS_SUBNORM, None, <cfloat>) SYMBOL(FLT_HAS_SUBNORM, None, <float.h>) SYMBOL(FLT_MANT_DIG, None, <cfloat>) SYMBOL(FLT_MANT_DIG, None, <float.h>) SYMBOL(FLT_MAX, None, <cfloat>) SYMBOL(FLT_MAX, None, <float.h>) SYMBOL(FLT_MAX_10_EXP, None, <cfloat>) SYMBOL(FLT_MAX_10_EXP, None, <float.h>) SYMBOL(FLT_MAX_EXP, None, <cfloat>) SYMBOL(FLT_MAX_EXP, None, <float.h>) SYMBOL(FLT_MIN, None, <cfloat>) SYMBOL(FLT_MIN, None, <float.h>) SYMBOL(FLT_MIN_10_EXP, None, <cfloat>) SYMBOL(FLT_MIN_10_EXP, None, <float.h>) SYMBOL(FLT_MIN_EXP, None, <cfloat>) SYMBOL(FLT_MIN_EXP, None, <float.h>) SYMBOL(FLT_RADIX, None, <cfloat>) SYMBOL(FLT_RADIX, None, <float.h>) SYMBOL(FLT_ROUNDS, None, <cfloat>) SYMBOL(FLT_ROUNDS, None, <float.h>) SYMBOL(FLT_TRUE_MIN, None, <cfloat>) SYMBOL(FLT_TRUE_MIN, None, <float.h>) SYMBOL(FOPEN_MAX, None, <cstdio>) SYMBOL(FOPEN_MAX, None, <stdio.h>) SYMBOL(FP_FAST_FMA, None, <cmath>) SYMBOL(FP_FAST_FMA, None, <math.h>) SYMBOL(FP_FAST_FMAF, None, <cmath>) SYMBOL(FP_FAST_FMAF, None, <math.h>) SYMBOL(FP_FAST_FMAL, None, <cmath>) SYMBOL(FP_FAST_FMAL, None, <math.h>) SYMBOL(FP_ILOGB0, None, <cmath>) SYMBOL(FP_ILOGB0, None, <math.h>) SYMBOL(FP_ILOGBNAN, None, <cmath>) SYMBOL(FP_ILOGBNAN, None, <math.h>) SYMBOL(FP_INFINITE, None, <cmath>) SYMBOL(FP_INFINITE, None, <math.h>) SYMBOL(FP_NAN, None, <cmath>) SYMBOL(FP_NAN, None, <math.h>) SYMBOL(FP_NORMAL, None, <cmath>) SYMBOL(FP_NORMAL, None, <math.h>) SYMBOL(FP_SUBNORMAL, None, <cmath>) SYMBOL(FP_SUBNORMAL, None, <math.h>) SYMBOL(FP_ZERO, None, <cmath>) SYMBOL(FP_ZERO, None, <math.h>) SYMBOL(HUGE_VAL, None, <cmath>) SYMBOL(HUGE_VAL, None, <math.h>) SYMBOL(HUGE_VALF, None, <cmath>) SYMBOL(HUGE_VALF, None, <math.h>) SYMBOL(HUGE_VALL, None, <cmath>) SYMBOL(HUGE_VALL, None, <math.h>) SYMBOL(INFINITY, None, <cmath>) SYMBOL(INFINITY, None, <math.h>) SYMBOL(INT16_MAX, None, <cstdint>) SYMBOL(INT16_MAX, None, <stdint.h>) SYMBOL(INT16_MIN, None, <cstdint>) SYMBOL(INT16_MIN, None, <stdint.h>) SYMBOL(INT32_MAX, None, <cstdint>) SYMBOL(INT32_MAX, None, <stdint.h>) SYMBOL(INT32_MIN, None, <cstdint>) SYMBOL(INT32_MIN, None, <stdint.h>) SYMBOL(INT64_MAX, None, <cstdint>) SYMBOL(INT64_MAX, None, <stdint.h>) SYMBOL(INT64_MIN, None, <cstdint>) SYMBOL(INT64_MIN, None, <stdint.h>) SYMBOL(INT8_MAX, None, <cstdint>) SYMBOL(INT8_MAX, None, <stdint.h>) SYMBOL(INT8_MIN, None, <cstdint>) SYMBOL(INT8_MIN, None, <stdint.h>) SYMBOL(INTMAX_MAX, None, <cstdint>) SYMBOL(INTMAX_MAX, None, <stdint.h>) SYMBOL(INTMAX_MIN, None, <cstdint>) SYMBOL(INTMAX_MIN, None, <stdint.h>) SYMBOL(INTPTR_MAX, None, <cstdint>) SYMBOL(INTPTR_MAX, None, <stdint.h>) SYMBOL(INTPTR_MIN, None, <cstdint>) SYMBOL(INTPTR_MIN, None, <stdint.h>) SYMBOL(INT_FAST16_MAX, None, <cstdint>) SYMBOL(INT_FAST16_MAX, None, <stdint.h>) SYMBOL(INT_FAST16_MIN, None, <cstdint>) SYMBOL(INT_FAST16_MIN, None, <stdint.h>) SYMBOL(INT_FAST32_MAX, None, <cstdint>) SYMBOL(INT_FAST32_MAX, None, <stdint.h>) SYMBOL(INT_FAST32_MIN, None, <cstdint>) SYMBOL(INT_FAST32_MIN, None, <stdint.h>) SYMBOL(INT_FAST64_MAX, None, <cstdint>) SYMBOL(INT_FAST64_MAX, None, <stdint.h>) SYMBOL(INT_FAST64_MIN, None, <cstdint>) SYMBOL(INT_FAST64_MIN, None, <stdint.h>) SYMBOL(INT_FAST8_MAX, None, <cstdint>) SYMBOL(INT_FAST8_MAX, None, <stdint.h>) SYMBOL(INT_FAST8_MIN, None, <cstdint>) SYMBOL(INT_FAST8_MIN, None, <stdint.h>) SYMBOL(INT_LEAST16_MAX, None, <cstdint>) SYMBOL(INT_LEAST16_MAX, None, <stdint.h>) SYMBOL(INT_LEAST16_MIN, None, <cstdint>) SYMBOL(INT_LEAST16_MIN, None, <stdint.h>) SYMBOL(INT_LEAST32_MAX, None, <cstdint>) SYMBOL(INT_LEAST32_MAX, None, <stdint.h>) SYMBOL(INT_LEAST32_MIN, None, <cstdint>) SYMBOL(INT_LEAST32_MIN, None, <stdint.h>) SYMBOL(INT_LEAST64_MAX, None, <cstdint>) SYMBOL(INT_LEAST64_MAX, None, <stdint.h>) SYMBOL(INT_LEAST64_MIN, None, <cstdint>) SYMBOL(INT_LEAST64_MIN, None, <stdint.h>) SYMBOL(INT_LEAST8_MAX, None, <cstdint>) SYMBOL(INT_LEAST8_MAX, None, <stdint.h>) SYMBOL(INT_LEAST8_MIN, None, <cstdint>) SYMBOL(INT_LEAST8_MIN, None, <stdint.h>) SYMBOL(INT_MAX, None, <climits>) SYMBOL(INT_MAX, None, <limits.h>) SYMBOL(INT_MIN, None, <climits>) SYMBOL(INT_MIN, None, <limits.h>) SYMBOL(LC_ALL, None, <clocale>) SYMBOL(LC_ALL, None, <locale.h>) SYMBOL(LC_COLLATE, None, <clocale>) SYMBOL(LC_COLLATE, None, <locale.h>) SYMBOL(LC_CTYPE, None, <clocale>) SYMBOL(LC_CTYPE, None, <locale.h>) SYMBOL(LC_MONETARY, None, <clocale>) SYMBOL(LC_MONETARY, None, <locale.h>) SYMBOL(LC_NUMERIC, None, <clocale>) SYMBOL(LC_NUMERIC, None, <locale.h>) SYMBOL(LC_TIME, None, <clocale>) SYMBOL(LC_TIME, None, <locale.h>) SYMBOL(LDBL_DECIMAL_DIG, None, <cfloat>) SYMBOL(LDBL_DECIMAL_DIG, None, <float.h>) SYMBOL(LDBL_DIG, None, <cfloat>) SYMBOL(LDBL_DIG, None, <float.h>) SYMBOL(LDBL_EPSILON, None, <cfloat>) SYMBOL(LDBL_EPSILON, None, <float.h>) SYMBOL(LDBL_HAS_SUBNORM, None, <cfloat>) SYMBOL(LDBL_HAS_SUBNORM, None, <float.h>) SYMBOL(LDBL_MANT_DIG, None, <cfloat>) SYMBOL(LDBL_MANT_DIG, None, <float.h>) SYMBOL(LDBL_MAX, None, <cfloat>) SYMBOL(LDBL_MAX, None, <float.h>) SYMBOL(LDBL_MAX_10_EXP, None, <cfloat>) SYMBOL(LDBL_MAX_10_EXP, None, <float.h>) SYMBOL(LDBL_MAX_EXP, None, <cfloat>) SYMBOL(LDBL_MAX_EXP, None, <float.h>) SYMBOL(LDBL_MIN, None, <cfloat>) SYMBOL(LDBL_MIN, None, <float.h>) SYMBOL(LDBL_MIN_10_EXP, None, <cfloat>) SYMBOL(LDBL_MIN_10_EXP, None, <float.h>) SYMBOL(LDBL_MIN_EXP, None, <cfloat>) SYMBOL(LDBL_MIN_EXP, None, <float.h>) SYMBOL(LDBL_TRUE_MIN, None, <cfloat>) SYMBOL(LDBL_TRUE_MIN, None, <float.h>) SYMBOL(LLONG_MAX, None, <climits>) SYMBOL(LLONG_MAX, None, <limits.h>) SYMBOL(LLONG_MIN, None, <climits>) SYMBOL(LLONG_MIN, None, <limits.h>) SYMBOL(LONG_MAX, None, <climits>) SYMBOL(LONG_MAX, None, <limits.h>) SYMBOL(LONG_MIN, None, <climits>) SYMBOL(LONG_MIN, None, <limits.h>) SYMBOL(L_tmpnam, None, <cstdio>) SYMBOL(L_tmpnam, None, <stdio.h>) SYMBOL(MATH_ERREXCEPT, None, <cmath>) SYMBOL(MATH_ERREXCEPT, None, <math.h>) SYMBOL(MATH_ERRNO, None, <cmath>) SYMBOL(MATH_ERRNO, None, <math.h>) SYMBOL(MB_CUR_MAX, None, <cstdlib>) SYMBOL(MB_CUR_MAX, None, <stdlib.h>) SYMBOL(MB_LEN_MAX, None, <climits>) SYMBOL(MB_LEN_MAX, None, <limits.h>) SYMBOL(NAN, None, <cmath>) SYMBOL(NAN, None, <math.h>) SYMBOL(ONCE_FLAG_INIT, None, <mutex>) SYMBOL(PTRDIFF_MAX, None, <cstdint>) SYMBOL(PTRDIFF_MAX, None, <stdint.h>) SYMBOL(PTRDIFF_MIN, None, <cstdint>) SYMBOL(PTRDIFF_MIN, None, <stdint.h>) SYMBOL(RAND_MAX, None, <cstdlib>) SYMBOL(RAND_MAX, None, <stdlib.h>) SYMBOL(SCHAR_MAX, None, <climits>) SYMBOL(SCHAR_MAX, None, <limits.h>) SYMBOL(SCHAR_MIN, None, <climits>) SYMBOL(SCHAR_MIN, None, <limits.h>) SYMBOL(SEEK_CUR, None, <cstdio>) SYMBOL(SEEK_CUR, None, <stdio.h>) SYMBOL(SEEK_END, None, <cstdio>) SYMBOL(SEEK_END, None, <stdio.h>) SYMBOL(SEEK_SET, None, <cstdio>) SYMBOL(SEEK_SET, None, <stdio.h>) SYMBOL(SHRT_MAX, None, <climits>) SYMBOL(SHRT_MAX, None, <limits.h>) SYMBOL(SHRT_MIN, None, <climits>) SYMBOL(SHRT_MIN, None, <limits.h>) SYMBOL(SIGABRT, None, <csignal>) SYMBOL(SIGABRT, None, <signal.h>) SYMBOL(SIGFPE, None, <csignal>) SYMBOL(SIGFPE, None, <signal.h>) SYMBOL(SIGILL, None, <csignal>) SYMBOL(SIGILL, None, <signal.h>) SYMBOL(SIGINT, None, <csignal>) SYMBOL(SIGINT, None, <signal.h>) SYMBOL(SIGSEGV, None, <csignal>) SYMBOL(SIGSEGV, None, <signal.h>) SYMBOL(SIGTERM, None, <csignal>) SYMBOL(SIGTERM, None, <signal.h>) SYMBOL(SIG_ATOMIC_MAX, None, <cstdint>) SYMBOL(SIG_ATOMIC_MAX, None, <stdint.h>) SYMBOL(SIG_ATOMIC_MIN, None, <cstdint>) SYMBOL(SIG_ATOMIC_MIN, None, <stdint.h>) SYMBOL(SIG_DFL, None, <csignal>) SYMBOL(SIG_DFL, None, <signal.h>) SYMBOL(SIG_ERR, None, <csignal>) SYMBOL(SIG_ERR, None, <signal.h>) SYMBOL(SIG_IGN, None, <csignal>) SYMBOL(SIG_IGN, None, <signal.h>) SYMBOL(SIZE_MAX, None, <cstdint>) SYMBOL(SIZE_MAX, None, <stdint.h>) SYMBOL(TIME_UTC, None, <ctime>) SYMBOL(TIME_UTC, None, <time.h>) SYMBOL(TMP_MAX, None, <cstdio>) SYMBOL(TMP_MAX, None, <stdio.h>) SYMBOL(UCHAR_MAX, None, <climits>) SYMBOL(UCHAR_MAX, None, <limits.h>) SYMBOL(UINT16_MAX, None, <cstdint>) SYMBOL(UINT16_MAX, None, <stdint.h>) SYMBOL(UINT32_MAX, None, <cstdint>) SYMBOL(UINT32_MAX, None, <stdint.h>) SYMBOL(UINT64_MAX, None, <cstdint>) SYMBOL(UINT64_MAX, None, <stdint.h>) SYMBOL(UINT8_MAX, None, <cstdint>) SYMBOL(UINT8_MAX, None, <stdint.h>) SYMBOL(UINTMAX_MAX, None, <cstdint>) SYMBOL(UINTMAX_MAX, None, <stdint.h>) SYMBOL(UINTPTR_MAX, None, <cstdint>) SYMBOL(UINTPTR_MAX, None, <stdint.h>) SYMBOL(UINT_FAST16_MAX, None, <cstdint>) SYMBOL(UINT_FAST16_MAX, None, <stdint.h>) SYMBOL(UINT_FAST32_MAX, None, <cstdint>) SYMBOL(UINT_FAST32_MAX, None, <stdint.h>) SYMBOL(UINT_FAST64_MAX, None, <cstdint>) SYMBOL(UINT_FAST64_MAX, None, <stdint.h>) SYMBOL(UINT_FAST8_MAX, None, <cstdint>) SYMBOL(UINT_FAST8_MAX, None, <stdint.h>) SYMBOL(UINT_LEAST16_MAX, None, <cstdint>) SYMBOL(UINT_LEAST16_MAX, None, <stdint.h>) SYMBOL(UINT_LEAST32_MAX, None, <cstdint>) SYMBOL(UINT_LEAST32_MAX, None, <stdint.h>) SYMBOL(UINT_LEAST64_MAX, None, <cstdint>) SYMBOL(UINT_LEAST64_MAX, None, <stdint.h>) SYMBOL(UINT_LEAST8_MAX, None, <cstdint>) SYMBOL(UINT_LEAST8_MAX, None, <stdint.h>) SYMBOL(UINT_MAX, None, <climits>) SYMBOL(UINT_MAX, None, <limits.h>) SYMBOL(ULLONG_MAX, None, <climits>) SYMBOL(ULLONG_MAX, None, <limits.h>) SYMBOL(ULONG_MAX, None, <climits>) SYMBOL(ULONG_MAX, None, <limits.h>) SYMBOL(USHRT_MAX, None, <climits>) SYMBOL(USHRT_MAX, None, <limits.h>) SYMBOL(WEOF, None, <cwchar>) SYMBOL(WEOF, None, <wchar.h>) SYMBOL(WINT_MAX, None, <cstdint>) SYMBOL(WINT_MAX, None, <stdint.h>) SYMBOL(WINT_MIN, None, <cstdint>) SYMBOL(WINT_MIN, None, <stdint.h>) SYMBOL(_IOFBF, None, <cstdio>) SYMBOL(_IOFBF, None, <stdio.h>) SYMBOL(_IOLBF, None, <cstdio>) SYMBOL(_IOLBF, None, <stdio.h>) SYMBOL(_IONBF, None, <cstdio>) SYMBOL(_IONBF, None, <stdio.h>) SYMBOL(assert, None, <cassert>) SYMBOL(assert, None, <assert.h>) SYMBOL(errno, None, <cerrno>) SYMBOL(errno, None, <errno.h>) SYMBOL(math_errhandling, None, <cmath>) SYMBOL(math_errhandling, None, <math.h>) SYMBOL(offsetof, None, <cstddef>) SYMBOL(offsetof, None, <stddef.h>) SYMBOL(setjmp, None, <csetjmp>) SYMBOL(setjmp, None, <setjmp.h>) SYMBOL(stderr, None, <cstdio>) SYMBOL(stderr, None, <stdio.h>) SYMBOL(stdin, None, <cstdio>) SYMBOL(stdin, None, <stdio.h>) SYMBOL(stdout, None, <cstdio>) SYMBOL(stdout, None, <stdio.h>) SYMBOL(va_arg, None, <cstdarg>) SYMBOL(va_arg, None, <stdarg.h>) SYMBOL(va_copy, None, <cstdarg>) SYMBOL(va_copy, None, <stdarg.h>) SYMBOL(va_end, None, <cstdarg>) SYMBOL(va_end, None, <stdarg.h>) SYMBOL(va_start, None, <cstdarg>) SYMBOL(va_start, None, <stdarg.h>) SYMBOL(FILE, std::, <cstdio>) SYMBOL(FILE, None, <cstdio>) SYMBOL(FILE, None, <stdio.h>) SYMBOL(_Exit, std::, <cstdlib>) SYMBOL(_Exit, None, <cstdlib>) SYMBOL(_Exit, None, <stdlib.h>) SYMBOL(accumulate, std::, <numeric>) SYMBOL(acos, std::, <cmath>) SYMBOL(acos, None, <cmath>) SYMBOL(acos, None, <math.h>) SYMBOL(acosf, std::, <cmath>) SYMBOL(acosf, None, <cmath>) SYMBOL(acosf, None, <math.h>) SYMBOL(acosh, std::, <cmath>) SYMBOL(acosh, None, <cmath>) SYMBOL(acosh, None, <math.h>) SYMBOL(acoshf, std::, <cmath>) SYMBOL(acoshf, None, <cmath>) SYMBOL(acoshf, None, <math.h>) SYMBOL(acoshl, std::, <cmath>) SYMBOL(acoshl, None, <cmath>) SYMBOL(acoshl, None, <math.h>) SYMBOL(acosl, std::, <cmath>) SYMBOL(acosl, None, <cmath>) SYMBOL(acosl, None, <math.h>) SYMBOL(add_const, std::, <type_traits>) SYMBOL(add_const_t, std::, <type_traits>) SYMBOL(add_cv, std::, <type_traits>) SYMBOL(add_cv_t, std::, <type_traits>) SYMBOL(add_lvalue_reference, std::, <type_traits>) SYMBOL(add_lvalue_reference_t, std::, <type_traits>) SYMBOL(add_pointer, std::, <type_traits>) SYMBOL(add_pointer_t, std::, <type_traits>) SYMBOL(add_rvalue_reference, std::, <type_traits>) SYMBOL(add_rvalue_reference_t, std::, <type_traits>) SYMBOL(add_volatile, std::, <type_traits>) SYMBOL(add_volatile_t, std::, <type_traits>) SYMBOL(addressof, std::, <memory>) SYMBOL(adjacent_difference, std::, <numeric>) SYMBOL(adjacent_find, std::, <algorithm>) SYMBOL(adopt_lock, std::, <mutex>) SYMBOL(adopt_lock_t, std::, <mutex>) SYMBOL(advance, std::, <iterator>) SYMBOL(align, std::, <memory>) SYMBOL(align_val_t, std::, <new>) SYMBOL(aligned_alloc, std::, <cstdlib>) SYMBOL(aligned_alloc, None, <cstdlib>) SYMBOL(aligned_alloc, None, <stdlib.h>) SYMBOL(aligned_storage, std::, <type_traits>) SYMBOL(aligned_storage_t, std::, <type_traits>) SYMBOL(aligned_union, std::, <type_traits>) SYMBOL(aligned_union_t, std::, <type_traits>) SYMBOL(alignment_of, std::, <type_traits>) SYMBOL(alignment_of_v, std::, <type_traits>) SYMBOL(all_of, std::, <algorithm>) SYMBOL(allocate_at_least, std::, <memory>) SYMBOL(allocate_shared, std::, <memory>) SYMBOL(allocate_shared_for_overwrite, std::, <memory>) SYMBOL(allocation_result, std::, <memory>) SYMBOL(allocator, std::, <memory>) SYMBOL(allocator_arg, std::, <memory>) SYMBOL(allocator_arg_t, std::, <memory>) SYMBOL(allocator_traits, std::, <memory>) SYMBOL(any, std::, <any>) SYMBOL(any_of, std::, <algorithm>) SYMBOL(apply, std::, <tuple>) SYMBOL(arg, std::, <complex>) SYMBOL(array, std::, <array>) SYMBOL(as_bytes, std::, <span>) SYMBOL(as_const, std::, <utility>) SYMBOL(as_writable_bytes, std::, <span>) SYMBOL(asctime, std::, <ctime>) SYMBOL(asctime, None, <ctime>) SYMBOL(asctime, None, <time.h>) SYMBOL(asin, std::, <cmath>) SYMBOL(asin, None, <cmath>) SYMBOL(asin, None, <math.h>) SYMBOL(asinf, std::, <cmath>) SYMBOL(asinf, None, <cmath>) SYMBOL(asinf, None, <math.h>) SYMBOL(asinh, std::, <cmath>) SYMBOL(asinh, None, <cmath>) SYMBOL(asinh, None, <math.h>) SYMBOL(asinhf, std::, <cmath>) SYMBOL(asinhf, None, <cmath>) SYMBOL(asinhf, None, <math.h>) SYMBOL(asinhl, std::, <cmath>) SYMBOL(asinhl, None, <cmath>) SYMBOL(asinhl, None, <math.h>) SYMBOL(asinl, std::, <cmath>) SYMBOL(asinl, None, <cmath>) SYMBOL(asinl, None, <math.h>) SYMBOL(assignable_from, std::, <concepts>) SYMBOL(assoc_laguerre, std::, <cmath>) SYMBOL(assoc_laguerref, std::, <cmath>) SYMBOL(assoc_laguerrel, std::, <cmath>) SYMBOL(assoc_legendre, std::, <cmath>) SYMBOL(assoc_legendref, std::, <cmath>) SYMBOL(assoc_legendrel, std::, <cmath>) SYMBOL(assume_aligned, std::, <memory>) SYMBOL(async, std::, <future>) SYMBOL(at_quick_exit, std::, <cstdlib>) SYMBOL(at_quick_exit, None, <cstdlib>) SYMBOL(at_quick_exit, None, <stdlib.h>) SYMBOL(atan, std::, <cmath>) SYMBOL(atan, None, <cmath>) SYMBOL(atan, None, <math.h>) SYMBOL(atan2, std::, <cmath>) SYMBOL(atan2, None, <cmath>) SYMBOL(atan2, None, <math.h>) SYMBOL(atan2f, std::, <cmath>) SYMBOL(atan2f, None, <cmath>) SYMBOL(atan2f, None, <math.h>) SYMBOL(atan2l, std::, <cmath>) SYMBOL(atan2l, None, <cmath>) SYMBOL(atan2l, None, <math.h>) SYMBOL(atanf, std::, <cmath>) SYMBOL(atanf, None, <cmath>) SYMBOL(atanf, None, <math.h>) SYMBOL(atanh, std::, <cmath>) SYMBOL(atanh, None, <cmath>) SYMBOL(atanh, None, <math.h>) SYMBOL(atanhf, std::, <cmath>) SYMBOL(atanhf, None, <cmath>) SYMBOL(atanhf, None, <math.h>) SYMBOL(atanhl, std::, <cmath>) SYMBOL(atanhl, None, <cmath>) SYMBOL(atanhl, None, <math.h>) SYMBOL(atanl, std::, <cmath>) SYMBOL(atanl, None, <cmath>) SYMBOL(atanl, None, <math.h>) SYMBOL(atexit, std::, <cstdlib>) SYMBOL(atexit, None, <cstdlib>) SYMBOL(atexit, None, <stdlib.h>) SYMBOL(atof, std::, <cstdlib>) SYMBOL(atof, None, <cstdlib>) SYMBOL(atof, None, <stdlib.h>) SYMBOL(atoi, std::, <cstdlib>) SYMBOL(atoi, None, <cstdlib>) SYMBOL(atoi, None, <stdlib.h>) SYMBOL(atol, std::, <cstdlib>) SYMBOL(atol, None, <cstdlib>) SYMBOL(atol, None, <stdlib.h>) SYMBOL(atoll, std::, <cstdlib>) SYMBOL(atoll, None, <cstdlib>) SYMBOL(atoll, None, <stdlib.h>) SYMBOL(atomic_compare_exchange_strong, std::, <atomic>) SYMBOL(atomic_compare_exchange_strong_explicit, std::, <atomic>) SYMBOL(atomic_compare_exchange_weak, std::, <atomic>) SYMBOL(atomic_compare_exchange_weak_explicit, std::, <atomic>) SYMBOL(atomic_exchange, std::, <atomic>) SYMBOL(atomic_exchange_explicit, std::, <atomic>) SYMBOL(atomic_fetch_add, std::, <atomic>) SYMBOL(atomic_fetch_add_explicit, std::, <atomic>) SYMBOL(atomic_fetch_and, std::, <atomic>) SYMBOL(atomic_fetch_and_explicit, std::, <atomic>) SYMBOL(atomic_fetch_or, std::, <atomic>) SYMBOL(atomic_fetch_or_explicit, std::, <atomic>) SYMBOL(atomic_fetch_sub, std::, <atomic>) SYMBOL(atomic_fetch_sub_explicit, std::, <atomic>) SYMBOL(atomic_fetch_xor, std::, <atomic>) SYMBOL(atomic_fetch_xor_explicit, std::, <atomic>) SYMBOL(atomic_flag, std::, <atomic>) SYMBOL(atomic_flag_clear, std::, <atomic>) SYMBOL(atomic_flag_clear_explicit, std::, <atomic>) SYMBOL(atomic_flag_notify_all, std::, <atomic>) SYMBOL(atomic_flag_notify_one, std::, <atomic>) SYMBOL(atomic_flag_test, std::, <atomic>) SYMBOL(atomic_flag_test_and_set, std::, <atomic>) SYMBOL(atomic_flag_test_and_set_explicit, std::, <atomic>) SYMBOL(atomic_flag_test_explicit, std::, <atomic>) SYMBOL(atomic_flag_wait, std::, <atomic>) SYMBOL(atomic_flag_wait_explicit, std::, <atomic>) SYMBOL(atomic_init, std::, <atomic>) SYMBOL(atomic_is_lock_free, std::, <atomic>) SYMBOL(atomic_load, std::, <atomic>) SYMBOL(atomic_load_explicit, std::, <atomic>) SYMBOL(atomic_notify_all, std::, <atomic>) SYMBOL(atomic_notify_one, std::, <atomic>) SYMBOL(atomic_ref, std::, <atomic>) SYMBOL(atomic_signal_fence, std::, <atomic>) SYMBOL(atomic_store, std::, <atomic>) SYMBOL(atomic_store_explicit, std::, <atomic>) SYMBOL(atomic_thread_fence, std::, <atomic>) SYMBOL(atomic_wait, std::, <atomic>) SYMBOL(atomic_wait_explicit, std::, <atomic>) SYMBOL(atto, std::, <ratio>) SYMBOL(auto_ptr, std::, <memory>) SYMBOL(back_insert_iterator, std::, <iterator>) SYMBOL(back_inserter, std::, <iterator>) SYMBOL(bad_alloc, std::, <new>) SYMBOL(bad_any_cast, std::, <any>) SYMBOL(bad_array_new_length, std::, <new>) SYMBOL(bad_cast, std::, <typeinfo>) SYMBOL(bad_exception, std::, <exception>) SYMBOL(bad_function_call, std::, <functional>) SYMBOL(bad_optional_access, std::, <optional>) SYMBOL(bad_typeid, std::, <typeinfo>) SYMBOL(bad_variant_access, std::, <variant>) SYMBOL(bad_weak_ptr, std::, <memory>) SYMBOL(barrier, std::, <barrier>) SYMBOL(basic_common_reference, std::, <type_traits>) SYMBOL(basic_filebuf, std::, <fstream>) SYMBOL(basic_filebuf, std::, <iosfwd>) SYMBOL(basic_format_arg, std::, <format>) SYMBOL(basic_format_args, std::, <format>) SYMBOL(basic_format_context, std::, <format>) SYMBOL(basic_format_parse_context, std::, <format>) SYMBOL(basic_fstream, std::, <fstream>) SYMBOL(basic_fstream, std::, <iosfwd>) SYMBOL(basic_ifstream, std::, <fstream>) SYMBOL(basic_ifstream, std::, <iosfwd>) SYMBOL(basic_ios, std::, <ios>) SYMBOL(basic_ios, std::, <iostream>) SYMBOL(basic_ios, std::, <iosfwd>) SYMBOL(basic_iostream, std::, <istream>) SYMBOL(basic_iostream, std::, <iostream>) SYMBOL(basic_iostream, std::, <iosfwd>) SYMBOL(basic_ispanstream, std::, <spanstream>) SYMBOL(basic_ispanstream, std::, <iosfwd>) SYMBOL(basic_istream, std::, <istream>) SYMBOL(basic_istream, std::, <iostream>) SYMBOL(basic_istream, std::, <iosfwd>) SYMBOL(basic_istringstream, std::, <sstream>) SYMBOL(basic_istringstream, std::, <iosfwd>) SYMBOL(basic_ofstream, std::, <fstream>) SYMBOL(basic_ofstream, std::, <iosfwd>) SYMBOL(basic_ospanstream, std::, <spanstream>) SYMBOL(basic_ospanstream, std::, <iosfwd>) SYMBOL(basic_ostream, std::, <ostream>) SYMBOL(basic_ostream, std::, <iostream>) SYMBOL(basic_ostream, std::, <iosfwd>) SYMBOL(basic_ostringstream, std::, <sstream>) SYMBOL(basic_ostringstream, std::, <iosfwd>) SYMBOL(basic_osyncstream, std::, <syncstream>) SYMBOL(basic_osyncstream, std::, <iosfwd>) SYMBOL(basic_regex, std::, <regex>) SYMBOL(basic_spanbuf, std::, <spanstream>) SYMBOL(basic_spanbuf, std::, <iosfwd>) SYMBOL(basic_spanstream, std::, <spanstream>) SYMBOL(basic_spanstream, std::, <iosfwd>) SYMBOL(basic_stacktrace, std::, <stacktrace>) SYMBOL(basic_streambuf, std::, <streambuf>) SYMBOL(basic_streambuf, std::, <iostream>) SYMBOL(basic_streambuf, std::, <iosfwd>) SYMBOL(basic_string, std::, <string>) SYMBOL(basic_string_view, std::, <string_view>) SYMBOL(basic_stringbuf, std::, <sstream>) SYMBOL(basic_stringbuf, std::, <iosfwd>) SYMBOL(basic_stringstream, std::, <sstream>) SYMBOL(basic_stringstream, std::, <iosfwd>) SYMBOL(basic_syncbuf, std::, <syncstream>) SYMBOL(basic_syncbuf, std::, <iosfwd>) SYMBOL(bernoulli_distribution, std::, <random>) SYMBOL(beta, std::, <cmath>) SYMBOL(betaf, std::, <cmath>) SYMBOL(betal, std::, <cmath>) SYMBOL(bidirectional_iterator, std::, <iterator>) SYMBOL(bidirectional_iterator_tag, std::, <iterator>) SYMBOL(binary_function, std::, <functional>) SYMBOL(binary_negate, std::, <functional>) SYMBOL(binary_search, std::, <algorithm>) SYMBOL(binary_semaphore, std::, <semaphore>) SYMBOL(bind, std::, <functional>) SYMBOL(bind1st, std::, <functional>) SYMBOL(bind2nd, std::, <functional>) SYMBOL(bind_back, std::, <functional>) SYMBOL(bind_front, std::, <functional>) SYMBOL(binder1st, std::, <functional>) SYMBOL(binder2nd, std::, <functional>) SYMBOL(binomial_distribution, std::, <random>) SYMBOL(bit_and, std::, <functional>) SYMBOL(bit_cast, std::, <bit>) SYMBOL(bit_ceil, std::, <bit>) SYMBOL(bit_floor, std::, <bit>) SYMBOL(bit_not, std::, <functional>) SYMBOL(bit_or, std::, <functional>) SYMBOL(bit_width, std::, <bit>) SYMBOL(bit_xor, std::, <functional>) SYMBOL(bitset, std::, <bitset>) SYMBOL(bool_constant, std::, <type_traits>) SYMBOL(boolalpha, std::, <ios>) SYMBOL(boolalpha, std::, <iostream>) SYMBOL(boyer_moore_horspool_searcher, std::, <functional>) SYMBOL(boyer_moore_searcher, std::, <functional>) SYMBOL(bsearch, std::, <cstdlib>) SYMBOL(bsearch, None, <cstdlib>) SYMBOL(bsearch, None, <stdlib.h>) SYMBOL(btowc, std::, <cwchar>) SYMBOL(btowc, None, <cwchar>) SYMBOL(btowc, None, <wchar.h>) SYMBOL(byte, std::, <cstddef>) SYMBOL(byteswap, std::, <bit>) SYMBOL(c16rtomb, std::, <cuchar>) SYMBOL(c16rtomb, None, <cuchar>) SYMBOL(c16rtomb, None, <uchar.h>) SYMBOL(c32rtomb, std::, <cuchar>) SYMBOL(c32rtomb, None, <cuchar>) SYMBOL(c32rtomb, None, <uchar.h>) SYMBOL(c8rtomb, std::, <cuchar>) SYMBOL(c8rtomb, None, <cuchar>) SYMBOL(c8rtomb, None, <uchar.h>) SYMBOL(call_once, std::, <mutex>) SYMBOL(calloc, std::, <cstdlib>) SYMBOL(calloc, None, <cstdlib>) SYMBOL(calloc, None, <stdlib.h>) SYMBOL(cauchy_distribution, std::, <random>) SYMBOL(cbrt, std::, <cmath>) SYMBOL(cbrt, None, <cmath>) SYMBOL(cbrt, None, <math.h>) SYMBOL(cbrtf, std::, <cmath>) SYMBOL(cbrtf, None, <cmath>) SYMBOL(cbrtf, None, <math.h>) SYMBOL(cbrtl, std::, <cmath>) SYMBOL(cbrtl, None, <cmath>) SYMBOL(cbrtl, None, <math.h>) SYMBOL(ceil, std::, <cmath>) SYMBOL(ceil, None, <cmath>) SYMBOL(ceil, None, <math.h>) SYMBOL(ceilf, std::, <cmath>) SYMBOL(ceilf, None, <cmath>) SYMBOL(ceilf, None, <math.h>) SYMBOL(ceill, std::, <cmath>) SYMBOL(ceill, None, <cmath>) SYMBOL(ceill, None, <math.h>) SYMBOL(centi, std::, <ratio>) SYMBOL(cerr, std::, <iostream>) SYMBOL(char_traits, std::, <string>) SYMBOL(chars_format, std::, <charconv>) SYMBOL(chi_squared_distribution, std::, <random>) SYMBOL(cin, std::, <iostream>) SYMBOL(clamp, std::, <algorithm>) SYMBOL(clearerr, std::, <cstdio>) SYMBOL(clearerr, None, <cstdio>) SYMBOL(clearerr, None, <stdio.h>) SYMBOL(clock, std::, <ctime>) SYMBOL(clock, None, <ctime>) SYMBOL(clock, None, <time.h>) SYMBOL(clock_t, std::, <ctime>) SYMBOL(clock_t, None, <ctime>) SYMBOL(clock_t, None, <time.h>) SYMBOL(clog, std::, <iostream>) SYMBOL(cmatch, std::, <regex>) SYMBOL(cmp_equal, std::, <utility>) SYMBOL(cmp_greater, std::, <utility>) SYMBOL(cmp_greater_equal, std::, <utility>) SYMBOL(cmp_less, std::, <utility>) SYMBOL(cmp_less_equal, std::, <utility>) SYMBOL(cmp_not_equal, std::, <utility>) SYMBOL(codecvt, std::, <locale>) SYMBOL(codecvt_base, std::, <locale>) SYMBOL(codecvt_byname, std::, <locale>) SYMBOL(codecvt_mode, std::, <codecvt>) SYMBOL(codecvt_utf16, std::, <codecvt>) SYMBOL(codecvt_utf8, std::, <codecvt>) SYMBOL(codecvt_utf8_utf16, std::, <codecvt>) SYMBOL(collate, std::, <locale>) SYMBOL(collate_byname, std::, <locale>) SYMBOL(common_comparison_category, std::, <compare>) SYMBOL(common_comparison_category_t, std::, <compare>) SYMBOL(common_iterator, std::, <iterator>) SYMBOL(common_reference, std::, <type_traits>) SYMBOL(common_reference_t, std::, <type_traits>) SYMBOL(common_reference_with, std::, <concepts>) SYMBOL(common_type, std::, <type_traits>) SYMBOL(common_type_t, std::, <type_traits>) SYMBOL(common_with, std::, <concepts>) SYMBOL(comp_ellint_1, std::, <cmath>) SYMBOL(comp_ellint_1f, std::, <cmath>) SYMBOL(comp_ellint_1l, std::, <cmath>) SYMBOL(comp_ellint_2, std::, <cmath>) SYMBOL(comp_ellint_2f, std::, <cmath>) SYMBOL(comp_ellint_2l, std::, <cmath>) SYMBOL(comp_ellint_3, std::, <cmath>) SYMBOL(comp_ellint_3f, std::, <cmath>) SYMBOL(comp_ellint_3l, std::, <cmath>) SYMBOL(compare_partial_order_fallback, std::, <compare>) SYMBOL(compare_strong_order_fallback, std::, <compare>) SYMBOL(compare_three_way_result, std::, <compare>) SYMBOL(compare_three_way_result_t, std::, <compare>) SYMBOL(compare_weak_order_fallback, std::, <compare>) SYMBOL(complex, std::, <complex>) SYMBOL(condition_variable, std::, <condition_variable>) SYMBOL(condition_variable_any, std::, <condition_variable>) SYMBOL(conditional, std::, <type_traits>) SYMBOL(conditional_t, std::, <type_traits>) SYMBOL(conj, std::, <complex>) SYMBOL(conjunction, std::, <type_traits>) SYMBOL(conjunction_v, std::, <type_traits>) SYMBOL(const_mem_fun1_ref_t, std::, <functional>) SYMBOL(const_mem_fun1_t, std::, <functional>) SYMBOL(const_mem_fun_ref_t, std::, <functional>) SYMBOL(const_mem_fun_t, std::, <functional>) SYMBOL(const_pointer_cast, std::, <memory>) SYMBOL(construct_at, std::, <memory>) SYMBOL(constructible_from, std::, <concepts>) SYMBOL(contiguous_iterator, std::, <iterator>) SYMBOL(contiguous_iterator_tag, std::, <iterator>) SYMBOL(convertible_to, std::, <concepts>) SYMBOL(copy, std::, <algorithm>) SYMBOL(copy_backward, std::, <algorithm>) SYMBOL(copy_constructible, std::, <concepts>) SYMBOL(copy_if, std::, <algorithm>) SYMBOL(copy_n, std::, <algorithm>) SYMBOL(copyable, std::, <concepts>) SYMBOL(copysign, std::, <cmath>) SYMBOL(copysign, None, <cmath>) SYMBOL(copysign, None, <math.h>) SYMBOL(copysignf, std::, <cmath>) SYMBOL(copysignf, None, <cmath>) SYMBOL(copysignf, None, <math.h>) SYMBOL(copysignl, std::, <cmath>) SYMBOL(copysignl, None, <cmath>) SYMBOL(copysignl, None, <math.h>) SYMBOL(coroutine_handle, std::, <coroutine>) SYMBOL(coroutine_traits, std::, <coroutine>) SYMBOL(cos, std::, <cmath>) SYMBOL(cos, None, <cmath>) SYMBOL(cos, None, <math.h>) SYMBOL(cosf, std::, <cmath>) SYMBOL(cosf, None, <cmath>) SYMBOL(cosf, None, <math.h>) SYMBOL(cosh, std::, <cmath>) SYMBOL(cosh, None, <cmath>) SYMBOL(cosh, None, <math.h>) SYMBOL(coshf, std::, <cmath>) SYMBOL(coshf, None, <cmath>) SYMBOL(coshf, None, <math.h>) SYMBOL(coshl, std::, <cmath>) SYMBOL(coshl, None, <cmath>) SYMBOL(coshl, None, <math.h>) SYMBOL(cosl, std::, <cmath>) SYMBOL(cosl, None, <cmath>) SYMBOL(cosl, None, <math.h>) SYMBOL(count, std::, <algorithm>) SYMBOL(count_if, std::, <algorithm>) SYMBOL(counted_iterator, std::, <iterator>) SYMBOL(counting_semaphore, std::, <semaphore>) SYMBOL(countl_one, std::, <bit>) SYMBOL(countl_zero, std::, <bit>) SYMBOL(countr_one, std::, <bit>) SYMBOL(countr_zero, std::, <bit>) SYMBOL(cout, std::, <iostream>) SYMBOL(cref, std::, <functional>) SYMBOL(cregex_iterator, std::, <regex>) SYMBOL(cregex_token_iterator, std::, <regex>) SYMBOL(csub_match, std::, <regex>) SYMBOL(ctime, std::, <ctime>) SYMBOL(ctime, None, <ctime>) SYMBOL(ctime, None, <time.h>) SYMBOL(ctype, std::, <locale>) SYMBOL(ctype_base, std::, <locale>) SYMBOL(ctype_byname, std::, <locale>) SYMBOL(current_exception, std::, <exception>) SYMBOL(cv_status, std::, <condition_variable>) SYMBOL(cyl_bessel_i, std::, <cmath>) SYMBOL(cyl_bessel_if, std::, <cmath>) SYMBOL(cyl_bessel_il, std::, <cmath>) SYMBOL(cyl_bessel_j, std::, <cmath>) SYMBOL(cyl_bessel_jf, std::, <cmath>) SYMBOL(cyl_bessel_jl, std::, <cmath>) SYMBOL(cyl_bessel_k, std::, <cmath>) SYMBOL(cyl_bessel_kf, std::, <cmath>) SYMBOL(cyl_bessel_kl, std::, <cmath>) SYMBOL(cyl_neumann, std::, <cmath>) SYMBOL(cyl_neumannf, std::, <cmath>) SYMBOL(cyl_neumannl, std::, <cmath>) SYMBOL(dec, std::, <ios>) SYMBOL(dec, std::, <iostream>) SYMBOL(deca, std::, <ratio>) SYMBOL(decay, std::, <type_traits>) SYMBOL(decay_t, std::, <type_traits>) SYMBOL(deci, std::, <ratio>) SYMBOL(declare_no_pointers, std::, <memory>) SYMBOL(declare_reachable, std::, <memory>) SYMBOL(declval, std::, <utility>) SYMBOL(default_delete, std::, <memory>) SYMBOL(default_initializable, std::, <concepts>) SYMBOL(default_random_engine, std::, <random>) SYMBOL(default_searcher, std::, <functional>) SYMBOL(default_sentinel, std::, <iterator>) SYMBOL(default_sentinel_t, std::, <iterator>) SYMBOL(defaultfloat, std::, <ios>) SYMBOL(defaultfloat, std::, <iostream>) SYMBOL(defer_lock, std::, <mutex>) SYMBOL(defer_lock_t, std::, <mutex>) SYMBOL(denorm_absent, std::, <limits>) SYMBOL(denorm_indeterminate, std::, <limits>) SYMBOL(denorm_present, std::, <limits>) SYMBOL(deque, std::, <deque>) SYMBOL(derived_from, std::, <concepts>) SYMBOL(destroy, std::, <memory>) SYMBOL(destroy_at, std::, <memory>) SYMBOL(destroy_n, std::, <memory>) SYMBOL(destroying_delete, std::, <new>) SYMBOL(destroying_delete_t, std::, <new>) SYMBOL(destructible, std::, <concepts>) SYMBOL(difftime, std::, <ctime>) SYMBOL(difftime, None, <ctime>) SYMBOL(difftime, None, <time.h>) SYMBOL(disable_sized_sentinel_for, std::, <iterator>) SYMBOL(discard_block_engine, std::, <random>) SYMBOL(discrete_distribution, std::, <random>) SYMBOL(disjunction, std::, <type_traits>) SYMBOL(disjunction_v, std::, <type_traits>) SYMBOL(distance, std::, <iterator>) SYMBOL(div_t, std::, <cstdlib>) SYMBOL(div_t, None, <cstdlib>) SYMBOL(div_t, None, <stdlib.h>) SYMBOL(divides, std::, <functional>) SYMBOL(domain_error, std::, <stdexcept>) SYMBOL(double_t, std::, <cmath>) SYMBOL(double_t, None, <cmath>) SYMBOL(double_t, None, <math.h>) SYMBOL(dynamic_extent, std::, <span>) SYMBOL(dynamic_pointer_cast, std::, <memory>) SYMBOL(ellint_1, std::, <cmath>) SYMBOL(ellint_1f, std::, <cmath>) SYMBOL(ellint_1l, std::, <cmath>) SYMBOL(ellint_2, std::, <cmath>) SYMBOL(ellint_2f, std::, <cmath>) SYMBOL(ellint_2l, std::, <cmath>) SYMBOL(ellint_3, std::, <cmath>) SYMBOL(ellint_3f, std::, <cmath>) SYMBOL(ellint_3l, std::, <cmath>) SYMBOL(emit_on_flush, std::, <ostream>) SYMBOL(emit_on_flush, std::, <iostream>) SYMBOL(enable_if, std::, <type_traits>) SYMBOL(enable_if_t, std::, <type_traits>) SYMBOL(enable_shared_from_this, std::, <memory>) SYMBOL(endian, std::, <bit>) SYMBOL(endl, std::, <ostream>) SYMBOL(endl, std::, <iostream>) SYMBOL(ends, std::, <ostream>) SYMBOL(ends, std::, <iostream>) SYMBOL(equal, std::, <algorithm>) SYMBOL(equal_range, std::, <algorithm>) SYMBOL(equal_to, std::, <functional>) SYMBOL(equality_comparable, std::, <concepts>) SYMBOL(equality_comparable_with, std::, <concepts>) SYMBOL(equivalence_relation, std::, <concepts>) SYMBOL(erase, std::, <vector>) SYMBOL(erase_if, std::, <vector>) SYMBOL(erf, std::, <cmath>) SYMBOL(erf, None, <cmath>) SYMBOL(erf, None, <math.h>) SYMBOL(erfc, std::, <cmath>) SYMBOL(erfc, None, <cmath>) SYMBOL(erfc, None, <math.h>) SYMBOL(erfcf, std::, <cmath>) SYMBOL(erfcf, None, <cmath>) SYMBOL(erfcf, None, <math.h>) SYMBOL(erfcl, std::, <cmath>) SYMBOL(erfcl, None, <cmath>) SYMBOL(erfcl, None, <math.h>) SYMBOL(erff, std::, <cmath>) SYMBOL(erff, None, <cmath>) SYMBOL(erff, None, <math.h>) SYMBOL(erfl, std::, <cmath>) SYMBOL(erfl, None, <cmath>) SYMBOL(erfl, None, <math.h>) SYMBOL(errc, std::, <system_error>) SYMBOL(error_category, std::, <system_error>) SYMBOL(error_code, std::, <system_error>) SYMBOL(error_condition, std::, <system_error>) SYMBOL(exa, std::, <ratio>) SYMBOL(exception, std::, <exception>) SYMBOL(exception_ptr, std::, <exception>) SYMBOL(exchange, std::, <utility>) SYMBOL(exclusive_scan, std::, <numeric>) SYMBOL(exit, std::, <cstdlib>) SYMBOL(exit, None, <cstdlib>) SYMBOL(exit, None, <stdlib.h>) SYMBOL(exp, std::, <cmath>) SYMBOL(exp, None, <cmath>) SYMBOL(exp, None, <math.h>) SYMBOL(exp2, std::, <cmath>) SYMBOL(exp2, None, <cmath>) SYMBOL(exp2, None, <math.h>) SYMBOL(exp2f, std::, <cmath>) SYMBOL(exp2f, None, <cmath>) SYMBOL(exp2f, None, <math.h>) SYMBOL(exp2l, std::, <cmath>) SYMBOL(exp2l, None, <cmath>) SYMBOL(exp2l, None, <math.h>) SYMBOL(expf, std::, <cmath>) SYMBOL(expf, None, <cmath>) SYMBOL(expf, None, <math.h>) SYMBOL(expint, std::, <cmath>) SYMBOL(expintf, std::, <cmath>) SYMBOL(expintl, std::, <cmath>) SYMBOL(expl, std::, <cmath>) SYMBOL(expl, None, <cmath>) SYMBOL(expl, None, <math.h>) SYMBOL(expm1, std::, <cmath>) SYMBOL(expm1, None, <cmath>) SYMBOL(expm1, None, <math.h>) SYMBOL(expm1f, std::, <cmath>) SYMBOL(expm1f, None, <cmath>) SYMBOL(expm1f, None, <math.h>) SYMBOL(expm1l, std::, <cmath>) SYMBOL(expm1l, None, <cmath>) SYMBOL(expm1l, None, <math.h>) SYMBOL(exponential_distribution, std::, <random>) SYMBOL(extent, std::, <type_traits>) SYMBOL(extent_v, std::, <type_traits>) SYMBOL(extreme_value_distribution, std::, <random>) SYMBOL(fabs, std::, <cmath>) SYMBOL(fabs, None, <cmath>) SYMBOL(fabs, None, <math.h>) SYMBOL(fabsf, std::, <cmath>) SYMBOL(fabsf, None, <cmath>) SYMBOL(fabsf, None, <math.h>) SYMBOL(fabsl, std::, <cmath>) SYMBOL(fabsl, None, <cmath>) SYMBOL(fabsl, None, <math.h>) SYMBOL(false_type, std::, <type_traits>) SYMBOL(fclose, std::, <cstdio>) SYMBOL(fclose, None, <cstdio>) SYMBOL(fclose, None, <stdio.h>) SYMBOL(fdim, std::, <cmath>) SYMBOL(fdim, None, <cmath>) SYMBOL(fdim, None, <math.h>) SYMBOL(fdimf, std::, <cmath>) SYMBOL(fdimf, None, <cmath>) SYMBOL(fdimf, None, <math.h>) SYMBOL(fdiml, std::, <cmath>) SYMBOL(fdiml, None, <cmath>) SYMBOL(fdiml, None, <math.h>) SYMBOL(feclearexcept, std::, <cfenv>) SYMBOL(feclearexcept, None, <cfenv>) SYMBOL(feclearexcept, None, <fenv.h>) SYMBOL(fegetenv, std::, <cfenv>) SYMBOL(fegetenv, None, <cfenv>) SYMBOL(fegetenv, None, <fenv.h>) SYMBOL(fegetexceptflag, std::, <cfenv>) SYMBOL(fegetexceptflag, None, <cfenv>) SYMBOL(fegetexceptflag, None, <fenv.h>) SYMBOL(fegetround, std::, <cfenv>) SYMBOL(fegetround, None, <cfenv>) SYMBOL(fegetround, None, <fenv.h>) SYMBOL(feholdexcept, std::, <cfenv>) SYMBOL(feholdexcept, None, <cfenv>) SYMBOL(feholdexcept, None, <fenv.h>) SYMBOL(femto, std::, <ratio>) SYMBOL(fenv_t, std::, <cfenv>) SYMBOL(fenv_t, None, <cfenv>) SYMBOL(fenv_t, None, <fenv.h>) SYMBOL(feof, std::, <cstdio>) SYMBOL(feof, None, <cstdio>) SYMBOL(feof, None, <stdio.h>) SYMBOL(feraiseexcept, std::, <cfenv>) SYMBOL(feraiseexcept, None, <cfenv>) SYMBOL(feraiseexcept, None, <fenv.h>) SYMBOL(ferror, std::, <cstdio>) SYMBOL(ferror, None, <cstdio>) SYMBOL(ferror, None, <stdio.h>) SYMBOL(fesetenv, std::, <cfenv>) SYMBOL(fesetenv, None, <cfenv>) SYMBOL(fesetenv, None, <fenv.h>) SYMBOL(fesetexceptflag, std::, <cfenv>) SYMBOL(fesetexceptflag, None, <cfenv>) SYMBOL(fesetexceptflag, None, <fenv.h>) SYMBOL(fesetround, std::, <cfenv>) SYMBOL(fesetround, None, <cfenv>) SYMBOL(fesetround, None, <fenv.h>) SYMBOL(fetestexcept, std::, <cfenv>) SYMBOL(fetestexcept, None, <cfenv>) SYMBOL(fetestexcept, None, <fenv.h>) SYMBOL(feupdateenv, std::, <cfenv>) SYMBOL(feupdateenv, None, <cfenv>) SYMBOL(feupdateenv, None, <fenv.h>) SYMBOL(fexcept_t, std::, <cfenv>) SYMBOL(fexcept_t, None, <cfenv>) SYMBOL(fexcept_t, None, <fenv.h>) SYMBOL(fflush, std::, <cstdio>) SYMBOL(fflush, None, <cstdio>) SYMBOL(fflush, None, <stdio.h>) SYMBOL(fgetc, std::, <cstdio>) SYMBOL(fgetc, None, <cstdio>) SYMBOL(fgetc, None, <stdio.h>) SYMBOL(fgetpos, std::, <cstdio>) SYMBOL(fgetpos, None, <cstdio>) SYMBOL(fgetpos, None, <stdio.h>) SYMBOL(fgets, std::, <cstdio>) SYMBOL(fgets, None, <cstdio>) SYMBOL(fgets, None, <stdio.h>) SYMBOL(fgetwc, std::, <cwchar>) SYMBOL(fgetwc, None, <cwchar>) SYMBOL(fgetwc, None, <wchar.h>) SYMBOL(fgetws, std::, <cwchar>) SYMBOL(fgetws, None, <cwchar>) SYMBOL(fgetws, None, <wchar.h>) SYMBOL(filebuf, std::, <streambuf>) SYMBOL(filebuf, std::, <iostream>) SYMBOL(filebuf, std::, <iosfwd>) SYMBOL(fill, std::, <algorithm>) SYMBOL(fill_n, std::, <algorithm>) SYMBOL(find, std::, <algorithm>) SYMBOL(find_end, std::, <algorithm>) SYMBOL(find_first_of, std::, <algorithm>) SYMBOL(find_if, std::, <algorithm>) SYMBOL(find_if_not, std::, <algorithm>) SYMBOL(fisher_f_distribution, std::, <random>) SYMBOL(fixed, std::, <ios>) SYMBOL(fixed, std::, <iostream>) SYMBOL(float_denorm_style, std::, <limits>) SYMBOL(float_round_style, std::, <limits>) SYMBOL(float_t, std::, <cmath>) SYMBOL(float_t, None, <cmath>) SYMBOL(float_t, None, <math.h>) SYMBOL(floating_point, std::, <concepts>) SYMBOL(floor, std::, <cmath>) SYMBOL(floor, None, <cmath>) SYMBOL(floor, None, <math.h>) SYMBOL(floorf, std::, <cmath>) SYMBOL(floorf, None, <cmath>) SYMBOL(floorf, None, <math.h>) SYMBOL(floorl, std::, <cmath>) SYMBOL(floorl, None, <cmath>) SYMBOL(floorl, None, <math.h>) SYMBOL(flush, std::, <ostream>) SYMBOL(flush, std::, <iostream>) SYMBOL(flush_emit, std::, <ostream>) SYMBOL(flush_emit, std::, <iostream>) SYMBOL(fma, std::, <cmath>) SYMBOL(fma, None, <cmath>) SYMBOL(fma, None, <math.h>) SYMBOL(fmaf, std::, <cmath>) SYMBOL(fmaf, None, <cmath>) SYMBOL(fmaf, None, <math.h>) SYMBOL(fmal, std::, <cmath>) SYMBOL(fmal, None, <cmath>) SYMBOL(fmal, None, <math.h>) SYMBOL(fmax, std::, <cmath>) SYMBOL(fmax, None, <cmath>) SYMBOL(fmax, None, <math.h>) SYMBOL(fmaxf, std::, <cmath>) SYMBOL(fmaxf, None, <cmath>) SYMBOL(fmaxf, None, <math.h>) SYMBOL(fmaxl, std::, <cmath>) SYMBOL(fmaxl, None, <cmath>) SYMBOL(fmaxl, None, <math.h>) SYMBOL(fmin, std::, <cmath>) SYMBOL(fmin, None, <cmath>) SYMBOL(fmin, None, <math.h>) SYMBOL(fminf, std::, <cmath>) SYMBOL(fminf, None, <cmath>) SYMBOL(fminf, None, <math.h>) SYMBOL(fminl, std::, <cmath>) SYMBOL(fminl, None, <cmath>) SYMBOL(fminl, None, <math.h>) SYMBOL(fmod, std::, <cmath>) SYMBOL(fmod, None, <cmath>) SYMBOL(fmod, None, <math.h>) SYMBOL(fmodf, std::, <cmath>) SYMBOL(fmodf, None, <cmath>) SYMBOL(fmodf, None, <math.h>) SYMBOL(fmodl, std::, <cmath>) SYMBOL(fmodl, None, <cmath>) SYMBOL(fmodl, None, <math.h>) SYMBOL(fopen, std::, <cstdio>) SYMBOL(fopen, None, <cstdio>) SYMBOL(fopen, None, <stdio.h>) SYMBOL(for_each, std::, <algorithm>) SYMBOL(for_each_n, std::, <algorithm>) SYMBOL(format, std::, <format>) SYMBOL(format_args, std::, <format>) SYMBOL(format_context, std::, <format>) SYMBOL(format_error, std::, <format>) SYMBOL(format_parse_context, std::, <format>) SYMBOL(format_to, std::, <format>) SYMBOL(format_to_n, std::, <format>) SYMBOL(format_to_n_result, std::, <format>) SYMBOL(formatted_size, std::, <format>) SYMBOL(formatter, std::, <format>) SYMBOL(forward, std::, <utility>) SYMBOL(forward_as_tuple, std::, <tuple>) SYMBOL(forward_iterator, std::, <iterator>) SYMBOL(forward_iterator_tag, std::, <iterator>) SYMBOL(forward_like, std::, <utility>) SYMBOL(forward_list, std::, <forward_list>) SYMBOL(fpclassify, std::, <cmath>) SYMBOL(fpclassify, None, <cmath>) SYMBOL(fpclassify, None, <math.h>) SYMBOL(fpos, std::, <ios>) SYMBOL(fpos, std::, <iostream>) SYMBOL(fpos, std::, <iosfwd>) SYMBOL(fpos_t, std::, <cstdio>) SYMBOL(fpos_t, None, <cstdio>) SYMBOL(fpos_t, None, <stdio.h>) SYMBOL(fprintf, std::, <cstdio>) SYMBOL(fprintf, None, <cstdio>) SYMBOL(fprintf, None, <stdio.h>) SYMBOL(fputc, std::, <cstdio>) SYMBOL(fputc, None, <cstdio>) SYMBOL(fputc, None, <stdio.h>) SYMBOL(fputs, std::, <cstdio>) SYMBOL(fputs, None, <cstdio>) SYMBOL(fputs, None, <stdio.h>) SYMBOL(fputwc, std::, <cwchar>) SYMBOL(fputwc, None, <cwchar>) SYMBOL(fputwc, None, <wchar.h>) SYMBOL(fputws, std::, <cwchar>) SYMBOL(fputws, None, <cwchar>) SYMBOL(fputws, None, <wchar.h>) SYMBOL(fread, std::, <cstdio>) SYMBOL(fread, None, <cstdio>) SYMBOL(fread, None, <stdio.h>) SYMBOL(free, std::, <cstdlib>) SYMBOL(free, None, <cstdlib>) SYMBOL(free, None, <stdlib.h>) SYMBOL(freopen, std::, <cstdio>) SYMBOL(freopen, None, <cstdio>) SYMBOL(freopen, None, <stdio.h>) SYMBOL(frexp, std::, <cmath>) SYMBOL(frexp, None, <cmath>) SYMBOL(frexp, None, <math.h>) SYMBOL(frexpf, std::, <cmath>) SYMBOL(frexpf, None, <cmath>) SYMBOL(frexpf, None, <math.h>) SYMBOL(frexpl, std::, <cmath>) SYMBOL(frexpl, None, <cmath>) SYMBOL(frexpl, None, <math.h>) SYMBOL(from_chars, std::, <charconv>) SYMBOL(from_chars_result, std::, <charconv>) SYMBOL(from_range, std::, <ranges>) SYMBOL(from_range_t, std::, <ranges>) SYMBOL(front_insert_iterator, std::, <iterator>) SYMBOL(front_inserter, std::, <iterator>) SYMBOL(fscanf, std::, <cstdio>) SYMBOL(fscanf, None, <cstdio>) SYMBOL(fscanf, None, <stdio.h>) SYMBOL(fseek, std::, <cstdio>) SYMBOL(fseek, None, <cstdio>) SYMBOL(fseek, None, <stdio.h>) SYMBOL(fsetpos, std::, <cstdio>) SYMBOL(fsetpos, None, <cstdio>) SYMBOL(fsetpos, None, <stdio.h>) SYMBOL(fstream, std::, <fstream>) SYMBOL(fstream, std::, <iosfwd>) SYMBOL(ftell, std::, <cstdio>) SYMBOL(ftell, None, <cstdio>) SYMBOL(ftell, None, <stdio.h>) SYMBOL(function, std::, <functional>) SYMBOL(future, std::, <future>) SYMBOL(future_category, std::, <future>) SYMBOL(future_errc, std::, <future>) SYMBOL(future_error, std::, <future>) SYMBOL(future_status, std::, <future>) SYMBOL(fwide, std::, <cwchar>) SYMBOL(fwide, None, <cwchar>) SYMBOL(fwide, None, <wchar.h>) SYMBOL(fwprintf, std::, <cwchar>) SYMBOL(fwprintf, None, <cwchar>) SYMBOL(fwprintf, None, <wchar.h>) SYMBOL(fwrite, std::, <cstdio>) SYMBOL(fwrite, None, <cstdio>) SYMBOL(fwrite, None, <stdio.h>) SYMBOL(fwscanf, std::, <cwchar>) SYMBOL(fwscanf, None, <cwchar>) SYMBOL(fwscanf, None, <wchar.h>) SYMBOL(gamma_distribution, std::, <random>) SYMBOL(gcd, std::, <numeric>) SYMBOL(generate, std::, <algorithm>) SYMBOL(generate_canonical, std::, <random>) SYMBOL(generate_n, std::, <algorithm>) SYMBOL(generic_category, std::, <system_error>) SYMBOL(geometric_distribution, std::, <random>) SYMBOL(get_deleter, std::, <memory>) SYMBOL(get_if, std::, <variant>) SYMBOL(get_money, std::, <iomanip>) SYMBOL(get_new_handler, std::, <new>) SYMBOL(get_pointer_safety, std::, <memory>) SYMBOL(get_temporary_buffer, std::, <memory>) SYMBOL(get_terminate, std::, <exception>) SYMBOL(get_time, std::, <iomanip>) SYMBOL(get_unexpected, std::, <exception>) SYMBOL(getc, std::, <cstdio>) SYMBOL(getc, None, <cstdio>) SYMBOL(getc, None, <stdio.h>) SYMBOL(getchar, std::, <cstdio>) SYMBOL(getchar, None, <cstdio>) SYMBOL(getchar, None, <stdio.h>) SYMBOL(getenv, std::, <cstdlib>) SYMBOL(getenv, None, <cstdlib>) SYMBOL(getenv, None, <stdlib.h>) SYMBOL(getline, std::, <string>) SYMBOL(gets, std::, <cstdio>) SYMBOL(gets, None, <cstdio>) SYMBOL(gets, None, <stdio.h>) SYMBOL(getwc, std::, <cwchar>) SYMBOL(getwc, None, <cwchar>) SYMBOL(getwc, None, <wchar.h>) SYMBOL(getwchar, std::, <cwchar>) SYMBOL(getwchar, None, <cwchar>) SYMBOL(getwchar, None, <wchar.h>) SYMBOL(giga, std::, <ratio>) SYMBOL(gmtime, std::, <ctime>) SYMBOL(gmtime, None, <ctime>) SYMBOL(gmtime, None, <time.h>) SYMBOL(greater, std::, <functional>) SYMBOL(greater_equal, std::, <functional>) SYMBOL(gslice, std::, <valarray>) SYMBOL(gslice_array, std::, <valarray>) SYMBOL(hardware_constructive_interference_size, std::, <new>) SYMBOL(hardware_destructive_interference_size, std::, <new>) SYMBOL(has_facet, std::, <locale>) SYMBOL(has_single_bit, std::, <bit>) SYMBOL(has_unique_object_representations, std::, <type_traits>) SYMBOL(has_unique_object_representations_v, std::, <type_traits>) SYMBOL(has_virtual_destructor, std::, <type_traits>) SYMBOL(has_virtual_destructor_v, std::, <type_traits>) SYMBOL(hash, std::, <functional>) SYMBOL(hecto, std::, <ratio>) SYMBOL(hermite, std::, <cmath>) SYMBOL(hermitef, std::, <cmath>) SYMBOL(hermitel, std::, <cmath>) SYMBOL(hex, std::, <ios>) SYMBOL(hex, std::, <iostream>) SYMBOL(hexfloat, std::, <ios>) SYMBOL(hexfloat, std::, <iostream>) SYMBOL(holds_alternative, std::, <variant>) SYMBOL(hypot, std::, <cmath>) SYMBOL(hypot, None, <cmath>) SYMBOL(hypot, None, <math.h>) SYMBOL(hypotf, std::, <cmath>) SYMBOL(hypotf, None, <cmath>) SYMBOL(hypotf, None, <math.h>) SYMBOL(hypotl, std::, <cmath>) SYMBOL(hypotl, None, <cmath>) SYMBOL(hypotl, None, <math.h>) SYMBOL(identity, std::, <functional>) SYMBOL(ifstream, std::, <fstream>) SYMBOL(ifstream, std::, <iosfwd>) SYMBOL(ignore, std::, <tuple>) SYMBOL(ilogb, std::, <cmath>) SYMBOL(ilogb, None, <cmath>) SYMBOL(ilogb, None, <math.h>) SYMBOL(ilogbf, std::, <cmath>) SYMBOL(ilogbf, None, <cmath>) SYMBOL(ilogbf, None, <math.h>) SYMBOL(ilogbl, std::, <cmath>) SYMBOL(ilogbl, None, <cmath>) SYMBOL(ilogbl, None, <math.h>) SYMBOL(imag, std::, <complex>) SYMBOL(imaxabs, std::, <cinttypes>) SYMBOL(imaxabs, None, <cinttypes>) SYMBOL(imaxabs, None, <inttypes.h>) SYMBOL(imaxdiv, std::, <cinttypes>) SYMBOL(imaxdiv, None, <cinttypes>) SYMBOL(imaxdiv, None, <inttypes.h>) SYMBOL(imaxdiv_t, std::, <cinttypes>) SYMBOL(imaxdiv_t, None, <cinttypes>) SYMBOL(imaxdiv_t, None, <inttypes.h>) SYMBOL(in_place, std::, <utility>) SYMBOL(in_place_index, std::, <utility>) SYMBOL(in_place_index_t, std::, <utility>) SYMBOL(in_place_t, std::, <utility>) SYMBOL(in_place_type, std::, <utility>) SYMBOL(in_place_type_t, std::, <utility>) SYMBOL(in_range, std::, <utility>) SYMBOL(includes, std::, <algorithm>) SYMBOL(inclusive_scan, std::, <numeric>) SYMBOL(incrementable, std::, <iterator>) SYMBOL(incrementable_traits, std::, <iterator>) SYMBOL(independent_bits_engine, std::, <random>) SYMBOL(indirect_array, std::, <valarray>) SYMBOL(indirect_binary_predicate, std::, <iterator>) SYMBOL(indirect_equivalence_relation, std::, <iterator>) SYMBOL(indirect_result_t, std::, <iterator>) SYMBOL(indirect_strict_weak_order, std::, <iterator>) SYMBOL(indirect_unary_predicate, std::, <iterator>) SYMBOL(indirectly_comparable, std::, <iterator>) SYMBOL(indirectly_copyable, std::, <iterator>) SYMBOL(indirectly_copyable_storable, std::, <iterator>) SYMBOL(indirectly_movable, std::, <iterator>) SYMBOL(indirectly_movable_storable, std::, <iterator>) SYMBOL(indirectly_readable, std::, <iterator>) SYMBOL(indirectly_readable_traits, std::, <iterator>) SYMBOL(indirectly_regular_unary_invocable, std::, <iterator>) SYMBOL(indirectly_swappable, std::, <iterator>) SYMBOL(indirectly_unary_invocable, std::, <iterator>) SYMBOL(indirectly_writable, std::, <iterator>) SYMBOL(initializer_list, std::, <initializer_list>) SYMBOL(inner_product, std::, <numeric>) SYMBOL(inout_ptr, std::, <memory>) SYMBOL(inout_ptr_t, std::, <memory>) SYMBOL(inplace_merge, std::, <algorithm>) SYMBOL(input_iterator, std::, <iterator>) SYMBOL(input_iterator_tag, std::, <iterator>) SYMBOL(input_or_output_iterator, std::, <iterator>) SYMBOL(insert_iterator, std::, <iterator>) SYMBOL(inserter, std::, <iterator>) SYMBOL(int16_t, std::, <cstdint>) SYMBOL(int16_t, None, <cstdint>) SYMBOL(int16_t, None, <stdint.h>) SYMBOL(int32_t, std::, <cstdint>) SYMBOL(int32_t, None, <cstdint>) SYMBOL(int32_t, None, <stdint.h>) SYMBOL(int64_t, std::, <cstdint>) SYMBOL(int64_t, None, <cstdint>) SYMBOL(int64_t, None, <stdint.h>) SYMBOL(int8_t, std::, <cstdint>) SYMBOL(int8_t, None, <cstdint>) SYMBOL(int8_t, None, <stdint.h>) SYMBOL(int_fast16_t, std::, <cstdint>) SYMBOL(int_fast16_t, None, <cstdint>) SYMBOL(int_fast16_t, None, <stdint.h>) SYMBOL(int_fast32_t, std::, <cstdint>) SYMBOL(int_fast32_t, None, <cstdint>) SYMBOL(int_fast32_t, None, <stdint.h>) SYMBOL(int_fast64_t, std::, <cstdint>) SYMBOL(int_fast64_t, None, <cstdint>) SYMBOL(int_fast64_t, None, <stdint.h>) SYMBOL(int_fast8_t, std::, <cstdint>) SYMBOL(int_fast8_t, None, <cstdint>) SYMBOL(int_fast8_t, None, <stdint.h>) SYMBOL(int_least16_t, std::, <cstdint>) SYMBOL(int_least16_t, None, <cstdint>) SYMBOL(int_least16_t, None, <stdint.h>) SYMBOL(int_least32_t, std::, <cstdint>) SYMBOL(int_least32_t, None, <cstdint>) SYMBOL(int_least32_t, None, <stdint.h>) SYMBOL(int_least64_t, std::, <cstdint>) SYMBOL(int_least64_t, None, <cstdint>) SYMBOL(int_least64_t, None, <stdint.h>) SYMBOL(int_least8_t, std::, <cstdint>) SYMBOL(int_least8_t, None, <cstdint>) SYMBOL(int_least8_t, None, <stdint.h>) SYMBOL(integer_sequence, std::, <utility>) SYMBOL(integral, std::, <concepts>) SYMBOL(integral_constant, std::, <type_traits>) SYMBOL(internal, std::, <ios>) SYMBOL(internal, std::, <iostream>) SYMBOL(intmax_t, std::, <cstdint>) SYMBOL(intmax_t, None, <cstdint>) SYMBOL(intmax_t, None, <stdint.h>) SYMBOL(intptr_t, std::, <cstdint>) SYMBOL(intptr_t, None, <cstdint>) SYMBOL(intptr_t, None, <stdint.h>) SYMBOL(invalid_argument, std::, <stdexcept>) SYMBOL(invocable, std::, <concepts>) SYMBOL(invoke, std::, <functional>) SYMBOL(invoke_r, std::, <functional>) SYMBOL(invoke_result, std::, <type_traits>) SYMBOL(invoke_result_t, std::, <type_traits>) SYMBOL(io_errc, std::, <ios>) SYMBOL(io_errc, std::, <iostream>) SYMBOL(io_state, std::, <ios>) SYMBOL(io_state, std::, <iostream>) SYMBOL(ios, std::, <ios>) SYMBOL(ios, std::, <iostream>) SYMBOL(ios, std::, <iosfwd>) SYMBOL(ios_base, std::, <ios>) SYMBOL(ios_base, std::, <iostream>) SYMBOL(iostream, std::, <istream>) SYMBOL(iostream, std::, <iostream>) SYMBOL(iostream, std::, <iosfwd>) SYMBOL(iostream_category, std::, <ios>) SYMBOL(iostream_category, std::, <iostream>) SYMBOL(iota, std::, <numeric>) SYMBOL(is_abstract, std::, <type_traits>) SYMBOL(is_abstract_v, std::, <type_traits>) SYMBOL(is_aggregate, std::, <type_traits>) SYMBOL(is_aggregate_v, std::, <type_traits>) SYMBOL(is_arithmetic, std::, <type_traits>) SYMBOL(is_arithmetic_v, std::, <type_traits>) SYMBOL(is_array, std::, <type_traits>) SYMBOL(is_array_v, std::, <type_traits>) SYMBOL(is_assignable, std::, <type_traits>) SYMBOL(is_assignable_v, std::, <type_traits>) SYMBOL(is_base_of, std::, <type_traits>) SYMBOL(is_base_of_v, std::, <type_traits>) SYMBOL(is_bind_expression, std::, <functional>) SYMBOL(is_bind_expression_v, std::, <functional>) SYMBOL(is_bounded_array, std::, <type_traits>) SYMBOL(is_bounded_array_v, std::, <type_traits>) SYMBOL(is_class, std::, <type_traits>) SYMBOL(is_class_v, std::, <type_traits>) SYMBOL(is_compound, std::, <type_traits>) SYMBOL(is_compound_v, std::, <type_traits>) SYMBOL(is_const, std::, <type_traits>) SYMBOL(is_const_v, std::, <type_traits>) SYMBOL(is_constant_evaluated, std::, <type_traits>) SYMBOL(is_constructible, std::, <type_traits>) SYMBOL(is_constructible_v, std::, <type_traits>) SYMBOL(is_convertible, std::, <type_traits>) SYMBOL(is_convertible_v, std::, <type_traits>) SYMBOL(is_copy_assignable, std::, <type_traits>) SYMBOL(is_copy_assignable_v, std::, <type_traits>) SYMBOL(is_copy_constructible, std::, <type_traits>) SYMBOL(is_copy_constructible_v, std::, <type_traits>) SYMBOL(is_corresponding_member, std::, <type_traits>) SYMBOL(is_default_constructible, std::, <type_traits>) SYMBOL(is_default_constructible_v, std::, <type_traits>) SYMBOL(is_destructible, std::, <type_traits>) SYMBOL(is_destructible_v, std::, <type_traits>) SYMBOL(is_empty, std::, <type_traits>) SYMBOL(is_empty_v, std::, <type_traits>) SYMBOL(is_enum, std::, <type_traits>) SYMBOL(is_enum_v, std::, <type_traits>) SYMBOL(is_eq, std::, <compare>) SYMBOL(is_error_code_enum, std::, <system_error>) SYMBOL(is_error_condition_enum, std::, <system_error>) SYMBOL(is_error_condition_enum_v, std::, <system_error>) SYMBOL(is_execution_policy, std::, <execution>) SYMBOL(is_execution_policy_v, std::, <execution>) SYMBOL(is_final, std::, <type_traits>) SYMBOL(is_final_v, std::, <type_traits>) SYMBOL(is_floating_point, std::, <type_traits>) SYMBOL(is_floating_point_v, std::, <type_traits>) SYMBOL(is_function, std::, <type_traits>) SYMBOL(is_function_v, std::, <type_traits>) SYMBOL(is_fundamental, std::, <type_traits>) SYMBOL(is_fundamental_v, std::, <type_traits>) SYMBOL(is_gt, std::, <compare>) SYMBOL(is_gteq, std::, <compare>) SYMBOL(is_heap, std::, <algorithm>) SYMBOL(is_heap_until, std::, <algorithm>) SYMBOL(is_integral, std::, <type_traits>) SYMBOL(is_integral_v, std::, <type_traits>) SYMBOL(is_invocable, std::, <type_traits>) SYMBOL(is_invocable_r, std::, <type_traits>) SYMBOL(is_invocable_r_v, std::, <type_traits>) SYMBOL(is_invocable_v, std::, <type_traits>) SYMBOL(is_layout_compatible, std::, <type_traits>) SYMBOL(is_layout_compatible_v, std::, <type_traits>) SYMBOL(is_literal_type, std::, <type_traits>) SYMBOL(is_literal_type_v, std::, <type_traits>) SYMBOL(is_lt, std::, <compare>) SYMBOL(is_lteq, std::, <compare>) SYMBOL(is_lvalue_reference, std::, <type_traits>) SYMBOL(is_lvalue_reference_v, std::, <type_traits>) SYMBOL(is_member_function_pointer, std::, <type_traits>) SYMBOL(is_member_function_pointer_v, std::, <type_traits>) SYMBOL(is_member_object_pointer, std::, <type_traits>) SYMBOL(is_member_object_pointer_v, std::, <type_traits>) SYMBOL(is_member_pointer, std::, <type_traits>) SYMBOL(is_member_pointer_v, std::, <type_traits>) SYMBOL(is_move_assignable, std::, <type_traits>) SYMBOL(is_move_assignable_v, std::, <type_traits>) SYMBOL(is_move_constructible, std::, <type_traits>) SYMBOL(is_move_constructible_v, std::, <type_traits>) SYMBOL(is_neq, std::, <compare>) SYMBOL(is_nothrow_assignable, std::, <type_traits>) SYMBOL(is_nothrow_assignable_v, std::, <type_traits>) SYMBOL(is_nothrow_constructible, std::, <type_traits>) SYMBOL(is_nothrow_constructible_v, std::, <type_traits>) SYMBOL(is_nothrow_convertible, std::, <type_traits>) SYMBOL(is_nothrow_convertible_v, std::, <type_traits>) SYMBOL(is_nothrow_copy_assignable, std::, <type_traits>) SYMBOL(is_nothrow_copy_assignable_v, std::, <type_traits>) SYMBOL(is_nothrow_copy_constructible, std::, <type_traits>) SYMBOL(is_nothrow_copy_constructible_v, std::, <type_traits>) SYMBOL(is_nothrow_default_constructible, std::, <type_traits>) SYMBOL(is_nothrow_default_constructible_v, std::, <type_traits>) SYMBOL(is_nothrow_destructible, std::, <type_traits>) SYMBOL(is_nothrow_destructible_v, std::, <type_traits>) SYMBOL(is_nothrow_invocable, std::, <type_traits>) SYMBOL(is_nothrow_invocable_r, std::, <type_traits>) SYMBOL(is_nothrow_invocable_r_v, std::, <type_traits>) SYMBOL(is_nothrow_invocable_v, std::, <type_traits>) SYMBOL(is_nothrow_move_assignable, std::, <type_traits>) SYMBOL(is_nothrow_move_assignable_v, std::, <type_traits>) SYMBOL(is_nothrow_move_constructible, std::, <type_traits>) SYMBOL(is_nothrow_move_constructible_v, std::, <type_traits>) SYMBOL(is_nothrow_swappable, std::, <type_traits>) SYMBOL(is_nothrow_swappable_v, std::, <type_traits>) SYMBOL(is_nothrow_swappable_with, std::, <type_traits>) SYMBOL(is_nothrow_swappable_with_v, std::, <type_traits>) SYMBOL(is_null_pointer, std::, <type_traits>) SYMBOL(is_null_pointer_v, std::, <type_traits>) SYMBOL(is_object, std::, <type_traits>) SYMBOL(is_object_v, std::, <type_traits>) SYMBOL(is_partitioned, std::, <algorithm>) SYMBOL(is_permutation, std::, <algorithm>) SYMBOL(is_placeholder, std::, <functional>) SYMBOL(is_placeholder_v, std::, <functional>) SYMBOL(is_pod, std::, <type_traits>) SYMBOL(is_pod_v, std::, <type_traits>) SYMBOL(is_pointer, std::, <type_traits>) SYMBOL(is_pointer_interconvertible_base_of, std::, <type_traits>) SYMBOL(is_pointer_interconvertible_base_of_v, std::, <type_traits>) SYMBOL(is_pointer_interconvertible_with_class, std::, <type_traits>) SYMBOL(is_pointer_v, std::, <type_traits>) SYMBOL(is_polymorphic, std::, <type_traits>) SYMBOL(is_polymorphic_v, std::, <type_traits>) SYMBOL(is_reference, std::, <type_traits>) SYMBOL(is_reference_v, std::, <type_traits>) SYMBOL(is_rvalue_reference, std::, <type_traits>) SYMBOL(is_rvalue_reference_v, std::, <type_traits>) SYMBOL(is_same, std::, <type_traits>) SYMBOL(is_same_v, std::, <type_traits>) SYMBOL(is_scalar, std::, <type_traits>) SYMBOL(is_scalar_v, std::, <type_traits>) SYMBOL(is_scoped_enum, std::, <type_traits>) SYMBOL(is_scoped_enum_v, std::, <type_traits>) SYMBOL(is_signed, std::, <type_traits>) SYMBOL(is_signed_v, std::, <type_traits>) SYMBOL(is_sorted, std::, <algorithm>) SYMBOL(is_sorted_until, std::, <algorithm>) SYMBOL(is_standard_layout, std::, <type_traits>) SYMBOL(is_standard_layout_v, std::, <type_traits>) SYMBOL(is_swappable, std::, <type_traits>) SYMBOL(is_swappable_v, std::, <type_traits>) SYMBOL(is_swappable_with, std::, <type_traits>) SYMBOL(is_swappable_with_v, std::, <type_traits>) SYMBOL(is_trivial, std::, <type_traits>) SYMBOL(is_trivial_v, std::, <type_traits>) SYMBOL(is_trivially_assignable, std::, <type_traits>) SYMBOL(is_trivially_assignable_v, std::, <type_traits>) SYMBOL(is_trivially_constructible, std::, <type_traits>) SYMBOL(is_trivially_constructible_v, std::, <type_traits>) SYMBOL(is_trivially_copy_assignable, std::, <type_traits>) SYMBOL(is_trivially_copy_assignable_v, std::, <type_traits>) SYMBOL(is_trivially_copy_constructible, std::, <type_traits>) SYMBOL(is_trivially_copy_constructible_v, std::, <type_traits>) SYMBOL(is_trivially_copyable, std::, <type_traits>) SYMBOL(is_trivially_copyable_v, std::, <type_traits>) SYMBOL(is_trivially_default_constructible, std::, <type_traits>) SYMBOL(is_trivially_default_constructible_v, std::, <type_traits>) SYMBOL(is_trivially_destructible, std::, <type_traits>) SYMBOL(is_trivially_destructible_v, std::, <type_traits>) SYMBOL(is_trivially_move_assignable, std::, <type_traits>) SYMBOL(is_trivially_move_assignable_v, std::, <type_traits>) SYMBOL(is_trivially_move_constructible, std::, <type_traits>) SYMBOL(is_trivially_move_constructible_v, std::, <type_traits>) SYMBOL(is_unbounded_array, std::, <type_traits>) SYMBOL(is_unbounded_array_v, std::, <type_traits>) SYMBOL(is_union, std::, <type_traits>) SYMBOL(is_union_v, std::, <type_traits>) SYMBOL(is_unsigned, std::, <type_traits>) SYMBOL(is_unsigned_v, std::, <type_traits>) SYMBOL(is_void, std::, <type_traits>) SYMBOL(is_void_v, std::, <type_traits>) SYMBOL(is_volatile, std::, <type_traits>) SYMBOL(is_volatile_v, std::, <type_traits>) SYMBOL(isalnum, std::, <cctype>) SYMBOL(isalnum, None, <cctype>) SYMBOL(isalnum, None, <ctype.h>) SYMBOL(isalpha, std::, <cctype>) SYMBOL(isalpha, None, <cctype>) SYMBOL(isalpha, None, <ctype.h>) SYMBOL(isblank, std::, <cctype>) SYMBOL(isblank, None, <cctype>) SYMBOL(isblank, None, <ctype.h>) SYMBOL(iscntrl, std::, <cctype>) SYMBOL(iscntrl, None, <cctype>) SYMBOL(iscntrl, None, <ctype.h>) SYMBOL(isdigit, std::, <cctype>) SYMBOL(isdigit, None, <cctype>) SYMBOL(isdigit, None, <ctype.h>) SYMBOL(isfinite, std::, <cmath>) SYMBOL(isfinite, None, <cmath>) SYMBOL(isfinite, None, <math.h>) SYMBOL(isgraph, std::, <cctype>) SYMBOL(isgraph, None, <cctype>) SYMBOL(isgraph, None, <ctype.h>) SYMBOL(isgreater, std::, <cmath>) SYMBOL(isgreater, None, <cmath>) SYMBOL(isgreater, None, <math.h>) SYMBOL(isgreaterequal, std::, <cmath>) SYMBOL(isgreaterequal, None, <cmath>) SYMBOL(isgreaterequal, None, <math.h>) SYMBOL(isinf, std::, <cmath>) SYMBOL(isinf, None, <cmath>) SYMBOL(isinf, None, <math.h>) SYMBOL(isless, std::, <cmath>) SYMBOL(isless, None, <cmath>) SYMBOL(isless, None, <math.h>) SYMBOL(islessequal, std::, <cmath>) SYMBOL(islessequal, None, <cmath>) SYMBOL(islessequal, None, <math.h>) SYMBOL(islessgreater, std::, <cmath>) SYMBOL(islessgreater, None, <cmath>) SYMBOL(islessgreater, None, <math.h>) SYMBOL(islower, std::, <cctype>) SYMBOL(islower, None, <cctype>) SYMBOL(islower, None, <ctype.h>) SYMBOL(isnan, std::, <cmath>) SYMBOL(isnan, None, <cmath>) SYMBOL(isnan, None, <math.h>) SYMBOL(isnormal, std::, <cmath>) SYMBOL(isnormal, None, <cmath>) SYMBOL(isnormal, None, <math.h>) SYMBOL(ispanstream, std::, <spanstream>) SYMBOL(ispanstream, std::, <iosfwd>) SYMBOL(isprint, std::, <cctype>) SYMBOL(isprint, None, <cctype>) SYMBOL(isprint, None, <ctype.h>) SYMBOL(ispunct, std::, <cctype>) SYMBOL(ispunct, None, <cctype>) SYMBOL(ispunct, None, <ctype.h>) SYMBOL(isspace, std::, <cctype>) SYMBOL(isspace, None, <cctype>) SYMBOL(isspace, None, <ctype.h>) SYMBOL(istream, std::, <istream>) SYMBOL(istream, std::, <iostream>) SYMBOL(istream, std::, <iosfwd>) SYMBOL(istream_iterator, std::, <iterator>) SYMBOL(istreambuf_iterator, std::, <iterator>) SYMBOL(istreambuf_iterator, std::, <iosfwd>) SYMBOL(istringstream, std::, <sstream>) SYMBOL(istringstream, std::, <iosfwd>) SYMBOL(istrstream, std::, <strstream>) SYMBOL(isunordered, std::, <cmath>) SYMBOL(isunordered, None, <cmath>) SYMBOL(isunordered, None, <math.h>) SYMBOL(isupper, std::, <cctype>) SYMBOL(isupper, None, <cctype>) SYMBOL(isupper, None, <ctype.h>) SYMBOL(iswalnum, std::, <cwctype>) SYMBOL(iswalnum, None, <cwctype>) SYMBOL(iswalnum, None, <wctype.h>) SYMBOL(iswalpha, std::, <cwctype>) SYMBOL(iswalpha, None, <cwctype>) SYMBOL(iswalpha, None, <wctype.h>) SYMBOL(iswblank, std::, <cwctype>) SYMBOL(iswblank, None, <cwctype>) SYMBOL(iswblank, None, <wctype.h>) SYMBOL(iswcntrl, std::, <cwctype>) SYMBOL(iswcntrl, None, <cwctype>) SYMBOL(iswcntrl, None, <wctype.h>) SYMBOL(iswctype, std::, <cwctype>) SYMBOL(iswctype, None, <cwctype>) SYMBOL(iswctype, None, <wctype.h>) SYMBOL(iswdigit, std::, <cwctype>) SYMBOL(iswdigit, None, <cwctype>) SYMBOL(iswdigit, None, <wctype.h>) SYMBOL(iswgraph, std::, <cwctype>) SYMBOL(iswgraph, None, <cwctype>) SYMBOL(iswgraph, None, <wctype.h>) SYMBOL(iswlower, std::, <cwctype>) SYMBOL(iswlower, None, <cwctype>) SYMBOL(iswlower, None, <wctype.h>) SYMBOL(iswprint, std::, <cwctype>) SYMBOL(iswprint, None, <cwctype>) SYMBOL(iswprint, None, <wctype.h>) SYMBOL(iswpunct, std::, <cwctype>) SYMBOL(iswpunct, None, <cwctype>) SYMBOL(iswpunct, None, <wctype.h>) SYMBOL(iswspace, std::, <cwctype>) SYMBOL(iswspace, None, <cwctype>) SYMBOL(iswspace, None, <wctype.h>) SYMBOL(iswupper, std::, <cwctype>) SYMBOL(iswupper, None, <cwctype>) SYMBOL(iswupper, None, <wctype.h>) SYMBOL(iswxdigit, std::, <cwctype>) SYMBOL(iswxdigit, None, <cwctype>) SYMBOL(iswxdigit, None, <wctype.h>) SYMBOL(isxdigit, std::, <cctype>) SYMBOL(isxdigit, None, <cctype>) SYMBOL(isxdigit, None, <ctype.h>) SYMBOL(iter_common_reference_t, std::, <iterator>) SYMBOL(iter_const_reference_t, std::, <iterator>) SYMBOL(iter_difference_t, std::, <iterator>) SYMBOL(iter_reference_t, std::, <iterator>) SYMBOL(iter_rvalue_reference_t, std::, <iterator>) SYMBOL(iter_swap, std::, <algorithm>) SYMBOL(iter_value_t, std::, <iterator>) SYMBOL(iterator, std::, <iterator>) SYMBOL(iterator_traits, std::, <iterator>) SYMBOL(jmp_buf, std::, <csetjmp>) SYMBOL(jmp_buf, None, <csetjmp>) SYMBOL(jmp_buf, None, <setjmp.h>) SYMBOL(jthread, std::, <thread>) SYMBOL(kill_dependency, std::, <atomic>) SYMBOL(kilo, std::, <ratio>) SYMBOL(knuth_b, std::, <random>) SYMBOL(labs, std::, <cstdlib>) SYMBOL(labs, None, <cstdlib>) SYMBOL(labs, None, <stdlib.h>) SYMBOL(laguerre, std::, <cmath>) SYMBOL(laguerref, std::, <cmath>) SYMBOL(laguerrel, std::, <cmath>) SYMBOL(latch, std::, <latch>) SYMBOL(launch, std::, <future>) SYMBOL(launder, std::, <new>) SYMBOL(lcm, std::, <numeric>) SYMBOL(lconv, std::, <clocale>) SYMBOL(lconv, None, <clocale>) SYMBOL(lconv, None, <locale.h>) SYMBOL(ldexp, std::, <cmath>) SYMBOL(ldexp, None, <cmath>) SYMBOL(ldexp, None, <math.h>) SYMBOL(ldexpf, std::, <cmath>) SYMBOL(ldexpf, None, <cmath>) SYMBOL(ldexpf, None, <math.h>) SYMBOL(ldexpl, std::, <cmath>) SYMBOL(ldexpl, None, <cmath>) SYMBOL(ldexpl, None, <math.h>) SYMBOL(ldiv, std::, <cstdlib>) SYMBOL(ldiv, None, <cstdlib>) SYMBOL(ldiv, None, <stdlib.h>) SYMBOL(ldiv_t, std::, <cstdlib>) SYMBOL(ldiv_t, None, <cstdlib>) SYMBOL(ldiv_t, None, <stdlib.h>) SYMBOL(left, std::, <ios>) SYMBOL(left, std::, <iostream>) SYMBOL(legendre, std::, <cmath>) SYMBOL(legendref, std::, <cmath>) SYMBOL(legendrel, std::, <cmath>) SYMBOL(length_error, std::, <stdexcept>) SYMBOL(lerp, std::, <cmath>) SYMBOL(less, std::, <functional>) SYMBOL(less_equal, std::, <functional>) SYMBOL(lexicographical_compare, std::, <algorithm>) SYMBOL(lexicographical_compare_three_way, std::, <algorithm>) SYMBOL(lgamma, std::, <cmath>) SYMBOL(lgamma, None, <cmath>) SYMBOL(lgamma, None, <math.h>) SYMBOL(lgammaf, std::, <cmath>) SYMBOL(lgammaf, None, <cmath>) SYMBOL(lgammaf, None, <math.h>) SYMBOL(lgammal, std::, <cmath>) SYMBOL(lgammal, None, <cmath>) SYMBOL(lgammal, None, <math.h>) SYMBOL(linear_congruential_engine, std::, <random>) SYMBOL(list, std::, <list>) SYMBOL(llabs, std::, <cstdlib>) SYMBOL(llabs, None, <cstdlib>) SYMBOL(llabs, None, <stdlib.h>) SYMBOL(lldiv, std::, <cstdlib>) SYMBOL(lldiv, None, <cstdlib>) SYMBOL(lldiv, None, <stdlib.h>) SYMBOL(lldiv_t, std::, <cstdlib>) SYMBOL(lldiv_t, None, <cstdlib>) SYMBOL(lldiv_t, None, <stdlib.h>) SYMBOL(llrint, std::, <cmath>) SYMBOL(llrint, None, <cmath>) SYMBOL(llrint, None, <math.h>) SYMBOL(llrintf, std::, <cmath>) SYMBOL(llrintf, None, <cmath>) SYMBOL(llrintf, None, <math.h>) SYMBOL(llrintl, std::, <cmath>) SYMBOL(llrintl, None, <cmath>) SYMBOL(llrintl, None, <math.h>) SYMBOL(llround, std::, <cmath>) SYMBOL(llround, None, <cmath>) SYMBOL(llround, None, <math.h>) SYMBOL(llroundf, std::, <cmath>) SYMBOL(llroundf, None, <cmath>) SYMBOL(llroundf, None, <math.h>) SYMBOL(llroundl, std::, <cmath>) SYMBOL(llroundl, None, <cmath>) SYMBOL(llroundl, None, <math.h>) SYMBOL(locale, std::, <locale>) SYMBOL(localeconv, std::, <clocale>) SYMBOL(localeconv, None, <clocale>) SYMBOL(localeconv, None, <locale.h>) SYMBOL(localtime, std::, <ctime>) SYMBOL(localtime, None, <ctime>) SYMBOL(localtime, None, <time.h>) SYMBOL(lock, std::, <mutex>) SYMBOL(lock_guard, std::, <mutex>) SYMBOL(log, std::, <cmath>) SYMBOL(log, None, <cmath>) SYMBOL(log, None, <math.h>) SYMBOL(log10, std::, <cmath>) SYMBOL(log10, None, <cmath>) SYMBOL(log10, None, <math.h>) SYMBOL(log10f, std::, <cmath>) SYMBOL(log10f, None, <cmath>) SYMBOL(log10f, None, <math.h>) SYMBOL(log10l, std::, <cmath>) SYMBOL(log10l, None, <cmath>) SYMBOL(log10l, None, <math.h>) SYMBOL(log1p, std::, <cmath>) SYMBOL(log1p, None, <cmath>) SYMBOL(log1p, None, <math.h>) SYMBOL(log1pf, std::, <cmath>) SYMBOL(log1pf, None, <cmath>) SYMBOL(log1pf, None, <math.h>) SYMBOL(log1pl, std::, <cmath>) SYMBOL(log1pl, None, <cmath>) SYMBOL(log1pl, None, <math.h>) SYMBOL(log2, std::, <cmath>) SYMBOL(log2, None, <cmath>) SYMBOL(log2, None, <math.h>) SYMBOL(log2f, std::, <cmath>) SYMBOL(log2f, None, <cmath>) SYMBOL(log2f, None, <math.h>) SYMBOL(log2l, std::, <cmath>) SYMBOL(log2l, None, <cmath>) SYMBOL(log2l, None, <math.h>) SYMBOL(logb, std::, <cmath>) SYMBOL(logb, None, <cmath>) SYMBOL(logb, None, <math.h>) SYMBOL(logbf, std::, <cmath>) SYMBOL(logbf, None, <cmath>) SYMBOL(logbf, None, <math.h>) SYMBOL(logbl, std::, <cmath>) SYMBOL(logbl, None, <cmath>) SYMBOL(logbl, None, <math.h>) SYMBOL(logf, std::, <cmath>) SYMBOL(logf, None, <cmath>) SYMBOL(logf, None, <math.h>) SYMBOL(logic_error, std::, <stdexcept>) SYMBOL(logical_and, std::, <functional>) SYMBOL(logical_not, std::, <functional>) SYMBOL(logical_or, std::, <functional>) SYMBOL(logl, std::, <cmath>) SYMBOL(logl, None, <cmath>) SYMBOL(logl, None, <math.h>) SYMBOL(lognormal_distribution, std::, <random>) SYMBOL(longjmp, std::, <csetjmp>) SYMBOL(longjmp, None, <csetjmp>) SYMBOL(longjmp, None, <setjmp.h>) SYMBOL(lower_bound, std::, <algorithm>) SYMBOL(lrint, std::, <cmath>) SYMBOL(lrint, None, <cmath>) SYMBOL(lrint, None, <math.h>) SYMBOL(lrintf, std::, <cmath>) SYMBOL(lrintf, None, <cmath>) SYMBOL(lrintf, None, <math.h>) SYMBOL(lrintl, std::, <cmath>) SYMBOL(lrintl, None, <cmath>) SYMBOL(lrintl, None, <math.h>) SYMBOL(lround, std::, <cmath>) SYMBOL(lround, None, <cmath>) SYMBOL(lround, None, <math.h>) SYMBOL(lroundf, std::, <cmath>) SYMBOL(lroundf, None, <cmath>) SYMBOL(lroundf, None, <math.h>) SYMBOL(lroundl, std::, <cmath>) SYMBOL(lroundl, None, <cmath>) SYMBOL(lroundl, None, <math.h>) SYMBOL(make_exception_ptr, std::, <exception>) SYMBOL(make_format_args, std::, <format>) SYMBOL(make_from_tuple, std::, <tuple>) SYMBOL(make_heap, std::, <algorithm>) SYMBOL(make_move_iterator, std::, <iterator>) SYMBOL(make_obj_using_allocator, std::, <memory>) SYMBOL(make_optional, std::, <optional>) SYMBOL(make_pair, std::, <utility>) SYMBOL(make_reverse_iterator, std::, <iterator>) SYMBOL(make_shared, std::, <memory>) SYMBOL(make_shared_for_overwrite, std::, <memory>) SYMBOL(make_signed, std::, <type_traits>) SYMBOL(make_signed_t, std::, <type_traits>) SYMBOL(make_tuple, std::, <tuple>) SYMBOL(make_unique, std::, <memory>) SYMBOL(make_unique_for_overwrite, std::, <memory>) SYMBOL(make_unsigned, std::, <type_traits>) SYMBOL(make_unsigned_t, std::, <type_traits>) SYMBOL(make_wformat_args, std::, <format>) SYMBOL(malloc, std::, <cstdlib>) SYMBOL(malloc, None, <cstdlib>) SYMBOL(malloc, None, <stdlib.h>) SYMBOL(map, std::, <map>) SYMBOL(mask_array, std::, <valarray>) SYMBOL(match_results, std::, <regex>) SYMBOL(max, std::, <algorithm>) SYMBOL(max_align_t, std::, <cstddef>) SYMBOL(max_align_t, None, <cstddef>) SYMBOL(max_align_t, None, <stddef.h>) SYMBOL(max_element, std::, <algorithm>) SYMBOL(mblen, std::, <cstdlib>) SYMBOL(mblen, None, <cstdlib>) SYMBOL(mblen, None, <stdlib.h>) SYMBOL(mbrlen, std::, <cwchar>) SYMBOL(mbrlen, None, <cwchar>) SYMBOL(mbrlen, None, <wchar.h>) SYMBOL(mbrtoc16, std::, <cuchar>) SYMBOL(mbrtoc16, None, <cuchar>) SYMBOL(mbrtoc16, None, <uchar.h>) SYMBOL(mbrtoc32, std::, <cuchar>) SYMBOL(mbrtoc32, None, <cuchar>) SYMBOL(mbrtoc32, None, <uchar.h>) SYMBOL(mbrtoc8, std::, <cuchar>) SYMBOL(mbrtoc8, None, <cuchar>) SYMBOL(mbrtoc8, None, <uchar.h>) SYMBOL(mbrtowc, std::, <cwchar>) SYMBOL(mbrtowc, None, <cwchar>) SYMBOL(mbrtowc, None, <wchar.h>) SYMBOL(mbsinit, std::, <cwchar>) SYMBOL(mbsinit, None, <cwchar>) SYMBOL(mbsinit, None, <wchar.h>) SYMBOL(mbsrtowcs, std::, <cwchar>) SYMBOL(mbsrtowcs, None, <cwchar>) SYMBOL(mbsrtowcs, None, <wchar.h>) SYMBOL(mbstowcs, std::, <cstdlib>) SYMBOL(mbstowcs, None, <cstdlib>) SYMBOL(mbstowcs, None, <stdlib.h>) SYMBOL(mbtowc, std::, <cstdlib>) SYMBOL(mbtowc, None, <cstdlib>) SYMBOL(mbtowc, None, <stdlib.h>) SYMBOL(mega, std::, <ratio>) SYMBOL(mem_fn, std::, <functional>) SYMBOL(mem_fun, std::, <functional>) SYMBOL(mem_fun1_ref_t, std::, <functional>) SYMBOL(mem_fun1_t, std::, <functional>) SYMBOL(mem_fun_ref, std::, <functional>) SYMBOL(mem_fun_ref_t, std::, <functional>) SYMBOL(mem_fun_t, std::, <functional>) SYMBOL(memchr, std::, <cstring>) SYMBOL(memchr, None, <cstring>) SYMBOL(memchr, None, <string.h>) SYMBOL(memcmp, std::, <cstring>) SYMBOL(memcmp, None, <cstring>) SYMBOL(memcmp, None, <string.h>) SYMBOL(memcpy, std::, <cstring>) SYMBOL(memcpy, None, <cstring>) SYMBOL(memcpy, None, <string.h>) SYMBOL(memmove, std::, <cstring>) SYMBOL(memmove, None, <cstring>) SYMBOL(memmove, None, <string.h>) SYMBOL(memory_order, std::, <atomic>) SYMBOL(memory_order_acq_rel, std::, <atomic>) SYMBOL(memory_order_acquire, std::, <atomic>) SYMBOL(memory_order_consume, std::, <atomic>) SYMBOL(memory_order_relaxed, std::, <atomic>) SYMBOL(memory_order_release, std::, <atomic>) SYMBOL(memory_order_seq_cst, std::, <atomic>) SYMBOL(memset, std::, <cstring>) SYMBOL(memset, None, <cstring>) SYMBOL(memset, None, <string.h>) SYMBOL(merge, std::, <algorithm>) SYMBOL(mergeable, std::, <iterator>) SYMBOL(mersenne_twister_engine, std::, <random>) SYMBOL(messages, std::, <locale>) SYMBOL(messages_base, std::, <locale>) SYMBOL(messages_byname, std::, <locale>) SYMBOL(micro, std::, <ratio>) SYMBOL(midpoint, std::, <numeric>) SYMBOL(milli, std::, <ratio>) SYMBOL(min, std::, <algorithm>) SYMBOL(min_element, std::, <algorithm>) SYMBOL(minmax, std::, <algorithm>) SYMBOL(minmax_element, std::, <algorithm>) SYMBOL(minstd_rand, std::, <random>) SYMBOL(minstd_rand0, std::, <random>) SYMBOL(minus, std::, <functional>) SYMBOL(mismatch, std::, <algorithm>) SYMBOL(mktime, std::, <ctime>) SYMBOL(mktime, None, <ctime>) SYMBOL(mktime, None, <time.h>) SYMBOL(modf, std::, <cmath>) SYMBOL(modf, None, <cmath>) SYMBOL(modf, None, <math.h>) SYMBOL(modff, std::, <cmath>) SYMBOL(modff, None, <cmath>) SYMBOL(modff, None, <math.h>) SYMBOL(modfl, std::, <cmath>) SYMBOL(modfl, None, <cmath>) SYMBOL(modfl, None, <math.h>) SYMBOL(modulus, std::, <functional>) SYMBOL(money_base, std::, <locale>) SYMBOL(money_get, std::, <locale>) SYMBOL(money_put, std::, <locale>) SYMBOL(moneypunct, std::, <locale>) SYMBOL(moneypunct_byname, std::, <locale>) SYMBOL(monostate, std::, <variant>) SYMBOL(movable, std::, <concepts>) SYMBOL(move_backward, std::, <algorithm>) SYMBOL(move_constructible, std::, <concepts>) SYMBOL(move_if_noexcept, std::, <utility>) SYMBOL(move_iterator, std::, <iterator>) SYMBOL(move_only_function, std::, <functional>) SYMBOL(move_sentinel, std::, <iterator>) SYMBOL(mt19937, std::, <random>) SYMBOL(mt19937_64, std::, <random>) SYMBOL(multimap, std::, <map>) SYMBOL(multiplies, std::, <functional>) SYMBOL(multiset, std::, <set>) SYMBOL(mutex, std::, <mutex>) SYMBOL(nan, std::, <cmath>) SYMBOL(nan, None, <cmath>) SYMBOL(nan, None, <math.h>) SYMBOL(nanf, std::, <cmath>) SYMBOL(nanf, None, <cmath>) SYMBOL(nanf, None, <math.h>) SYMBOL(nanl, std::, <cmath>) SYMBOL(nanl, None, <cmath>) SYMBOL(nanl, None, <math.h>) SYMBOL(nano, std::, <ratio>) SYMBOL(nearbyint, std::, <cmath>) SYMBOL(nearbyint, None, <cmath>) SYMBOL(nearbyint, None, <math.h>) SYMBOL(nearbyintf, std::, <cmath>) SYMBOL(nearbyintf, None, <cmath>) SYMBOL(nearbyintf, None, <math.h>) SYMBOL(nearbyintl, std::, <cmath>) SYMBOL(nearbyintl, None, <cmath>) SYMBOL(nearbyintl, None, <math.h>) SYMBOL(negate, std::, <functional>) SYMBOL(negation, std::, <type_traits>) SYMBOL(negation_v, std::, <type_traits>) SYMBOL(negative_binomial_distribution, std::, <random>) SYMBOL(nested_exception, std::, <exception>) SYMBOL(new_handler, std::, <new>) SYMBOL(next, std::, <iterator>) SYMBOL(next_permutation, std::, <algorithm>) SYMBOL(nextafter, std::, <cmath>) SYMBOL(nextafter, None, <cmath>) SYMBOL(nextafter, None, <math.h>) SYMBOL(nextafterf, std::, <cmath>) SYMBOL(nextafterf, None, <cmath>) SYMBOL(nextafterf, None, <math.h>) SYMBOL(nextafterl, std::, <cmath>) SYMBOL(nextafterl, None, <cmath>) SYMBOL(nextafterl, None, <math.h>) SYMBOL(nexttoward, std::, <cmath>) SYMBOL(nexttoward, None, <cmath>) SYMBOL(nexttoward, None, <math.h>) SYMBOL(nexttowardf, std::, <cmath>) SYMBOL(nexttowardf, None, <cmath>) SYMBOL(nexttowardf, None, <math.h>) SYMBOL(nexttowardl, std::, <cmath>) SYMBOL(nexttowardl, None, <cmath>) SYMBOL(nexttowardl, None, <math.h>) SYMBOL(noboolalpha, std::, <ios>) SYMBOL(noboolalpha, std::, <iostream>) SYMBOL(noemit_on_flush, std::, <ostream>) SYMBOL(noemit_on_flush, std::, <iostream>) SYMBOL(none_of, std::, <algorithm>) SYMBOL(noop_coroutine, std::, <coroutine>) SYMBOL(noop_coroutine_handle, std::, <coroutine>) SYMBOL(noop_coroutine_promise, std::, <coroutine>) SYMBOL(norm, std::, <complex>) SYMBOL(normal_distribution, std::, <random>) SYMBOL(noshowbase, std::, <ios>) SYMBOL(noshowbase, std::, <iostream>) SYMBOL(noshowpoint, std::, <ios>) SYMBOL(noshowpoint, std::, <iostream>) SYMBOL(noshowpos, std::, <ios>) SYMBOL(noshowpos, std::, <iostream>) SYMBOL(noskipws, std::, <ios>) SYMBOL(noskipws, std::, <iostream>) SYMBOL(nostopstate, std::, <stop_token>) SYMBOL(nostopstate_t, std::, <stop_token>) SYMBOL(not1, std::, <functional>) SYMBOL(not2, std::, <functional>) SYMBOL(not_equal_to, std::, <functional>) SYMBOL(not_fn, std::, <functional>) SYMBOL(nothrow, std::, <new>) SYMBOL(nothrow_t, std::, <new>) SYMBOL(notify_all_at_thread_exit, std::, <condition_variable>) SYMBOL(nounitbuf, std::, <ios>) SYMBOL(nounitbuf, std::, <iostream>) SYMBOL(nouppercase, std::, <ios>) SYMBOL(nouppercase, std::, <iostream>) SYMBOL(nth_element, std::, <algorithm>) SYMBOL(nullopt, std::, <optional>) SYMBOL(nullopt_t, std::, <optional>) SYMBOL(nullptr_t, std::, <cstddef>) SYMBOL(nullptr_t, None, <cstddef>) SYMBOL(nullptr_t, None, <stddef.h>) SYMBOL(num_get, std::, <locale>) SYMBOL(num_put, std::, <locale>) SYMBOL(numeric_limits, std::, <limits>) SYMBOL(numpunct, std::, <locale>) SYMBOL(numpunct_byname, std::, <locale>) SYMBOL(oct, std::, <ios>) SYMBOL(oct, std::, <iostream>) SYMBOL(ofstream, std::, <fstream>) SYMBOL(ofstream, std::, <iosfwd>) SYMBOL(once_flag, std::, <mutex>) SYMBOL(open_mode, std::, <ios>) SYMBOL(open_mode, std::, <iostream>) SYMBOL(optional, std::, <optional>) SYMBOL(ospanstream, std::, <spanstream>) SYMBOL(ospanstream, std::, <iosfwd>) SYMBOL(ostream, std::, <ostream>) SYMBOL(ostream, std::, <iostream>) SYMBOL(ostream, std::, <iosfwd>) SYMBOL(ostream_iterator, std::, <iterator>) SYMBOL(ostreambuf_iterator, std::, <iterator>) SYMBOL(ostreambuf_iterator, std::, <iosfwd>) SYMBOL(ostringstream, std::, <sstream>) SYMBOL(ostringstream, std::, <iosfwd>) SYMBOL(ostrstream, std::, <strstream>) SYMBOL(osyncstream, std::, <syncstream>) SYMBOL(osyncstream, std::, <iosfwd>) SYMBOL(out_of_range, std::, <stdexcept>) SYMBOL(out_ptr, std::, <memory>) SYMBOL(out_ptr_t, std::, <memory>) SYMBOL(output_iterator, std::, <iterator>) SYMBOL(output_iterator_tag, std::, <iterator>) SYMBOL(overflow_error, std::, <stdexcept>) SYMBOL(owner_less, std::, <memory>) SYMBOL(packaged_task, std::, <future>) SYMBOL(pair, std::, <utility>) SYMBOL(partial_order, std::, <compare>) SYMBOL(partial_ordering, std::, <compare>) SYMBOL(partial_sort, std::, <algorithm>) SYMBOL(partial_sort_copy, std::, <algorithm>) SYMBOL(partial_sum, std::, <numeric>) SYMBOL(partition, std::, <algorithm>) SYMBOL(partition_copy, std::, <algorithm>) SYMBOL(partition_point, std::, <algorithm>) SYMBOL(permutable, std::, <iterator>) SYMBOL(perror, std::, <cstdio>) SYMBOL(perror, None, <cstdio>) SYMBOL(perror, None, <stdio.h>) SYMBOL(peta, std::, <ratio>) SYMBOL(pico, std::, <ratio>) SYMBOL(piecewise_constant_distribution, std::, <random>) SYMBOL(piecewise_construct, std::, <utility>) SYMBOL(piecewise_construct_t, std::, <utility>) SYMBOL(piecewise_linear_distribution, std::, <random>) SYMBOL(plus, std::, <functional>) SYMBOL(pointer_safety, std::, <memory>) SYMBOL(pointer_traits, std::, <memory>) SYMBOL(poisson_distribution, std::, <random>) SYMBOL(polar, std::, <complex>) SYMBOL(pop_heap, std::, <algorithm>) SYMBOL(popcount, std::, <bit>) SYMBOL(pow, std::, <cmath>) SYMBOL(pow, None, <cmath>) SYMBOL(pow, None, <math.h>) SYMBOL(powf, std::, <cmath>) SYMBOL(powf, None, <cmath>) SYMBOL(powf, None, <math.h>) SYMBOL(powl, std::, <cmath>) SYMBOL(powl, None, <cmath>) SYMBOL(powl, None, <math.h>) SYMBOL(predicate, std::, <concepts>) SYMBOL(preferred, std::, <memory>) SYMBOL(prev, std::, <iterator>) SYMBOL(prev_permutation, std::, <algorithm>) SYMBOL(printf, std::, <cstdio>) SYMBOL(printf, None, <cstdio>) SYMBOL(printf, None, <stdio.h>) SYMBOL(priority_queue, std::, <queue>) SYMBOL(proj, std::, <complex>) SYMBOL(projected, std::, <iterator>) SYMBOL(promise, std::, <future>) SYMBOL(ptr_fun, std::, <functional>) SYMBOL(ptrdiff_t, std::, <cstddef>) SYMBOL(ptrdiff_t, None, <cstddef>) SYMBOL(ptrdiff_t, None, <stddef.h>) SYMBOL(push_heap, std::, <algorithm>) SYMBOL(put_money, std::, <iomanip>) SYMBOL(put_time, std::, <iomanip>) SYMBOL(putc, std::, <cstdio>) SYMBOL(putc, None, <cstdio>) SYMBOL(putc, None, <stdio.h>) SYMBOL(putchar, std::, <cstdio>) SYMBOL(putchar, None, <cstdio>) SYMBOL(putchar, None, <stdio.h>) SYMBOL(puts, std::, <cstdio>) SYMBOL(puts, None, <cstdio>) SYMBOL(puts, None, <stdio.h>) SYMBOL(putwc, std::, <cwchar>) SYMBOL(putwc, None, <cwchar>) SYMBOL(putwc, None, <wchar.h>) SYMBOL(putwchar, std::, <cwchar>) SYMBOL(putwchar, None, <cwchar>) SYMBOL(putwchar, None, <wchar.h>) SYMBOL(qsort, std::, <cstdlib>) SYMBOL(qsort, None, <cstdlib>) SYMBOL(qsort, None, <stdlib.h>) SYMBOL(queue, std::, <queue>) SYMBOL(quick_exit, std::, <cstdlib>) SYMBOL(quick_exit, None, <cstdlib>) SYMBOL(quick_exit, None, <stdlib.h>) SYMBOL(quoted, std::, <iomanip>) SYMBOL(raise, std::, <csignal>) SYMBOL(raise, None, <csignal>) SYMBOL(raise, None, <signal.h>) SYMBOL(rand, std::, <cstdlib>) SYMBOL(rand, None, <cstdlib>) SYMBOL(rand, None, <stdlib.h>) SYMBOL(random_access_iterator, std::, <iterator>) SYMBOL(random_access_iterator_tag, std::, <iterator>) SYMBOL(random_device, std::, <random>) SYMBOL(random_shuffle, std::, <algorithm>) SYMBOL(range_error, std::, <stdexcept>) SYMBOL(rank, std::, <type_traits>) SYMBOL(rank_v, std::, <type_traits>) SYMBOL(ranlux24, std::, <random>) SYMBOL(ranlux24_base, std::, <random>) SYMBOL(ranlux48, std::, <random>) SYMBOL(ranlux48_base, std::, <random>) SYMBOL(ratio, std::, <ratio>) SYMBOL(ratio_add, std::, <ratio>) SYMBOL(ratio_divide, std::, <ratio>) SYMBOL(ratio_equal, std::, <ratio>) SYMBOL(ratio_equal_v, std::, <ratio>) SYMBOL(ratio_greater, std::, <ratio>) SYMBOL(ratio_greater_equal, std::, <ratio>) SYMBOL(ratio_greater_equal_v, std::, <ratio>) SYMBOL(ratio_greater_v, std::, <ratio>) SYMBOL(ratio_less, std::, <ratio>) SYMBOL(ratio_less_equal, std::, <ratio>) SYMBOL(ratio_less_equal_v, std::, <ratio>) SYMBOL(ratio_less_v, std::, <ratio>) SYMBOL(ratio_multiply, std::, <ratio>) SYMBOL(ratio_not_equal, std::, <ratio>) SYMBOL(ratio_not_equal_v, std::, <ratio>) SYMBOL(ratio_subtract, std::, <ratio>) SYMBOL(raw_storage_iterator, std::, <memory>) SYMBOL(real, std::, <complex>) SYMBOL(realloc, std::, <cstdlib>) SYMBOL(realloc, None, <cstdlib>) SYMBOL(realloc, None, <stdlib.h>) SYMBOL(recursive_mutex, std::, <mutex>) SYMBOL(recursive_timed_mutex, std::, <mutex>) SYMBOL(reduce, std::, <numeric>) SYMBOL(ref, std::, <functional>) SYMBOL(reference_wrapper, std::, <functional>) SYMBOL(regex, std::, <regex>) SYMBOL(regex_error, std::, <regex>) SYMBOL(regex_iterator, std::, <regex>) SYMBOL(regex_match, std::, <regex>) SYMBOL(regex_replace, std::, <regex>) SYMBOL(regex_search, std::, <regex>) SYMBOL(regex_token_iterator, std::, <regex>) SYMBOL(regex_traits, std::, <regex>) SYMBOL(regular, std::, <concepts>) SYMBOL(regular_invocable, std::, <concepts>) SYMBOL(reinterpret_pointer_cast, std::, <memory>) SYMBOL(relation, std::, <concepts>) SYMBOL(remainder, std::, <cmath>) SYMBOL(remainder, None, <cmath>) SYMBOL(remainder, None, <math.h>) SYMBOL(remainderf, std::, <cmath>) SYMBOL(remainderf, None, <cmath>) SYMBOL(remainderf, None, <math.h>) SYMBOL(remainderl, std::, <cmath>) SYMBOL(remainderl, None, <cmath>) SYMBOL(remainderl, None, <math.h>) SYMBOL(remove_all_extents, std::, <type_traits>) SYMBOL(remove_all_extents_t, std::, <type_traits>) SYMBOL(remove_const, std::, <type_traits>) SYMBOL(remove_const_t, std::, <type_traits>) SYMBOL(remove_copy, std::, <algorithm>) SYMBOL(remove_copy_if, std::, <algorithm>) SYMBOL(remove_cv, std::, <type_traits>) SYMBOL(remove_cv_t, std::, <type_traits>) SYMBOL(remove_cvref, std::, <type_traits>) SYMBOL(remove_cvref_t, std::, <type_traits>) SYMBOL(remove_extent, std::, <type_traits>) SYMBOL(remove_extent_t, std::, <type_traits>) SYMBOL(remove_if, std::, <algorithm>) SYMBOL(remove_pointer, std::, <type_traits>) SYMBOL(remove_pointer_t, std::, <type_traits>) SYMBOL(remove_reference, std::, <type_traits>) SYMBOL(remove_reference_t, std::, <type_traits>) SYMBOL(remove_volatile, std::, <type_traits>) SYMBOL(remove_volatile_t, std::, <type_traits>) SYMBOL(remquo, std::, <cmath>) SYMBOL(remquo, None, <cmath>) SYMBOL(remquo, None, <math.h>) SYMBOL(remquof, std::, <cmath>) SYMBOL(remquof, None, <cmath>) SYMBOL(remquof, None, <math.h>) SYMBOL(remquol, std::, <cmath>) SYMBOL(remquol, None, <cmath>) SYMBOL(remquol, None, <math.h>) SYMBOL(rename, std::, <cstdio>) SYMBOL(rename, None, <cstdio>) SYMBOL(rename, None, <stdio.h>) SYMBOL(replace, std::, <algorithm>) SYMBOL(replace_copy, std::, <algorithm>) SYMBOL(replace_copy_if, std::, <algorithm>) SYMBOL(replace_if, std::, <algorithm>) SYMBOL(resetiosflags, std::, <iomanip>) SYMBOL(result_of, std::, <type_traits>) SYMBOL(result_of_t, std::, <type_traits>) SYMBOL(rethrow_exception, std::, <exception>) SYMBOL(rethrow_if_nested, std::, <exception>) SYMBOL(return_temporary_buffer, std::, <memory>) SYMBOL(reverse, std::, <algorithm>) SYMBOL(reverse_copy, std::, <algorithm>) SYMBOL(reverse_iterator, std::, <iterator>) SYMBOL(rewind, std::, <cstdio>) SYMBOL(rewind, None, <cstdio>) SYMBOL(rewind, None, <stdio.h>) SYMBOL(riemann_zeta, std::, <cmath>) SYMBOL(riemann_zetaf, std::, <cmath>) SYMBOL(riemann_zetal, std::, <cmath>) SYMBOL(right, std::, <ios>) SYMBOL(right, std::, <iostream>) SYMBOL(rint, std::, <cmath>) SYMBOL(rint, None, <cmath>) SYMBOL(rint, None, <math.h>) SYMBOL(rintf, std::, <cmath>) SYMBOL(rintf, None, <cmath>) SYMBOL(rintf, None, <math.h>) SYMBOL(rintl, std::, <cmath>) SYMBOL(rintl, None, <cmath>) SYMBOL(rintl, None, <math.h>) SYMBOL(rotate, std::, <algorithm>) SYMBOL(rotate_copy, std::, <algorithm>) SYMBOL(rotl, std::, <bit>) SYMBOL(rotr, std::, <bit>) SYMBOL(round, std::, <cmath>) SYMBOL(round, None, <cmath>) SYMBOL(round, None, <math.h>) SYMBOL(round_indeterminate, std::, <limits>) SYMBOL(round_to_nearest, std::, <limits>) SYMBOL(round_toward_infinity, std::, <limits>) SYMBOL(round_toward_neg_infinity, std::, <limits>) SYMBOL(round_toward_zero, std::, <limits>) SYMBOL(roundf, std::, <cmath>) SYMBOL(roundf, None, <cmath>) SYMBOL(roundf, None, <math.h>) SYMBOL(roundl, std::, <cmath>) SYMBOL(roundl, None, <cmath>) SYMBOL(roundl, None, <math.h>) SYMBOL(runtime_error, std::, <stdexcept>) SYMBOL(same_as, std::, <concepts>) SYMBOL(sample, std::, <algorithm>) SYMBOL(scalbln, std::, <cmath>) SYMBOL(scalbln, None, <cmath>) SYMBOL(scalbln, None, <math.h>) SYMBOL(scalblnf, std::, <cmath>) SYMBOL(scalblnf, None, <cmath>) SYMBOL(scalblnf, None, <math.h>) SYMBOL(scalblnl, std::, <cmath>) SYMBOL(scalblnl, None, <cmath>) SYMBOL(scalblnl, None, <math.h>) SYMBOL(scalbn, std::, <cmath>) SYMBOL(scalbn, None, <cmath>) SYMBOL(scalbn, None, <math.h>) SYMBOL(scalbnf, std::, <cmath>) SYMBOL(scalbnf, None, <cmath>) SYMBOL(scalbnf, None, <math.h>) SYMBOL(scalbnl, std::, <cmath>) SYMBOL(scalbnl, None, <cmath>) SYMBOL(scalbnl, None, <math.h>) SYMBOL(scanf, std::, <cstdio>) SYMBOL(scanf, None, <cstdio>) SYMBOL(scanf, None, <stdio.h>) SYMBOL(scientific, std::, <ios>) SYMBOL(scientific, std::, <iostream>) SYMBOL(scoped_allocator_adaptor, std::, <scoped_allocator>) SYMBOL(scoped_lock, std::, <mutex>) SYMBOL(search, std::, <algorithm>) SYMBOL(search_n, std::, <algorithm>) SYMBOL(seed_seq, std::, <random>) SYMBOL(seek_dir, std::, <ios>) SYMBOL(seek_dir, std::, <iostream>) SYMBOL(semiregular, std::, <concepts>) SYMBOL(sentinel_for, std::, <iterator>) SYMBOL(set, std::, <set>) SYMBOL(set_difference, std::, <algorithm>) SYMBOL(set_intersection, std::, <algorithm>) SYMBOL(set_new_handler, std::, <new>) SYMBOL(set_symmetric_difference, std::, <algorithm>) SYMBOL(set_terminate, std::, <exception>) SYMBOL(set_unexpected, std::, <exception>) SYMBOL(set_union, std::, <algorithm>) SYMBOL(setbase, std::, <iomanip>) SYMBOL(setbuf, std::, <cstdio>) SYMBOL(setbuf, None, <cstdio>) SYMBOL(setbuf, None, <stdio.h>) SYMBOL(setfill, std::, <iomanip>) SYMBOL(setiosflags, std::, <iomanip>) SYMBOL(setlocale, std::, <clocale>) SYMBOL(setlocale, None, <clocale>) SYMBOL(setlocale, None, <locale.h>) SYMBOL(setprecision, std::, <iomanip>) SYMBOL(setvbuf, std::, <cstdio>) SYMBOL(setvbuf, None, <cstdio>) SYMBOL(setvbuf, None, <stdio.h>) SYMBOL(setw, std::, <iomanip>) SYMBOL(shared_future, std::, <future>) SYMBOL(shared_lock, std::, <shared_mutex>) SYMBOL(shared_mutex, std::, <shared_mutex>) SYMBOL(shared_ptr, std::, <memory>) SYMBOL(shared_timed_mutex, std::, <shared_mutex>) SYMBOL(shift_left, std::, <algorithm>) SYMBOL(shift_right, std::, <algorithm>) SYMBOL(showbase, std::, <ios>) SYMBOL(showbase, std::, <iostream>) SYMBOL(showpoint, std::, <ios>) SYMBOL(showpoint, std::, <iostream>) SYMBOL(showpos, std::, <ios>) SYMBOL(showpos, std::, <iostream>) SYMBOL(shuffle, std::, <algorithm>) SYMBOL(shuffle_order_engine, std::, <random>) SYMBOL(sig_atomic_t, std::, <csignal>) SYMBOL(sig_atomic_t, None, <csignal>) SYMBOL(sig_atomic_t, None, <signal.h>) SYMBOL(signal, std::, <csignal>) SYMBOL(signal, None, <csignal>) SYMBOL(signal, None, <signal.h>) SYMBOL(signbit, std::, <cmath>) SYMBOL(signbit, None, <cmath>) SYMBOL(signbit, None, <math.h>) SYMBOL(signed_integral, std::, <concepts>) SYMBOL(sin, std::, <cmath>) SYMBOL(sin, None, <cmath>) SYMBOL(sin, None, <math.h>) SYMBOL(sinf, std::, <cmath>) SYMBOL(sinf, None, <cmath>) SYMBOL(sinf, None, <math.h>) SYMBOL(sinh, std::, <cmath>) SYMBOL(sinh, None, <cmath>) SYMBOL(sinh, None, <math.h>) SYMBOL(sinhf, std::, <cmath>) SYMBOL(sinhf, None, <cmath>) SYMBOL(sinhf, None, <math.h>) SYMBOL(sinhl, std::, <cmath>) SYMBOL(sinhl, None, <cmath>) SYMBOL(sinhl, None, <math.h>) SYMBOL(sinl, std::, <cmath>) SYMBOL(sinl, None, <cmath>) SYMBOL(sinl, None, <math.h>) SYMBOL(sized_sentinel_for, std::, <iterator>) SYMBOL(skipws, std::, <ios>) SYMBOL(skipws, std::, <iostream>) SYMBOL(slice, std::, <valarray>) SYMBOL(slice_array, std::, <valarray>) SYMBOL(smatch, std::, <regex>) SYMBOL(snprintf, std::, <cstdio>) SYMBOL(snprintf, None, <cstdio>) SYMBOL(snprintf, None, <stdio.h>) SYMBOL(sort, std::, <algorithm>) SYMBOL(sort_heap, std::, <algorithm>) SYMBOL(sortable, std::, <iterator>) SYMBOL(source_location, std::, <source_location>) SYMBOL(span, std::, <span>) SYMBOL(spanbuf, std::, <spanstream>) SYMBOL(spanbuf, std::, <iosfwd>) SYMBOL(spanstream, std::, <spanstream>) SYMBOL(spanstream, std::, <iosfwd>) SYMBOL(sph_bessel, std::, <cmath>) SYMBOL(sph_bessel, None, <cmath>) SYMBOL(sph_bessel, None, <math.h>) SYMBOL(sph_besself, std::, <cmath>) SYMBOL(sph_besself, None, <cmath>) SYMBOL(sph_besself, None, <math.h>) SYMBOL(sph_bessell, std::, <cmath>) SYMBOL(sph_bessell, None, <cmath>) SYMBOL(sph_bessell, None, <math.h>) SYMBOL(sph_legendre, std::, <cmath>) SYMBOL(sph_legendref, std::, <cmath>) SYMBOL(sph_legendrel, std::, <cmath>) SYMBOL(sph_neumann, std::, <cmath>) SYMBOL(sph_neumannf, std::, <cmath>) SYMBOL(sph_neumannl, std::, <cmath>) SYMBOL(sprintf, std::, <cstdio>) SYMBOL(sprintf, None, <cstdio>) SYMBOL(sprintf, None, <stdio.h>) SYMBOL(sqrt, std::, <cmath>) SYMBOL(sqrt, None, <cmath>) SYMBOL(sqrt, None, <math.h>) SYMBOL(sqrtf, std::, <cmath>) SYMBOL(sqrtf, None, <cmath>) SYMBOL(sqrtf, None, <math.h>) SYMBOL(sqrtl, std::, <cmath>) SYMBOL(sqrtl, None, <cmath>) SYMBOL(sqrtl, None, <math.h>) SYMBOL(srand, std::, <cstdlib>) SYMBOL(srand, None, <cstdlib>) SYMBOL(srand, None, <stdlib.h>) SYMBOL(sregex_iterator, std::, <regex>) SYMBOL(sregex_token_iterator, std::, <regex>) SYMBOL(sscanf, std::, <cstdio>) SYMBOL(sscanf, None, <cstdio>) SYMBOL(sscanf, None, <stdio.h>) SYMBOL(ssub_match, std::, <regex>) SYMBOL(stable_partition, std::, <algorithm>) SYMBOL(stable_sort, std::, <algorithm>) SYMBOL(stack, std::, <stack>) SYMBOL(stacktrace, std::, <stacktrace>) SYMBOL(stacktrace_entry, std::, <stacktrace>) SYMBOL(static_pointer_cast, std::, <memory>) SYMBOL(stod, std::, <string>) SYMBOL(stof, std::, <string>) SYMBOL(stoi, std::, <string>) SYMBOL(stol, std::, <string>) SYMBOL(stold, std::, <string>) SYMBOL(stoll, std::, <string>) SYMBOL(stop_callback, std::, <stop_token>) SYMBOL(stop_source, std::, <stop_token>) SYMBOL(stop_token, std::, <stop_token>) SYMBOL(stoul, std::, <string>) SYMBOL(stoull, std::, <string>) SYMBOL(strcat, std::, <cstring>) SYMBOL(strcat, None, <cstring>) SYMBOL(strcat, None, <string.h>) SYMBOL(strchr, std::, <cstring>) SYMBOL(strchr, None, <cstring>) SYMBOL(strchr, None, <string.h>) SYMBOL(strcmp, std::, <cstring>) SYMBOL(strcmp, None, <cstring>) SYMBOL(strcmp, None, <string.h>) SYMBOL(strcoll, std::, <cstring>) SYMBOL(strcoll, None, <cstring>) SYMBOL(strcoll, None, <string.h>) SYMBOL(strcpy, std::, <cstring>) SYMBOL(strcpy, None, <cstring>) SYMBOL(strcpy, None, <string.h>) SYMBOL(strcspn, std::, <cstring>) SYMBOL(strcspn, None, <cstring>) SYMBOL(strcspn, None, <string.h>) SYMBOL(streambuf, std::, <streambuf>) SYMBOL(streambuf, std::, <iostream>) SYMBOL(streambuf, std::, <iosfwd>) SYMBOL(streamoff, std::, <ios>) SYMBOL(streamoff, std::, <iostream>) SYMBOL(streampos, std::, <iosfwd>) SYMBOL(streampos, std::, <iosfwd>) SYMBOL(streamsize, std::, <ios>) SYMBOL(streamsize, std::, <iostream>) SYMBOL(strerror, std::, <cstring>) SYMBOL(strerror, None, <cstring>) SYMBOL(strerror, None, <string.h>) SYMBOL(strftime, std::, <ctime>) SYMBOL(strftime, None, <ctime>) SYMBOL(strftime, None, <time.h>) SYMBOL(strict, std::, <memory>) SYMBOL(strict_weak_order, std::, <concepts>) SYMBOL(string, std::, <string>) SYMBOL(string_view, std::, <string_view>) SYMBOL(stringbuf, std::, <sstream>) SYMBOL(stringbuf, std::, <iosfwd>) SYMBOL(stringstream, std::, <sstream>) SYMBOL(stringstream, std::, <iosfwd>) SYMBOL(strlen, std::, <cstring>) SYMBOL(strlen, None, <cstring>) SYMBOL(strlen, None, <string.h>) SYMBOL(strncat, std::, <cstring>) SYMBOL(strncat, None, <cstring>) SYMBOL(strncat, None, <string.h>) SYMBOL(strncmp, std::, <cstring>) SYMBOL(strncmp, None, <cstring>) SYMBOL(strncmp, None, <string.h>) SYMBOL(strncpy, std::, <cstring>) SYMBOL(strncpy, None, <cstring>) SYMBOL(strncpy, None, <string.h>) SYMBOL(strong_order, std::, <compare>) SYMBOL(strong_ordering, std::, <compare>) SYMBOL(strpbrk, std::, <cstring>) SYMBOL(strpbrk, None, <cstring>) SYMBOL(strpbrk, None, <string.h>) SYMBOL(strrchr, std::, <cstring>) SYMBOL(strrchr, None, <cstring>) SYMBOL(strrchr, None, <string.h>) SYMBOL(strspn, std::, <cstring>) SYMBOL(strspn, None, <cstring>) SYMBOL(strspn, None, <string.h>) SYMBOL(strstr, std::, <cstring>) SYMBOL(strstr, None, <cstring>) SYMBOL(strstr, None, <string.h>) SYMBOL(strstream, std::, <strstream>) SYMBOL(strstreambuf, std::, <strstream>) SYMBOL(strtod, std::, <cstdlib>) SYMBOL(strtod, None, <cstdlib>) SYMBOL(strtod, None, <stdlib.h>) SYMBOL(strtof, std::, <cstdlib>) SYMBOL(strtof, None, <cstdlib>) SYMBOL(strtof, None, <stdlib.h>) SYMBOL(strtoimax, std::, <cinttypes>) SYMBOL(strtoimax, None, <cinttypes>) SYMBOL(strtoimax, None, <inttypes.h>) SYMBOL(strtok, std::, <cstring>) SYMBOL(strtok, None, <cstring>) SYMBOL(strtok, None, <string.h>) SYMBOL(strtol, std::, <cstdlib>) SYMBOL(strtol, None, <cstdlib>) SYMBOL(strtol, None, <stdlib.h>) SYMBOL(strtold, std::, <cstdlib>) SYMBOL(strtold, None, <cstdlib>) SYMBOL(strtold, None, <stdlib.h>) SYMBOL(strtoll, std::, <cstdlib>) SYMBOL(strtoll, None, <cstdlib>) SYMBOL(strtoll, None, <stdlib.h>) SYMBOL(strtoul, std::, <cstdlib>) SYMBOL(strtoul, None, <cstdlib>) SYMBOL(strtoul, None, <stdlib.h>) SYMBOL(strtoull, std::, <cstdlib>) SYMBOL(strtoull, None, <cstdlib>) SYMBOL(strtoull, None, <stdlib.h>) SYMBOL(strtoumax, std::, <cinttypes>) SYMBOL(strtoumax, None, <cinttypes>) SYMBOL(strtoumax, None, <inttypes.h>) SYMBOL(strxfrm, std::, <cstring>) SYMBOL(strxfrm, None, <cstring>) SYMBOL(strxfrm, None, <string.h>) SYMBOL(student_t_distribution, std::, <random>) SYMBOL(sub_match, std::, <regex>) SYMBOL(subtract_with_carry_engine, std::, <random>) SYMBOL(suspend_always, std::, <coroutine>) SYMBOL(suspend_never, std::, <coroutine>) SYMBOL(swap_ranges, std::, <algorithm>) SYMBOL(swappable, std::, <concepts>) SYMBOL(swappable_with, std::, <concepts>) SYMBOL(swprintf, std::, <cwchar>) SYMBOL(swprintf, None, <cwchar>) SYMBOL(swprintf, None, <wchar.h>) SYMBOL(swscanf, std::, <cwchar>) SYMBOL(swscanf, None, <cwchar>) SYMBOL(swscanf, None, <wchar.h>) SYMBOL(syncbuf, std::, <syncstream>) SYMBOL(syncbuf, std::, <iosfwd>) SYMBOL(system, std::, <cstdlib>) SYMBOL(system, None, <cstdlib>) SYMBOL(system, None, <stdlib.h>) SYMBOL(system_category, std::, <system_error>) SYMBOL(system_error, std::, <system_error>) SYMBOL(tan, std::, <cmath>) SYMBOL(tan, None, <cmath>) SYMBOL(tan, None, <math.h>) SYMBOL(tanf, std::, <cmath>) SYMBOL(tanf, None, <cmath>) SYMBOL(tanf, None, <math.h>) SYMBOL(tanh, std::, <cmath>) SYMBOL(tanh, None, <cmath>) SYMBOL(tanh, None, <math.h>) SYMBOL(tanhf, std::, <cmath>) SYMBOL(tanhf, None, <cmath>) SYMBOL(tanhf, None, <math.h>) SYMBOL(tanhl, std::, <cmath>) SYMBOL(tanhl, None, <cmath>) SYMBOL(tanhl, None, <math.h>) SYMBOL(tanl, std::, <cmath>) SYMBOL(tanl, None, <cmath>) SYMBOL(tanl, None, <math.h>) SYMBOL(tera, std::, <ratio>) SYMBOL(terminate, std::, <exception>) SYMBOL(terminate_handler, std::, <exception>) SYMBOL(tgamma, std::, <cmath>) SYMBOL(tgamma, None, <cmath>) SYMBOL(tgamma, None, <math.h>) SYMBOL(tgammaf, std::, <cmath>) SYMBOL(tgammaf, None, <cmath>) SYMBOL(tgammaf, None, <math.h>) SYMBOL(tgammal, std::, <cmath>) SYMBOL(tgammal, None, <cmath>) SYMBOL(tgammal, None, <math.h>) SYMBOL(thread, std::, <thread>) SYMBOL(three_way_comparable, std::, <compare>) SYMBOL(three_way_comparable_with, std::, <compare>) SYMBOL(throw_with_nested, std::, <exception>) SYMBOL(tie, std::, <tuple>) SYMBOL(time, std::, <ctime>) SYMBOL(time, None, <ctime>) SYMBOL(time, None, <time.h>) SYMBOL(time_base, std::, <locale>) SYMBOL(time_get, std::, <locale>) SYMBOL(time_get_byname, std::, <locale>) SYMBOL(time_put, std::, <locale>) SYMBOL(time_put_byname, std::, <locale>) SYMBOL(time_t, std::, <ctime>) SYMBOL(time_t, None, <ctime>) SYMBOL(time_t, None, <time.h>) SYMBOL(timed_mutex, std::, <mutex>) SYMBOL(timespec, std::, <ctime>) SYMBOL(timespec, None, <ctime>) SYMBOL(timespec, None, <time.h>) SYMBOL(timespec_get, std::, <ctime>) SYMBOL(timespec_get, None, <ctime>) SYMBOL(timespec_get, None, <time.h>) SYMBOL(tm, std::, <ctime>) SYMBOL(tm, None, <ctime>) SYMBOL(tm, None, <time.h>) SYMBOL(tmpfile, std::, <cstdio>) SYMBOL(tmpfile, None, <cstdio>) SYMBOL(tmpfile, None, <stdio.h>) SYMBOL(tmpnam, std::, <cstdio>) SYMBOL(tmpnam, None, <cstdio>) SYMBOL(tmpnam, None, <stdio.h>) SYMBOL(to_address, std::, <memory>) SYMBOL(to_array, std::, <array>) SYMBOL(to_chars, std::, <charconv>) SYMBOL(to_chars_result, std::, <charconv>) SYMBOL(to_integer, std::, <cstddef>) SYMBOL(to_integer, None, <cstddef>) SYMBOL(to_integer, None, <stddef.h>) SYMBOL(to_string, std::, <string>) SYMBOL(to_underlying, std::, <utility>) SYMBOL(to_wstring, std::, <string>) SYMBOL(tolower, std::, <cctype>) SYMBOL(tolower, None, <cctype>) SYMBOL(tolower, None, <ctype.h>) SYMBOL(totally_ordered, std::, <concepts>) SYMBOL(totally_ordered_with, std::, <concepts>) SYMBOL(toupper, std::, <cctype>) SYMBOL(toupper, None, <cctype>) SYMBOL(toupper, None, <ctype.h>) SYMBOL(towctrans, std::, <cwctype>) SYMBOL(towctrans, None, <cwctype>) SYMBOL(towctrans, None, <wctype.h>) SYMBOL(towlower, std::, <cwctype>) SYMBOL(towlower, None, <cwctype>) SYMBOL(towlower, None, <wctype.h>) SYMBOL(towupper, std::, <cwctype>) SYMBOL(towupper, None, <cwctype>) SYMBOL(towupper, None, <wctype.h>) SYMBOL(transform, std::, <algorithm>) SYMBOL(transform_exclusive_scan, std::, <numeric>) SYMBOL(transform_inclusive_scan, std::, <numeric>) SYMBOL(transform_reduce, std::, <numeric>) SYMBOL(true_type, std::, <type_traits>) SYMBOL(trunc, std::, <cmath>) SYMBOL(trunc, None, <cmath>) SYMBOL(trunc, None, <math.h>) SYMBOL(truncf, std::, <cmath>) SYMBOL(truncf, None, <cmath>) SYMBOL(truncf, None, <math.h>) SYMBOL(truncl, std::, <cmath>) SYMBOL(truncl, None, <cmath>) SYMBOL(truncl, None, <math.h>) SYMBOL(try_lock, std::, <mutex>) SYMBOL(try_to_lock, std::, <mutex>) SYMBOL(try_to_lock_t, std::, <mutex>) SYMBOL(tuple, std::, <tuple>) SYMBOL(tuple_cat, std::, <tuple>) SYMBOL(tuple_element_t, std::, <tuple>) SYMBOL(tuple_size_v, std::, <tuple>) SYMBOL(type_identity, std::, <type_traits>) SYMBOL(type_identity_t, std::, <type_traits>) SYMBOL(type_index, std::, <typeindex>) SYMBOL(type_info, std::, <typeinfo>) SYMBOL(u16streampos, std::, <iosfwd>) SYMBOL(u16streampos, std::, <iosfwd>) SYMBOL(u16string, std::, <string>) SYMBOL(u16string_view, std::, <string_view>) SYMBOL(u32streampos, std::, <iosfwd>) SYMBOL(u32streampos, std::, <iosfwd>) SYMBOL(u32string, std::, <string>) SYMBOL(u32string_view, std::, <string_view>) SYMBOL(u8streampos, std::, <iosfwd>) SYMBOL(u8streampos, std::, <iosfwd>) SYMBOL(u8string, std::, <string>) SYMBOL(u8string_view, std::, <string_view>) SYMBOL(uint16_t, std::, <cstdint>) SYMBOL(uint16_t, None, <cstdint>) SYMBOL(uint16_t, None, <stdint.h>) SYMBOL(uint32_t, std::, <cstdint>) SYMBOL(uint32_t, None, <cstdint>) SYMBOL(uint32_t, None, <stdint.h>) SYMBOL(uint64_t, std::, <cstdint>) SYMBOL(uint64_t, None, <cstdint>) SYMBOL(uint64_t, None, <stdint.h>) SYMBOL(uint8_t, std::, <cstdint>) SYMBOL(uint8_t, None, <cstdint>) SYMBOL(uint8_t, None, <stdint.h>) SYMBOL(uint_fast16_t, std::, <cstdint>) SYMBOL(uint_fast16_t, None, <cstdint>) SYMBOL(uint_fast16_t, None, <stdint.h>) SYMBOL(uint_fast32_t, std::, <cstdint>) SYMBOL(uint_fast32_t, None, <cstdint>) SYMBOL(uint_fast32_t, None, <stdint.h>) SYMBOL(uint_fast64_t, std::, <cstdint>) SYMBOL(uint_fast64_t, None, <cstdint>) SYMBOL(uint_fast64_t, None, <stdint.h>) SYMBOL(uint_fast8_t, std::, <cstdint>) SYMBOL(uint_fast8_t, None, <cstdint>) SYMBOL(uint_fast8_t, None, <stdint.h>) SYMBOL(uint_least16_t, std::, <cstdint>) SYMBOL(uint_least16_t, None, <cstdint>) SYMBOL(uint_least16_t, None, <stdint.h>) SYMBOL(uint_least32_t, std::, <cstdint>) SYMBOL(uint_least32_t, None, <cstdint>) SYMBOL(uint_least32_t, None, <stdint.h>) SYMBOL(uint_least64_t, std::, <cstdint>) SYMBOL(uint_least64_t, None, <cstdint>) SYMBOL(uint_least64_t, None, <stdint.h>) SYMBOL(uint_least8_t, std::, <cstdint>) SYMBOL(uint_least8_t, None, <cstdint>) SYMBOL(uint_least8_t, None, <stdint.h>) SYMBOL(uintmax_t, std::, <cstdint>) SYMBOL(uintmax_t, None, <cstdint>) SYMBOL(uintmax_t, None, <stdint.h>) SYMBOL(uintptr_t, std::, <cstdint>) SYMBOL(uintptr_t, None, <cstdint>) SYMBOL(uintptr_t, None, <stdint.h>) SYMBOL(unary_function, std::, <functional>) SYMBOL(unary_negate, std::, <functional>) SYMBOL(uncaught_exception, std::, <exception>) SYMBOL(uncaught_exceptions, std::, <exception>) SYMBOL(undeclare_no_pointers, std::, <memory>) SYMBOL(undeclare_reachable, std::, <memory>) SYMBOL(underflow_error, std::, <stdexcept>) SYMBOL(underlying_type, std::, <type_traits>) SYMBOL(underlying_type_t, std::, <type_traits>) SYMBOL(unexpected_handler, std::, <exception>) SYMBOL(ungetc, std::, <cstdio>) SYMBOL(ungetc, None, <cstdio>) SYMBOL(ungetc, None, <stdio.h>) SYMBOL(ungetwc, std::, <cwchar>) SYMBOL(ungetwc, None, <cwchar>) SYMBOL(ungetwc, None, <wchar.h>) SYMBOL(uniform_int_distribution, std::, <random>) SYMBOL(uniform_random_bit_generator, std::, <random>) SYMBOL(uniform_real_distribution, std::, <random>) SYMBOL(uninitialized_construct_using_allocator, std::, <memory>) SYMBOL(uninitialized_copy, std::, <memory>) SYMBOL(uninitialized_copy_n, std::, <memory>) SYMBOL(uninitialized_default_construct, std::, <memory>) SYMBOL(uninitialized_default_construct_n, std::, <memory>) SYMBOL(uninitialized_fill, std::, <memory>) SYMBOL(uninitialized_fill_n, std::, <memory>) SYMBOL(uninitialized_move, std::, <memory>) SYMBOL(uninitialized_move_n, std::, <memory>) SYMBOL(uninitialized_value_construct, std::, <memory>) SYMBOL(uninitialized_value_construct_n, std::, <memory>) SYMBOL(unique, std::, <algorithm>) SYMBOL(unique_copy, std::, <algorithm>) SYMBOL(unique_lock, std::, <mutex>) SYMBOL(unique_ptr, std::, <memory>) SYMBOL(unitbuf, std::, <ios>) SYMBOL(unitbuf, std::, <iostream>) SYMBOL(unordered_map, std::, <unordered_map>) SYMBOL(unordered_multimap, std::, <unordered_map>) SYMBOL(unordered_multiset, std::, <unordered_set>) SYMBOL(unordered_set, std::, <unordered_set>) SYMBOL(unreachable, std::, <utility>) SYMBOL(unreachable_sentinel, std::, <iterator>) SYMBOL(unreachable_sentinel_t, std::, <iterator>) SYMBOL(unsigned_integral, std::, <concepts>) SYMBOL(upper_bound, std::, <algorithm>) SYMBOL(uppercase, std::, <ios>) SYMBOL(uppercase, std::, <iostream>) SYMBOL(use_facet, std::, <locale>) SYMBOL(uses_allocator, std::, <memory>) SYMBOL(uses_allocator_construction_args, std::, <memory>) SYMBOL(uses_allocator_v, std::, <memory>) SYMBOL(va_list, std::, <cstdarg>) SYMBOL(va_list, None, <cstdarg>) SYMBOL(va_list, None, <stdarg.h>) SYMBOL(valarray, std::, <valarray>) SYMBOL(variant, std::, <variant>) SYMBOL(variant_alternative, std::, <variant>) SYMBOL(variant_alternative_t, std::, <variant>) SYMBOL(variant_npos, std::, <variant>) SYMBOL(variant_size, std::, <variant>) SYMBOL(variant_size_v, std::, <variant>) SYMBOL(vector, std::, <vector>) SYMBOL(vformat, std::, <format>) SYMBOL(vformat_to, std::, <format>) SYMBOL(vfprintf, std::, <cstdio>) SYMBOL(vfprintf, None, <cstdio>) SYMBOL(vfprintf, None, <stdio.h>) SYMBOL(vfscanf, std::, <cstdio>) SYMBOL(vfscanf, None, <cstdio>) SYMBOL(vfscanf, None, <stdio.h>) SYMBOL(vfwprintf, std::, <cwchar>) SYMBOL(vfwprintf, None, <cwchar>) SYMBOL(vfwprintf, None, <wchar.h>) SYMBOL(vfwscanf, std::, <cwchar>) SYMBOL(vfwscanf, None, <cwchar>) SYMBOL(vfwscanf, None, <wchar.h>) SYMBOL(visit, std::, <variant>) SYMBOL(visit_format_arg, std::, <format>) SYMBOL(void_t, std::, <type_traits>) SYMBOL(vprintf, std::, <cstdio>) SYMBOL(vprintf, None, <cstdio>) SYMBOL(vprintf, None, <stdio.h>) SYMBOL(vscanf, std::, <cstdio>) SYMBOL(vscanf, None, <cstdio>) SYMBOL(vscanf, None, <stdio.h>) SYMBOL(vsnprintf, std::, <cstdio>) SYMBOL(vsnprintf, None, <cstdio>) SYMBOL(vsnprintf, None, <stdio.h>) SYMBOL(vsprintf, std::, <cstdio>) SYMBOL(vsprintf, None, <cstdio>) SYMBOL(vsprintf, None, <stdio.h>) SYMBOL(vsscanf, std::, <cstdio>) SYMBOL(vsscanf, None, <cstdio>) SYMBOL(vsscanf, None, <stdio.h>) SYMBOL(vswprintf, std::, <cwchar>) SYMBOL(vswprintf, None, <cwchar>) SYMBOL(vswprintf, None, <wchar.h>) SYMBOL(vswscanf, std::, <cwchar>) SYMBOL(vswscanf, None, <cwchar>) SYMBOL(vswscanf, None, <wchar.h>) SYMBOL(vwprintf, std::, <cwchar>) SYMBOL(vwprintf, None, <cwchar>) SYMBOL(vwprintf, None, <wchar.h>) SYMBOL(vwscanf, std::, <cwchar>) SYMBOL(vwscanf, None, <cwchar>) SYMBOL(vwscanf, None, <wchar.h>) SYMBOL(wbuffer_convert, std::, <locale>) SYMBOL(wcerr, std::, <iostream>) SYMBOL(wcin, std::, <iostream>) SYMBOL(wclog, std::, <iostream>) SYMBOL(wcmatch, std::, <regex>) SYMBOL(wcout, std::, <iostream>) SYMBOL(wcregex_iterator, std::, <regex>) SYMBOL(wcregex_token_iterator, std::, <regex>) SYMBOL(wcrtomb, std::, <cwchar>) SYMBOL(wcrtomb, None, <cwchar>) SYMBOL(wcrtomb, None, <wchar.h>) SYMBOL(wcscat, std::, <cwchar>) SYMBOL(wcscat, None, <cwchar>) SYMBOL(wcscat, None, <wchar.h>) SYMBOL(wcschr, std::, <cwchar>) SYMBOL(wcschr, None, <cwchar>) SYMBOL(wcschr, None, <wchar.h>) SYMBOL(wcscmp, std::, <cwchar>) SYMBOL(wcscmp, None, <cwchar>) SYMBOL(wcscmp, None, <wchar.h>) SYMBOL(wcscoll, std::, <cwchar>) SYMBOL(wcscoll, None, <cwchar>) SYMBOL(wcscoll, None, <wchar.h>) SYMBOL(wcscpy, std::, <cwchar>) SYMBOL(wcscpy, None, <cwchar>) SYMBOL(wcscpy, None, <wchar.h>) SYMBOL(wcscspn, std::, <cwchar>) SYMBOL(wcscspn, None, <cwchar>) SYMBOL(wcscspn, None, <wchar.h>) SYMBOL(wcsftime, std::, <cwchar>) SYMBOL(wcsftime, None, <cwchar>) SYMBOL(wcsftime, None, <wchar.h>) SYMBOL(wcslen, std::, <cwchar>) SYMBOL(wcslen, None, <cwchar>) SYMBOL(wcslen, None, <wchar.h>) SYMBOL(wcsncat, std::, <cwchar>) SYMBOL(wcsncat, None, <cwchar>) SYMBOL(wcsncat, None, <wchar.h>) SYMBOL(wcsncmp, std::, <cwchar>) SYMBOL(wcsncmp, None, <cwchar>) SYMBOL(wcsncmp, None, <wchar.h>) SYMBOL(wcsncpy, std::, <cwchar>) SYMBOL(wcsncpy, None, <cwchar>) SYMBOL(wcsncpy, None, <wchar.h>) SYMBOL(wcspbrk, std::, <cwchar>) SYMBOL(wcspbrk, None, <cwchar>) SYMBOL(wcspbrk, None, <wchar.h>) SYMBOL(wcsrchr, std::, <cwchar>) SYMBOL(wcsrchr, None, <cwchar>) SYMBOL(wcsrchr, None, <wchar.h>) SYMBOL(wcsrtombs, std::, <cwchar>) SYMBOL(wcsrtombs, None, <cwchar>) SYMBOL(wcsrtombs, None, <wchar.h>) SYMBOL(wcsspn, std::, <cwchar>) SYMBOL(wcsspn, None, <cwchar>) SYMBOL(wcsspn, None, <wchar.h>) SYMBOL(wcsstr, std::, <cwchar>) SYMBOL(wcsstr, None, <cwchar>) SYMBOL(wcsstr, None, <wchar.h>) SYMBOL(wcstod, std::, <cwchar>) SYMBOL(wcstod, None, <cwchar>) SYMBOL(wcstod, None, <wchar.h>) SYMBOL(wcstof, std::, <cwchar>) SYMBOL(wcstof, None, <cwchar>) SYMBOL(wcstof, None, <wchar.h>) SYMBOL(wcstoimax, std::, <cinttypes>) SYMBOL(wcstoimax, None, <cinttypes>) SYMBOL(wcstoimax, None, <inttypes.h>) SYMBOL(wcstok, std::, <cwchar>) SYMBOL(wcstok, None, <cwchar>) SYMBOL(wcstok, None, <wchar.h>) SYMBOL(wcstol, std::, <cwchar>) SYMBOL(wcstol, None, <cwchar>) SYMBOL(wcstol, None, <wchar.h>) SYMBOL(wcstold, std::, <cwchar>) SYMBOL(wcstold, None, <cwchar>) SYMBOL(wcstold, None, <wchar.h>) SYMBOL(wcstoll, std::, <cwchar>) SYMBOL(wcstoll, None, <cwchar>) SYMBOL(wcstoll, None, <wchar.h>) SYMBOL(wcstombs, std::, <cstdlib>) SYMBOL(wcstombs, None, <cstdlib>) SYMBOL(wcstombs, None, <stdlib.h>) SYMBOL(wcstoul, std::, <cwchar>) SYMBOL(wcstoul, None, <cwchar>) SYMBOL(wcstoul, None, <wchar.h>) SYMBOL(wcstoull, std::, <cwchar>) SYMBOL(wcstoull, None, <cwchar>) SYMBOL(wcstoull, None, <wchar.h>) SYMBOL(wcstoumax, std::, <cinttypes>) SYMBOL(wcstoumax, None, <cinttypes>) SYMBOL(wcstoumax, None, <inttypes.h>) SYMBOL(wcsub_match, std::, <regex>) SYMBOL(wcsxfrm, std::, <cwchar>) SYMBOL(wcsxfrm, None, <cwchar>) SYMBOL(wcsxfrm, None, <wchar.h>) SYMBOL(wctob, std::, <cwchar>) SYMBOL(wctob, None, <cwchar>) SYMBOL(wctob, None, <wchar.h>) SYMBOL(wctomb, std::, <cstdlib>) SYMBOL(wctomb, None, <cstdlib>) SYMBOL(wctomb, None, <stdlib.h>) SYMBOL(wctrans, std::, <cwctype>) SYMBOL(wctrans, None, <cwctype>) SYMBOL(wctrans, None, <wctype.h>) SYMBOL(wctrans_t, std::, <cwctype>) SYMBOL(wctrans_t, None, <cwctype>) SYMBOL(wctrans_t, None, <wctype.h>) SYMBOL(wctype, std::, <cwctype>) SYMBOL(wctype, None, <cwctype>) SYMBOL(wctype, None, <wctype.h>) SYMBOL(wctype_t, std::, <cwctype>) SYMBOL(wctype_t, None, <cwctype>) SYMBOL(wctype_t, None, <wctype.h>) SYMBOL(weak_order, std::, <compare>) SYMBOL(weak_ordering, std::, <compare>) SYMBOL(weak_ptr, std::, <memory>) SYMBOL(weakly_incrementable, std::, <iterator>) SYMBOL(weibull_distribution, std::, <random>) SYMBOL(wfilebuf, std::, <streambuf>) SYMBOL(wfilebuf, std::, <iostream>) SYMBOL(wfilebuf, std::, <iosfwd>) SYMBOL(wformat_args, std::, <format>) SYMBOL(wformat_context, std::, <format>) SYMBOL(wformat_parse_context, std::, <format>) SYMBOL(wfstream, std::, <fstream>) SYMBOL(wfstream, std::, <iosfwd>) SYMBOL(wifstream, std::, <fstream>) SYMBOL(wifstream, std::, <iosfwd>) SYMBOL(wios, std::, <ios>) SYMBOL(wios, std::, <iostream>) SYMBOL(wios, std::, <iosfwd>) SYMBOL(wiostream, std::, <istream>) SYMBOL(wiostream, std::, <iostream>) SYMBOL(wiostream, std::, <iosfwd>) SYMBOL(wispanstream, std::, <spanstream>) SYMBOL(wispanstream, std::, <iosfwd>) SYMBOL(wistream, std::, <istream>) SYMBOL(wistream, std::, <iostream>) SYMBOL(wistream, std::, <iosfwd>) SYMBOL(wistringstream, std::, <sstream>) SYMBOL(wistringstream, std::, <iosfwd>) SYMBOL(wmemchr, std::, <cwchar>) SYMBOL(wmemchr, None, <cwchar>) SYMBOL(wmemchr, None, <wchar.h>) SYMBOL(wmemcmp, std::, <cwchar>) SYMBOL(wmemcmp, None, <cwchar>) SYMBOL(wmemcmp, None, <wchar.h>) SYMBOL(wmemcpy, std::, <cwchar>) SYMBOL(wmemcpy, None, <cwchar>) SYMBOL(wmemcpy, None, <wchar.h>) SYMBOL(wmemmove, std::, <cwchar>) SYMBOL(wmemmove, None, <cwchar>) SYMBOL(wmemmove, None, <wchar.h>) SYMBOL(wmemset, std::, <cwchar>) SYMBOL(wmemset, None, <cwchar>) SYMBOL(wmemset, None, <wchar.h>) SYMBOL(wofstream, std::, <fstream>) SYMBOL(wofstream, std::, <iosfwd>) SYMBOL(wospanstream, std::, <spanstream>) SYMBOL(wospanstream, std::, <iosfwd>) SYMBOL(wostream, std::, <ostream>) SYMBOL(wostream, std::, <iostream>) SYMBOL(wostream, std::, <iosfwd>) SYMBOL(wostringstream, std::, <sstream>) SYMBOL(wostringstream, std::, <iosfwd>) SYMBOL(wosyncstream, std::, <syncstream>) SYMBOL(wosyncstream, std::, <iosfwd>) SYMBOL(wprintf, std::, <cwchar>) SYMBOL(wprintf, None, <cwchar>) SYMBOL(wprintf, None, <wchar.h>) SYMBOL(wregex, std::, <regex>) SYMBOL(ws, std::, <istream>) SYMBOL(ws, std::, <iostream>) SYMBOL(wscanf, std::, <cwchar>) SYMBOL(wscanf, None, <cwchar>) SYMBOL(wscanf, None, <wchar.h>) SYMBOL(wsmatch, std::, <regex>) SYMBOL(wspanbuf, std::, <spanstream>) SYMBOL(wspanbuf, std::, <iosfwd>) SYMBOL(wspanstream, std::, <spanstream>) SYMBOL(wspanstream, std::, <iosfwd>) SYMBOL(wsregex_iterator, std::, <regex>) SYMBOL(wsregex_token_iterator, std::, <regex>) SYMBOL(wssub_match, std::, <regex>) SYMBOL(wstreambuf, std::, <streambuf>) SYMBOL(wstreambuf, std::, <iostream>) SYMBOL(wstreambuf, std::, <iosfwd>) SYMBOL(wstreampos, std::, <iosfwd>) SYMBOL(wstreampos, std::, <iosfwd>) SYMBOL(wstring, std::, <string>) SYMBOL(wstring_convert, std::, <locale>) SYMBOL(wstring_view, std::, <string_view>) SYMBOL(wstringbuf, std::, <sstream>) SYMBOL(wstringbuf, std::, <iosfwd>) SYMBOL(wstringstream, std::, <sstream>) SYMBOL(wstringstream, std::, <iosfwd>) SYMBOL(wsyncbuf, std::, <syncstream>) SYMBOL(wsyncbuf, std::, <iosfwd>) SYMBOL(yocto, std::, <ratio>) SYMBOL(yotta, std::, <ratio>) SYMBOL(zepto, std::, <ratio>) SYMBOL(zetta, std::, <ratio>) SYMBOL(April, std::chrono::, <chrono>) SYMBOL(August, std::chrono::, <chrono>) SYMBOL(December, std::chrono::, <chrono>) SYMBOL(February, std::chrono::, <chrono>) SYMBOL(Friday, std::chrono::, <chrono>) SYMBOL(January, std::chrono::, <chrono>) SYMBOL(July, std::chrono::, <chrono>) SYMBOL(June, std::chrono::, <chrono>) SYMBOL(March, std::chrono::, <chrono>) SYMBOL(May, std::chrono::, <chrono>) SYMBOL(Monday, std::chrono::, <chrono>) SYMBOL(November, std::chrono::, <chrono>) SYMBOL(October, std::chrono::, <chrono>) SYMBOL(Saturday, std::chrono::, <chrono>) SYMBOL(September, std::chrono::, <chrono>) SYMBOL(Sunday, std::chrono::, <chrono>) SYMBOL(Thursday, std::chrono::, <chrono>) SYMBOL(Tuesday, std::chrono::, <chrono>) SYMBOL(Wednesday, std::chrono::, <chrono>) SYMBOL(abs, std::chrono::, <chrono>) SYMBOL(ambiguous_local_time, std::chrono::, <chrono>) SYMBOL(choose, std::chrono::, <chrono>) SYMBOL(clock_cast, std::chrono::, <chrono>) SYMBOL(clock_time_conversion, std::chrono::, <chrono>) SYMBOL(current_zone, std::chrono::, <chrono>) SYMBOL(day, std::chrono::, <chrono>) SYMBOL(duration, std::chrono::, <chrono>) SYMBOL(duration_cast, std::chrono::, <chrono>) SYMBOL(duration_values, std::chrono::, <chrono>) SYMBOL(file_clock, std::chrono::, <chrono>) SYMBOL(file_seconds, std::chrono::, <chrono>) SYMBOL(file_time, std::chrono::, <chrono>) SYMBOL(get_leap_second_info, std::chrono::, <chrono>) SYMBOL(gps_clock, std::chrono::, <chrono>) SYMBOL(gps_seconds, std::chrono::, <chrono>) SYMBOL(gps_time, std::chrono::, <chrono>) SYMBOL(hh_mm_ss, std::chrono::, <chrono>) SYMBOL(high_resolution_clock, std::chrono::, <chrono>) SYMBOL(hours, std::chrono::, <chrono>) SYMBOL(is_am, std::chrono::, <chrono>) SYMBOL(is_clock, std::chrono::, <chrono>) SYMBOL(is_clock_v, std::chrono::, <chrono>) SYMBOL(is_pm, std::chrono::, <chrono>) SYMBOL(last, std::chrono::, <chrono>) SYMBOL(last_spec, std::chrono::, <chrono>) SYMBOL(leap_second, std::chrono::, <chrono>) SYMBOL(leap_second_info, std::chrono::, <chrono>) SYMBOL(local_info, std::chrono::, <chrono>) SYMBOL(local_seconds, std::chrono::, <chrono>) SYMBOL(local_t, std::chrono::, <chrono>) SYMBOL(local_time, std::chrono::, <chrono>) SYMBOL(local_time_format, std::chrono::, <chrono>) SYMBOL(locate_zone, std::chrono::, <chrono>) SYMBOL(make12, std::chrono::, <chrono>) SYMBOL(make24, std::chrono::, <chrono>) SYMBOL(microseconds, std::chrono::, <chrono>) SYMBOL(milliseconds, std::chrono::, <chrono>) SYMBOL(minutes, std::chrono::, <chrono>) SYMBOL(month, std::chrono::, <chrono>) SYMBOL(month_day, std::chrono::, <chrono>) SYMBOL(month_day_last, std::chrono::, <chrono>) SYMBOL(month_weekday, std::chrono::, <chrono>) SYMBOL(month_weekday_last, std::chrono::, <chrono>) SYMBOL(nanoseconds, std::chrono::, <chrono>) SYMBOL(nonexistent_local_time, std::chrono::, <chrono>) SYMBOL(parse, std::chrono::, <chrono>) SYMBOL(seconds, std::chrono::, <chrono>) SYMBOL(steady_clock, std::chrono::, <chrono>) SYMBOL(sys_days, std::chrono::, <chrono>) SYMBOL(sys_info, std::chrono::, <chrono>) SYMBOL(sys_seconds, std::chrono::, <chrono>) SYMBOL(sys_time, std::chrono::, <chrono>) SYMBOL(system_clock, std::chrono::, <chrono>) SYMBOL(tai_clock, std::chrono::, <chrono>) SYMBOL(tai_seconds, std::chrono::, <chrono>) SYMBOL(tai_time, std::chrono::, <chrono>) SYMBOL(time_point, std::chrono::, <chrono>) SYMBOL(time_point_cast, std::chrono::, <chrono>) SYMBOL(time_zone, std::chrono::, <chrono>) SYMBOL(time_zone_link, std::chrono::, <chrono>) SYMBOL(treat_as_floating_point, std::chrono::, <chrono>) SYMBOL(treat_as_floating_point_v, std::chrono::, <chrono>) SYMBOL(tzdb, std::chrono::, <chrono>) SYMBOL(tzdb_list, std::chrono::, <chrono>) SYMBOL(utc_clock, std::chrono::, <chrono>) SYMBOL(utc_seconds, std::chrono::, <chrono>) SYMBOL(utc_time, std::chrono::, <chrono>) SYMBOL(weekday, std::chrono::, <chrono>) SYMBOL(weekday_indexed, std::chrono::, <chrono>) SYMBOL(weekday_last, std::chrono::, <chrono>) SYMBOL(year, std::chrono::, <chrono>) SYMBOL(year_month, std::chrono::, <chrono>) SYMBOL(year_month_day, std::chrono::, <chrono>) SYMBOL(year_month_day_last, std::chrono::, <chrono>) SYMBOL(year_month_weekday, std::chrono::, <chrono>) SYMBOL(year_month_weekday_last, std::chrono::, <chrono>) SYMBOL(zoned_seconds, std::chrono::, <chrono>) SYMBOL(zoned_time, std::chrono::, <chrono>) SYMBOL(zoned_traits, std::chrono::, <chrono>) SYMBOL(par, std::execution::, <execution>) SYMBOL(par_unseq, std::execution::, <execution>) SYMBOL(parallel_policy, std::execution::, <execution>) SYMBOL(parallel_unsequenced_policy, std::execution::, <execution>) SYMBOL(seq, std::execution::, <execution>) SYMBOL(sequenced_policy, std::execution::, <execution>) SYMBOL(unseq, std::execution::, <execution>) SYMBOL(unsequenced_policy, std::execution::, <execution>) SYMBOL(absolute, std::filesystem::, <filesystem>) SYMBOL(canonical, std::filesystem::, <filesystem>) SYMBOL(copy, std::filesystem::, <filesystem>) SYMBOL(copy_file, std::filesystem::, <filesystem>) SYMBOL(copy_options, std::filesystem::, <filesystem>) SYMBOL(copy_symlink, std::filesystem::, <filesystem>) SYMBOL(create_directories, std::filesystem::, <filesystem>) SYMBOL(create_directory, std::filesystem::, <filesystem>) SYMBOL(create_directory_symlink, std::filesystem::, <filesystem>) SYMBOL(create_hard_link, std::filesystem::, <filesystem>) SYMBOL(create_symlink, std::filesystem::, <filesystem>) SYMBOL(current_path, std::filesystem::, <filesystem>) SYMBOL(directory_entry, std::filesystem::, <filesystem>) SYMBOL(directory_iterator, std::filesystem::, <filesystem>) SYMBOL(directory_options, std::filesystem::, <filesystem>) SYMBOL(equivalent, std::filesystem::, <filesystem>) SYMBOL(exists, std::filesystem::, <filesystem>) SYMBOL(file_size, std::filesystem::, <filesystem>) SYMBOL(file_status, std::filesystem::, <filesystem>) SYMBOL(file_time_type, std::filesystem::, <filesystem>) SYMBOL(file_type, std::filesystem::, <filesystem>) SYMBOL(filesystem_error, std::filesystem::, <filesystem>) SYMBOL(hard_link_count, std::filesystem::, <filesystem>) SYMBOL(hash_value, std::filesystem::, <filesystem>) SYMBOL(is_block_file, std::filesystem::, <filesystem>) SYMBOL(is_character_file, std::filesystem::, <filesystem>) SYMBOL(is_directory, std::filesystem::, <filesystem>) SYMBOL(is_empty, std::filesystem::, <filesystem>) SYMBOL(is_fifo, std::filesystem::, <filesystem>) SYMBOL(is_other, std::filesystem::, <filesystem>) SYMBOL(is_regular_file, std::filesystem::, <filesystem>) SYMBOL(is_socket, std::filesystem::, <filesystem>) SYMBOL(is_symlink, std::filesystem::, <filesystem>) SYMBOL(last_write_time, std::filesystem::, <filesystem>) SYMBOL(path, std::filesystem::, <filesystem>) SYMBOL(perm_options, std::filesystem::, <filesystem>) SYMBOL(permissions, std::filesystem::, <filesystem>) SYMBOL(perms, std::filesystem::, <filesystem>) SYMBOL(proximate, std::filesystem::, <filesystem>) SYMBOL(read_symlink, std::filesystem::, <filesystem>) SYMBOL(recursive_directory_iterator, std::filesystem::, <filesystem>) SYMBOL(relative, std::filesystem::, <filesystem>) SYMBOL(remove, std::filesystem::, <filesystem>) SYMBOL(remove_all, std::filesystem::, <filesystem>) SYMBOL(rename, std::filesystem::, <filesystem>) SYMBOL(resize_file, std::filesystem::, <filesystem>) SYMBOL(space, std::filesystem::, <filesystem>) SYMBOL(space_info, std::filesystem::, <filesystem>) SYMBOL(status, std::filesystem::, <filesystem>) SYMBOL(status_known, std::filesystem::, <filesystem>) SYMBOL(symlink_status, std::filesystem::, <filesystem>) SYMBOL(temp_directory_path, std::filesystem::, <filesystem>) SYMBOL(u8path, std::filesystem::, <filesystem>) SYMBOL(weakly_canonical, std::filesystem::, <filesystem>) SYMBOL(e, std::numbers::, <numbers>) SYMBOL(e_v, std::numbers::, <numbers>) SYMBOL(egamma, std::numbers::, <numbers>) SYMBOL(egamma_v, std::numbers::, <numbers>) SYMBOL(inv_pi, std::numbers::, <numbers>) SYMBOL(inv_pi_v, std::numbers::, <numbers>) SYMBOL(inv_sqrt3, std::numbers::, <numbers>) SYMBOL(inv_sqrt3_v, std::numbers::, <numbers>) SYMBOL(inv_sqrtpi, std::numbers::, <numbers>) SYMBOL(inv_sqrtpi_v, std::numbers::, <numbers>) SYMBOL(ln10, std::numbers::, <numbers>) SYMBOL(ln10_v, std::numbers::, <numbers>) SYMBOL(ln2, std::numbers::, <numbers>) SYMBOL(ln2_v, std::numbers::, <numbers>) SYMBOL(log10e, std::numbers::, <numbers>) SYMBOL(log10e_v, std::numbers::, <numbers>) SYMBOL(log2e, std::numbers::, <numbers>) SYMBOL(log2e_v, std::numbers::, <numbers>) SYMBOL(phi, std::numbers::, <numbers>) SYMBOL(phi_v, std::numbers::, <numbers>) SYMBOL(pi, std::numbers::, <numbers>) SYMBOL(pi_v, std::numbers::, <numbers>) SYMBOL(sqrt2, std::numbers::, <numbers>) SYMBOL(sqrt2_v, std::numbers::, <numbers>) SYMBOL(sqrt3, std::numbers::, <numbers>) SYMBOL(sqrt3_v, std::numbers::, <numbers>) SYMBOL(basic_string, std::pmr::, <string>) SYMBOL(cmatch, std::pmr::, <regex>) SYMBOL(deque, std::pmr::, <deque>) SYMBOL(forward_list, std::pmr::, <forward_list>) SYMBOL(get_default_resource, std::pmr::, <memory_resource>) SYMBOL(list, std::pmr::, <list>) SYMBOL(map, std::pmr::, <map>) SYMBOL(match_results, std::pmr::, <regex>) SYMBOL(memory_resource, std::pmr::, <memory_resource>) SYMBOL(monotonic_buffer_resource, std::pmr::, <memory_resource>) SYMBOL(multimap, std::pmr::, <map>) SYMBOL(multiset, std::pmr::, <set>) SYMBOL(new_delete_resource, std::pmr::, <memory_resource>) SYMBOL(null_memory_resource, std::pmr::, <memory_resource>) SYMBOL(polymorphic_allocator, std::pmr::, <memory_resource>) SYMBOL(pool_options, std::pmr::, <memory_resource>) SYMBOL(set, std::pmr::, <set>) SYMBOL(set_default_resource, std::pmr::, <memory_resource>) SYMBOL(smatch, std::pmr::, <regex>) SYMBOL(stacktrace, std::pmr::, <stacktrace>) SYMBOL(string, std::pmr::, <string>) SYMBOL(synchronized_pool_resource, std::pmr::, <memory_resource>) SYMBOL(u16string, std::pmr::, <string>) SYMBOL(u32string, std::pmr::, <string>) SYMBOL(u8string, std::pmr::, <string>) SYMBOL(unordered_map, std::pmr::, <unordered_map>) SYMBOL(unordered_multimap, std::pmr::, <unordered_map>) SYMBOL(unordered_multiset, std::pmr::, <unordered_set>) SYMBOL(unordered_set, std::pmr::, <unordered_set>) SYMBOL(unsynchronized_pool_resource, std::pmr::, <memory_resource>) SYMBOL(vector, std::pmr::, <vector>) SYMBOL(wcmatch, std::pmr::, <regex>) SYMBOL(wsmatch, std::pmr::, <regex>) SYMBOL(wstring, std::pmr::, <string>) SYMBOL(adjacent_find, std::ranges::, <algorithm>) SYMBOL(advance, std::ranges::, <iterator>) SYMBOL(all_of, std::ranges::, <algorithm>) SYMBOL(any_of, std::ranges::, <algorithm>) SYMBOL(as_const_view, std::ranges::, <ranges>) SYMBOL(as_rvalue_view, std::ranges::, <ranges>) SYMBOL(basic_istream_view, std::ranges::, <ranges>) SYMBOL(begin, std::ranges::, <ranges>) SYMBOL(bidirectional_range, std::ranges::, <ranges>) SYMBOL(binary_transform_result, std::ranges::, <algorithm>) SYMBOL(borrowed_iterator_t, std::ranges::, <ranges>) SYMBOL(borrowed_range, std::ranges::, <ranges>) SYMBOL(borrowed_subrange_t, std::ranges::, <ranges>) SYMBOL(cbegin, std::ranges::, <ranges>) SYMBOL(cdata, std::ranges::, <ranges>) SYMBOL(cend, std::ranges::, <ranges>) SYMBOL(clamp, std::ranges::, <algorithm>) SYMBOL(common_range, std::ranges::, <ranges>) SYMBOL(common_view, std::ranges::, <ranges>) SYMBOL(const_iterator_t, std::ranges::, <ranges>) SYMBOL(constant_range, std::ranges::, <ranges>) SYMBOL(construct_at, std::ranges::, <memory>) SYMBOL(contains, std::ranges::, <algorithm>) SYMBOL(contains_subrange, std::ranges::, <algorithm>) SYMBOL(contiguous_range, std::ranges::, <ranges>) SYMBOL(copy, std::ranges::, <algorithm>) SYMBOL(copy_backward, std::ranges::, <algorithm>) SYMBOL(copy_backward_result, std::ranges::, <algorithm>) SYMBOL(copy_if, std::ranges::, <algorithm>) SYMBOL(copy_if_result, std::ranges::, <algorithm>) SYMBOL(copy_n, std::ranges::, <algorithm>) SYMBOL(copy_n_result, std::ranges::, <algorithm>) SYMBOL(copy_result, std::ranges::, <algorithm>) SYMBOL(count, std::ranges::, <algorithm>) SYMBOL(count_if, std::ranges::, <algorithm>) SYMBOL(crbegin, std::ranges::, <ranges>) SYMBOL(crend, std::ranges::, <ranges>) SYMBOL(dangling, std::ranges::, <ranges>) SYMBOL(data, std::ranges::, <ranges>) SYMBOL(destroy, std::ranges::, <memory>) SYMBOL(destroy_at, std::ranges::, <memory>) SYMBOL(destroy_n, std::ranges::, <memory>) SYMBOL(disable_sized_range, std::ranges::, <ranges>) SYMBOL(distance, std::ranges::, <iterator>) SYMBOL(drop_view, std::ranges::, <ranges>) SYMBOL(drop_while_view, std::ranges::, <ranges>) SYMBOL(elements_view, std::ranges::, <ranges>) SYMBOL(empty, std::ranges::, <ranges>) SYMBOL(empty_view, std::ranges::, <ranges>) SYMBOL(enable_borrowed_range, std::ranges::, <ranges>) SYMBOL(enable_view, std::ranges::, <ranges>) SYMBOL(end, std::ranges::, <ranges>) SYMBOL(ends_with, std::ranges::, <algorithm>) SYMBOL(equal, std::ranges::, <algorithm>) SYMBOL(equal_to, std::ranges::, <functional>) SYMBOL(fill, std::ranges::, <algorithm>) SYMBOL(fill_n, std::ranges::, <algorithm>) SYMBOL(filter_view, std::ranges::, <ranges>) SYMBOL(find, std::ranges::, <algorithm>) SYMBOL(find_end, std::ranges::, <algorithm>) SYMBOL(find_first_of, std::ranges::, <algorithm>) SYMBOL(find_if, std::ranges::, <algorithm>) SYMBOL(find_if_not, std::ranges::, <algorithm>) SYMBOL(find_last, std::ranges::, <algorithm>) SYMBOL(find_last_if, std::ranges::, <algorithm>) SYMBOL(find_last_if_not, std::ranges::, <algorithm>) SYMBOL(for_each, std::ranges::, <algorithm>) SYMBOL(for_each_n, std::ranges::, <algorithm>) SYMBOL(for_each_n_result, std::ranges::, <algorithm>) SYMBOL(for_each_result, std::ranges::, <algorithm>) SYMBOL(forward_range, std::ranges::, <ranges>) SYMBOL(generate, std::ranges::, <algorithm>) SYMBOL(generate_n, std::ranges::, <algorithm>) SYMBOL(greater, std::ranges::, <functional>) SYMBOL(greater_equal, std::ranges::, <functional>) SYMBOL(in_found_result, std::ranges::, <algorithm>) SYMBOL(in_fun_result, std::ranges::, <algorithm>) SYMBOL(in_in_out_result, std::ranges::, <algorithm>) SYMBOL(in_in_result, std::ranges::, <algorithm>) SYMBOL(in_out_out_result, std::ranges::, <algorithm>) SYMBOL(in_out_result, std::ranges::, <algorithm>) SYMBOL(in_value_result, std::ranges::, <algorithm>) SYMBOL(includes, std::ranges::, <algorithm>) SYMBOL(inplace_merge, std::ranges::, <algorithm>) SYMBOL(input_range, std::ranges::, <ranges>) SYMBOL(iota, std::ranges::, <numeric>) SYMBOL(iota_result, std::ranges::, <numeric>) SYMBOL(iota_view, std::ranges::, <ranges>) SYMBOL(is_heap, std::ranges::, <algorithm>) SYMBOL(is_heap_until, std::ranges::, <algorithm>) SYMBOL(is_partitioned, std::ranges::, <algorithm>) SYMBOL(is_permutation, std::ranges::, <algorithm>) SYMBOL(is_sorted, std::ranges::, <algorithm>) SYMBOL(is_sorted_until, std::ranges::, <algorithm>) SYMBOL(istream_view, std::ranges::, <ranges>) SYMBOL(iter_move, std::ranges::, <iterator>) SYMBOL(iter_swap, std::ranges::, <iterator>) SYMBOL(iterator_t, std::ranges::, <ranges>) SYMBOL(join_view, std::ranges::, <ranges>) SYMBOL(join_with_view, std::ranges::, <ranges>) SYMBOL(keys_view, std::ranges::, <ranges>) SYMBOL(lazy_split_view, std::ranges::, <ranges>) SYMBOL(less, std::ranges::, <functional>) SYMBOL(less_equal, std::ranges::, <functional>) SYMBOL(lexicographical_compare, std::ranges::, <algorithm>) SYMBOL(make_heap, std::ranges::, <algorithm>) SYMBOL(max, std::ranges::, <algorithm>) SYMBOL(max_element, std::ranges::, <algorithm>) SYMBOL(merge, std::ranges::, <algorithm>) SYMBOL(merge_result, std::ranges::, <algorithm>) SYMBOL(min, std::ranges::, <algorithm>) SYMBOL(min_element, std::ranges::, <algorithm>) SYMBOL(min_max_result, std::ranges::, <algorithm>) SYMBOL(minmax, std::ranges::, <algorithm>) SYMBOL(minmax_element, std::ranges::, <algorithm>) SYMBOL(minmax_element_result, std::ranges::, <algorithm>) SYMBOL(minmax_result, std::ranges::, <algorithm>) SYMBOL(mismatch, std::ranges::, <algorithm>) SYMBOL(mismatch_result, std::ranges::, <algorithm>) SYMBOL(move, std::ranges::, <algorithm>) SYMBOL(move_backward, std::ranges::, <algorithm>) SYMBOL(move_backward_result, std::ranges::, <algorithm>) SYMBOL(move_result, std::ranges::, <algorithm>) SYMBOL(next, std::ranges::, <iterator>) SYMBOL(next_permutation, std::ranges::, <algorithm>) SYMBOL(next_permutation_result, std::ranges::, <algorithm>) SYMBOL(none_of, std::ranges::, <algorithm>) SYMBOL(not_equal_to, std::ranges::, <functional>) SYMBOL(nth_element, std::ranges::, <algorithm>) SYMBOL(out_value_result, std::ranges::, <algorithm>) SYMBOL(output_range, std::ranges::, <ranges>) SYMBOL(owning_view, std::ranges::, <ranges>) SYMBOL(partial_sort, std::ranges::, <algorithm>) SYMBOL(partial_sort_copy, std::ranges::, <algorithm>) SYMBOL(partial_sort_copy_result, std::ranges::, <algorithm>) SYMBOL(partition, std::ranges::, <algorithm>) SYMBOL(partition_copy, std::ranges::, <algorithm>) SYMBOL(partition_copy_result, std::ranges::, <algorithm>) SYMBOL(partition_point, std::ranges::, <algorithm>) SYMBOL(pop_heap, std::ranges::, <algorithm>) SYMBOL(prev, std::ranges::, <iterator>) SYMBOL(prev_permutation, std::ranges::, <algorithm>) SYMBOL(prev_permutation_result, std::ranges::, <algorithm>) SYMBOL(push_heap, std::ranges::, <algorithm>) SYMBOL(random_access_range, std::ranges::, <ranges>) SYMBOL(range, std::ranges::, <ranges>) SYMBOL(range_const_reference_t, std::ranges::, <ranges>) SYMBOL(range_difference_t, std::ranges::, <ranges>) SYMBOL(range_reference_t, std::ranges::, <ranges>) SYMBOL(range_rvalue_reference_t, std::ranges::, <ranges>) SYMBOL(range_size_t, std::ranges::, <ranges>) SYMBOL(range_value_t, std::ranges::, <ranges>) SYMBOL(rbegin, std::ranges::, <ranges>) SYMBOL(ref_view, std::ranges::, <ranges>) SYMBOL(remove, std::ranges::, <algorithm>) SYMBOL(remove_copy, std::ranges::, <algorithm>) SYMBOL(remove_copy_if, std::ranges::, <algorithm>) SYMBOL(remove_copy_if_result, std::ranges::, <algorithm>) SYMBOL(remove_copy_result, std::ranges::, <algorithm>) SYMBOL(remove_if, std::ranges::, <algorithm>) SYMBOL(rend, std::ranges::, <ranges>) SYMBOL(replace, std::ranges::, <algorithm>) SYMBOL(replace_copy, std::ranges::, <algorithm>) SYMBOL(replace_copy_if, std::ranges::, <algorithm>) SYMBOL(replace_copy_if_result, std::ranges::, <algorithm>) SYMBOL(replace_copy_result, std::ranges::, <algorithm>) SYMBOL(replace_if, std::ranges::, <algorithm>) SYMBOL(reverse, std::ranges::, <algorithm>) SYMBOL(reverse_copy, std::ranges::, <algorithm>) SYMBOL(reverse_copy_result, std::ranges::, <algorithm>) SYMBOL(reverse_view, std::ranges::, <ranges>) SYMBOL(rotate, std::ranges::, <algorithm>) SYMBOL(rotate_copy, std::ranges::, <algorithm>) SYMBOL(rotate_copy_result, std::ranges::, <algorithm>) SYMBOL(sample, std::ranges::, <algorithm>) SYMBOL(search, std::ranges::, <algorithm>) SYMBOL(search_n, std::ranges::, <algorithm>) SYMBOL(sentinel_t, std::ranges::, <ranges>) SYMBOL(set_difference, std::ranges::, <algorithm>) SYMBOL(set_difference_result, std::ranges::, <algorithm>) SYMBOL(set_intersection, std::ranges::, <algorithm>) SYMBOL(set_intersection_result, std::ranges::, <algorithm>) SYMBOL(set_symmetric_difference, std::ranges::, <algorithm>) SYMBOL(set_symmetric_difference_result, std::ranges::, <algorithm>) SYMBOL(set_union, std::ranges::, <algorithm>) SYMBOL(set_union_result, std::ranges::, <algorithm>) SYMBOL(shift_left, std::ranges::, <algorithm>) SYMBOL(shift_right, std::ranges::, <algorithm>) SYMBOL(shuffle, std::ranges::, <algorithm>) SYMBOL(single_view, std::ranges::, <ranges>) SYMBOL(size, std::ranges::, <ranges>) SYMBOL(sized_range, std::ranges::, <ranges>) SYMBOL(sort, std::ranges::, <algorithm>) SYMBOL(sort_heap, std::ranges::, <algorithm>) SYMBOL(split_view, std::ranges::, <ranges>) SYMBOL(ssize, std::ranges::, <ranges>) SYMBOL(stable_partition, std::ranges::, <algorithm>) SYMBOL(stable_sort, std::ranges::, <algorithm>) SYMBOL(starts_with, std::ranges::, <algorithm>) SYMBOL(subrange, std::ranges::, <ranges>) SYMBOL(subrange_kind, std::ranges::, <ranges>) SYMBOL(swap, std::ranges::, <concepts>) SYMBOL(swap_ranges, std::ranges::, <algorithm>) SYMBOL(swap_ranges_result, std::ranges::, <algorithm>) SYMBOL(take_view, std::ranges::, <ranges>) SYMBOL(take_while_view, std::ranges::, <ranges>) SYMBOL(to, std::ranges::, <ranges>) SYMBOL(transform, std::ranges::, <algorithm>) SYMBOL(transform_view, std::ranges::, <ranges>) SYMBOL(unary_transform_result, std::ranges::, <algorithm>) SYMBOL(uninitialized_copy, std::ranges::, <memory>) SYMBOL(uninitialized_copy_n, std::ranges::, <memory>) SYMBOL(uninitialized_copy_n_result, std::ranges::, <memory>) SYMBOL(uninitialized_copy_result, std::ranges::, <memory>) SYMBOL(uninitialized_default_construct, std::ranges::, <memory>) SYMBOL(uninitialized_default_construct_n, std::ranges::, <memory>) SYMBOL(uninitialized_fill, std::ranges::, <memory>) SYMBOL(uninitialized_fill_n, std::ranges::, <memory>) SYMBOL(uninitialized_move, std::ranges::, <memory>) SYMBOL(uninitialized_move_n, std::ranges::, <memory>) SYMBOL(uninitialized_move_n_result, std::ranges::, <memory>) SYMBOL(uninitialized_move_result, std::ranges::, <memory>) SYMBOL(uninitialized_value_construct, std::ranges::, <memory>) SYMBOL(uninitialized_value_construct_n, std::ranges::, <memory>) SYMBOL(unique, std::ranges::, <algorithm>) SYMBOL(unique_copy, std::ranges::, <algorithm>) SYMBOL(unique_copy_result, std::ranges::, <algorithm>) SYMBOL(values_view, std::ranges::, <ranges>) SYMBOL(view, std::ranges::, <ranges>) SYMBOL(view_base, std::ranges::, <ranges>) SYMBOL(view_interface, std::ranges::, <ranges>) SYMBOL(viewable_range, std::ranges::, <ranges>) SYMBOL(wistream_view, std::ranges::, <ranges>) SYMBOL(zip_transform_view, std::ranges::, <ranges>) SYMBOL(zip_view, std::ranges::, <ranges>) SYMBOL(all, std::ranges::views::, <ranges>) SYMBOL(all_t, std::ranges::views::, <ranges>) SYMBOL(as_const, std::ranges::views::, <ranges>) SYMBOL(as_rvalue, std::ranges::views::, <ranges>) SYMBOL(common, std::ranges::views::, <ranges>) SYMBOL(counted, std::ranges::views::, <ranges>) SYMBOL(drop, std::ranges::views::, <ranges>) SYMBOL(drop_while, std::ranges::views::, <ranges>) SYMBOL(elements, std::ranges::views::, <ranges>) SYMBOL(empty, std::ranges::views::, <ranges>) SYMBOL(filter, std::ranges::views::, <ranges>) SYMBOL(iota, std::ranges::views::, <ranges>) SYMBOL(istream, std::ranges::views::, <ranges>) SYMBOL(istream, std::ranges::views::, <iosfwd>) SYMBOL(join, std::ranges::views::, <ranges>) SYMBOL(join_with, std::ranges::views::, <ranges>) SYMBOL(keys, std::ranges::views::, <ranges>) SYMBOL(lazy_split, std::ranges::views::, <ranges>) SYMBOL(reverse, std::ranges::views::, <ranges>) SYMBOL(single, std::ranges::views::, <ranges>) SYMBOL(split, std::ranges::views::, <ranges>) SYMBOL(take, std::ranges::views::, <ranges>) SYMBOL(take_while, std::ranges::views::, <ranges>) SYMBOL(transform, std::ranges::views::, <ranges>) SYMBOL(values, std::ranges::views::, <ranges>) SYMBOL(zip, std::ranges::views::, <ranges>) SYMBOL(zip_transform, std::ranges::views::, <ranges>) SYMBOL(ECMAScript, std::regex_constants::, <regex>) SYMBOL(awk, std::regex_constants::, <regex>) SYMBOL(basic, std::regex_constants::, <regex>) SYMBOL(collate, std::regex_constants::, <regex>) SYMBOL(egrep, std::regex_constants::, <regex>) SYMBOL(error_backref, std::regex_constants::, <regex>) SYMBOL(error_badbrace, std::regex_constants::, <regex>) SYMBOL(error_badrepeat, std::regex_constants::, <regex>) SYMBOL(error_brace, std::regex_constants::, <regex>) SYMBOL(error_brack, std::regex_constants::, <regex>) SYMBOL(error_collate, std::regex_constants::, <regex>) SYMBOL(error_complexity, std::regex_constants::, <regex>) SYMBOL(error_ctype, std::regex_constants::, <regex>) SYMBOL(error_escape, std::regex_constants::, <regex>) SYMBOL(error_paren, std::regex_constants::, <regex>) SYMBOL(error_range, std::regex_constants::, <regex>) SYMBOL(error_space, std::regex_constants::, <regex>) SYMBOL(error_stack, std::regex_constants::, <regex>) SYMBOL(error_type, std::regex_constants::, <regex>) SYMBOL(extended, std::regex_constants::, <regex>) SYMBOL(format_default, std::regex_constants::, <regex>) SYMBOL(format_first_only, std::regex_constants::, <regex>) SYMBOL(format_no_copy, std::regex_constants::, <regex>) SYMBOL(format_sed, std::regex_constants::, <regex>) SYMBOL(grep, std::regex_constants::, <regex>) SYMBOL(icase, std::regex_constants::, <regex>) SYMBOL(match_any, std::regex_constants::, <regex>) SYMBOL(match_continuous, std::regex_constants::, <regex>) SYMBOL(match_default, std::regex_constants::, <regex>) SYMBOL(match_flag_type, std::regex_constants::, <regex>) SYMBOL(match_not_bol, std::regex_constants::, <regex>) SYMBOL(match_not_bow, std::regex_constants::, <regex>) SYMBOL(match_not_eol, std::regex_constants::, <regex>) SYMBOL(match_not_eow, std::regex_constants::, <regex>) SYMBOL(match_not_null, std::regex_constants::, <regex>) SYMBOL(match_prev_avail, std::regex_constants::, <regex>) SYMBOL(multiline, std::regex_constants::, <regex>) SYMBOL(nosubs, std::regex_constants::, <regex>) SYMBOL(optimize, std::regex_constants::, <regex>) SYMBOL(syntax_option_type, std::regex_constants::, <regex>) SYMBOL(get_id, std::this_thread::, <thread>) SYMBOL(sleep_for, std::this_thread::, <thread>) SYMBOL(sleep_until, std::this_thread::, <thread>) SYMBOL(yield, std::this_thread::, <thread>) SYMBOL(all, std::views::, <ranges>) SYMBOL(all_t, std::views::, <ranges>) SYMBOL(as_const, std::views::, <ranges>) SYMBOL(as_rvalue, std::views::, <ranges>) SYMBOL(common, std::views::, <ranges>) SYMBOL(counted, std::views::, <ranges>) SYMBOL(drop, std::views::, <ranges>) SYMBOL(drop_while, std::views::, <ranges>) SYMBOL(elements, std::views::, <ranges>) SYMBOL(empty, std::views::, <ranges>) SYMBOL(filter, std::views::, <ranges>) SYMBOL(iota, std::views::, <ranges>) SYMBOL(istream, std::views::, <ranges>) SYMBOL(istream, std::views::, <iosfwd>) SYMBOL(join, std::views::, <ranges>) SYMBOL(join_with, std::views::, <ranges>) SYMBOL(keys, std::views::, <ranges>) SYMBOL(lazy_split, std::views::, <ranges>) SYMBOL(reverse, std::views::, <ranges>) SYMBOL(single, std::views::, <ranges>) SYMBOL(split, std::views::, <ranges>) SYMBOL(take, std::views::, <ranges>) SYMBOL(take_while, std::views::, <ranges>) SYMBOL(transform, std::views::, <ranges>) SYMBOL(values, std::views::, <ranges>) SYMBOL(zip, std::views::, <ranges>) SYMBOL(zip_transform, std::views::, <ranges>)