[Tooling/Inclusion] Get rid of the "None" magic string for empty namespace symbols.

clang/lib/Tooling/Inclusions/Stdlib/CSymbolMap.inc

 //===-- gen_std.py generated file -------------------------------*- C++ -*-===//
 //
 // Used to build a lookup table (qualified names => include headers) for C
 // 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 2018-10-28).
 //===----------------------------------------------------------------------===//
 
-SYMBOL(ATOMIC_BOOL_LOCK_FREE, None, <stdatomic.h>)
-SYMBOL(ATOMIC_CHAR16_T_LOCK_FREE, None, <stdatomic.h>)
-SYMBOL(ATOMIC_CHAR32_T_LOCK_FREE, None, <stdatomic.h>)
-SYMBOL(ATOMIC_CHAR_LOCK_FREE, None, <stdatomic.h>)
-SYMBOL(ATOMIC_FLAG_INIT, None, <stdatomic.h>)
-SYMBOL(ATOMIC_INT_LOCK_FREE, None, <stdatomic.h>)
-SYMBOL(ATOMIC_LLONG_LOCK_FREE, None, <stdatomic.h>)
-SYMBOL(ATOMIC_LONG_LOGK_FREE, None, <stdatomic.h>)
-SYMBOL(ATOMIC_POINTER_LOCK_FREE, None, <stdatomic.h>)
-SYMBOL(ATOMIC_SHORT_LOCK_FREE, None, <stdatomic.h>)
-SYMBOL(ATOMIC_VAR_INIT, None, <stdatomic.h>)
-SYMBOL(ATOMIC_WCHAR_T_LOCK_FREE, None, <stdatomic.h>)
-SYMBOL(BUFSIZ, None, <stdio.h>)
-SYMBOL(CHAR_BIT, None, <limits.h>)
-SYMBOL(CHAR_MAX, None, <limits.h>)
-SYMBOL(CHAR_MIN, None, <limits.h>)
-SYMBOL(CLOCKS_PER_SEC, None, <time.h>)
-SYMBOL(CMPLX, None, <complex.h>)
-SYMBOL(CMPLXF, None, <complex.h>)
-SYMBOL(CMPLXL, None, <complex.h>)
-SYMBOL(DBL_DECIMAL_DIG, None, <float.h>)
-SYMBOL(DBL_DIG, None, <float.h>)
-SYMBOL(DBL_EPSILON, None, <float.h>)
-SYMBOL(DBL_HAS_SUBNORM, None, <float.h>)
-SYMBOL(DBL_MANT_DIG, None, <float.h>)
-SYMBOL(DBL_MAX, None, <float.h>)
-SYMBOL(DBL_MAX_10_EXP, None, <float.h>)
-SYMBOL(DBL_MAX_EXP, None, <float.h>)
-SYMBOL(DBL_MIN, None, <float.h>)
-SYMBOL(DBL_MIN_10_EXP, None, <float.h>)
-SYMBOL(DBL_MIN_EXP, None, <float.h>)
-SYMBOL(DBL_TRUE_MIN, None, <float.h>)
-SYMBOL(DECIMAL_DIG, None, <float.h>)
-SYMBOL(EDOM, None, <errno.h>)
-SYMBOL(EILSEQ, None, <errno.h>)
-SYMBOL(EOF, None, <stdio.h>)
-SYMBOL(ERANGE, None, <errno.h>)
-SYMBOL(EXIT_FAILURE, None, <stdlib.h>)
-SYMBOL(EXIT_SUCCESS, None, <stdlib.h>)
-SYMBOL(FE_ALL_EXCEPT, None, <fenv.h>)
-SYMBOL(FE_DFL_ENV, None, <fenv.h>)
-SYMBOL(FE_DIVBYZERO, None, <fenv.h>)
-SYMBOL(FE_DOWNWARD, None, <fenv.h>)
-SYMBOL(FE_INEXACT, None, <fenv.h>)
-SYMBOL(FE_INVALID, None, <fenv.h>)
-SYMBOL(FE_OVERFLOW, None, <fenv.h>)
-SYMBOL(FE_TONEAREST, None, <fenv.h>)
-SYMBOL(FE_TOWARDZERO, None, <fenv.h>)
-SYMBOL(FE_UNDERFLOW, None, <fenv.h>)
-SYMBOL(FE_UPWARD, None, <fenv.h>)
-SYMBOL(FILE, None, <stdio.h>)
-SYMBOL(FILENAME_MAX, None, <stdio.h>)
-SYMBOL(FLT_DECIMAL_DIG, None, <float.h>)
-SYMBOL(FLT_DIG, None, <float.h>)
-SYMBOL(FLT_EPSILON, None, <float.h>)
-SYMBOL(FLT_EVAL_METHOD, None, <float.h>)
-SYMBOL(FLT_HAS_SUBNORM, None, <float.h>)
-SYMBOL(FLT_MANT_DIG, None, <float.h>)
-SYMBOL(FLT_MAX, None, <float.h>)
-SYMBOL(FLT_MAX_10_EXP, None, <float.h>)
-SYMBOL(FLT_MAX_EXP, None, <float.h>)
-SYMBOL(FLT_MIN, None, <float.h>)
-SYMBOL(FLT_MIN_10_EXP, None, <float.h>)
-SYMBOL(FLT_MIN_EXP, None, <float.h>)
-SYMBOL(FLT_RADIX, None, <float.h>)
-SYMBOL(FLT_ROUNDS, None, <float.h>)
-SYMBOL(FLT_TRUE_MIN, None, <float.h>)
-SYMBOL(FOPEN_MAX, None, <stdio.h>)
-SYMBOL(FP_INFINITE, None, <math.h>)
-SYMBOL(FP_NAN, None, <math.h>)
-SYMBOL(FP_NORNAL, None, <math.h>)
-SYMBOL(FP_SUBNORMAL, None, <math.h>)
-SYMBOL(FP_ZERO, None, <math.h>)
-SYMBOL(HUGE_VAL, None, <math.h>)
-SYMBOL(HUGE_VALF, None, <math.h>)
-SYMBOL(HUGE_VALL, None, <math.h>)
-SYMBOL(I, None, <complex.h>)
-SYMBOL(INFINITY, None, <math.h>)
-SYMBOL(INT16_MAX, None, <stdint.h>)
-SYMBOL(INT16_MIN, None, <stdint.h>)
-SYMBOL(INT32_MAX, None, <stdint.h>)
-SYMBOL(INT32_MIN, None, <stdint.h>)
-SYMBOL(INT64_MAX, None, <stdint.h>)
-SYMBOL(INT64_MIN, None, <stdint.h>)
-SYMBOL(INT8_MAX, None, <stdint.h>)
-SYMBOL(INT8_MIN, None, <stdint.h>)
-SYMBOL(INTMAX_MAX, None, <stdint.h>)
-SYMBOL(INTMAX_MIN, None, <stdint.h>)
-SYMBOL(INTPTR_MAX, None, <stdint.h>)
-SYMBOL(INTPTR_MIN, None, <stdint.h>)
-SYMBOL(INT_FAST16_MAX, None, <stdint.h>)
-SYMBOL(INT_FAST16_MIN, None, <stdint.h>)
-SYMBOL(INT_FAST32_MAX, None, <stdint.h>)
-SYMBOL(INT_FAST32_MIN, None, <stdint.h>)
-SYMBOL(INT_FAST64_MAX, None, <stdint.h>)
-SYMBOL(INT_FAST64_MIN, None, <stdint.h>)
-SYMBOL(INT_FAST8_MAX, None, <stdint.h>)
-SYMBOL(INT_FAST8_MIN, None, <stdint.h>)
-SYMBOL(INT_LEAST16_MAX, None, <stdint.h>)
-SYMBOL(INT_LEAST16_MIN, None, <stdint.h>)
-SYMBOL(INT_LEAST32_MAX, None, <stdint.h>)
-SYMBOL(INT_LEAST32_MIN, None, <stdint.h>)
-SYMBOL(INT_LEAST64_MAX, None, <stdint.h>)
-SYMBOL(INT_LEAST64_MIN, None, <stdint.h>)
-SYMBOL(INT_LEAST8_MAX, None, <stdint.h>)
-SYMBOL(INT_LEAST8_MIN, None, <stdint.h>)
-SYMBOL(INT_MAX, None, <limits.h>)
-SYMBOL(INT_MIN, None, <limits.h>)
-SYMBOL(LC_ALL, None, <locale.h>)
-SYMBOL(LC_COLLATE, None, <locale.h>)
-SYMBOL(LC_CTYPE, None, <locale.h>)
-SYMBOL(LC_MONETARY, None, <locale.h>)
-SYMBOL(LC_NUMERIC, None, <locale.h>)
-SYMBOL(LC_TIME, None, <locale.h>)
-SYMBOL(LDBL_DECIMAL_DIG, None, <float.h>)
-SYMBOL(LDBL_DIG, None, <float.h>)
-SYMBOL(LDBL_EPSILON, None, <float.h>)
-SYMBOL(LDBL_HAS_SUBNORM, None, <float.h>)
-SYMBOL(LDBL_MANT_DIG, None, <float.h>)
-SYMBOL(LDBL_MAX, None, <float.h>)
-SYMBOL(LDBL_MAX_10_EXP, None, <float.h>)
-SYMBOL(LDBL_MAX_EXP, None, <float.h>)
-SYMBOL(LDBL_MIN, None, <float.h>)
-SYMBOL(LDBL_MIN_10_EXP, None, <float.h>)
-SYMBOL(LDBL_MIN_EXP, None, <float.h>)
-SYMBOL(LDBL_TRUE_MIN, None, <float.h>)
-SYMBOL(LLONG_MAX, None, <limits.h>)
-SYMBOL(LLONG_MIN, None, <limits.h>)
-SYMBOL(LONG_MAX, None, <limits.h>)
-SYMBOL(LONG_MIN, None, <limits.h>)
-SYMBOL(L_tmpnam, None, <stdio.h>)
-SYMBOL(L_tmpnam_s, None, <stdio.h>)
-SYMBOL(MATH_ERREXCEPT, None, <math.h>)
-SYMBOL(MATH_ERRNO, None, <math.h>)
-SYMBOL(MB_CUR_MAX, None, <stdlib.h>)
-SYMBOL(MB_LEN_MAX, None, <limits.h>)
-SYMBOL(NAN, None, <math.h>)
-SYMBOL(ONCE_FLAG_INIT, None, <threads.h>)
-SYMBOL(PTRDIFF_MAX, None, <stdint.h>)
-SYMBOL(PTRDIFF_MIN, None, <stdint.h>)
-SYMBOL(RAND_MAX, None, <stdlib.h>)
-SYMBOL(RSIZE_MAX, None, <stdint.h>)
-SYMBOL(SCHAR_MAX, None, <limits.h>)
-SYMBOL(SCHAR_MIN, None, <limits.h>)
-SYMBOL(SEEK_CUR, None, <stdio.h>)
-SYMBOL(SEEK_END, None, <stdio.h>)
-SYMBOL(SEEK_SET, None, <stdio.h>)
-SYMBOL(SHRT_MAX, None, <limits.h>)
-SYMBOL(SHRT_MIN, None, <limits.h>)
-SYMBOL(SIGABRT, None, <signal.h>)
-SYMBOL(SIGFPE, None, <signal.h>)
-SYMBOL(SIGILL, None, <signal.h>)
-SYMBOL(SIGINT, None, <signal.h>)
-SYMBOL(SIGSEGV, None, <signal.h>)
-SYMBOL(SIGTERM, None, <signal.h>)
-SYMBOL(SIG_ATOMIC_MAX, None, <stdint.h>)
-SYMBOL(SIG_ATOMIC_MIN, None, <stdint.h>)
-SYMBOL(SIG_DFL, None, <signal.h>)
-SYMBOL(SIG_ERR, None, <signal.h>)
-SYMBOL(SIG_IGN, None, <signal.h>)
-SYMBOL(SIZE_MAX, None, <stdint.h>)
-SYMBOL(TIME_UTC, None, <time.h>)
-SYMBOL(TMP_MAX, None, <stdio.h>)
-SYMBOL(TMP_MAX_S, None, <stdio.h>)
-SYMBOL(TSS_DTOR_ITERATIONS, None, <threads.h>)
-SYMBOL(UCHAR_MAX, None, <limits.h>)
-SYMBOL(UINT16_MAX, None, <stdint.h>)
-SYMBOL(UINT32_MAX, None, <stdint.h>)
-SYMBOL(UINT64_MAX, None, <stdint.h>)
-SYMBOL(UINT8_MAX, None, <stdint.h>)
-SYMBOL(UINTMAX_MAX, None, <stdint.h>)
-SYMBOL(UINTPTR_MAX, None, <stdint.h>)
-SYMBOL(UINT_FAST16_MAX, None, <stdint.h>)
-SYMBOL(UINT_FAST32_MAX, None, <stdint.h>)
-SYMBOL(UINT_FAST64_MAX, None, <stdint.h>)
-SYMBOL(UINT_FAST8_MAX, None, <stdint.h>)
-SYMBOL(UINT_LEAST16_MAX, None, <stdint.h>)
-SYMBOL(UINT_LEAST32_MAX, None, <stdint.h>)
-SYMBOL(UINT_LEAST64_MAX, None, <stdint.h>)
-SYMBOL(UINT_LEAST8_MAX, None, <stdint.h>)
-SYMBOL(UINT_MAX, None, <limits.h>)
-SYMBOL(ULLONG_MAX, None, <limits.h>)
-SYMBOL(ULONG_MAX, None, <limits.h>)
-SYMBOL(USHRT_MAX, None, <limits.h>)
-SYMBOL(WCHAR_MAX, None, <wchar.h>)
-SYMBOL(WCHAR_MIN, None, <wchar.h>)
-SYMBOL(WEOF, None, <wchar.h>)
-SYMBOL(WINT_MAX, None, <stdint.h>)
-SYMBOL(WINT_MIN, None, <stdint.h>)
-SYMBOL(_Complex_I, None, <complex.h>)
-SYMBOL(_IOFBF, None, <stdio.h>)
-SYMBOL(_IOLBF, None, <stdio.h>)
-SYMBOL(_IONBF, None, <stdio.h>)
-SYMBOL(_Imaginary_I, None, <complex.h>)
-SYMBOL(__alignas_is_defined, None, <stdalign.h>)
-SYMBOL(__alignof_is_defined, None, <stdalign.h>)
-SYMBOL(abort_handler_s, None, <stdlib.h>)
-SYMBOL(abs, None, <stdlib.h>)
-SYMBOL(acos, None, <math.h>)
-SYMBOL(acosf, None, <math.h>)
-SYMBOL(acosh, None, <math.h>)
-SYMBOL(acoshf, None, <math.h>)
-SYMBOL(acoshl, None, <math.h>)
-SYMBOL(acosl, None, <math.h>)
-SYMBOL(alignas, None, <stdalign.h>)
-SYMBOL(aligned_alloc, None, <stdlib.h>)
-SYMBOL(alignof, None, <stdalign.h>)
-SYMBOL(and, None, <iso646.h>)
-SYMBOL(and_eq, None, <iso646.h>)
-SYMBOL(asctime, None, <time.h>)
-SYMBOL(asctime_s, None, <time.h>)
-SYMBOL(asin, None, <math.h>)
-SYMBOL(asinf, None, <math.h>)
-SYMBOL(asinh, None, <math.h>)
-SYMBOL(asinhf, None, <math.h>)
-SYMBOL(asinhl, None, <math.h>)
-SYMBOL(asinl, None, <math.h>)
-SYMBOL(assert, None, <assert.h>)
-SYMBOL(at_quick_exit, None, <stdlib.h>)
-SYMBOL(atan, None, <math.h>)
-SYMBOL(atan2, None, <math.h>)
-SYMBOL(atan2f, None, <math.h>)
-SYMBOL(atan2l, None, <math.h>)
-SYMBOL(atanf, None, <math.h>)
-SYMBOL(atanh, None, <math.h>)
-SYMBOL(atanhf, None, <math.h>)
-SYMBOL(atanhl, None, <math.h>)
-SYMBOL(atanl, None, <math.h>)
-SYMBOL(atexit, None, <stdlib.h>)
-SYMBOL(atof, None, <stdlib.h>)
-SYMBOL(atoi, None, <stdlib.h>)
-SYMBOL(atol, None, <stdlib.h>)
-SYMBOL(atoll, None, <stdlib.h>)
-SYMBOL(atomic_bool, None, <stdatomic.h>)
-SYMBOL(atomic_char, None, <stdatomic.h>)
-SYMBOL(atomic_char16_t, None, <stdatomic.h>)
-SYMBOL(atomic_char32_t, None, <stdatomic.h>)
-SYMBOL(atomic_compare_exchange_strong, None, <stdatomic.h>)
-SYMBOL(atomic_compare_exchange_strong_explicit, None, <stdatomic.h>)
-SYMBOL(atomic_compare_exchange_weak, None, <stdatomic.h>)
-SYMBOL(atomic_compare_exchange_weak_explicit, None, <stdatomic.h>)
-SYMBOL(atomic_exchange, None, <stdatomic.h>)
-SYMBOL(atomic_exchange_explicit, None, <stdatomic.h>)
-SYMBOL(atomic_fetch_add, None, <stdatomic.h>)
-SYMBOL(atomic_fetch_add_explicit, None, <stdatomic.h>)
-SYMBOL(atomic_fetch_and, None, <stdatomic.h>)
-SYMBOL(atomic_fetch_and_explicit, None, <stdatomic.h>)
-SYMBOL(atomic_fetch_or, None, <stdatomic.h>)
-SYMBOL(atomic_fetch_or_explicit, None, <stdatomic.h>)
-SYMBOL(atomic_fetch_sub, None, <stdatomic.h>)
-SYMBOL(atomic_fetch_sub_explicit, None, <stdatomic.h>)
-SYMBOL(atomic_fetch_xor, None, <stdatomic.h>)
-SYMBOL(atomic_fetch_xor_explicit, None, <stdatomic.h>)
-SYMBOL(atomic_flag, None, <stdatomic.h>)
-SYMBOL(atomic_flag_clear, None, <stdatomic.h>)
-SYMBOL(atomic_flag_clear_explicit, None, <stdatomic.h>)
-SYMBOL(atomic_flag_test_and_set, None, <stdatomic.h>)
-SYMBOL(atomic_flag_test_and_set_explicit, None, <stdatomic.h>)
-SYMBOL(atomic_init, None, <stdatomic.h>)
-SYMBOL(atomic_int, None, <stdatomic.h>)
-SYMBOL(atomic_int_fast16_t, None, <stdatomic.h>)
-SYMBOL(atomic_int_fast32_t, None, <stdatomic.h>)
-SYMBOL(atomic_int_fast64_t, None, <stdatomic.h>)
-SYMBOL(atomic_int_fast8_t, None, <stdatomic.h>)
-SYMBOL(atomic_int_least16_t, None, <stdatomic.h>)
-SYMBOL(atomic_int_least32_t, None, <stdatomic.h>)
-SYMBOL(atomic_int_least64_t, None, <stdatomic.h>)
-SYMBOL(atomic_int_least8_t, None, <stdatomic.h>)
-SYMBOL(atomic_intmax_t, None, <stdatomic.h>)
-SYMBOL(atomic_intptr_t, None, <stdatomic.h>)
-SYMBOL(atomic_is_lock_free, None, <stdatomic.h>)
-SYMBOL(atomic_llong, None, <stdatomic.h>)
-SYMBOL(atomic_load, None, <stdatomic.h>)
-SYMBOL(atomic_load_explicit, None, <stdatomic.h>)
-SYMBOL(atomic_long, None, <stdatomic.h>)
-SYMBOL(atomic_ptrdiff_t, None, <stdatomic.h>)
-SYMBOL(atomic_schar, None, <stdatomic.h>)
-SYMBOL(atomic_short, None, <stdatomic.h>)
-SYMBOL(atomic_signal_fence, None, <stdatomic.h>)
-SYMBOL(atomic_size_t, None, <stdatomic.h>)
-SYMBOL(atomic_store, None, <stdatomic.h>)
-SYMBOL(atomic_store_explicit, None, <stdatomic.h>)
-SYMBOL(atomic_thread_fence, None, <stdatomic.h>)
-SYMBOL(atomic_uchar, None, <stdatomic.h>)
-SYMBOL(atomic_uint, None, <stdatomic.h>)
-SYMBOL(atomic_uint_fast16_t, None, <stdatomic.h>)
-SYMBOL(atomic_uint_fast32_t, None, <stdatomic.h>)
-SYMBOL(atomic_uint_fast64_t, None, <stdatomic.h>)
-SYMBOL(atomic_uint_fast8_t, None, <stdatomic.h>)
-SYMBOL(atomic_uint_least16_t, None, <stdatomic.h>)
-SYMBOL(atomic_uint_least32_t, None, <stdatomic.h>)
-SYMBOL(atomic_uint_least64_t, None, <stdatomic.h>)
-SYMBOL(atomic_uint_least8_t, None, <stdatomic.h>)
-SYMBOL(atomic_uintmax_t, None, <stdatomic.h>)
-SYMBOL(atomic_uintptr_t, None, <stdatomic.h>)
-SYMBOL(atomic_ullong, None, <stdatomic.h>)
-SYMBOL(atomic_ulong, None, <stdatomic.h>)
-SYMBOL(atomic_ushort, None, <stdatomic.h>)
-SYMBOL(atomic_wchar_t, None, <stdatomic.h>)
-SYMBOL(bitand, None, <iso646.h>)
-SYMBOL(bitor, None, <iso646.h>)
-SYMBOL(bsearch, None, <stdlib.h>)
-SYMBOL(bsearch_s, None, <stdlib.h>)
-SYMBOL(btowc, None, <wchar.h>)
-SYMBOL(c16rtomb, None, <uchar.h>)
-SYMBOL(c32rtomb, None, <uchar.h>)
-SYMBOL(cabs, None, <complex.h>)
-SYMBOL(cabsf, None, <complex.h>)
-SYMBOL(cabsl, None, <complex.h>)
-SYMBOL(cacos, None, <complex.h>)
-SYMBOL(cacosf, None, <complex.h>)
-SYMBOL(cacosh, None, <complex.h>)
-SYMBOL(cacoshf, None, <complex.h>)
-SYMBOL(cacoshl, None, <complex.h>)
-SYMBOL(cacosl, None, <complex.h>)
-SYMBOL(call_once, None, <threads.h>)
-SYMBOL(calloc, None, <stdlib.h>)
-SYMBOL(carg, None, <complex.h>)
-SYMBOL(cargf, None, <complex.h>)
-SYMBOL(cargl, None, <complex.h>)
-SYMBOL(casin, None, <complex.h>)
-SYMBOL(casinf, None, <complex.h>)
-SYMBOL(casinh, None, <complex.h>)
-SYMBOL(casinhf, None, <complex.h>)
-SYMBOL(casinhl, None, <complex.h>)
-SYMBOL(casinl, None, <complex.h>)
-SYMBOL(catan, None, <complex.h>)
-SYMBOL(catanf, None, <complex.h>)
-SYMBOL(catanh, None, <complex.h>)
-SYMBOL(catanhf, None, <complex.h>)
-SYMBOL(catanhl, None, <complex.h>)
-SYMBOL(catanl, None, <complex.h>)
-SYMBOL(cbrt, None, <math.h>)
-SYMBOL(cbrtf, None, <math.h>)
-SYMBOL(cbrtl, None, <math.h>)
-SYMBOL(ccos, None, <complex.h>)
-SYMBOL(ccosf, None, <complex.h>)
-SYMBOL(ccosh, None, <complex.h>)
-SYMBOL(ccoshf, None, <complex.h>)
-SYMBOL(ccoshl, None, <complex.h>)
-SYMBOL(ccosl, None, <complex.h>)
-SYMBOL(ceil, None, <math.h>)
-SYMBOL(ceilf, None, <math.h>)
-SYMBOL(ceill, None, <math.h>)
-SYMBOL(cexp, None, <complex.h>)
-SYMBOL(cexpf, None, <complex.h>)
-SYMBOL(cexpl, None, <complex.h>)
-SYMBOL(char16_t, None, <uchar.h>)
-SYMBOL(char32_t, None, <uchar.h>)
-SYMBOL(cimag, None, <complex.h>)
-SYMBOL(cimagf, None, <complex.h>)
-SYMBOL(cimagl, None, <complex.h>)
-SYMBOL(clearerr, None, <stdio.h>)
-SYMBOL(clock, None, <time.h>)
-SYMBOL(clock_t, None, <time.h>)
-SYMBOL(clog, None, <complex.h>)
-SYMBOL(clogf, None, <complex.h>)
-SYMBOL(clogl, None, <complex.h>)
-SYMBOL(cnd_broadcast, None, <threads.h>)
-SYMBOL(cnd_destroy, None, <threads.h>)
-SYMBOL(cnd_init, None, <threads.h>)
-SYMBOL(cnd_signal, None, <threads.h>)
-SYMBOL(cnd_t, None, <threads.h>)
-SYMBOL(cnd_timedwait, None, <threads.h>)
-SYMBOL(cnd_wait, None, <threads.h>)
-SYMBOL(compl, None, <iso646.h>)
-SYMBOL(complex, None, <complex.h>)
-SYMBOL(conj, None, <complex.h>)
-SYMBOL(conjf, None, <complex.h>)
-SYMBOL(conjl, None, <complex.h>)
-SYMBOL(constraint_handler_t, None, <stdlib.h>)
-SYMBOL(copysign, None, <math.h>)
-SYMBOL(copysignf, None, <math.h>)
-SYMBOL(copysignl, None, <math.h>)
-SYMBOL(cos, None, <math.h>)
-SYMBOL(cosf, None, <math.h>)
-SYMBOL(cosh, None, <math.h>)
-SYMBOL(coshf, None, <math.h>)
-SYMBOL(coshl, None, <math.h>)
-SYMBOL(cosl, None, <math.h>)
-SYMBOL(cpow, None, <complex.h>)
-SYMBOL(cpowf, None, <complex.h>)
-SYMBOL(cpowl, None, <complex.h>)
-SYMBOL(cproj, None, <complex.h>)
-SYMBOL(cprojf, None, <complex.h>)
-SYMBOL(cprojl, None, <complex.h>)
-SYMBOL(creal, None, <complex.h>)
-SYMBOL(crealf, None, <complex.h>)
-SYMBOL(creall, None, <complex.h>)
-SYMBOL(csin, None, <complex.h>)
-SYMBOL(csinf, None, <complex.h>)
-SYMBOL(csinh, None, <complex.h>)
-SYMBOL(csinhf, None, <complex.h>)
-SYMBOL(csinhl, None, <complex.h>)
-SYMBOL(csinl, None, <complex.h>)
-SYMBOL(csqrt, None, <complex.h>)
-SYMBOL(csqrtf, None, <complex.h>)
-SYMBOL(csqrtl, None, <complex.h>)
-SYMBOL(ctan, None, <complex.h>)
-SYMBOL(ctanf, None, <complex.h>)
-SYMBOL(ctanh, None, <complex.h>)
-SYMBOL(ctanhf, None, <complex.h>)
-SYMBOL(ctanhl, None, <complex.h>)
-SYMBOL(ctanl, None, <complex.h>)
-SYMBOL(ctime, None, <time.h>)
-SYMBOL(ctime_s, None, <time.h>)
-SYMBOL(difftime, None, <time.h>)
-SYMBOL(double_t, None, <math.h>)
-SYMBOL(erf, None, <math.h>)
-SYMBOL(erfc, None, <math.h>)
-SYMBOL(erfcf, None, <math.h>)
-SYMBOL(erfcl, None, <math.h>)
-SYMBOL(erff, None, <math.h>)
-SYMBOL(erfl, None, <math.h>)
-SYMBOL(errno, None, <errno.h>)
-SYMBOL(exit, None, <stdlib.h>)
-SYMBOL(exp, None, <math.h>)
-SYMBOL(exp2, None, <math.h>)
-SYMBOL(exp2f, None, <math.h>)
-SYMBOL(exp2l, None, <math.h>)
-SYMBOL(expf, None, <math.h>)
-SYMBOL(expl, None, <math.h>)
-SYMBOL(expm1, None, <math.h>)
-SYMBOL(expm1f, None, <math.h>)
-SYMBOL(expm1l, None, <math.h>)
-SYMBOL(fabs, None, <math.h>)
-SYMBOL(fabsf, None, <math.h>)
-SYMBOL(fabsl, None, <math.h>)
-SYMBOL(fclose, None, <stdio.h>)
-SYMBOL(fdim, None, <math.h>)
-SYMBOL(fdimf, None, <math.h>)
-SYMBOL(fdiml, None, <math.h>)
-SYMBOL(feclearexcept, None, <fenv.h>)
-SYMBOL(fegetenv, None, <fenv.h>)
-SYMBOL(fegetexceptflag, None, <fenv.h>)
-SYMBOL(fegetround, None, <fenv.h>)
-SYMBOL(feholdexcept, None, <fenv.h>)
-SYMBOL(fenv_t, None, <fenv.h>)
-SYMBOL(feof, None, <stdio.h>)
-SYMBOL(feraiseexcept, None, <fenv.h>)
-SYMBOL(ferror, None, <stdio.h>)
-SYMBOL(fesetenv, None, <fenv.h>)
-SYMBOL(fesetexceptflag, None, <fenv.h>)
-SYMBOL(fesetround, None, <fenv.h>)
-SYMBOL(fetestexcept, None, <fenv.h>)
-SYMBOL(feupdateenv, None, <fenv.h>)
-SYMBOL(fexcept_t, None, <fenv.h>)
-SYMBOL(fflush, None, <stdio.h>)
-SYMBOL(fgetc, None, <stdio.h>)
-SYMBOL(fgetpos, None, <stdio.h>)
-SYMBOL(fgets, None, <stdio.h>)
-SYMBOL(fgetwc, None, <wchar.h>)
-SYMBOL(fgetws, None, <wchar.h>)
-SYMBOL(float_t, None, <math.h>)
-SYMBOL(floor, None, <math.h>)
-SYMBOL(floorf, None, <math.h>)
-SYMBOL(floorl, None, <math.h>)
-SYMBOL(fma, None, <math.h>)
-SYMBOL(fmaf, None, <math.h>)
-SYMBOL(fmal, None, <math.h>)
-SYMBOL(fmax, None, <math.h>)
-SYMBOL(fmaxf, None, <math.h>)
-SYMBOL(fmaxl, None, <math.h>)
-SYMBOL(fmin, None, <math.h>)
-SYMBOL(fminf, None, <math.h>)
-SYMBOL(fminl, None, <math.h>)
-SYMBOL(fmod, None, <math.h>)
-SYMBOL(fmodf, None, <math.h>)
-SYMBOL(fmodl, None, <math.h>)
-SYMBOL(fopen, None, <stdio.h>)
-SYMBOL(fopen_s, None, <stdio.h>)
-SYMBOL(fpclassify, None, <math.h>)
-SYMBOL(fpos_t, None, <stdio.h>)
-SYMBOL(fprintf, None, <stdio.h>)
-SYMBOL(fprintf_s, None, <stdio.h>)
-SYMBOL(fputc, None, <stdio.h>)
-SYMBOL(fputs, None, <stdio.h>)
-SYMBOL(fputwc, None, <wchar.h>)
-SYMBOL(fputws, None, <wchar.h>)
-SYMBOL(fread, None, <stdio.h>)
-SYMBOL(free, None, <stdlib.h>)
-SYMBOL(freopen, None, <stdio.h>)
-SYMBOL(freopen_s, None, <stdio.h>)
-SYMBOL(frexp, None, <math.h>)
-SYMBOL(frexpf, None, <math.h>)
-SYMBOL(frexpl, None, <math.h>)
-SYMBOL(fscanf, None, <stdio.h>)
-SYMBOL(fscanf_s, None, <stdio.h>)
-SYMBOL(fseek, None, <stdio.h>)
-SYMBOL(fsetpos, None, <stdio.h>)
-SYMBOL(ftell, None, <stdio.h>)
-SYMBOL(fwide, None, <wchar.h>)
-SYMBOL(fwprintf, None, <wchar.h>)
-SYMBOL(fwprintf_s, None, <wchar.h>)
-SYMBOL(fwrite, None, <stdio.h>)
-SYMBOL(fwscanf, None, <wchar.h>)
-SYMBOL(fwscanf_s, None, <wchar.h>)
-SYMBOL(getc, None, <stdio.h>)
-SYMBOL(getchar, None, <stdio.h>)
-SYMBOL(getenv, None, <stdlib.h>)
-SYMBOL(getenv_s, None, <stdlib.h>)
-SYMBOL(gets, None, <stdio.h>)
-SYMBOL(gets_s, None, <stdio.h>)
-SYMBOL(getwc, None, <wchar.h>)
-SYMBOL(getwchar, None, <wchar.h>)
-SYMBOL(gmtime, None, <time.h>)
-SYMBOL(gmtime_s, None, <time.h>)
-SYMBOL(hypot, None, <math.h>)
-SYMBOL(hypotf, None, <math.h>)
-SYMBOL(hypotl, None, <math.h>)
-SYMBOL(ignore_handler_s, None, <stdlib.h>)
-SYMBOL(ilogb, None, <math.h>)
-SYMBOL(ilogbf, None, <math.h>)
-SYMBOL(ilogbl, None, <math.h>)
-SYMBOL(imaginary, None, <complex.h>)
-SYMBOL(imaxabs, None, <inttypes.h>)
-SYMBOL(int16_t, None, <stdint.h>)
-SYMBOL(int32_t, None, <stdint.h>)
-SYMBOL(int64_t, None, <stdint.h>)
-SYMBOL(int8_t, None, <stdint.h>)
-SYMBOL(int_fast16_t, None, <stdint.h>)
-SYMBOL(int_fast32_t, None, <stdint.h>)
-SYMBOL(int_fast64_t, None, <stdint.h>)
-SYMBOL(int_fast8_t, None, <stdint.h>)
-SYMBOL(int_least16_t, None, <stdint.h>)
-SYMBOL(int_least32_t, None, <stdint.h>)
-SYMBOL(int_least64_t, None, <stdint.h>)
-SYMBOL(int_least8_t, None, <stdint.h>)
-SYMBOL(intmax_t, None, <stdint.h>)
-SYMBOL(intptr_t, None, <stdint.h>)
-SYMBOL(isalnum, None, <ctype.h>)
-SYMBOL(isalpha, None, <ctype.h>)
-SYMBOL(isblank, None, <ctype.h>)
-SYMBOL(iscntrl, None, <ctype.h>)
-SYMBOL(isdigit, None, <ctype.h>)
-SYMBOL(isfinite, None, <math.h>)
-SYMBOL(isgraph, None, <ctype.h>)
-SYMBOL(isgreater, None, <math.h>)
-SYMBOL(isgreaterequal, None, <math.h>)
-SYMBOL(isinf, None, <math.h>)
-SYMBOL(isless, None, <math.h>)
-SYMBOL(islessequal, None, <math.h>)
-SYMBOL(islessgreater, None, <math.h>)
-SYMBOL(islower, None, <ctype.h>)
-SYMBOL(isnan, None, <math.h>)
-SYMBOL(isnormal, None, <math.h>)
-SYMBOL(isprint, None, <ctype.h>)
-SYMBOL(ispunct, None, <ctype.h>)
-SYMBOL(isspace, None, <ctype.h>)
-SYMBOL(isunordered, None, <math.h>)
-SYMBOL(isupper, None, <ctype.h>)
-SYMBOL(iswalnum, None, <wctype.h>)
-SYMBOL(iswalpha, None, <wctype.h>)
-SYMBOL(iswblank, None, <wctype.h>)
-SYMBOL(iswcntrl, None, <wctype.h>)
-SYMBOL(iswctype, None, <wctype.h>)
-SYMBOL(iswdigit, None, <wctype.h>)
-SYMBOL(iswgraph, None, <wctype.h>)
-SYMBOL(iswlower, None, <wctype.h>)
-SYMBOL(iswprint, None, <wctype.h>)
-SYMBOL(iswpunct, None, <wctype.h>)
-SYMBOL(iswspace, None, <wctype.h>)
-SYMBOL(iswupper, None, <wctype.h>)
-SYMBOL(iswxdigit, None, <wctype.h>)
-SYMBOL(isxdigit, None, <ctype.h>)
-SYMBOL(jmp_buf, None, <setjmp.h>)
-SYMBOL(kill_dependency, None, <stdatomic.h>)
-SYMBOL(labs, None, <stdlib.h>)
-SYMBOL(lconv, None, <locale.h>)
-SYMBOL(ldexp, None, <math.h>)
-SYMBOL(ldexpf, None, <math.h>)
-SYMBOL(ldexpl, None, <math.h>)
-SYMBOL(lgamma, None, <math.h>)
-SYMBOL(lgammaf, None, <math.h>)
-SYMBOL(lgammal, None, <math.h>)
-SYMBOL(llabs, None, <stdlib.h>)
-SYMBOL(llrint, None, <math.h>)
-SYMBOL(llrintf, None, <math.h>)
-SYMBOL(llrintl, None, <math.h>)
-SYMBOL(llround, None, <math.h>)
-SYMBOL(llroundf, None, <math.h>)
-SYMBOL(llroundl, None, <math.h>)
-SYMBOL(localeconv, None, <locale.h>)
-SYMBOL(localtime, None, <time.h>)
-SYMBOL(localtime_s, None, <time.h>)
-SYMBOL(log, None, <math.h>)
-SYMBOL(log10, None, <math.h>)
-SYMBOL(log10f, None, <math.h>)
-SYMBOL(log10l, None, <math.h>)
-SYMBOL(log1p, None, <math.h>)
-SYMBOL(log1pf, None, <math.h>)
-SYMBOL(log1pl, None, <math.h>)
-SYMBOL(log2, None, <math.h>)
-SYMBOL(log2f, None, <math.h>)
-SYMBOL(log2l, None, <math.h>)
-SYMBOL(logb, None, <math.h>)
-SYMBOL(logbf, None, <math.h>)
-SYMBOL(logbl, None, <math.h>)
-SYMBOL(logf, None, <math.h>)
-SYMBOL(logl, None, <math.h>)
-SYMBOL(longjmp, None, <setjmp.h>)
-SYMBOL(lrint, None, <math.h>)
-SYMBOL(lrintf, None, <math.h>)
-SYMBOL(lrintl, None, <math.h>)
-SYMBOL(lround, None, <math.h>)
-SYMBOL(lroundf, None, <math.h>)
-SYMBOL(lroundl, None, <math.h>)
-SYMBOL(malloc, None, <stdlib.h>)
-SYMBOL(math_errhandling, None, <math.h>)
-SYMBOL(max_align_t, None, <stddef.h>)
-SYMBOL(mblen, None, <stdlib.h>)
-SYMBOL(mbrlen, None, <wchar.h>)
-SYMBOL(mbrtoc16, None, <uchar.h>)
-SYMBOL(mbrtoc32, None, <uchar.h>)
-SYMBOL(mbrtowc, None, <wchar.h>)
-SYMBOL(mbsinit, None, <wchar.h>)
-SYMBOL(mbsrtowcs, None, <wchar.h>)
-SYMBOL(mbsrtowcs_s, None, <wchar.h>)
-SYMBOL(mbstowcs, None, <stdlib.h>)
-SYMBOL(mbstowcs_s, None, <stdlib.h>)
-SYMBOL(mbtowc, None, <stdlib.h>)
-SYMBOL(memchr, None, <string.h>)
-SYMBOL(memcmp, None, <string.h>)
-SYMBOL(memcpy, None, <string.h>)
-SYMBOL(memcpy_s, None, <string.h>)
-SYMBOL(memmove, None, <string.h>)
-SYMBOL(memmove_s, None, <string.h>)
-SYMBOL(memory_order, None, <stdatomic.h>)
-SYMBOL(memory_order_acq_rel, None, <stdatomic.h>)
-SYMBOL(memory_order_acquire, None, <stdatomic.h>)
-SYMBOL(memory_order_consume, None, <stdatomic.h>)
-SYMBOL(memory_order_relaxed, None, <stdatomic.h>)
-SYMBOL(memory_order_release, None, <stdatomic.h>)
-SYMBOL(memory_order_seq_cst, None, <stdatomic.h>)
-SYMBOL(memset, None, <string.h>)
-SYMBOL(memset_s, None, <string.h>)
-SYMBOL(mktime, None, <time.h>)
-SYMBOL(modf, None, <math.h>)
-SYMBOL(modff, None, <math.h>)
-SYMBOL(modfl, None, <math.h>)
-SYMBOL(mtx_destroy, None, <threads.h>)
-SYMBOL(mtx_init, None, <threads.h>)
-SYMBOL(mtx_lock, None, <threads.h>)
-SYMBOL(mtx_plain, None, <threads.h>)
-SYMBOL(mtx_recursive, None, <threads.h>)
-SYMBOL(mtx_t, None, <threads.h>)
-SYMBOL(mtx_timed, None, <threads.h>)
-SYMBOL(mtx_timedlock, None, <threads.h>)
-SYMBOL(mtx_trylock, None, <threads.h>)
-SYMBOL(mtx_unlock, None, <threads.h>)
-SYMBOL(nan, None, <math.h>)
-SYMBOL(nanf, None, <math.h>)
-SYMBOL(nanl, None, <math.h>)
-SYMBOL(nearbyint, None, <math.h>)
-SYMBOL(nearbyintf, None, <math.h>)
-SYMBOL(nearbyintl, None, <math.h>)
-SYMBOL(nextafter, None, <math.h>)
-SYMBOL(nextafterf, None, <math.h>)
-SYMBOL(nextafterl, None, <math.h>)
-SYMBOL(nexttoward, None, <math.h>)
-SYMBOL(nexttowardf, None, <math.h>)
-SYMBOL(nexttowardl, None, <math.h>)
-SYMBOL(noreturn, None, <stdnoreturn.h>)
-SYMBOL(not, None, <iso646.h>)
-SYMBOL(not_eq, None, <iso646.h>)
-SYMBOL(offsetof, None, <stddef.h>)
-SYMBOL(once_flag, None, <threads.h>)
-SYMBOL(or, None, <iso646.h>)
-SYMBOL(or_eq, None, <iso646.h>)
-SYMBOL(perror, None, <stdio.h>)
-SYMBOL(pow, None, <math.h>)
-SYMBOL(powf, None, <math.h>)
-SYMBOL(powl, None, <math.h>)
-SYMBOL(printf, None, <stdio.h>)
-SYMBOL(printf_s, None, <stdio.h>)
-SYMBOL(ptrdiff_t, None, <stddef.h>)
-SYMBOL(putc, None, <stdio.h>)
-SYMBOL(putchar, None, <stdio.h>)
-SYMBOL(puts, None, <stdio.h>)
-SYMBOL(putwc, None, <wchar.h>)
-SYMBOL(putwchar, None, <wchar.h>)
-SYMBOL(qsort, None, <stdlib.h>)
-SYMBOL(qsort_s, None, <stdlib.h>)
-SYMBOL(quick_exit, None, <stdlib.h>)
-SYMBOL(raise, None, <signal.h>)
-SYMBOL(rand, None, <stdlib.h>)
-SYMBOL(realloc, None, <stdlib.h>)
-SYMBOL(remainder, None, <math.h>)
-SYMBOL(remainderf, None, <math.h>)
-SYMBOL(remainderl, None, <math.h>)
-SYMBOL(remove, None, <stdio.h>)
-SYMBOL(remquo, None, <math.h>)
-SYMBOL(remquof, None, <math.h>)
-SYMBOL(remquol, None, <math.h>)
-SYMBOL(rename, None, <stdio.h>)
-SYMBOL(rewind, None, <stdio.h>)
-SYMBOL(rint, None, <math.h>)
-SYMBOL(rintf, None, <math.h>)
-SYMBOL(rintl, None, <math.h>)
-SYMBOL(round, None, <math.h>)
-SYMBOL(roundf, None, <math.h>)
-SYMBOL(roundl, None, <math.h>)
-SYMBOL(rsize_t, None, <stddef.h>)
-SYMBOL(scalbln, None, <math.h>)
-SYMBOL(scalblnf, None, <math.h>)
-SYMBOL(scalblnl, None, <math.h>)
-SYMBOL(scalbn, None, <math.h>)
-SYMBOL(scalbnf, None, <math.h>)
-SYMBOL(scalbnl, None, <math.h>)
-SYMBOL(scanf, None, <stdio.h>)
-SYMBOL(scanf_s, None, <stdio.h>)
-SYMBOL(set_constraint_handler_s, None, <stdlib.h>)
-SYMBOL(setbuf, None, <stdio.h>)
-SYMBOL(setjmp, None, <setjmp.h>)
-SYMBOL(setlocale, None, <locale.h>)
-SYMBOL(setvbuf, None, <stdio.h>)
-SYMBOL(sig_atomic_t, None, <signal.h>)
-SYMBOL(signal, None, <signal.h>)
-SYMBOL(signbit, None, <math.h>)
-SYMBOL(sin, None, <math.h>)
-SYMBOL(sinf, None, <math.h>)
-SYMBOL(sinh, None, <math.h>)
-SYMBOL(sinhf, None, <math.h>)
-SYMBOL(sinhl, None, <math.h>)
-SYMBOL(sinl, None, <math.h>)
-SYMBOL(snprintf, None, <stdio.h>)
-SYMBOL(snprintf_s, None, <stdio.h>)
-SYMBOL(snwprintf_s, None, <wchar.h>)
-SYMBOL(sprintf, None, <stdio.h>)
-SYMBOL(sprintf_s, None, <stdio.h>)
-SYMBOL(sqrt, None, <math.h>)
-SYMBOL(sqrtf, None, <math.h>)
-SYMBOL(sqrtl, None, <math.h>)
-SYMBOL(srand, None, <stdlib.h>)
-SYMBOL(sscanf, None, <stdio.h>)
-SYMBOL(sscanf_s, None, <stdio.h>)
-SYMBOL(static_assert, None, <assert.h>)
-SYMBOL(stderr, None, <stdio.h>)
-SYMBOL(stdin, None, <stdio.h>)
-SYMBOL(stdout, None, <stdio.h>)
-SYMBOL(strcat, None, <string.h>)
-SYMBOL(strcat_s, None, <string.h>)
-SYMBOL(strchr, None, <string.h>)
-SYMBOL(strcmp, None, <string.h>)
-SYMBOL(strcoll, None, <string.h>)
-SYMBOL(strcpy, None, <string.h>)
-SYMBOL(strcpy_s, None, <string.h>)
-SYMBOL(strcspn, None, <string.h>)
-SYMBOL(strerror, None, <string.h>)
-SYMBOL(strerror_s, None, <string.h>)
-SYMBOL(strerrorlen_s, None, <string.h>)
-SYMBOL(strftime, None, <time.h>)
-SYMBOL(strlen, None, <string.h>)
-SYMBOL(strncat, None, <string.h>)
-SYMBOL(strncat_s, None, <string.h>)
-SYMBOL(strncmp, None, <string.h>)
-SYMBOL(strncpy, None, <string.h>)
-SYMBOL(strncpy_s, None, <string.h>)
-SYMBOL(strnlen_s, None, <string.h>)
-SYMBOL(strpbrk, None, <string.h>)
-SYMBOL(strrchr, None, <string.h>)
-SYMBOL(strspn, None, <string.h>)
-SYMBOL(strstr, None, <string.h>)
-SYMBOL(strtod, None, <stdlib.h>)
-SYMBOL(strtof, None, <stdlib.h>)
-SYMBOL(strtoimax, None, <inttypes.h>)
-SYMBOL(strtok, None, <string.h>)
-SYMBOL(strtok_s, None, <string.h>)
-SYMBOL(strtol, None, <stdlib.h>)
-SYMBOL(strtold, None, <stdlib.h>)
-SYMBOL(strtoll, None, <stdlib.h>)
-SYMBOL(strtoul, None, <stdlib.h>)
-SYMBOL(strtoull, None, <stdlib.h>)
-SYMBOL(strtoumax, None, <inttypes.h>)
-SYMBOL(strxfrm, None, <string.h>)
-SYMBOL(swprintf, None, <wchar.h>)
-SYMBOL(swprintf_s, None, <wchar.h>)
-SYMBOL(swscanf, None, <wchar.h>)
-SYMBOL(swscanf_s, None, <wchar.h>)
-SYMBOL(system, None, <stdlib.h>)
-SYMBOL(tan, None, <math.h>)
-SYMBOL(tanf, None, <math.h>)
-SYMBOL(tanh, None, <math.h>)
-SYMBOL(tanhf, None, <math.h>)
-SYMBOL(tanhl, None, <math.h>)
-SYMBOL(tanl, None, <math.h>)
-SYMBOL(tgamma, None, <math.h>)
-SYMBOL(tgammaf, None, <math.h>)
-SYMBOL(tgammal, None, <math.h>)
-SYMBOL(thrd_busy, None, <threads.h>)
-SYMBOL(thrd_create, None, <threads.h>)
-SYMBOL(thrd_current, None, <threads.h>)
-SYMBOL(thrd_detach, None, <threads.h>)
-SYMBOL(thrd_equal, None, <threads.h>)
-SYMBOL(thrd_error, None, <threads.h>)
-SYMBOL(thrd_join, None, <threads.h>)
-SYMBOL(thrd_nomem, None, <threads.h>)
-SYMBOL(thrd_sleep, None, <threads.h>)
-SYMBOL(thrd_start_t, None, <threads.h>)
-SYMBOL(thrd_success, None, <threads.h>)
-SYMBOL(thrd_t, None, <threads.h>)
-SYMBOL(thrd_timedout, None, <threads.h>)
-SYMBOL(thrd_yield, None, <threads.h>)
-SYMBOL(thread_local, None, <threads.h>)
-SYMBOL(time, None, <time.h>)
-SYMBOL(time_t, None, <time.h>)
-SYMBOL(timespec, None, <time.h>)
-SYMBOL(timespec_get, None, <time.h>)
-SYMBOL(tm, None, <time.h>)
-SYMBOL(tmpfile, None, <stdio.h>)
-SYMBOL(tmpfile_s, None, <stdio.h>)
-SYMBOL(tmpnam, None, <stdio.h>)
-SYMBOL(tmpnam_s, None, <stdio.h>)
-SYMBOL(tolower, None, <ctype.h>)
-SYMBOL(toupper, None, <ctype.h>)
-SYMBOL(towctrans, None, <wctype.h>)
-SYMBOL(towlower, None, <wctype.h>)
-SYMBOL(towupper, None, <wctype.h>)
-SYMBOL(trunc, None, <math.h>)
-SYMBOL(truncf, None, <math.h>)
-SYMBOL(truncl, None, <math.h>)
-SYMBOL(tss_create, None, <threads.h>)
-SYMBOL(tss_delete, None, <threads.h>)
-SYMBOL(tss_dtor_t, None, <threads.h>)
-SYMBOL(tss_get, None, <threads.h>)
-SYMBOL(tss_set, None, <threads.h>)
-SYMBOL(tss_t, None, <threads.h>)
-SYMBOL(uint16_t, None, <stdint.h>)
-SYMBOL(uint32_t, None, <stdint.h>)
-SYMBOL(uint64_t, None, <stdint.h>)
-SYMBOL(uint8_t, None, <stdint.h>)
-SYMBOL(uint_fast16_t, None, <stdint.h>)
-SYMBOL(uint_fast32_t, None, <stdint.h>)
-SYMBOL(uint_fast64_t, None, <stdint.h>)
-SYMBOL(uint_fast8_t, None, <stdint.h>)
-SYMBOL(uint_least16_t, None, <stdint.h>)
-SYMBOL(uint_least32_t, None, <stdint.h>)
-SYMBOL(uint_least64_t, None, <stdint.h>)
-SYMBOL(uint_least8_t, None, <stdint.h>)
-SYMBOL(uintmax_t, None, <stdint.h>)
-SYMBOL(uintptr_t, None, <stdint.h>)
-SYMBOL(ungetc, None, <stdio.h>)
-SYMBOL(ungetwc, None, <wchar.h>)
-SYMBOL(va_arg, None, <stdarg.h>)
-SYMBOL(va_copy, None, <stdarg.h>)
-SYMBOL(va_end, None, <stdarg.h>)
-SYMBOL(va_start, None, <stdarg.h>)
-SYMBOL(vfprintf, None, <stdio.h>)
-SYMBOL(vfprintf_s, None, <stdio.h>)
-SYMBOL(vfscanf, None, <stdio.h>)
-SYMBOL(vfscanf_s, None, <stdio.h>)
-SYMBOL(vfwprintf, None, <wchar.h>)
-SYMBOL(vfwprintf_s, None, <wchar.h>)
-SYMBOL(vfwscanf, None, <wchar.h>)
-SYMBOL(vfwscanf_s, None, <wchar.h>)
-SYMBOL(vprintf, None, <stdio.h>)
-SYMBOL(vprintf_s, None, <stdio.h>)
-SYMBOL(vscanf, None, <stdio.h>)
-SYMBOL(vscanf_s, None, <stdio.h>)
-SYMBOL(vsnprintf, None, <stdio.h>)
-SYMBOL(vsnprintf_s, None, <stdio.h>)
-SYMBOL(vsnwprintf_s, None, <wchar.h>)
-SYMBOL(vsprintf, None, <stdio.h>)
-SYMBOL(vsprintf_s, None, <stdio.h>)
-SYMBOL(vsscanf, None, <stdio.h>)
-SYMBOL(vsscanf_s, None, <stdio.h>)
-SYMBOL(vswprintf, None, <wchar.h>)
-SYMBOL(vswprintf_s, None, <wchar.h>)
-SYMBOL(vswscanf, None, <wchar.h>)
-SYMBOL(vswscanf_s, None, <wchar.h>)
-SYMBOL(vwprintf, None, <wchar.h>)
-SYMBOL(vwprintf_s, None, <wchar.h>)
-SYMBOL(vwscanf, None, <wchar.h>)
-SYMBOL(vwscanf_s, None, <wchar.h>)
-SYMBOL(wchar_t, None, <wchar.h>)
-SYMBOL(wcrtomb, None, <wchar.h>)
-SYMBOL(wcrtomb_s, None, <wchar.h>)
-SYMBOL(wcscat, None, <wchar.h>)
-SYMBOL(wcscat_s, None, <wchar.h>)
-SYMBOL(wcschr, None, <wchar.h>)
-SYMBOL(wcscmp, None, <wchar.h>)
-SYMBOL(wcscoll, None, <wchar.h>)
-SYMBOL(wcscpy, None, <wchar.h>)
-SYMBOL(wcscpy_s, None, <wchar.h>)
-SYMBOL(wcscspn, None, <wchar.h>)
-SYMBOL(wcsftime, None, <wchar.h>)
-SYMBOL(wcslen, None, <wchar.h>)
-SYMBOL(wcsncat, None, <wchar.h>)
-SYMBOL(wcsncat_s, None, <wchar.h>)
-SYMBOL(wcsncmp, None, <wchar.h>)
-SYMBOL(wcsncpy, None, <wchar.h>)
-SYMBOL(wcsncpy_s, None, <wchar.h>)
-SYMBOL(wcsnlen_s, None, <wchar.h>)
-SYMBOL(wcspbrk, None, <wchar.h>)
-SYMBOL(wcsrchr, None, <wchar.h>)
-SYMBOL(wcsrtombs, None, <wchar.h>)
-SYMBOL(wcsrtombs_s, None, <wchar.h>)
-SYMBOL(wcsspn, None, <wchar.h>)
-SYMBOL(wcsstr, None, <wchar.h>)
-SYMBOL(wcstod, None, <wchar.h>)
-SYMBOL(wcstof, None, <wchar.h>)
-SYMBOL(wcstoimax, None, <inttypes.h>)
-SYMBOL(wcstok, None, <wchar.h>)
-SYMBOL(wcstok_s, None, <wchar.h>)
-SYMBOL(wcstol, None, <wchar.h>)
-SYMBOL(wcstold, None, <wchar.h>)
-SYMBOL(wcstoll, None, <wchar.h>)
-SYMBOL(wcstombs, None, <stdlib.h>)
-SYMBOL(wcstombs_s, None, <stdlib.h>)
-SYMBOL(wcstoul, None, <wchar.h>)
-SYMBOL(wcstoull, None, <wchar.h>)
-SYMBOL(wcstoumax, None, <inttypes.h>)
-SYMBOL(wcsxfrm, None, <wchar.h>)
-SYMBOL(wctob, None, <wchar.h>)
-SYMBOL(wctomb, None, <stdlib.h>)
-SYMBOL(wctomb_s, None, <stdlib.h>)
-SYMBOL(wctrans, None, <wctype.h>)
-SYMBOL(wctrans_t, None, <wctype.h>)
-SYMBOL(wctype, None, <wctype.h>)
-SYMBOL(wctype_t, None, <wctype.h>)
-SYMBOL(wint_t, None, <wctype.h>)
-SYMBOL(wmemchr, None, <wchar.h>)
-SYMBOL(wmemcmp, None, <wchar.h>)
-SYMBOL(wmemcpy, None, <wchar.h>)
-SYMBOL(wmemcpy_s, None, <wchar.h>)
-SYMBOL(wmemmove, None, <wchar.h>)
-SYMBOL(wmemmove_s, None, <wchar.h>)
-SYMBOL(wmemset, None, <wchar.h>)
-SYMBOL(wprintf, None, <wchar.h>)
-SYMBOL(wprintf_s, None, <wchar.h>)
-SYMBOL(wscanf, None, <wchar.h>)
-SYMBOL(wscanf_s, None, <wchar.h>)
-SYMBOL(xor, None, <iso646.h>)
-SYMBOL(xor_eq, None, <iso646.h>)
+SYMBOL(ATOMIC_BOOL_LOCK_FREE, , <stdatomic.h>)
+SYMBOL(ATOMIC_CHAR16_T_LOCK_FREE, , <stdatomic.h>)
+SYMBOL(ATOMIC_CHAR32_T_LOCK_FREE, , <stdatomic.h>)
+SYMBOL(ATOMIC_CHAR_LOCK_FREE, , <stdatomic.h>)
+SYMBOL(ATOMIC_FLAG_INIT, , <stdatomic.h>)
+SYMBOL(ATOMIC_INT_LOCK_FREE, , <stdatomic.h>)
+SYMBOL(ATOMIC_LLONG_LOCK_FREE, , <stdatomic.h>)
+SYMBOL(ATOMIC_LONG_LOGK_FREE, , <stdatomic.h>)
+SYMBOL(ATOMIC_POINTER_LOCK_FREE, , <stdatomic.h>)
+SYMBOL(ATOMIC_SHORT_LOCK_FREE, , <stdatomic.h>)
+SYMBOL(ATOMIC_VAR_INIT, , <stdatomic.h>)
+SYMBOL(ATOMIC_WCHAR_T_LOCK_FREE, , <stdatomic.h>)
+SYMBOL(BUFSIZ, , <stdio.h>)
+SYMBOL(CHAR_BIT, , <limits.h>)
+SYMBOL(CHAR_MAX, , <limits.h>)
+SYMBOL(CHAR_MIN, , <limits.h>)
+SYMBOL(CLOCKS_PER_SEC, , <time.h>)
+SYMBOL(CMPLX, , <complex.h>)
+SYMBOL(CMPLXF, , <complex.h>)
+SYMBOL(CMPLXL, , <complex.h>)
+SYMBOL(DBL_DECIMAL_DIG, , <float.h>)
+SYMBOL(DBL_DIG, , <float.h>)
+SYMBOL(DBL_EPSILON, , <float.h>)
+SYMBOL(DBL_HAS_SUBNORM, , <float.h>)
+SYMBOL(DBL_MANT_DIG, , <float.h>)
+SYMBOL(DBL_MAX, , <float.h>)
+SYMBOL(DBL_MAX_10_EXP, , <float.h>)
+SYMBOL(DBL_MAX_EXP, , <float.h>)
+SYMBOL(DBL_MIN, , <float.h>)
+SYMBOL(DBL_MIN_10_EXP, , <float.h>)
+SYMBOL(DBL_MIN_EXP, , <float.h>)
+SYMBOL(DBL_TRUE_MIN, , <float.h>)
+SYMBOL(DECIMAL_DIG, , <float.h>)
+SYMBOL(EDOM, , <errno.h>)
+SYMBOL(EILSEQ, , <errno.h>)
+SYMBOL(EOF, , <stdio.h>)
+SYMBOL(ERANGE, , <errno.h>)
+SYMBOL(EXIT_FAILURE, , <stdlib.h>)
+SYMBOL(EXIT_SUCCESS, , <stdlib.h>)
+SYMBOL(FE_ALL_EXCEPT, , <fenv.h>)
+SYMBOL(FE_DFL_ENV, , <fenv.h>)
+SYMBOL(FE_DIVBYZERO, , <fenv.h>)
+SYMBOL(FE_DOWNWARD, , <fenv.h>)
+SYMBOL(FE_INEXACT, , <fenv.h>)
+SYMBOL(FE_INVALID, , <fenv.h>)
+SYMBOL(FE_OVERFLOW, , <fenv.h>)
+SYMBOL(FE_TONEAREST, , <fenv.h>)
+SYMBOL(FE_TOWARDZERO, , <fenv.h>)
+SYMBOL(FE_UNDERFLOW, , <fenv.h>)
+SYMBOL(FE_UPWARD, , <fenv.h>)
+SYMBOL(FILE, , <stdio.h>)
+SYMBOL(FILENAME_MAX, , <stdio.h>)
+SYMBOL(FLT_DECIMAL_DIG, , <float.h>)
+SYMBOL(FLT_DIG, , <float.h>)
+SYMBOL(FLT_EPSILON, , <float.h>)
+SYMBOL(FLT_EVAL_METHOD, , <float.h>)
+SYMBOL(FLT_HAS_SUBNORM, , <float.h>)
+SYMBOL(FLT_MANT_DIG, , <float.h>)
+SYMBOL(FLT_MAX, , <float.h>)
+SYMBOL(FLT_MAX_10_EXP, , <float.h>)
+SYMBOL(FLT_MAX_EXP, , <float.h>)
+SYMBOL(FLT_MIN, , <float.h>)
+SYMBOL(FLT_MIN_10_EXP, , <float.h>)
+SYMBOL(FLT_MIN_EXP, , <float.h>)
+SYMBOL(FLT_RADIX, , <float.h>)
+SYMBOL(FLT_ROUNDS, , <float.h>)
+SYMBOL(FLT_TRUE_MIN, , <float.h>)
+SYMBOL(FOPEN_MAX, , <stdio.h>)
+SYMBOL(FP_INFINITE, , <math.h>)
+SYMBOL(FP_NAN, , <math.h>)
+SYMBOL(FP_NORNAL, , <math.h>)
+SYMBOL(FP_SUBNORMAL, , <math.h>)
+SYMBOL(FP_ZERO, , <math.h>)
+SYMBOL(HUGE_VAL, , <math.h>)
+SYMBOL(HUGE_VALF, , <math.h>)
+SYMBOL(HUGE_VALL, , <math.h>)
+SYMBOL(I, , <complex.h>)
+SYMBOL(INFINITY, , <math.h>)
+SYMBOL(INT16_MAX, , <stdint.h>)
+SYMBOL(INT16_MIN, , <stdint.h>)
+SYMBOL(INT32_MAX, , <stdint.h>)
+SYMBOL(INT32_MIN, , <stdint.h>)
+SYMBOL(INT64_MAX, , <stdint.h>)
+SYMBOL(INT64_MIN, , <stdint.h>)
+SYMBOL(INT8_MAX, , <stdint.h>)
+SYMBOL(INT8_MIN, , <stdint.h>)
+SYMBOL(INTMAX_MAX, , <stdint.h>)
+SYMBOL(INTMAX_MIN, , <stdint.h>)
+SYMBOL(INTPTR_MAX, , <stdint.h>)
+SYMBOL(INTPTR_MIN, , <stdint.h>)
+SYMBOL(INT_FAST16_MAX, , <stdint.h>)
+SYMBOL(INT_FAST16_MIN, , <stdint.h>)
+SYMBOL(INT_FAST32_MAX, , <stdint.h>)
+SYMBOL(INT_FAST32_MIN, , <stdint.h>)
+SYMBOL(INT_FAST64_MAX, , <stdint.h>)
+SYMBOL(INT_FAST64_MIN, , <stdint.h>)
+SYMBOL(INT_FAST8_MAX, , <stdint.h>)
+SYMBOL(INT_FAST8_MIN, , <stdint.h>)
+SYMBOL(INT_LEAST16_MAX, , <stdint.h>)
+SYMBOL(INT_LEAST16_MIN, , <stdint.h>)
+SYMBOL(INT_LEAST32_MAX, , <stdint.h>)
+SYMBOL(INT_LEAST32_MIN, , <stdint.h>)
+SYMBOL(INT_LEAST64_MAX, , <stdint.h>)
+SYMBOL(INT_LEAST64_MIN, , <stdint.h>)
+SYMBOL(INT_LEAST8_MAX, , <stdint.h>)
+SYMBOL(INT_LEAST8_MIN, , <stdint.h>)
+SYMBOL(INT_MAX, , <limits.h>)
+SYMBOL(INT_MIN, , <limits.h>)
+SYMBOL(LC_ALL, , <locale.h>)
+SYMBOL(LC_COLLATE, , <locale.h>)
+SYMBOL(LC_CTYPE, , <locale.h>)
+SYMBOL(LC_MONETARY, , <locale.h>)
+SYMBOL(LC_NUMERIC, , <locale.h>)
+SYMBOL(LC_TIME, , <locale.h>)
+SYMBOL(LDBL_DECIMAL_DIG, , <float.h>)
+SYMBOL(LDBL_DIG, , <float.h>)
+SYMBOL(LDBL_EPSILON, , <float.h>)
+SYMBOL(LDBL_HAS_SUBNORM, , <float.h>)
+SYMBOL(LDBL_MANT_DIG, , <float.h>)
+SYMBOL(LDBL_MAX, , <float.h>)
+SYMBOL(LDBL_MAX_10_EXP, , <float.h>)
+SYMBOL(LDBL_MAX_EXP, , <float.h>)
+SYMBOL(LDBL_MIN, , <float.h>)
+SYMBOL(LDBL_MIN_10_EXP, , <float.h>)
+SYMBOL(LDBL_MIN_EXP, , <float.h>)
+SYMBOL(LDBL_TRUE_MIN, , <float.h>)
+SYMBOL(LLONG_MAX, , <limits.h>)
+SYMBOL(LLONG_MIN, , <limits.h>)
+SYMBOL(LONG_MAX, , <limits.h>)
+SYMBOL(LONG_MIN, , <limits.h>)
+SYMBOL(L_tmpnam, , <stdio.h>)
+SYMBOL(L_tmpnam_s, , <stdio.h>)
+SYMBOL(MATH_ERREXCEPT, , <math.h>)
+SYMBOL(MATH_ERRNO, , <math.h>)
+SYMBOL(MB_CUR_MAX, , <stdlib.h>)
+SYMBOL(MB_LEN_MAX, , <limits.h>)
+SYMBOL(NAN, , <math.h>)
+SYMBOL(ONCE_FLAG_INIT, , <threads.h>)
+SYMBOL(PTRDIFF_MAX, , <stdint.h>)
+SYMBOL(PTRDIFF_MIN, , <stdint.h>)
+SYMBOL(RAND_MAX, , <stdlib.h>)
+SYMBOL(RSIZE_MAX, , <stdint.h>)
+SYMBOL(SCHAR_MAX, , <limits.h>)
+SYMBOL(SCHAR_MIN, , <limits.h>)
+SYMBOL(SEEK_CUR, , <stdio.h>)
+SYMBOL(SEEK_END, , <stdio.h>)
+SYMBOL(SEEK_SET, , <stdio.h>)
+SYMBOL(SHRT_MAX, , <limits.h>)
+SYMBOL(SHRT_MIN, , <limits.h>)
+SYMBOL(SIGABRT, , <signal.h>)
+SYMBOL(SIGFPE, , <signal.h>)
+SYMBOL(SIGILL, , <signal.h>)
+SYMBOL(SIGINT, , <signal.h>)
+SYMBOL(SIGSEGV, , <signal.h>)
+SYMBOL(SIGTERM, , <signal.h>)
+SYMBOL(SIG_ATOMIC_MAX, , <stdint.h>)
+SYMBOL(SIG_ATOMIC_MIN, , <stdint.h>)
+SYMBOL(SIG_DFL, , <signal.h>)
+SYMBOL(SIG_ERR, , <signal.h>)
+SYMBOL(SIG_IGN, , <signal.h>)
+SYMBOL(SIZE_MAX, , <stdint.h>)
+SYMBOL(TIME_UTC, , <time.h>)
+SYMBOL(TMP_MAX, , <stdio.h>)
+SYMBOL(TMP_MAX_S, , <stdio.h>)
+SYMBOL(TSS_DTOR_ITERATIONS, , <threads.h>)
+SYMBOL(UCHAR_MAX, , <limits.h>)
+SYMBOL(UINT16_MAX, , <stdint.h>)
+SYMBOL(UINT32_MAX, , <stdint.h>)
+SYMBOL(UINT64_MAX, , <stdint.h>)
+SYMBOL(UINT8_MAX, , <stdint.h>)
+SYMBOL(UINTMAX_MAX, , <stdint.h>)
+SYMBOL(UINTPTR_MAX, , <stdint.h>)
+SYMBOL(UINT_FAST16_MAX, , <stdint.h>)
+SYMBOL(UINT_FAST32_MAX, , <stdint.h>)
+SYMBOL(UINT_FAST64_MAX, , <stdint.h>)
+SYMBOL(UINT_FAST8_MAX, , <stdint.h>)
+SYMBOL(UINT_LEAST16_MAX, , <stdint.h>)
+SYMBOL(UINT_LEAST32_MAX, , <stdint.h>)
+SYMBOL(UINT_LEAST64_MAX, , <stdint.h>)
+SYMBOL(UINT_LEAST8_MAX, , <stdint.h>)
+SYMBOL(UINT_MAX, , <limits.h>)
+SYMBOL(ULLONG_MAX, , <limits.h>)
+SYMBOL(ULONG_MAX, , <limits.h>)
+SYMBOL(USHRT_MAX, , <limits.h>)
+SYMBOL(WCHAR_MAX, , <wchar.h>)
+SYMBOL(WCHAR_MIN, , <wchar.h>)
+SYMBOL(WEOF, , <wchar.h>)
+SYMBOL(WINT_MAX, , <stdint.h>)
+SYMBOL(WINT_MIN, , <stdint.h>)
+SYMBOL(_Complex_I, , <complex.h>)
+SYMBOL(_IOFBF, , <stdio.h>)
+SYMBOL(_IOLBF, , <stdio.h>)
+SYMBOL(_IONBF, , <stdio.h>)
+SYMBOL(_Imaginary_I, , <complex.h>)
+SYMBOL(__alignas_is_defined, , <stdalign.h>)
+SYMBOL(__alignof_is_defined, , <stdalign.h>)
+SYMBOL(abort_handler_s, , <stdlib.h>)
+SYMBOL(abs, , <stdlib.h>)
+SYMBOL(acos, , <math.h>)
+SYMBOL(acosf, , <math.h>)
+SYMBOL(acosh, , <math.h>)
+SYMBOL(acoshf, , <math.h>)
+SYMBOL(acoshl, , <math.h>)
+SYMBOL(acosl, , <math.h>)
+SYMBOL(alignas, , <stdalign.h>)
+SYMBOL(aligned_alloc, , <stdlib.h>)
+SYMBOL(alignof, , <stdalign.h>)
+SYMBOL(and, , <iso646.h>)
+SYMBOL(and_eq, , <iso646.h>)
+SYMBOL(asctime, , <time.h>)
+SYMBOL(asctime_s, , <time.h>)
+SYMBOL(asin, , <math.h>)
+SYMBOL(asinf, , <math.h>)
+SYMBOL(asinh, , <math.h>)
+SYMBOL(asinhf, , <math.h>)
+SYMBOL(asinhl, , <math.h>)
+SYMBOL(asinl, , <math.h>)
+SYMBOL(assert, , <assert.h>)
+SYMBOL(at_quick_exit, , <stdlib.h>)
+SYMBOL(atan, , <math.h>)
+SYMBOL(atan2, , <math.h>)
+SYMBOL(atan2f, , <math.h>)
+SYMBOL(atan2l, , <math.h>)
+SYMBOL(atanf, , <math.h>)
+SYMBOL(atanh, , <math.h>)
+SYMBOL(atanhf, , <math.h>)
+SYMBOL(atanhl, , <math.h>)
+SYMBOL(atanl, , <math.h>)
+SYMBOL(atexit, , <stdlib.h>)
+SYMBOL(atof, , <stdlib.h>)
+SYMBOL(atoi, , <stdlib.h>)
+SYMBOL(atol, , <stdlib.h>)
+SYMBOL(atoll, , <stdlib.h>)
+SYMBOL(atomic_bool, , <stdatomic.h>)
+SYMBOL(atomic_char, , <stdatomic.h>)
+SYMBOL(atomic_char16_t, , <stdatomic.h>)
+SYMBOL(atomic_char32_t, , <stdatomic.h>)
+SYMBOL(atomic_compare_exchange_strong, , <stdatomic.h>)
+SYMBOL(atomic_compare_exchange_strong_explicit, , <stdatomic.h>)
+SYMBOL(atomic_compare_exchange_weak, , <stdatomic.h>)
+SYMBOL(atomic_compare_exchange_weak_explicit, , <stdatomic.h>)
+SYMBOL(atomic_exchange, , <stdatomic.h>)
+SYMBOL(atomic_exchange_explicit, , <stdatomic.h>)
+SYMBOL(atomic_fetch_add, , <stdatomic.h>)
+SYMBOL(atomic_fetch_add_explicit, , <stdatomic.h>)
+SYMBOL(atomic_fetch_and, , <stdatomic.h>)
+SYMBOL(atomic_fetch_and_explicit, , <stdatomic.h>)
+SYMBOL(atomic_fetch_or, , <stdatomic.h>)
+SYMBOL(atomic_fetch_or_explicit, , <stdatomic.h>)
+SYMBOL(atomic_fetch_sub, , <stdatomic.h>)
+SYMBOL(atomic_fetch_sub_explicit, , <stdatomic.h>)
+SYMBOL(atomic_fetch_xor, , <stdatomic.h>)
+SYMBOL(atomic_fetch_xor_explicit, , <stdatomic.h>)
+SYMBOL(atomic_flag, , <stdatomic.h>)
+SYMBOL(atomic_flag_clear, , <stdatomic.h>)
+SYMBOL(atomic_flag_clear_explicit, , <stdatomic.h>)
+SYMBOL(atomic_flag_test_and_set, , <stdatomic.h>)
+SYMBOL(atomic_flag_test_and_set_explicit, , <stdatomic.h>)
+SYMBOL(atomic_init, , <stdatomic.h>)
+SYMBOL(atomic_int, , <stdatomic.h>)
+SYMBOL(atomic_int_fast16_t, , <stdatomic.h>)
+SYMBOL(atomic_int_fast32_t, , <stdatomic.h>)
+SYMBOL(atomic_int_fast64_t, , <stdatomic.h>)
+SYMBOL(atomic_int_fast8_t, , <stdatomic.h>)
+SYMBOL(atomic_int_least16_t, , <stdatomic.h>)
+SYMBOL(atomic_int_least32_t, , <stdatomic.h>)
+SYMBOL(atomic_int_least64_t, , <stdatomic.h>)
+SYMBOL(atomic_int_least8_t, , <stdatomic.h>)
+SYMBOL(atomic_intmax_t, , <stdatomic.h>)
+SYMBOL(atomic_intptr_t, , <stdatomic.h>)
+SYMBOL(atomic_is_lock_free, , <stdatomic.h>)
+SYMBOL(atomic_llong, , <stdatomic.h>)
+SYMBOL(atomic_load, , <stdatomic.h>)
+SYMBOL(atomic_load_explicit, , <stdatomic.h>)
+SYMBOL(atomic_long, , <stdatomic.h>)
+SYMBOL(atomic_ptrdiff_t, , <stdatomic.h>)
+SYMBOL(atomic_schar, , <stdatomic.h>)
+SYMBOL(atomic_short, , <stdatomic.h>)
+SYMBOL(atomic_signal_fence, , <stdatomic.h>)
+SYMBOL(atomic_size_t, , <stdatomic.h>)
+SYMBOL(atomic_store, , <stdatomic.h>)
+SYMBOL(atomic_store_explicit, , <stdatomic.h>)
+SYMBOL(atomic_thread_fence, , <stdatomic.h>)
+SYMBOL(atomic_uchar, , <stdatomic.h>)
+SYMBOL(atomic_uint, , <stdatomic.h>)
+SYMBOL(atomic_uint_fast16_t, , <stdatomic.h>)
+SYMBOL(atomic_uint_fast32_t, , <stdatomic.h>)
+SYMBOL(atomic_uint_fast64_t, , <stdatomic.h>)
+SYMBOL(atomic_uint_fast8_t, , <stdatomic.h>)
+SYMBOL(atomic_uint_least16_t, , <stdatomic.h>)
+SYMBOL(atomic_uint_least32_t, , <stdatomic.h>)
+SYMBOL(atomic_uint_least64_t, , <stdatomic.h>)
+SYMBOL(atomic_uint_least8_t, , <stdatomic.h>)
+SYMBOL(atomic_uintmax_t, , <stdatomic.h>)
+SYMBOL(atomic_uintptr_t, , <stdatomic.h>)
+SYMBOL(atomic_ullong, , <stdatomic.h>)
+SYMBOL(atomic_ulong, , <stdatomic.h>)
+SYMBOL(atomic_ushort, , <stdatomic.h>)
+SYMBOL(atomic_wchar_t, , <stdatomic.h>)
+SYMBOL(bitand, , <iso646.h>)
+SYMBOL(bitor, , <iso646.h>)
+SYMBOL(bsearch, , <stdlib.h>)
+SYMBOL(bsearch_s, , <stdlib.h>)
+SYMBOL(btowc, , <wchar.h>)
+SYMBOL(c16rtomb, , <uchar.h>)
+SYMBOL(c32rtomb, , <uchar.h>)
+SYMBOL(cabs, , <complex.h>)
+SYMBOL(cabsf, , <complex.h>)
+SYMBOL(cabsl, , <complex.h>)
+SYMBOL(cacos, , <complex.h>)
+SYMBOL(cacosf, , <complex.h>)
+SYMBOL(cacosh, , <complex.h>)
+SYMBOL(cacoshf, , <complex.h>)
+SYMBOL(cacoshl, , <complex.h>)
+SYMBOL(cacosl, , <complex.h>)
+SYMBOL(call_once, , <threads.h>)
+SYMBOL(calloc, , <stdlib.h>)
+SYMBOL(carg, , <complex.h>)
+SYMBOL(cargf, , <complex.h>)
+SYMBOL(cargl, , <complex.h>)
+SYMBOL(casin, , <complex.h>)
+SYMBOL(casinf, , <complex.h>)
+SYMBOL(casinh, , <complex.h>)
+SYMBOL(casinhf, , <complex.h>)
+SYMBOL(casinhl, , <complex.h>)
+SYMBOL(casinl, , <complex.h>)
+SYMBOL(catan, , <complex.h>)
+SYMBOL(catanf, , <complex.h>)
+SYMBOL(catanh, , <complex.h>)
+SYMBOL(catanhf, , <complex.h>)
+SYMBOL(catanhl, , <complex.h>)
+SYMBOL(catanl, , <complex.h>)
+SYMBOL(cbrt, , <math.h>)
+SYMBOL(cbrtf, , <math.h>)
+SYMBOL(cbrtl, , <math.h>)
+SYMBOL(ccos, , <complex.h>)
+SYMBOL(ccosf, , <complex.h>)
+SYMBOL(ccosh, , <complex.h>)
+SYMBOL(ccoshf, , <complex.h>)
+SYMBOL(ccoshl, , <complex.h>)
+SYMBOL(ccosl, , <complex.h>)
+SYMBOL(ceil, , <math.h>)
+SYMBOL(ceilf, , <math.h>)
+SYMBOL(ceill, , <math.h>)
+SYMBOL(cexp, , <complex.h>)
+SYMBOL(cexpf, , <complex.h>)
+SYMBOL(cexpl, , <complex.h>)
+SYMBOL(char16_t, , <uchar.h>)
+SYMBOL(char32_t, , <uchar.h>)
+SYMBOL(cimag, , <complex.h>)
+SYMBOL(cimagf, , <complex.h>)
+SYMBOL(cimagl, , <complex.h>)
+SYMBOL(clearerr, , <stdio.h>)
+SYMBOL(clock, , <time.h>)
+SYMBOL(clock_t, , <time.h>)
+SYMBOL(clog, , <complex.h>)
+SYMBOL(clogf, , <complex.h>)
+SYMBOL(clogl, , <complex.h>)
+SYMBOL(cnd_broadcast, , <threads.h>)
+SYMBOL(cnd_destroy, , <threads.h>)
+SYMBOL(cnd_init, , <threads.h>)
+SYMBOL(cnd_signal, , <threads.h>)
+SYMBOL(cnd_t, , <threads.h>)
+SYMBOL(cnd_timedwait, , <threads.h>)
+SYMBOL(cnd_wait, , <threads.h>)
+SYMBOL(compl, , <iso646.h>)
+SYMBOL(complex, , <complex.h>)
+SYMBOL(conj, , <complex.h>)
+SYMBOL(conjf, , <complex.h>)
+SYMBOL(conjl, , <complex.h>)
+SYMBOL(constraint_handler_t, , <stdlib.h>)
+SYMBOL(copysign, , <math.h>)
+SYMBOL(copysignf, , <math.h>)
+SYMBOL(copysignl, , <math.h>)
+SYMBOL(cos, , <math.h>)
+SYMBOL(cosf, , <math.h>)
+SYMBOL(cosh, , <math.h>)
+SYMBOL(coshf, , <math.h>)
+SYMBOL(coshl, , <math.h>)
+SYMBOL(cosl, , <math.h>)
+SYMBOL(cpow, , <complex.h>)
+SYMBOL(cpowf, , <complex.h>)
+SYMBOL(cpowl, , <complex.h>)
+SYMBOL(cproj, , <complex.h>)
+SYMBOL(cprojf, , <complex.h>)
+SYMBOL(cprojl, , <complex.h>)
+SYMBOL(creal, , <complex.h>)
+SYMBOL(crealf, , <complex.h>)
+SYMBOL(creall, , <complex.h>)
+SYMBOL(csin, , <complex.h>)
+SYMBOL(csinf, , <complex.h>)
+SYMBOL(csinh, , <complex.h>)
+SYMBOL(csinhf, , <complex.h>)
+SYMBOL(csinhl, , <complex.h>)
+SYMBOL(csinl, , <complex.h>)
+SYMBOL(csqrt, , <complex.h>)
+SYMBOL(csqrtf, , <complex.h>)
+SYMBOL(csqrtl, , <complex.h>)
+SYMBOL(ctan, , <complex.h>)
+SYMBOL(ctanf, , <complex.h>)
+SYMBOL(ctanh, , <complex.h>)
+SYMBOL(ctanhf, , <complex.h>)
+SYMBOL(ctanhl, , <complex.h>)
+SYMBOL(ctanl, , <complex.h>)
+SYMBOL(ctime, , <time.h>)
+SYMBOL(ctime_s, , <time.h>)
+SYMBOL(difftime, , <time.h>)
+SYMBOL(double_t, , <math.h>)
+SYMBOL(erf, , <math.h>)
+SYMBOL(erfc, , <math.h>)
+SYMBOL(erfcf, , <math.h>)
+SYMBOL(erfcl, , <math.h>)
+SYMBOL(erff, , <math.h>)
+SYMBOL(erfl, , <math.h>)
+SYMBOL(errno, , <errno.h>)
+SYMBOL(exit, , <stdlib.h>)
+SYMBOL(exp, , <math.h>)
+SYMBOL(exp2, , <math.h>)
+SYMBOL(exp2f, , <math.h>)
+SYMBOL(exp2l, , <math.h>)
+SYMBOL(expf, , <math.h>)
+SYMBOL(expl, , <math.h>)
+SYMBOL(expm1, , <math.h>)
+SYMBOL(expm1f, , <math.h>)
+SYMBOL(expm1l, , <math.h>)
+SYMBOL(fabs, , <math.h>)
+SYMBOL(fabsf, , <math.h>)
+SYMBOL(fabsl, , <math.h>)
+SYMBOL(fclose, , <stdio.h>)
+SYMBOL(fdim, , <math.h>)
+SYMBOL(fdimf, , <math.h>)
+SYMBOL(fdiml, , <math.h>)
+SYMBOL(feclearexcept, , <fenv.h>)
+SYMBOL(fegetenv, , <fenv.h>)
+SYMBOL(fegetexceptflag, , <fenv.h>)
+SYMBOL(fegetround, , <fenv.h>)
+SYMBOL(feholdexcept, , <fenv.h>)
+SYMBOL(fenv_t, , <fenv.h>)
+SYMBOL(feof, , <stdio.h>)
+SYMBOL(feraiseexcept, , <fenv.h>)
+SYMBOL(ferror, , <stdio.h>)
+SYMBOL(fesetenv, , <fenv.h>)
+SYMBOL(fesetexceptflag, , <fenv.h>)
+SYMBOL(fesetround, , <fenv.h>)
+SYMBOL(fetestexcept, , <fenv.h>)
+SYMBOL(feupdateenv, , <fenv.h>)
+SYMBOL(fexcept_t, , <fenv.h>)
+SYMBOL(fflush, , <stdio.h>)
+SYMBOL(fgetc, , <stdio.h>)
+SYMBOL(fgetpos, , <stdio.h>)
+SYMBOL(fgets, , <stdio.h>)
+SYMBOL(fgetwc, , <wchar.h>)
+SYMBOL(fgetws, , <wchar.h>)
+SYMBOL(float_t, , <math.h>)
+SYMBOL(floor, , <math.h>)
+SYMBOL(floorf, , <math.h>)
+SYMBOL(floorl, , <math.h>)
+SYMBOL(fma, , <math.h>)
+SYMBOL(fmaf, , <math.h>)
+SYMBOL(fmal, , <math.h>)
+SYMBOL(fmax, , <math.h>)
+SYMBOL(fmaxf, , <math.h>)
+SYMBOL(fmaxl, , <math.h>)
+SYMBOL(fmin, , <math.h>)
+SYMBOL(fminf, , <math.h>)
+SYMBOL(fminl, , <math.h>)
+SYMBOL(fmod, , <math.h>)
+SYMBOL(fmodf, , <math.h>)
+SYMBOL(fmodl, , <math.h>)
+SYMBOL(fopen, , <stdio.h>)
+SYMBOL(fopen_s, , <stdio.h>)
+SYMBOL(fpclassify, , <math.h>)
+SYMBOL(fpos_t, , <stdio.h>)
+SYMBOL(fprintf, , <stdio.h>)
+SYMBOL(fprintf_s, , <stdio.h>)
+SYMBOL(fputc, , <stdio.h>)
+SYMBOL(fputs, , <stdio.h>)
+SYMBOL(fputwc, , <wchar.h>)
+SYMBOL(fputws, , <wchar.h>)
+SYMBOL(fread, , <stdio.h>)
+SYMBOL(free, , <stdlib.h>)
+SYMBOL(freopen, , <stdio.h>)
+SYMBOL(freopen_s, , <stdio.h>)
+SYMBOL(frexp, , <math.h>)
+SYMBOL(frexpf, , <math.h>)
+SYMBOL(frexpl, , <math.h>)
+SYMBOL(fscanf, , <stdio.h>)
+SYMBOL(fscanf_s, , <stdio.h>)
+SYMBOL(fseek, , <stdio.h>)
+SYMBOL(fsetpos, , <stdio.h>)
+SYMBOL(ftell, , <stdio.h>)
+SYMBOL(fwide, , <wchar.h>)
+SYMBOL(fwprintf, , <wchar.h>)
+SYMBOL(fwprintf_s, , <wchar.h>)
+SYMBOL(fwrite, , <stdio.h>)
+SYMBOL(fwscanf, , <wchar.h>)
+SYMBOL(fwscanf_s, , <wchar.h>)
+SYMBOL(getc, , <stdio.h>)
+SYMBOL(getchar, , <stdio.h>)
+SYMBOL(getenv, , <stdlib.h>)
+SYMBOL(getenv_s, , <stdlib.h>)
+SYMBOL(gets, , <stdio.h>)
+SYMBOL(gets_s, , <stdio.h>)
+SYMBOL(getwc, , <wchar.h>)
+SYMBOL(getwchar, , <wchar.h>)
+SYMBOL(gmtime, , <time.h>)
+SYMBOL(gmtime_s, , <time.h>)
+SYMBOL(hypot, , <math.h>)
+SYMBOL(hypotf, , <math.h>)
+SYMBOL(hypotl, , <math.h>)
+SYMBOL(ignore_handler_s, , <stdlib.h>)
+SYMBOL(ilogb, , <math.h>)
+SYMBOL(ilogbf, , <math.h>)
+SYMBOL(ilogbl, , <math.h>)
+SYMBOL(imaginary, , <complex.h>)
+SYMBOL(imaxabs, , <inttypes.h>)
+SYMBOL(int16_t, , <stdint.h>)
+SYMBOL(int32_t, , <stdint.h>)
+SYMBOL(int64_t, , <stdint.h>)
+SYMBOL(int8_t, , <stdint.h>)
+SYMBOL(int_fast16_t, , <stdint.h>)
+SYMBOL(int_fast32_t, , <stdint.h>)
+SYMBOL(int_fast64_t, , <stdint.h>)
+SYMBOL(int_fast8_t, , <stdint.h>)
+SYMBOL(int_least16_t, , <stdint.h>)
+SYMBOL(int_least32_t, , <stdint.h>)
+SYMBOL(int_least64_t, , <stdint.h>)
+SYMBOL(int_least8_t, , <stdint.h>)
+SYMBOL(intmax_t, , <stdint.h>)
+SYMBOL(intptr_t, , <stdint.h>)
+SYMBOL(isalnum, , <ctype.h>)
+SYMBOL(isalpha, , <ctype.h>)
+SYMBOL(isblank, , <ctype.h>)
+SYMBOL(iscntrl, , <ctype.h>)
+SYMBOL(isdigit, , <ctype.h>)
+SYMBOL(isfinite, , <math.h>)
+SYMBOL(isgraph, , <ctype.h>)
+SYMBOL(isgreater, , <math.h>)
+SYMBOL(isgreaterequal, , <math.h>)
+SYMBOL(isinf, , <math.h>)
+SYMBOL(isless, , <math.h>)
+SYMBOL(islessequal, , <math.h>)
+SYMBOL(islessgreater, , <math.h>)
+SYMBOL(islower, , <ctype.h>)
+SYMBOL(isnan, , <math.h>)
+SYMBOL(isnormal, , <math.h>)
+SYMBOL(isprint, , <ctype.h>)
+SYMBOL(ispunct, , <ctype.h>)
+SYMBOL(isspace, , <ctype.h>)
+SYMBOL(isunordered, , <math.h>)
+SYMBOL(isupper, , <ctype.h>)
+SYMBOL(iswalnum, , <wctype.h>)
+SYMBOL(iswalpha, , <wctype.h>)
+SYMBOL(iswblank, , <wctype.h>)
+SYMBOL(iswcntrl, , <wctype.h>)
+SYMBOL(iswctype, , <wctype.h>)
+SYMBOL(iswdigit, , <wctype.h>)
+SYMBOL(iswgraph, , <wctype.h>)
+SYMBOL(iswlower, , <wctype.h>)
+SYMBOL(iswprint, , <wctype.h>)
+SYMBOL(iswpunct, , <wctype.h>)
+SYMBOL(iswspace, , <wctype.h>)
+SYMBOL(iswupper, , <wctype.h>)
+SYMBOL(iswxdigit, , <wctype.h>)
+SYMBOL(isxdigit, , <ctype.h>)
+SYMBOL(jmp_buf, , <setjmp.h>)
+SYMBOL(kill_dependency, , <stdatomic.h>)
+SYMBOL(labs, , <stdlib.h>)
+SYMBOL(lconv, , <locale.h>)
+SYMBOL(ldexp, , <math.h>)
+SYMBOL(ldexpf, , <math.h>)
+SYMBOL(ldexpl, , <math.h>)
+SYMBOL(lgamma, , <math.h>)
+SYMBOL(lgammaf, , <math.h>)
+SYMBOL(lgammal, , <math.h>)
+SYMBOL(llabs, , <stdlib.h>)
+SYMBOL(llrint, , <math.h>)
+SYMBOL(llrintf, , <math.h>)
+SYMBOL(llrintl, , <math.h>)
+SYMBOL(llround, , <math.h>)
+SYMBOL(llroundf, , <math.h>)
+SYMBOL(llroundl, , <math.h>)
+SYMBOL(localeconv, , <locale.h>)
+SYMBOL(localtime, , <time.h>)
+SYMBOL(localtime_s, , <time.h>)
+SYMBOL(log, , <math.h>)
+SYMBOL(log10, , <math.h>)
+SYMBOL(log10f, , <math.h>)
+SYMBOL(log10l, , <math.h>)
+SYMBOL(log1p, , <math.h>)
+SYMBOL(log1pf, , <math.h>)
+SYMBOL(log1pl, , <math.h>)
+SYMBOL(log2, , <math.h>)
+SYMBOL(log2f, , <math.h>)
+SYMBOL(log2l, , <math.h>)
+SYMBOL(logb, , <math.h>)
+SYMBOL(logbf, , <math.h>)
+SYMBOL(logbl, , <math.h>)
+SYMBOL(logf, , <math.h>)
+SYMBOL(logl, , <math.h>)
+SYMBOL(longjmp, , <setjmp.h>)
+SYMBOL(lrint, , <math.h>)
+SYMBOL(lrintf, , <math.h>)
+SYMBOL(lrintl, , <math.h>)
+SYMBOL(lround, , <math.h>)
+SYMBOL(lroundf, , <math.h>)
+SYMBOL(lroundl, , <math.h>)
+SYMBOL(malloc, , <stdlib.h>)
+SYMBOL(math_errhandling, , <math.h>)
+SYMBOL(max_align_t, , <stddef.h>)
+SYMBOL(mblen, , <stdlib.h>)
+SYMBOL(mbrlen, , <wchar.h>)
+SYMBOL(mbrtoc16, , <uchar.h>)
+SYMBOL(mbrtoc32, , <uchar.h>)
+SYMBOL(mbrtowc, , <wchar.h>)
+SYMBOL(mbsinit, , <wchar.h>)
+SYMBOL(mbsrtowcs, , <wchar.h>)
+SYMBOL(mbsrtowcs_s, , <wchar.h>)
+SYMBOL(mbstowcs, , <stdlib.h>)
+SYMBOL(mbstowcs_s, , <stdlib.h>)
+SYMBOL(mbtowc, , <stdlib.h>)
+SYMBOL(memchr, , <string.h>)
+SYMBOL(memcmp, , <string.h>)
+SYMBOL(memcpy, , <string.h>)
+SYMBOL(memcpy_s, , <string.h>)
+SYMBOL(memmove, , <string.h>)
+SYMBOL(memmove_s, , <string.h>)
+SYMBOL(memory_order, , <stdatomic.h>)
+SYMBOL(memory_order_acq_rel, , <stdatomic.h>)
+SYMBOL(memory_order_acquire, , <stdatomic.h>)
+SYMBOL(memory_order_consume, , <stdatomic.h>)
+SYMBOL(memory_order_relaxed, , <stdatomic.h>)
+SYMBOL(memory_order_release, , <stdatomic.h>)
+SYMBOL(memory_order_seq_cst, , <stdatomic.h>)
+SYMBOL(memset, , <string.h>)
+SYMBOL(memset_s, , <string.h>)
+SYMBOL(mktime, , <time.h>)
+SYMBOL(modf, , <math.h>)
+SYMBOL(modff, , <math.h>)
+SYMBOL(modfl, , <math.h>)
+SYMBOL(mtx_destroy, , <threads.h>)
+SYMBOL(mtx_init, , <threads.h>)
+SYMBOL(mtx_lock, , <threads.h>)
+SYMBOL(mtx_plain, , <threads.h>)
+SYMBOL(mtx_recursive, , <threads.h>)
+SYMBOL(mtx_t, , <threads.h>)
+SYMBOL(mtx_timed, , <threads.h>)
+SYMBOL(mtx_timedlock, , <threads.h>)
+SYMBOL(mtx_trylock, , <threads.h>)
+SYMBOL(mtx_unlock, , <threads.h>)
+SYMBOL(nan, , <math.h>)
+SYMBOL(nanf, , <math.h>)
+SYMBOL(nanl, , <math.h>)
+SYMBOL(nearbyint, , <math.h>)
+SYMBOL(nearbyintf, , <math.h>)
+SYMBOL(nearbyintl, , <math.h>)
+SYMBOL(nextafter, , <math.h>)
+SYMBOL(nextafterf, , <math.h>)
+SYMBOL(nextafterl, , <math.h>)
+SYMBOL(nexttoward, , <math.h>)
+SYMBOL(nexttowardf, , <math.h>)
+SYMBOL(nexttowardl, , <math.h>)
+SYMBOL(noreturn, , <stdnoreturn.h>)
+SYMBOL(not, , <iso646.h>)
+SYMBOL(not_eq, , <iso646.h>)
+SYMBOL(offsetof, , <stddef.h>)
+SYMBOL(once_flag, , <threads.h>)
+SYMBOL(or, , <iso646.h>)
+SYMBOL(or_eq, , <iso646.h>)
+SYMBOL(perror, , <stdio.h>)
+SYMBOL(pow, , <math.h>)
+SYMBOL(powf, , <math.h>)
+SYMBOL(powl, , <math.h>)
+SYMBOL(printf, , <stdio.h>)
+SYMBOL(printf_s, , <stdio.h>)
+SYMBOL(ptrdiff_t, , <stddef.h>)
+SYMBOL(putc, , <stdio.h>)
+SYMBOL(putchar, , <stdio.h>)
+SYMBOL(puts, , <stdio.h>)
+SYMBOL(putwc, , <wchar.h>)
+SYMBOL(putwchar, , <wchar.h>)
+SYMBOL(qsort, , <stdlib.h>)
+SYMBOL(qsort_s, , <stdlib.h>)
+SYMBOL(quick_exit, , <stdlib.h>)
+SYMBOL(raise, , <signal.h>)
+SYMBOL(rand, , <stdlib.h>)
+SYMBOL(realloc, , <stdlib.h>)
+SYMBOL(remainder, , <math.h>)
+SYMBOL(remainderf, , <math.h>)
+SYMBOL(remainderl, , <math.h>)
+SYMBOL(remove, , <stdio.h>)
+SYMBOL(remquo, , <math.h>)
+SYMBOL(remquof, , <math.h>)
+SYMBOL(remquol, , <math.h>)
+SYMBOL(rename, , <stdio.h>)
+SYMBOL(rewind, , <stdio.h>)
+SYMBOL(rint, , <math.h>)
+SYMBOL(rintf, , <math.h>)
+SYMBOL(rintl, , <math.h>)
+SYMBOL(round, , <math.h>)
+SYMBOL(roundf, , <math.h>)
+SYMBOL(roundl, , <math.h>)
+SYMBOL(rsize_t, , <stddef.h>)
+SYMBOL(scalbln, , <math.h>)
+SYMBOL(scalblnf, , <math.h>)
+SYMBOL(scalblnl, , <math.h>)
+SYMBOL(scalbn, , <math.h>)
+SYMBOL(scalbnf, , <math.h>)
+SYMBOL(scalbnl, , <math.h>)
+SYMBOL(scanf, , <stdio.h>)
+SYMBOL(scanf_s, , <stdio.h>)
+SYMBOL(set_constraint_handler_s, , <stdlib.h>)
+SYMBOL(setbuf, , <stdio.h>)
+SYMBOL(setjmp, , <setjmp.h>)
+SYMBOL(setlocale, , <locale.h>)
+SYMBOL(setvbuf, , <stdio.h>)
+SYMBOL(sig_atomic_t, , <signal.h>)
+SYMBOL(signal, , <signal.h>)
+SYMBOL(signbit, , <math.h>)
+SYMBOL(sin, , <math.h>)
+SYMBOL(sinf, , <math.h>)
+SYMBOL(sinh, , <math.h>)
+SYMBOL(sinhf, , <math.h>)
+SYMBOL(sinhl, , <math.h>)
+SYMBOL(sinl, , <math.h>)
+SYMBOL(snprintf, , <stdio.h>)
+SYMBOL(snprintf_s, , <stdio.h>)
+SYMBOL(snwprintf_s, , <wchar.h>)
+SYMBOL(sprintf, , <stdio.h>)
+SYMBOL(sprintf_s, , <stdio.h>)
+SYMBOL(sqrt, , <math.h>)
+SYMBOL(sqrtf, , <math.h>)
+SYMBOL(sqrtl, , <math.h>)
+SYMBOL(srand, , <stdlib.h>)
+SYMBOL(sscanf, , <stdio.h>)
+SYMBOL(sscanf_s, , <stdio.h>)
+SYMBOL(static_assert, , <assert.h>)
+SYMBOL(stderr, , <stdio.h>)
+SYMBOL(stdin, , <stdio.h>)
+SYMBOL(stdout, , <stdio.h>)
+SYMBOL(strcat, , <string.h>)
+SYMBOL(strcat_s, , <string.h>)
+SYMBOL(strchr, , <string.h>)
+SYMBOL(strcmp, , <string.h>)
+SYMBOL(strcoll, , <string.h>)
+SYMBOL(strcpy, , <string.h>)
+SYMBOL(strcpy_s, , <string.h>)
+SYMBOL(strcspn, , <string.h>)
+SYMBOL(strerror, , <string.h>)
+SYMBOL(strerror_s, , <string.h>)
+SYMBOL(strerrorlen_s, , <string.h>)
+SYMBOL(strftime, , <time.h>)
+SYMBOL(strlen, , <string.h>)
+SYMBOL(strncat, , <string.h>)
+SYMBOL(strncat_s, , <string.h>)
+SYMBOL(strncmp, , <string.h>)
+SYMBOL(strncpy, , <string.h>)
+SYMBOL(strncpy_s, , <string.h>)
+SYMBOL(strnlen_s, , <string.h>)
+SYMBOL(strpbrk, , <string.h>)
+SYMBOL(strrchr, , <string.h>)
+SYMBOL(strspn, , <string.h>)
+SYMBOL(strstr, , <string.h>)
+SYMBOL(strtod, , <stdlib.h>)
+SYMBOL(strtof, , <stdlib.h>)
+SYMBOL(strtoimax, , <inttypes.h>)
+SYMBOL(strtok, , <string.h>)
+SYMBOL(strtok_s, , <string.h>)
+SYMBOL(strtol, , <stdlib.h>)
+SYMBOL(strtold, , <stdlib.h>)
+SYMBOL(strtoll, , <stdlib.h>)
+SYMBOL(strtoul, , <stdlib.h>)
+SYMBOL(strtoull, , <stdlib.h>)
+SYMBOL(strtoumax, , <inttypes.h>)
+SYMBOL(strxfrm, , <string.h>)
+SYMBOL(swprintf, , <wchar.h>)
+SYMBOL(swprintf_s, , <wchar.h>)
+SYMBOL(swscanf, , <wchar.h>)
+SYMBOL(swscanf_s, , <wchar.h>)
+SYMBOL(system, , <stdlib.h>)
+SYMBOL(tan, , <math.h>)
+SYMBOL(tanf, , <math.h>)
+SYMBOL(tanh, , <math.h>)
+SYMBOL(tanhf, , <math.h>)
+SYMBOL(tanhl, , <math.h>)
+SYMBOL(tanl, , <math.h>)
+SYMBOL(tgamma, , <math.h>)
+SYMBOL(tgammaf, , <math.h>)
+SYMBOL(tgammal, , <math.h>)
+SYMBOL(thrd_busy, , <threads.h>)
+SYMBOL(thrd_create, , <threads.h>)
+SYMBOL(thrd_current, , <threads.h>)
+SYMBOL(thrd_detach, , <threads.h>)
+SYMBOL(thrd_equal, , <threads.h>)
+SYMBOL(thrd_error, , <threads.h>)
+SYMBOL(thrd_join, , <threads.h>)
+SYMBOL(thrd_nomem, , <threads.h>)
+SYMBOL(thrd_sleep, , <threads.h>)
+SYMBOL(thrd_start_t, , <threads.h>)
+SYMBOL(thrd_success, , <threads.h>)
+SYMBOL(thrd_t, , <threads.h>)
+SYMBOL(thrd_timedout, , <threads.h>)
+SYMBOL(thrd_yield, , <threads.h>)
+SYMBOL(thread_local, , <threads.h>)
+SYMBOL(time, , <time.h>)
+SYMBOL(time_t, , <time.h>)
+SYMBOL(timespec, , <time.h>)
+SYMBOL(timespec_get, , <time.h>)
+SYMBOL(tm, , <time.h>)
+SYMBOL(tmpfile, , <stdio.h>)
+SYMBOL(tmpfile_s, , <stdio.h>)
+SYMBOL(tmpnam, , <stdio.h>)
+SYMBOL(tmpnam_s, , <stdio.h>)
+SYMBOL(tolower, , <ctype.h>)
+SYMBOL(toupper, , <ctype.h>)
+SYMBOL(towctrans, , <wctype.h>)
+SYMBOL(towlower, , <wctype.h>)
+SYMBOL(towupper, , <wctype.h>)
+SYMBOL(trunc, , <math.h>)
+SYMBOL(truncf, , <math.h>)
+SYMBOL(truncl, , <math.h>)
+SYMBOL(tss_create, , <threads.h>)
+SYMBOL(tss_delete, , <threads.h>)
+SYMBOL(tss_dtor_t, , <threads.h>)
+SYMBOL(tss_get, , <threads.h>)
+SYMBOL(tss_set, , <threads.h>)
+SYMBOL(tss_t, , <threads.h>)
+SYMBOL(uint16_t, , <stdint.h>)
+SYMBOL(uint32_t, , <stdint.h>)
+SYMBOL(uint64_t, , <stdint.h>)
+SYMBOL(uint8_t, , <stdint.h>)
+SYMBOL(uint_fast16_t, , <stdint.h>)
+SYMBOL(uint_fast32_t, , <stdint.h>)
+SYMBOL(uint_fast64_t, , <stdint.h>)
+SYMBOL(uint_fast8_t, , <stdint.h>)
+SYMBOL(uint_least16_t, , <stdint.h>)
+SYMBOL(uint_least32_t, , <stdint.h>)
+SYMBOL(uint_least64_t, , <stdint.h>)
+SYMBOL(uint_least8_t, , <stdint.h>)
+SYMBOL(uintmax_t, , <stdint.h>)
+SYMBOL(uintptr_t, , <stdint.h>)
+SYMBOL(ungetc, , <stdio.h>)
+SYMBOL(ungetwc, , <wchar.h>)
+SYMBOL(va_arg, , <stdarg.h>)
+SYMBOL(va_copy, , <stdarg.h>)
+SYMBOL(va_end, , <stdarg.h>)
+SYMBOL(va_start, , <stdarg.h>)
+SYMBOL(vfprintf, , <stdio.h>)
+SYMBOL(vfprintf_s, , <stdio.h>)
+SYMBOL(vfscanf, , <stdio.h>)
+SYMBOL(vfscanf_s, , <stdio.h>)
+SYMBOL(vfwprintf, , <wchar.h>)
+SYMBOL(vfwprintf_s, , <wchar.h>)
+SYMBOL(vfwscanf, , <wchar.h>)
+SYMBOL(vfwscanf_s, , <wchar.h>)
+SYMBOL(vprintf, , <stdio.h>)
+SYMBOL(vprintf_s, , <stdio.h>)
+SYMBOL(vscanf, , <stdio.h>)
+SYMBOL(vscanf_s, , <stdio.h>)
+SYMBOL(vsnprintf, , <stdio.h>)
+SYMBOL(vsnprintf_s, , <stdio.h>)
+SYMBOL(vsnwprintf_s, , <wchar.h>)
+SYMBOL(vsprintf, , <stdio.h>)
+SYMBOL(vsprintf_s, , <stdio.h>)
+SYMBOL(vsscanf, , <stdio.h>)
+SYMBOL(vsscanf_s, , <stdio.h>)
+SYMBOL(vswprintf, , <wchar.h>)
+SYMBOL(vswprintf_s, , <wchar.h>)
+SYMBOL(vswscanf, , <wchar.h>)
+SYMBOL(vswscanf_s, , <wchar.h>)
+SYMBOL(vwprintf, , <wchar.h>)
+SYMBOL(vwprintf_s, , <wchar.h>)
+SYMBOL(vwscanf, , <wchar.h>)
+SYMBOL(vwscanf_s, , <wchar.h>)
+SYMBOL(wchar_t, , <wchar.h>)
+SYMBOL(wcrtomb, , <wchar.h>)
+SYMBOL(wcrtomb_s, , <wchar.h>)
+SYMBOL(wcscat, , <wchar.h>)
+SYMBOL(wcscat_s, , <wchar.h>)
+SYMBOL(wcschr, , <wchar.h>)
+SYMBOL(wcscmp, , <wchar.h>)
+SYMBOL(wcscoll, , <wchar.h>)
+SYMBOL(wcscpy, , <wchar.h>)
+SYMBOL(wcscpy_s, , <wchar.h>)
+SYMBOL(wcscspn, , <wchar.h>)
+SYMBOL(wcsftime, , <wchar.h>)
+SYMBOL(wcslen, , <wchar.h>)
+SYMBOL(wcsncat, , <wchar.h>)
+SYMBOL(wcsncat_s, , <wchar.h>)
+SYMBOL(wcsncmp, , <wchar.h>)
+SYMBOL(wcsncpy, , <wchar.h>)
+SYMBOL(wcsncpy_s, , <wchar.h>)
+SYMBOL(wcsnlen_s, , <wchar.h>)
+SYMBOL(wcspbrk, , <wchar.h>)
+SYMBOL(wcsrchr, , <wchar.h>)
+SYMBOL(wcsrtombs, , <wchar.h>)
+SYMBOL(wcsrtombs_s, , <wchar.h>)
+SYMBOL(wcsspn, , <wchar.h>)
+SYMBOL(wcsstr, , <wchar.h>)
+SYMBOL(wcstod, , <wchar.h>)
+SYMBOL(wcstof, , <wchar.h>)
+SYMBOL(wcstoimax, , <inttypes.h>)
+SYMBOL(wcstok, , <wchar.h>)
+SYMBOL(wcstok_s, , <wchar.h>)
+SYMBOL(wcstol, , <wchar.h>)
+SYMBOL(wcstold, , <wchar.h>)
+SYMBOL(wcstoll, , <wchar.h>)
+SYMBOL(wcstombs, , <stdlib.h>)
+SYMBOL(wcstombs_s, , <stdlib.h>)
+SYMBOL(wcstoul, , <wchar.h>)
+SYMBOL(wcstoull, , <wchar.h>)
+SYMBOL(wcstoumax, , <inttypes.h>)
+SYMBOL(wcsxfrm, , <wchar.h>)
+SYMBOL(wctob, , <wchar.h>)
+SYMBOL(wctomb, , <stdlib.h>)
+SYMBOL(wctomb_s, , <stdlib.h>)
+SYMBOL(wctrans, , <wctype.h>)
+SYMBOL(wctrans_t, , <wctype.h>)
+SYMBOL(wctype, , <wctype.h>)
+SYMBOL(wctype_t, , <wctype.h>)
+SYMBOL(wint_t, , <wctype.h>)
+SYMBOL(wmemchr, , <wchar.h>)
+SYMBOL(wmemcmp, , <wchar.h>)
+SYMBOL(wmemcpy, , <wchar.h>)
+SYMBOL(wmemcpy_s, , <wchar.h>)
+SYMBOL(wmemmove, , <wchar.h>)
+SYMBOL(wmemmove_s, , <wchar.h>)
+SYMBOL(wmemset, , <wchar.h>)
+SYMBOL(wprintf, , <wchar.h>)
+SYMBOL(wprintf_s, , <wchar.h>)
+SYMBOL(wscanf, , <wchar.h>)
+SYMBOL(wscanf_s, , <wchar.h>)
+SYMBOL(xor, , <iso646.h>)
+SYMBOL(xor_eq, , <iso646.h>)

clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp

static int initialize(Lang Language) {
 
   auto AddHeader = [&](llvm::StringRef Header) -> unsigned {
     return Mapping->HeaderIDs->try_emplace(Header, Mapping->HeaderIDs->size())
         .first->second;
   };
 
   auto Add = [&, SymIndex(-1)](llvm::StringRef QName, unsigned NSLen,
                                llvm::StringRef HeaderName) mutable {
-    // Correct "Nonefoo" => foo.
-    // FIXME: get rid of "None" from the generated mapping files.
-    if (QName.take_front(NSLen) == "None") {
-      QName = QName.drop_front(NSLen);
-      NSLen = 0;
-    }
-
     if (SymIndex >= 0 &&
         Mapping->SymbolNames[SymIndex].qualifiedName() == QName) {
       // Not a new symbol, use the same index.
       assert(llvm::none_of(llvm::ArrayRef(Mapping->SymbolNames, SymIndex),
                            [&QName](const SymbolHeaderMapping::SymbolName &S) {
                              return S.qualifiedName() == QName;
                            }) &&
              "The symbol has been added before, make sure entries in the .inc "

clang/lib/Tooling/Inclusions/Stdlib/StdSpecialSymbolMap.inc

 SYMBOL(mbstate_t, std::, <cuchar>)
 SYMBOL(size_t, std::, <cstddef>)
 SYMBOL(size_t, std::, <cstdlib>)
 SYMBOL(size_t, std::, <cstring>)
 SYMBOL(size_t, std::, <cwchar>)
 SYMBOL(size_t, std::, <cuchar>)
 SYMBOL(size_t, std::, <ctime>)
 SYMBOL(size_t, std::, <cstdio>)
-SYMBOL(size_t, None, <cstddef>)
-SYMBOL(size_t, None, <cstdlib>)
-SYMBOL(size_t, None, <cstring>)
-SYMBOL(size_t, None, <cwchar>)
-SYMBOL(size_t, None, <cuchar>)
-SYMBOL(size_t, None, <ctime>)
-SYMBOL(size_t, None, <cstdio>)
-SYMBOL(size_t, None, <stddef.h>)
-SYMBOL(size_t, None, <stdlib.h>)
-SYMBOL(size_t, None, <string.h>)
-SYMBOL(size_t, None, <wchar.h>)
-SYMBOL(size_t, None, <uchar.h>)
-SYMBOL(size_t, None, <time.h>)
-SYMBOL(size_t, None, <stdio.h>)
+SYMBOL(size_t, , <cstddef>)
+SYMBOL(size_t, , <cstdlib>)
+SYMBOL(size_t, , <cstring>)
+SYMBOL(size_t, , <cwchar>)
+SYMBOL(size_t, , <cuchar>)
+SYMBOL(size_t, , <ctime>)
+SYMBOL(size_t, , <cstdio>)
+SYMBOL(size_t, , <stddef.h>)
+SYMBOL(size_t, , <stdlib.h>)
+SYMBOL(size_t, , <string.h>)
+SYMBOL(size_t, , <wchar.h>)
+SYMBOL(size_t, , <uchar.h>)
+SYMBOL(size_t, , <time.h>)
+SYMBOL(size_t, , <stdio.h>)
 SYMBOL(unwrap_ref_decay, std::, <type_traits>)
 SYMBOL(unwrap_ref_decay, std::, <functional>)
 SYMBOL(unwrap_reference, std::, <type_traits>)
 SYMBOL(unwrap_reference, std::, <functional>)
 SYMBOL(unwrap_ref_decay_t, std::, <type_traits>)
 SYMBOL(unwrap_ref_decay_t, std::, <functional>)
 SYMBOL(wint_t, std::, <cwctype>)
 SYMBOL(wint_t, std::, <cwchar>)

 SYMBOL(ssize, std::, <vector>)
 
 // std::get has a few variants for different types (tuple, array, pair etc)
 // which is tricky to disambiguate without type information.
 // Don't set any header for it, as it comes with the type header.
 SYMBOL(get, std::, /*no headers*/)
 
 // Macros
-SYMBOL(NULL, None, <cstddef>)
-SYMBOL(NULL, None, <stddef.h>)
-SYMBOL(NULL, None, <cstdlib>)
-SYMBOL(NULL, None, <stdlib.h>)
-SYMBOL(NULL, None, <cstring>)
-SYMBOL(NULL, None, <string.h>)
-SYMBOL(NULL, None, <cwchar>)
-SYMBOL(NULL, None, <wchar.h>)
-SYMBOL(NULL, None, <ctime>)
-SYMBOL(NULL, None, <time.h>)
-SYMBOL(NULL, None, <clocale>)
-SYMBOL(NULL, None, <locale.h>)
-SYMBOL(NULL, None, <cstdio>)
-SYMBOL(NULL, None, <stdio.h>)
+SYMBOL(NULL, , <cstddef>)
+SYMBOL(NULL, , <stddef.h>)
+SYMBOL(NULL, , <cstdlib>)
+SYMBOL(NULL, , <stdlib.h>)
+SYMBOL(NULL, , <cstring>)
+SYMBOL(NULL, , <string.h>)
+SYMBOL(NULL, , <cwchar>)
+SYMBOL(NULL, , <wchar.h>)
+SYMBOL(NULL, , <ctime>)
+SYMBOL(NULL, , <time.h>)
+SYMBOL(NULL, , <clocale>)
+SYMBOL(NULL, , <locale.h>)
+SYMBOL(NULL, , <cstdio>)
+SYMBOL(NULL, , <stdio.h>)

clang/lib/Tooling/Inclusions/Stdlib/StdSymbolMap.inc

 //===-- 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(ATOMIC_BOOL_LOCK_FREE, , <atomic>)
+SYMBOL(ATOMIC_CHAR16_T_LOCK_FREE, , <atomic>)
+SYMBOL(ATOMIC_CHAR32_T_LOCK_FREE, , <atomic>)
+SYMBOL(ATOMIC_CHAR8_T_LOCK_FREE, , <atomic>)
+SYMBOL(ATOMIC_CHAR_LOCK_FREE, , <atomic>)
+SYMBOL(ATOMIC_FLAG_INIT, , <atomic>)
+SYMBOL(ATOMIC_INT_LOCK_FREE, , <atomic>)
+SYMBOL(ATOMIC_LLONG_LOCK_FREE, , <atomic>)
+SYMBOL(ATOMIC_LONG_LOCK_FREE, , <atomic>)
+SYMBOL(ATOMIC_POINTER_LOCK_FREE, , <atomic>)
+SYMBOL(ATOMIC_SHORT_LOCK_FREE, , <atomic>)
+SYMBOL(ATOMIC_VAR_INIT, , <atomic>)
+SYMBOL(ATOMIC_WCHAR_T_LOCK_FREE, , <atomic>)
+SYMBOL(BUFSIZ, , <cstdio>)
+SYMBOL(BUFSIZ, , <stdio.h>)
+SYMBOL(CHAR_BIT, , <climits>)
+SYMBOL(CHAR_BIT, , <limits.h>)
+SYMBOL(CHAR_MAX, , <climits>)
+SYMBOL(CHAR_MAX, , <limits.h>)
+SYMBOL(CHAR_MIN, , <climits>)
+SYMBOL(CHAR_MIN, , <limits.h>)
+SYMBOL(CLOCKS_PER_SEC, , <ctime>)
+SYMBOL(CLOCKS_PER_SEC, , <time.h>)
+SYMBOL(DBL_DECIMAL_DIG, , <cfloat>)
+SYMBOL(DBL_DECIMAL_DIG, , <float.h>)
+SYMBOL(DBL_DIG, , <cfloat>)
+SYMBOL(DBL_DIG, , <float.h>)
+SYMBOL(DBL_EPSILON, , <cfloat>)
+SYMBOL(DBL_EPSILON, , <float.h>)
+SYMBOL(DBL_HAS_SUBNORM, , <cfloat>)
+SYMBOL(DBL_HAS_SUBNORM, , <float.h>)
+SYMBOL(DBL_MANT_DIG, , <cfloat>)
+SYMBOL(DBL_MANT_DIG, , <float.h>)
+SYMBOL(DBL_MAX, , <cfloat>)
+SYMBOL(DBL_MAX, , <float.h>)
+SYMBOL(DBL_MAX_10_EXP, , <cfloat>)
+SYMBOL(DBL_MAX_10_EXP, , <float.h>)
+SYMBOL(DBL_MAX_EXP, , <cfloat>)
+SYMBOL(DBL_MAX_EXP, , <float.h>)
+SYMBOL(DBL_MIN, , <cfloat>)
+SYMBOL(DBL_MIN, , <float.h>)
+SYMBOL(DBL_MIN_10_EXP, , <cfloat>)
+SYMBOL(DBL_MIN_10_EXP, , <float.h>)
+SYMBOL(DBL_MIN_EXP, , <cfloat>)
+SYMBOL(DBL_MIN_EXP, , <float.h>)
+SYMBOL(DBL_TRUE_MIN, , <cfloat>)
+SYMBOL(DBL_TRUE_MIN, , <float.h>)
+SYMBOL(DECIMAL_DIG, , <cfloat>)
+SYMBOL(DECIMAL_DIG, , <float.h>)
+SYMBOL(E2BIG, , <cerrno>)
+SYMBOL(E2BIG, , <errno.h>)
+SYMBOL(EACCES, , <cerrno>)
+SYMBOL(EACCES, , <errno.h>)
+SYMBOL(EADDRINUSE, , <cerrno>)
+SYMBOL(EADDRINUSE, , <errno.h>)
+SYMBOL(EADDRNOTAVAIL, , <cerrno>)
+SYMBOL(EADDRNOTAVAIL, , <errno.h>)
+SYMBOL(EAFNOSUPPORT, , <cerrno>)
+SYMBOL(EAFNOSUPPORT, , <errno.h>)
+SYMBOL(EAGAIN, , <cerrno>)
+SYMBOL(EAGAIN, , <errno.h>)
+SYMBOL(EALREADY, , <cerrno>)
+SYMBOL(EALREADY, , <errno.h>)
+SYMBOL(EBADF, , <cerrno>)
+SYMBOL(EBADF, , <errno.h>)
+SYMBOL(EBADMSG, , <cerrno>)
+SYMBOL(EBADMSG, , <errno.h>)
+SYMBOL(EBUSY, , <cerrno>)
+SYMBOL(EBUSY, , <errno.h>)
+SYMBOL(ECANCELED, , <cerrno>)
+SYMBOL(ECANCELED, , <errno.h>)
+SYMBOL(ECHILD, , <cerrno>)
+SYMBOL(ECHILD, , <errno.h>)
+SYMBOL(ECONNABORTED, , <cerrno>)
+SYMBOL(ECONNABORTED, , <errno.h>)
+SYMBOL(ECONNREFUSED, , <cerrno>)
+SYMBOL(ECONNREFUSED, , <errno.h>)
+SYMBOL(ECONNRESET, , <cerrno>)
+SYMBOL(ECONNRESET, , <errno.h>)
+SYMBOL(EDEADLK, , <cerrno>)
+SYMBOL(EDEADLK, , <errno.h>)
+SYMBOL(EDESTADDRREQ, , <cerrno>)
+SYMBOL(EDESTADDRREQ, , <errno.h>)
+SYMBOL(EDOM, , <cerrno>)
+SYMBOL(EDOM, , <errno.h>)
+SYMBOL(EEXIST, , <cerrno>)
+SYMBOL(EEXIST, , <errno.h>)
+SYMBOL(EFAULT, , <cerrno>)
+SYMBOL(EFAULT, , <errno.h>)
+SYMBOL(EFBIG, , <cerrno>)
+SYMBOL(EFBIG, , <errno.h>)
+SYMBOL(EHOSTUNREACH, , <cerrno>)
+SYMBOL(EHOSTUNREACH, , <errno.h>)
+SYMBOL(EIDRM, , <cerrno>)
+SYMBOL(EIDRM, , <errno.h>)
+SYMBOL(EILSEQ, , <cerrno>)
+SYMBOL(EILSEQ, , <errno.h>)
+SYMBOL(EINPROGRESS, , <cerrno>)
+SYMBOL(EINPROGRESS, , <errno.h>)
+SYMBOL(EINTR, , <cerrno>)
+SYMBOL(EINTR, , <errno.h>)
+SYMBOL(EINVAL, , <cerrno>)
+SYMBOL(EINVAL, , <errno.h>)
+SYMBOL(EIO, , <cerrno>)
+SYMBOL(EIO, , <errno.h>)
+SYMBOL(EISCONN, , <cerrno>)
+SYMBOL(EISCONN, , <errno.h>)
+SYMBOL(EISDIR, , <cerrno>)
+SYMBOL(EISDIR, , <errno.h>)
+SYMBOL(ELOOP, , <cerrno>)
+SYMBOL(ELOOP, , <errno.h>)
+SYMBOL(EMFILE, , <cerrno>)
+SYMBOL(EMFILE, , <errno.h>)
+SYMBOL(EMLINK, , <cerrno>)
+SYMBOL(EMLINK, , <errno.h>)
+SYMBOL(EMSGSIZE, , <cerrno>)
+SYMBOL(EMSGSIZE, , <errno.h>)
+SYMBOL(ENAMETOOLONG, , <cerrno>)
+SYMBOL(ENAMETOOLONG, , <errno.h>)
+SYMBOL(ENETDOWN, , <cerrno>)
+SYMBOL(ENETDOWN, , <errno.h>)
+SYMBOL(ENETRESET, , <cerrno>)
+SYMBOL(ENETRESET, , <errno.h>)
+SYMBOL(ENETUNREACH, , <cerrno>)
+SYMBOL(ENETUNREACH, , <errno.h>)
+SYMBOL(ENFILE, , <cerrno>)
+SYMBOL(ENFILE, , <errno.h>)
+SYMBOL(ENOBUFS, , <cerrno>)
+SYMBOL(ENOBUFS, , <errno.h>)
+SYMBOL(ENODATA, , <cerrno>)
+SYMBOL(ENODATA, , <errno.h>)
+SYMBOL(ENODEV, , <cerrno>)
+SYMBOL(ENODEV, , <errno.h>)
+SYMBOL(ENOENT, , <cerrno>)
+SYMBOL(ENOENT, , <errno.h>)
+SYMBOL(ENOEXEC, , <cerrno>)
+SYMBOL(ENOEXEC, , <errno.h>)
+SYMBOL(ENOLCK, , <cerrno>)
+SYMBOL(ENOLCK, , <errno.h>)
+SYMBOL(ENOLINK, , <cerrno>)
+SYMBOL(ENOLINK, , <errno.h>)
+SYMBOL(ENOMEM, , <cerrno>)
+SYMBOL(ENOMEM, , <errno.h>)
+SYMBOL(ENOMSG, , <cerrno>)
+SYMBOL(ENOMSG, , <errno.h>)
+SYMBOL(ENOPROTOOPT, , <cerrno>)
+SYMBOL(ENOPROTOOPT, , <errno.h>)
+SYMBOL(ENOSPC, , <cerrno>)
+SYMBOL(ENOSPC, , <errno.h>)
+SYMBOL(ENOSR, , <cerrno>)
+SYMBOL(ENOSR, , <errno.h>)
+SYMBOL(ENOSTR, , <cerrno>)
+SYMBOL(ENOSTR, , <errno.h>)
+SYMBOL(ENOSYS, , <cerrno>)
+SYMBOL(ENOSYS, , <errno.h>)
+SYMBOL(ENOTCONN, , <cerrno>)
+SYMBOL(ENOTCONN, , <errno.h>)
+SYMBOL(ENOTDIR, , <cerrno>)
+SYMBOL(ENOTDIR, , <errno.h>)
+SYMBOL(ENOTEMPTY, , <cerrno>)
+SYMBOL(ENOTEMPTY, , <errno.h>)
+SYMBOL(ENOTRECOVERABLE, , <cerrno>)
+SYMBOL(ENOTRECOVERABLE, , <errno.h>)
+SYMBOL(ENOTSOCK, , <cerrno>)
+SYMBOL(ENOTSOCK, , <errno.h>)
+SYMBOL(ENOTSUP, , <cerrno>)
+SYMBOL(ENOTSUP, , <errno.h>)
+SYMBOL(ENOTTY, , <cerrno>)
+SYMBOL(ENOTTY, , <errno.h>)
+SYMBOL(ENXIO, , <cerrno>)
+SYMBOL(ENXIO, , <errno.h>)
+SYMBOL(EOF, , <cstdio>)
+SYMBOL(EOF, , <stdio.h>)
+SYMBOL(EOPNOTSUPP, , <cerrno>)
+SYMBOL(EOPNOTSUPP, , <errno.h>)
+SYMBOL(EOVERFLOW, , <cerrno>)
+SYMBOL(EOVERFLOW, , <errno.h>)
+SYMBOL(EOWNERDEAD, , <cerrno>)
+SYMBOL(EOWNERDEAD, , <errno.h>)
+SYMBOL(EPERM, , <cerrno>)
+SYMBOL(EPERM, , <errno.h>)
+SYMBOL(EPIPE, , <cerrno>)
+SYMBOL(EPIPE, , <errno.h>)
+SYMBOL(EPROTO, , <cerrno>)
+SYMBOL(EPROTO, , <errno.h>)
+SYMBOL(EPROTONOSUPPORT, , <cerrno>)
+SYMBOL(EPROTONOSUPPORT, , <errno.h>)
+SYMBOL(EPROTOTYPE, , <cerrno>)
+SYMBOL(EPROTOTYPE, , <errno.h>)
+SYMBOL(ERANGE, , <cerrno>)
+SYMBOL(ERANGE, , <errno.h>)
+SYMBOL(EROFS, , <cerrno>)
+SYMBOL(EROFS, , <errno.h>)
+SYMBOL(ESPIPE, , <cerrno>)
+SYMBOL(ESPIPE, , <errno.h>)
+SYMBOL(ESRCH, , <cerrno>)
+SYMBOL(ESRCH, , <errno.h>)
+SYMBOL(ETIME, , <cerrno>)
+SYMBOL(ETIME, , <errno.h>)
+SYMBOL(ETIMEDOUT, , <cerrno>)
+SYMBOL(ETIMEDOUT, , <errno.h>)
+SYMBOL(ETXTBSY, , <cerrno>)
+SYMBOL(ETXTBSY, , <errno.h>)
+SYMBOL(EWOULDBLOCK, , <cerrno>)
+SYMBOL(EWOULDBLOCK, , <errno.h>)
+SYMBOL(EXDEV, , <cerrno>)
+SYMBOL(EXDEV, , <errno.h>)
+SYMBOL(EXIT_FAILURE, , <cstdlib>)
+SYMBOL(EXIT_FAILURE, , <stdlib.h>)
+SYMBOL(EXIT_SUCCESS, , <cstdlib>)
+SYMBOL(EXIT_SUCCESS, , <stdlib.h>)
+SYMBOL(FE_ALL_EXCEPT, , <cfenv>)
+SYMBOL(FE_ALL_EXCEPT, , <fenv.h>)
+SYMBOL(FE_DFL_ENV, , <cfenv>)
+SYMBOL(FE_DFL_ENV, , <fenv.h>)
+SYMBOL(FE_DIVBYZERO, , <cfenv>)
+SYMBOL(FE_DIVBYZERO, , <fenv.h>)
+SYMBOL(FE_DOWNWARD, , <cfenv>)
+SYMBOL(FE_DOWNWARD, , <fenv.h>)
+SYMBOL(FE_INEXACT, , <cfenv>)
+SYMBOL(FE_INEXACT, , <fenv.h>)
+SYMBOL(FE_INVALID, , <cfenv>)
+SYMBOL(FE_INVALID, , <fenv.h>)
+SYMBOL(FE_OVERFLOW, , <cfenv>)
+SYMBOL(FE_OVERFLOW, , <fenv.h>)
+SYMBOL(FE_TONEAREST, , <cfenv>)
+SYMBOL(FE_TONEAREST, , <fenv.h>)
+SYMBOL(FE_TOWARDZERO, , <cfenv>)
+SYMBOL(FE_TOWARDZERO, , <fenv.h>)
+SYMBOL(FE_UNDERFLOW, , <cfenv>)
+SYMBOL(FE_UNDERFLOW, , <fenv.h>)
+SYMBOL(FE_UPWARD, , <cfenv>)
+SYMBOL(FE_UPWARD, , <fenv.h>)
+SYMBOL(FILENAME_MAX, , <cstdio>)
+SYMBOL(FILENAME_MAX, , <stdio.h>)
+SYMBOL(FLT_DECIMAL_DIG, , <cfloat>)
+SYMBOL(FLT_DECIMAL_DIG, , <float.h>)
+SYMBOL(FLT_DIG, , <cfloat>)
+SYMBOL(FLT_DIG, , <float.h>)
+SYMBOL(FLT_EPSILON, , <cfloat>)
+SYMBOL(FLT_EPSILON, , <float.h>)
+SYMBOL(FLT_EVAL_METHOD, , <cfloat>)
+SYMBOL(FLT_EVAL_METHOD, , <float.h>)
+SYMBOL(FLT_HAS_SUBNORM, , <cfloat>)
+SYMBOL(FLT_HAS_SUBNORM, , <float.h>)
+SYMBOL(FLT_MANT_DIG, , <cfloat>)
+SYMBOL(FLT_MANT_DIG, , <float.h>)
+SYMBOL(FLT_MAX, , <cfloat>)
+SYMBOL(FLT_MAX, , <float.h>)
+SYMBOL(FLT_MAX_10_EXP, , <cfloat>)
+SYMBOL(FLT_MAX_10_EXP, , <float.h>)
+SYMBOL(FLT_MAX_EXP, , <cfloat>)
+SYMBOL(FLT_MAX_EXP, , <float.h>)
+SYMBOL(FLT_MIN, , <cfloat>)
+SYMBOL(FLT_MIN, , <float.h>)
+SYMBOL(FLT_MIN_10_EXP, , <cfloat>)
+SYMBOL(FLT_MIN_10_EXP, , <float.h>)
+SYMBOL(FLT_MIN_EXP, , <cfloat>)
+SYMBOL(FLT_MIN_EXP, , <float.h>)
+SYMBOL(FLT_RADIX, , <cfloat>)
+SYMBOL(FLT_RADIX, , <float.h>)
+SYMBOL(FLT_ROUNDS, , <cfloat>)
+SYMBOL(FLT_ROUNDS, , <float.h>)
+SYMBOL(FLT_TRUE_MIN, , <cfloat>)
+SYMBOL(FLT_TRUE_MIN, , <float.h>)
+SYMBOL(FOPEN_MAX, , <cstdio>)
+SYMBOL(FOPEN_MAX, , <stdio.h>)
+SYMBOL(FP_FAST_FMA, , <cmath>)
+SYMBOL(FP_FAST_FMA, , <math.h>)
+SYMBOL(FP_FAST_FMAF, , <cmath>)
+SYMBOL(FP_FAST_FMAF, , <math.h>)
+SYMBOL(FP_FAST_FMAL, , <cmath>)
+SYMBOL(FP_FAST_FMAL, , <math.h>)
+SYMBOL(FP_ILOGB0, , <cmath>)
+SYMBOL(FP_ILOGB0, , <math.h>)
+SYMBOL(FP_ILOGBNAN, , <cmath>)
+SYMBOL(FP_ILOGBNAN, , <math.h>)
+SYMBOL(FP_INFINITE, , <cmath>)
+SYMBOL(FP_INFINITE, , <math.h>)
+SYMBOL(FP_NAN, , <cmath>)
+SYMBOL(FP_NAN, , <math.h>)
+SYMBOL(FP_NORMAL, , <cmath>)
+SYMBOL(FP_NORMAL, , <math.h>)
+SYMBOL(FP_SUBNORMAL, , <cmath>)
+SYMBOL(FP_SUBNORMAL, , <math.h>)
+SYMBOL(FP_ZERO, , <cmath>)
+SYMBOL(FP_ZERO, , <math.h>)
+SYMBOL(HUGE_VAL, , <cmath>)
+SYMBOL(HUGE_VAL, , <math.h>)
+SYMBOL(HUGE_VALF, , <cmath>)
+SYMBOL(HUGE_VALF, , <math.h>)
+SYMBOL(HUGE_VALL, , <cmath>)
+SYMBOL(HUGE_VALL, , <math.h>)
+SYMBOL(INFINITY, , <cmath>)
+SYMBOL(INFINITY, , <math.h>)
+SYMBOL(INT16_MAX, , <cstdint>)
+SYMBOL(INT16_MAX, , <stdint.h>)
+SYMBOL(INT16_MIN, , <cstdint>)
+SYMBOL(INT16_MIN, , <stdint.h>)
+SYMBOL(INT32_MAX, , <cstdint>)
+SYMBOL(INT32_MAX, , <stdint.h>)
+SYMBOL(INT32_MIN, , <cstdint>)
+SYMBOL(INT32_MIN, , <stdint.h>)
+SYMBOL(INT64_MAX, , <cstdint>)
+SYMBOL(INT64_MAX, , <stdint.h>)
+SYMBOL(INT64_MIN, , <cstdint>)
+SYMBOL(INT64_MIN, , <stdint.h>)
+SYMBOL(INT8_MAX, , <cstdint>)
+SYMBOL(INT8_MAX, , <stdint.h>)
+SYMBOL(INT8_MIN, , <cstdint>)
+SYMBOL(INT8_MIN, , <stdint.h>)
+SYMBOL(INTMAX_MAX, , <cstdint>)
+SYMBOL(INTMAX_MAX, , <stdint.h>)
+SYMBOL(INTMAX_MIN, , <cstdint>)
+SYMBOL(INTMAX_MIN, , <stdint.h>)
+SYMBOL(INTPTR_MAX, , <cstdint>)
+SYMBOL(INTPTR_MAX, , <stdint.h>)
+SYMBOL(INTPTR_MIN, , <cstdint>)
+SYMBOL(INTPTR_MIN, , <stdint.h>)
+SYMBOL(INT_FAST16_MAX, , <cstdint>)
+SYMBOL(INT_FAST16_MAX, , <stdint.h>)
+SYMBOL(INT_FAST16_MIN, , <cstdint>)
+SYMBOL(INT_FAST16_MIN, , <stdint.h>)
+SYMBOL(INT_FAST32_MAX, , <cstdint>)
+SYMBOL(INT_FAST32_MAX, , <stdint.h>)
+SYMBOL(INT_FAST32_MIN, , <cstdint>)
+SYMBOL(INT_FAST32_MIN, , <stdint.h>)
+SYMBOL(INT_FAST64_MAX, , <cstdint>)
+SYMBOL(INT_FAST64_MAX, , <stdint.h>)
+SYMBOL(INT_FAST64_MIN, , <cstdint>)
+SYMBOL(INT_FAST64_MIN, , <stdint.h>)
+SYMBOL(INT_FAST8_MAX, , <cstdint>)
+SYMBOL(INT_FAST8_MAX, , <stdint.h>)
+SYMBOL(INT_FAST8_MIN, , <cstdint>)
+SYMBOL(INT_FAST8_MIN, , <stdint.h>)
+SYMBOL(INT_LEAST16_MAX, , <cstdint>)
+SYMBOL(INT_LEAST16_MAX, , <stdint.h>)
+SYMBOL(INT_LEAST16_MIN, , <cstdint>)
+SYMBOL(INT_LEAST16_MIN, , <stdint.h>)
+SYMBOL(INT_LEAST32_MAX, , <cstdint>)
+SYMBOL(INT_LEAST32_MAX, , <stdint.h>)
+SYMBOL(INT_LEAST32_MIN, , <cstdint>)
+SYMBOL(INT_LEAST32_MIN, , <stdint.h>)
+SYMBOL(INT_LEAST64_MAX, , <cstdint>)
+SYMBOL(INT_LEAST64_MAX, , <stdint.h>)
+SYMBOL(INT_LEAST64_MIN, , <cstdint>)
+SYMBOL(INT_LEAST64_MIN, , <stdint.h>)
+SYMBOL(INT_LEAST8_MAX, , <cstdint>)
+SYMBOL(INT_LEAST8_MAX, , <stdint.h>)
+SYMBOL(INT_LEAST8_MIN, , <cstdint>)
+SYMBOL(INT_LEAST8_MIN, , <stdint.h>)
+SYMBOL(INT_MAX, , <climits>)
+SYMBOL(INT_MAX, , <limits.h>)
+SYMBOL(INT_MIN, , <climits>)
+SYMBOL(INT_MIN, , <limits.h>)
+SYMBOL(LC_ALL, , <clocale>)
+SYMBOL(LC_ALL, , <locale.h>)
+SYMBOL(LC_COLLATE, , <clocale>)
+SYMBOL(LC_COLLATE, , <locale.h>)
+SYMBOL(LC_CTYPE, , <clocale>)
+SYMBOL(LC_CTYPE, , <locale.h>)
+SYMBOL(LC_MONETARY, , <clocale>)
+SYMBOL(LC_MONETARY, , <locale.h>)
+SYMBOL(LC_NUMERIC, , <clocale>)
+SYMBOL(LC_NUMERIC, , <locale.h>)
+SYMBOL(LC_TIME, , <clocale>)
+SYMBOL(LC_TIME, , <locale.h>)
+SYMBOL(LDBL_DECIMAL_DIG, , <cfloat>)
+SYMBOL(LDBL_DECIMAL_DIG, , <float.h>)
+SYMBOL(LDBL_DIG, , <cfloat>)
+SYMBOL(LDBL_DIG, , <float.h>)
+SYMBOL(LDBL_EPSILON, , <cfloat>)
+SYMBOL(LDBL_EPSILON, , <float.h>)
+SYMBOL(LDBL_HAS_SUBNORM, , <cfloat>)
+SYMBOL(LDBL_HAS_SUBNORM, , <float.h>)
+SYMBOL(LDBL_MANT_DIG, , <cfloat>)
+SYMBOL(LDBL_MANT_DIG, , <float.h>)
+SYMBOL(LDBL_MAX, , <cfloat>)
+SYMBOL(LDBL_MAX, , <float.h>)
+SYMBOL(LDBL_MAX_10_EXP, , <cfloat>)
+SYMBOL(LDBL_MAX_10_EXP, , <float.h>)
+SYMBOL(LDBL_MAX_EXP, , <cfloat>)
+SYMBOL(LDBL_MAX_EXP, , <float.h>)
+SYMBOL(LDBL_MIN, , <cfloat>)
+SYMBOL(LDBL_MIN, , <float.h>)
+SYMBOL(LDBL_MIN_10_EXP, , <cfloat>)
+SYMBOL(LDBL_MIN_10_EXP, , <float.h>)
+SYMBOL(LDBL_MIN_EXP, , <cfloat>)
+SYMBOL(LDBL_MIN_EXP, , <float.h>)
+SYMBOL(LDBL_TRUE_MIN, , <cfloat>)
+SYMBOL(LDBL_TRUE_MIN, , <float.h>)
+SYMBOL(LLONG_MAX, , <climits>)
+SYMBOL(LLONG_MAX, , <limits.h>)
+SYMBOL(LLONG_MIN, , <climits>)
+SYMBOL(LLONG_MIN, , <limits.h>)
+SYMBOL(LONG_MAX, , <climits>)
+SYMBOL(LONG_MAX, , <limits.h>)
+SYMBOL(LONG_MIN, , <climits>)
+SYMBOL(LONG_MIN, , <limits.h>)
+SYMBOL(L_tmpnam, , <cstdio>)
+SYMBOL(L_tmpnam, , <stdio.h>)
+SYMBOL(MATH_ERREXCEPT, , <cmath>)
+SYMBOL(MATH_ERREXCEPT, , <math.h>)
+SYMBOL(MATH_ERRNO, , <cmath>)
+SYMBOL(MATH_ERRNO, , <math.h>)
+SYMBOL(MB_CUR_MAX, , <cstdlib>)
+SYMBOL(MB_CUR_MAX, , <stdlib.h>)
+SYMBOL(MB_LEN_MAX, , <climits>)
+SYMBOL(MB_LEN_MAX, , <limits.h>)
+SYMBOL(NAN, , <cmath>)
+SYMBOL(NAN, , <math.h>)
+SYMBOL(ONCE_FLAG_INIT, , <mutex>)
+SYMBOL(PTRDIFF_MAX, , <cstdint>)
+SYMBOL(PTRDIFF_MAX, , <stdint.h>)
+SYMBOL(PTRDIFF_MIN, , <cstdint>)
+SYMBOL(PTRDIFF_MIN, , <stdint.h>)
+SYMBOL(RAND_MAX, , <cstdlib>)
+SYMBOL(RAND_MAX, , <stdlib.h>)
+SYMBOL(SCHAR_MAX, , <climits>)
+SYMBOL(SCHAR_MAX, , <limits.h>)
+SYMBOL(SCHAR_MIN, , <climits>)
+SYMBOL(SCHAR_MIN, , <limits.h>)
+SYMBOL(SEEK_CUR, , <cstdio>)
+SYMBOL(SEEK_CUR, , <stdio.h>)
+SYMBOL(SEEK_END, , <cstdio>)
+SYMBOL(SEEK_END, , <stdio.h>)
+SYMBOL(SEEK_SET, , <cstdio>)
+SYMBOL(SEEK_SET, , <stdio.h>)
+SYMBOL(SHRT_MAX, , <climits>)
+SYMBOL(SHRT_MAX, , <limits.h>)
+SYMBOL(SHRT_MIN, , <climits>)
+SYMBOL(SHRT_MIN, , <limits.h>)
+SYMBOL(SIGABRT, , <csignal>)
+SYMBOL(SIGABRT, , <signal.h>)
+SYMBOL(SIGFPE, , <csignal>)
+SYMBOL(SIGFPE, , <signal.h>)
+SYMBOL(SIGILL, , <csignal>)
+SYMBOL(SIGILL, , <signal.h>)
+SYMBOL(SIGINT, , <csignal>)
+SYMBOL(SIGINT, , <signal.h>)
+SYMBOL(SIGSEGV, , <csignal>)
+SYMBOL(SIGSEGV, , <signal.h>)
+SYMBOL(SIGTERM, , <csignal>)
+SYMBOL(SIGTERM, , <signal.h>)
+SYMBOL(SIG_ATOMIC_MAX, , <cstdint>)
+SYMBOL(SIG_ATOMIC_MAX, , <stdint.h>)
+SYMBOL(SIG_ATOMIC_MIN, , <cstdint>)
+SYMBOL(SIG_ATOMIC_MIN, , <stdint.h>)
+SYMBOL(SIG_DFL, , <csignal>)
+SYMBOL(SIG_DFL, , <signal.h>)
+SYMBOL(SIG_ERR, , <csignal>)
+SYMBOL(SIG_ERR, , <signal.h>)
+SYMBOL(SIG_IGN, , <csignal>)
+SYMBOL(SIG_IGN, , <signal.h>)
+SYMBOL(SIZE_MAX, , <cstdint>)
+SYMBOL(SIZE_MAX, , <stdint.h>)
+SYMBOL(TIME_UTC, , <ctime>)
+SYMBOL(TIME_UTC, , <time.h>)
+SYMBOL(TMP_MAX, , <cstdio>)
+SYMBOL(TMP_MAX, , <stdio.h>)
+SYMBOL(UCHAR_MAX, , <climits>)
+SYMBOL(UCHAR_MAX, , <limits.h>)
+SYMBOL(UINT16_MAX, , <cstdint>)
+SYMBOL(UINT16_MAX, , <stdint.h>)
+SYMBOL(UINT32_MAX, , <cstdint>)
+SYMBOL(UINT32_MAX, , <stdint.h>)
+SYMBOL(UINT64_MAX, , <cstdint>)
+SYMBOL(UINT64_MAX, , <stdint.h>)
+SYMBOL(UINT8_MAX, , <cstdint>)
+SYMBOL(UINT8_MAX, , <stdint.h>)
+SYMBOL(UINTMAX_MAX, , <cstdint>)
+SYMBOL(UINTMAX_MAX, , <stdint.h>)
+SYMBOL(UINTPTR_MAX, , <cstdint>)
+SYMBOL(UINTPTR_MAX, , <stdint.h>)
+SYMBOL(UINT_FAST16_MAX, , <cstdint>)
+SYMBOL(UINT_FAST16_MAX, , <stdint.h>)
+SYMBOL(UINT_FAST32_MAX, , <cstdint>)
+SYMBOL(UINT_FAST32_MAX, , <stdint.h>)
+SYMBOL(UINT_FAST64_MAX, , <cstdint>)
+SYMBOL(UINT_FAST64_MAX, , <stdint.h>)
+SYMBOL(UINT_FAST8_MAX, , <cstdint>)
+SYMBOL(UINT_FAST8_MAX, , <stdint.h>)
+SYMBOL(UINT_LEAST16_MAX, , <cstdint>)
+SYMBOL(UINT_LEAST16_MAX, , <stdint.h>)
+SYMBOL(UINT_LEAST32_MAX, , <cstdint>)
+SYMBOL(UINT_LEAST32_MAX, , <stdint.h>)
+SYMBOL(UINT_LEAST64_MAX, , <cstdint>)
+SYMBOL(UINT_LEAST64_MAX, , <stdint.h>)
+SYMBOL(UINT_LEAST8_MAX, , <cstdint>)
+SYMBOL(UINT_LEAST8_MAX, , <stdint.h>)
+SYMBOL(UINT_MAX, , <climits>)
+SYMBOL(UINT_MAX, , <limits.h>)
+SYMBOL(ULLONG_MAX, , <climits>)
+SYMBOL(ULLONG_MAX, , <limits.h>)
+SYMBOL(ULONG_MAX, , <climits>)
+SYMBOL(ULONG_MAX, , <limits.h>)
+SYMBOL(USHRT_MAX, , <climits>)
+SYMBOL(USHRT_MAX, , <limits.h>)
+SYMBOL(WEOF, , <cwchar>)
+SYMBOL(WEOF, , <wchar.h>)
+SYMBOL(WINT_MAX, , <cstdint>)
+SYMBOL(WINT_MAX, , <stdint.h>)
+SYMBOL(WINT_MIN, , <cstdint>)
+SYMBOL(WINT_MIN, , <stdint.h>)
+SYMBOL(_IOFBF, , <cstdio>)
+SYMBOL(_IOFBF, , <stdio.h>)
+SYMBOL(_IOLBF, , <cstdio>)
+SYMBOL(_IOLBF, , <stdio.h>)
+SYMBOL(_IONBF, , <cstdio>)
+SYMBOL(_IONBF, , <stdio.h>)
+SYMBOL(assert, , <cassert>)
+SYMBOL(assert, , <assert.h>)
+SYMBOL(errno, , <cerrno>)
+SYMBOL(errno, , <errno.h>)
+SYMBOL(math_errhandling, , <cmath>)
+SYMBOL(math_errhandling, , <math.h>)
+SYMBOL(offsetof, , <cstddef>)
+SYMBOL(offsetof, , <stddef.h>)
+SYMBOL(setjmp, , <csetjmp>)
+SYMBOL(setjmp, , <setjmp.h>)
+SYMBOL(stderr, , <cstdio>)
+SYMBOL(stderr, , <stdio.h>)
+SYMBOL(stdin, , <cstdio>)
+SYMBOL(stdin, , <stdio.h>)
+SYMBOL(stdout, , <cstdio>)
+SYMBOL(stdout, , <stdio.h>)
+SYMBOL(va_arg, , <cstdarg>)
+SYMBOL(va_arg, , <stdarg.h>)
+SYMBOL(va_copy, , <cstdarg>)
+SYMBOL(va_copy, , <stdarg.h>)
+SYMBOL(va_end, , <cstdarg>)
+SYMBOL(va_end, , <stdarg.h>)
+SYMBOL(va_start, , <cstdarg>)
+SYMBOL(va_start, , <stdarg.h>)
 SYMBOL(FILE, std::, <cstdio>)
-SYMBOL(FILE, None, <cstdio>)
-SYMBOL(FILE, None, <stdio.h>)
+SYMBOL(FILE, , <cstdio>)
+SYMBOL(FILE, , <stdio.h>)
 SYMBOL(_Exit, std::, <cstdlib>)
-SYMBOL(_Exit, None, <cstdlib>)
-SYMBOL(_Exit, None, <stdlib.h>)
+SYMBOL(_Exit, , <cstdlib>)
+SYMBOL(_Exit, , <stdlib.h>)
 SYMBOL(accumulate, std::, <numeric>)
 SYMBOL(acos, std::, <cmath>)
-SYMBOL(acos, None, <cmath>)
-SYMBOL(acos, None, <math.h>)
+SYMBOL(acos, , <cmath>)
+SYMBOL(acos, , <math.h>)
 SYMBOL(acosf, std::, <cmath>)
-SYMBOL(acosf, None, <cmath>)
-SYMBOL(acosf, None, <math.h>)
+SYMBOL(acosf, , <cmath>)
+SYMBOL(acosf, , <math.h>)
 SYMBOL(acosh, std::, <cmath>)
-SYMBOL(acosh, None, <cmath>)
-SYMBOL(acosh, None, <math.h>)
+SYMBOL(acosh, , <cmath>)
+SYMBOL(acosh, , <math.h>)
 SYMBOL(acoshf, std::, <cmath>)
-SYMBOL(acoshf, None, <cmath>)
-SYMBOL(acoshf, None, <math.h>)
+SYMBOL(acoshf, , <cmath>)
+SYMBOL(acoshf, , <math.h>)
 SYMBOL(acoshl, std::, <cmath>)
-SYMBOL(acoshl, None, <cmath>)
-SYMBOL(acoshl, None, <math.h>)
+SYMBOL(acoshl, , <cmath>)
+SYMBOL(acoshl, , <math.h>)
 SYMBOL(acosl, std::, <cmath>)
-SYMBOL(acosl, None, <cmath>)
-SYMBOL(acosl, None, <math.h>)
+SYMBOL(acosl, , <cmath>)
+SYMBOL(acosl, , <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_alloc, , <cstdlib>)
+SYMBOL(aligned_alloc, , <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(asctime, , <ctime>)
+SYMBOL(asctime, , <time.h>)
 SYMBOL(asin, std::, <cmath>)
-SYMBOL(asin, None, <cmath>)
-SYMBOL(asin, None, <math.h>)
+SYMBOL(asin, , <cmath>)
+SYMBOL(asin, , <math.h>)
 SYMBOL(asinf, std::, <cmath>)
-SYMBOL(asinf, None, <cmath>)
-SYMBOL(asinf, None, <math.h>)
+SYMBOL(asinf, , <cmath>)
+SYMBOL(asinf, , <math.h>)
 SYMBOL(asinh, std::, <cmath>)
-SYMBOL(asinh, None, <cmath>)
-SYMBOL(asinh, None, <math.h>)
+SYMBOL(asinh, , <cmath>)
+SYMBOL(asinh, , <math.h>)
 SYMBOL(asinhf, std::, <cmath>)
-SYMBOL(asinhf, None, <cmath>)
-SYMBOL(asinhf, None, <math.h>)
+SYMBOL(asinhf, , <cmath>)
+SYMBOL(asinhf, , <math.h>)
 SYMBOL(asinhl, std::, <cmath>)
-SYMBOL(asinhl, None, <cmath>)
-SYMBOL(asinhl, None, <math.h>)
+SYMBOL(asinhl, , <cmath>)
+SYMBOL(asinhl, , <math.h>)
 SYMBOL(asinl, std::, <cmath>)
-SYMBOL(asinl, None, <cmath>)
-SYMBOL(asinl, None, <math.h>)
+SYMBOL(asinl, , <cmath>)
+SYMBOL(asinl, , <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(at_quick_exit, , <cstdlib>)
+SYMBOL(at_quick_exit, , <stdlib.h>)
 SYMBOL(atan, std::, <cmath>)
-SYMBOL(atan, None, <cmath>)
-SYMBOL(atan, None, <math.h>)
+SYMBOL(atan, , <cmath>)
+SYMBOL(atan, , <math.h>)
 SYMBOL(atan2, std::, <cmath>)
-SYMBOL(atan2, None, <cmath>)
-SYMBOL(atan2, None, <math.h>)
+SYMBOL(atan2, , <cmath>)
+SYMBOL(atan2, , <math.h>)
 SYMBOL(atan2f, std::, <cmath>)
-SYMBOL(atan2f, None, <cmath>)
-SYMBOL(atan2f, None, <math.h>)
+SYMBOL(atan2f, , <cmath>)
+SYMBOL(atan2f, , <math.h>)
 SYMBOL(atan2l, std::, <cmath>)
-SYMBOL(atan2l, None, <cmath>)
-SYMBOL(atan2l, None, <math.h>)
+SYMBOL(atan2l, , <cmath>)
+SYMBOL(atan2l, , <math.h>)
 SYMBOL(atanf, std::, <cmath>)
-SYMBOL(atanf, None, <cmath>)
-SYMBOL(atanf, None, <math.h>)
+SYMBOL(atanf, , <cmath>)
+SYMBOL(atanf, , <math.h>)
 SYMBOL(atanh, std::, <cmath>)
-SYMBOL(atanh, None, <cmath>)
-SYMBOL(atanh, None, <math.h>)
+SYMBOL(atanh, , <cmath>)
+SYMBOL(atanh, , <math.h>)
 SYMBOL(atanhf, std::, <cmath>)
-SYMBOL(atanhf, None, <cmath>)
-SYMBOL(atanhf, None, <math.h>)
+SYMBOL(atanhf, , <cmath>)
+SYMBOL(atanhf, , <math.h>)
 SYMBOL(atanhl, std::, <cmath>)
-SYMBOL(atanhl, None, <cmath>)
-SYMBOL(atanhl, None, <math.h>)
+SYMBOL(atanhl, , <cmath>)
+SYMBOL(atanhl, , <math.h>)
 SYMBOL(atanl, std::, <cmath>)
-SYMBOL(atanl, None, <cmath>)
-SYMBOL(atanl, None, <math.h>)
+SYMBOL(atanl, , <cmath>)
+SYMBOL(atanl, , <math.h>)
 SYMBOL(atexit, std::, <cstdlib>)
-SYMBOL(atexit, None, <cstdlib>)
-SYMBOL(atexit, None, <stdlib.h>)
+SYMBOL(atexit, , <cstdlib>)
+SYMBOL(atexit, , <stdlib.h>)
 SYMBOL(atof, std::, <cstdlib>)
-SYMBOL(atof, None, <cstdlib>)
-SYMBOL(atof, None, <stdlib.h>)
+SYMBOL(atof, , <cstdlib>)
+SYMBOL(atof, , <stdlib.h>)
 SYMBOL(atoi, std::, <cstdlib>)
-SYMBOL(atoi, None, <cstdlib>)
-SYMBOL(atoi, None, <stdlib.h>)
+SYMBOL(atoi, , <cstdlib>)
+SYMBOL(atoi, , <stdlib.h>)
 SYMBOL(atol, std::, <cstdlib>)
-SYMBOL(atol, None, <cstdlib>)
-SYMBOL(atol, None, <stdlib.h>)
+SYMBOL(atol, , <cstdlib>)
+SYMBOL(atol, , <stdlib.h>)
 SYMBOL(atoll, std::, <cstdlib>)
-SYMBOL(atoll, None, <cstdlib>)
-SYMBOL(atoll, None, <stdlib.h>)
+SYMBOL(atoll, , <cstdlib>)
+SYMBOL(atoll, , <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(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(bsearch, , <cstdlib>)
+SYMBOL(bsearch, , <stdlib.h>)
 SYMBOL(btowc, std::, <cwchar>)
-SYMBOL(btowc, None, <cwchar>)
-SYMBOL(btowc, None, <wchar.h>)
+SYMBOL(btowc, , <cwchar>)
+SYMBOL(btowc, , <wchar.h>)
 SYMBOL(byte, std::, <cstddef>)
 SYMBOL(byteswap, std::, <bit>)
 SYMBOL(c16rtomb, std::, <cuchar>)
-SYMBOL(c16rtomb, None, <cuchar>)
-SYMBOL(c16rtomb, None, <uchar.h>)
+SYMBOL(c16rtomb, , <cuchar>)
+SYMBOL(c16rtomb, , <uchar.h>)
 SYMBOL(c32rtomb, std::, <cuchar>)
-SYMBOL(c32rtomb, None, <cuchar>)
-SYMBOL(c32rtomb, None, <uchar.h>)
+SYMBOL(c32rtomb, , <cuchar>)
+SYMBOL(c32rtomb, , <uchar.h>)
 SYMBOL(c8rtomb, std::, <cuchar>)
-SYMBOL(c8rtomb, None, <cuchar>)
-SYMBOL(c8rtomb, None, <uchar.h>)
+SYMBOL(c8rtomb, , <cuchar>)
+SYMBOL(c8rtomb, , <uchar.h>)
 SYMBOL(call_once, std::, <mutex>)
 SYMBOL(calloc, std::, <cstdlib>)
-SYMBOL(calloc, None, <cstdlib>)
-SYMBOL(calloc, None, <stdlib.h>)
+SYMBOL(calloc, , <cstdlib>)
+SYMBOL(calloc, , <stdlib.h>)
 SYMBOL(cauchy_distribution, std::, <random>)
 SYMBOL(cbrt, std::, <cmath>)
-SYMBOL(cbrt, None, <cmath>)
-SYMBOL(cbrt, None, <math.h>)
+SYMBOL(cbrt, , <cmath>)
+SYMBOL(cbrt, , <math.h>)
 SYMBOL(cbrtf, std::, <cmath>)
-SYMBOL(cbrtf, None, <cmath>)
-SYMBOL(cbrtf, None, <math.h>)
+SYMBOL(cbrtf, , <cmath>)
+SYMBOL(cbrtf, , <math.h>)
 SYMBOL(cbrtl, std::, <cmath>)
-SYMBOL(cbrtl, None, <cmath>)
-SYMBOL(cbrtl, None, <math.h>)
+SYMBOL(cbrtl, , <cmath>)
+SYMBOL(cbrtl, , <math.h>)
 SYMBOL(ceil, std::, <cmath>)
-SYMBOL(ceil, None, <cmath>)
-SYMBOL(ceil, None, <math.h>)
+SYMBOL(ceil, , <cmath>)
+SYMBOL(ceil, , <math.h>)
 SYMBOL(ceilf, std::, <cmath>)
-SYMBOL(ceilf, None, <cmath>)
-SYMBOL(ceilf, None, <math.h>)
+SYMBOL(ceilf, , <cmath>)
+SYMBOL(ceilf, , <math.h>)
 SYMBOL(ceill, std::, <cmath>)
-SYMBOL(ceill, None, <cmath>)
-SYMBOL(ceill, None, <math.h>)
+SYMBOL(ceill, , <cmath>)
+SYMBOL(ceill, , <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(clearerr, , <cstdio>)
+SYMBOL(clearerr, , <stdio.h>)
 SYMBOL(clock, std::, <ctime>)
-SYMBOL(clock, None, <ctime>)
-SYMBOL(clock, None, <time.h>)
+SYMBOL(clock, , <ctime>)
+SYMBOL(clock, , <time.h>)
 SYMBOL(clock_t, std::, <ctime>)
-SYMBOL(clock_t, None, <ctime>)
-SYMBOL(clock_t, None, <time.h>)
+SYMBOL(clock_t, , <ctime>)
+SYMBOL(clock_t, , <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(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(copysign, , <cmath>)
+SYMBOL(copysign, , <math.h>)
 SYMBOL(copysignf, std::, <cmath>)
-SYMBOL(copysignf, None, <cmath>)
-SYMBOL(copysignf, None, <math.h>)
+SYMBOL(copysignf, , <cmath>)
+SYMBOL(copysignf, , <math.h>)
 SYMBOL(copysignl, std::, <cmath>)
-SYMBOL(copysignl, None, <cmath>)
-SYMBOL(copysignl, None, <math.h>)
+SYMBOL(copysignl, , <cmath>)
+SYMBOL(copysignl, , <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(cos, , <cmath>)
+SYMBOL(cos, , <math.h>)
 SYMBOL(cosf, std::, <cmath>)
-SYMBOL(cosf, None, <cmath>)
-SYMBOL(cosf, None, <math.h>)
+SYMBOL(cosf, , <cmath>)
+SYMBOL(cosf, , <math.h>)
 SYMBOL(cosh, std::, <cmath>)
-SYMBOL(cosh, None, <cmath>)
-SYMBOL(cosh, None, <math.h>)
+SYMBOL(cosh, , <cmath>)
+SYMBOL(cosh, , <math.h>)
 SYMBOL(coshf, std::, <cmath>)
-SYMBOL(coshf, None, <cmath>)
-SYMBOL(coshf, None, <math.h>)
+SYMBOL(coshf, , <cmath>)
+SYMBOL(coshf, , <math.h>)
 SYMBOL(coshl, std::, <cmath>)
-SYMBOL(coshl, None, <cmath>)
-SYMBOL(coshl, None, <math.h>)
+SYMBOL(coshl, , <cmath>)
+SYMBOL(coshl, , <math.h>)
 SYMBOL(cosl, std::, <cmath>)
-SYMBOL(cosl, None, <cmath>)
-SYMBOL(cosl, None, <math.h>)
+SYMBOL(cosl, , <cmath>)
+SYMBOL(cosl, , <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(ctime, , <ctime>)
+SYMBOL(ctime, , <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(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(difftime, , <ctime>)
+SYMBOL(difftime, , <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(div_t, , <cstdlib>)
+SYMBOL(div_t, , <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(double_t, , <cmath>)
+SYMBOL(double_t, , <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(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(erf, , <cmath>)
+SYMBOL(erf, , <math.h>)
 SYMBOL(erfc, std::, <cmath>)
-SYMBOL(erfc, None, <cmath>)
-SYMBOL(erfc, None, <math.h>)
+SYMBOL(erfc, , <cmath>)
+SYMBOL(erfc, , <math.h>)
 SYMBOL(erfcf, std::, <cmath>)
-SYMBOL(erfcf, None, <cmath>)
-SYMBOL(erfcf, None, <math.h>)
+SYMBOL(erfcf, , <cmath>)
+SYMBOL(erfcf, , <math.h>)
 SYMBOL(erfcl, std::, <cmath>)
-SYMBOL(erfcl, None, <cmath>)
-SYMBOL(erfcl, None, <math.h>)
+SYMBOL(erfcl, , <cmath>)
+SYMBOL(erfcl, , <math.h>)
 SYMBOL(erff, std::, <cmath>)
-SYMBOL(erff, None, <cmath>)
-SYMBOL(erff, None, <math.h>)
+SYMBOL(erff, , <cmath>)
+SYMBOL(erff, , <math.h>)
 SYMBOL(erfl, std::, <cmath>)
-SYMBOL(erfl, None, <cmath>)
-SYMBOL(erfl, None, <math.h>)
+SYMBOL(erfl, , <cmath>)
+SYMBOL(erfl, , <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(exit, , <cstdlib>)
+SYMBOL(exit, , <stdlib.h>)
 SYMBOL(exp, std::, <cmath>)
-SYMBOL(exp, None, <cmath>)
-SYMBOL(exp, None, <math.h>)
+SYMBOL(exp, , <cmath>)
+SYMBOL(exp, , <math.h>)
 SYMBOL(exp2, std::, <cmath>)
-SYMBOL(exp2, None, <cmath>)
-SYMBOL(exp2, None, <math.h>)
+SYMBOL(exp2, , <cmath>)
+SYMBOL(exp2, , <math.h>)
 SYMBOL(exp2f, std::, <cmath>)
-SYMBOL(exp2f, None, <cmath>)
-SYMBOL(exp2f, None, <math.h>)
+SYMBOL(exp2f, , <cmath>)
+SYMBOL(exp2f, , <math.h>)
 SYMBOL(exp2l, std::, <cmath>)
-SYMBOL(exp2l, None, <cmath>)
-SYMBOL(exp2l, None, <math.h>)
+SYMBOL(exp2l, , <cmath>)
+SYMBOL(exp2l, , <math.h>)
 SYMBOL(expf, std::, <cmath>)
-SYMBOL(expf, None, <cmath>)
-SYMBOL(expf, None, <math.h>)
+SYMBOL(expf, , <cmath>)
+SYMBOL(expf, , <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(expl, , <cmath>)
+SYMBOL(expl, , <math.h>)
 SYMBOL(expm1, std::, <cmath>)
-SYMBOL(expm1, None, <cmath>)
-SYMBOL(expm1, None, <math.h>)
+SYMBOL(expm1, , <cmath>)
+SYMBOL(expm1, , <math.h>)
 SYMBOL(expm1f, std::, <cmath>)
-SYMBOL(expm1f, None, <cmath>)
-SYMBOL(expm1f, None, <math.h>)
+SYMBOL(expm1f, , <cmath>)
+SYMBOL(expm1f, , <math.h>)
 SYMBOL(expm1l, std::, <cmath>)
-SYMBOL(expm1l, None, <cmath>)
-SYMBOL(expm1l, None, <math.h>)
+SYMBOL(expm1l, , <cmath>)
+SYMBOL(expm1l, , <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(fabs, , <cmath>)
+SYMBOL(fabs, , <math.h>)
 SYMBOL(fabsf, std::, <cmath>)
-SYMBOL(fabsf, None, <cmath>)
-SYMBOL(fabsf, None, <math.h>)
+SYMBOL(fabsf, , <cmath>)
+SYMBOL(fabsf, , <math.h>)
 SYMBOL(fabsl, std::, <cmath>)
-SYMBOL(fabsl, None, <cmath>)
-SYMBOL(fabsl, None, <math.h>)
+SYMBOL(fabsl, , <cmath>)
+SYMBOL(fabsl, , <math.h>)
 SYMBOL(false_type, std::, <type_traits>)
 SYMBOL(fclose, std::, <cstdio>)
-SYMBOL(fclose, None, <cstdio>)
-SYMBOL(fclose, None, <stdio.h>)
+SYMBOL(fclose, , <cstdio>)
+SYMBOL(fclose, , <stdio.h>)
 SYMBOL(fdim, std::, <cmath>)
-SYMBOL(fdim, None, <cmath>)
-SYMBOL(fdim, None, <math.h>)
+SYMBOL(fdim, , <cmath>)
+SYMBOL(fdim, , <math.h>)
 SYMBOL(fdimf, std::, <cmath>)
-SYMBOL(fdimf, None, <cmath>)
-SYMBOL(fdimf, None, <math.h>)
+SYMBOL(fdimf, , <cmath>)
+SYMBOL(fdimf, , <math.h>)
 SYMBOL(fdiml, std::, <cmath>)
-SYMBOL(fdiml, None, <cmath>)
-SYMBOL(fdiml, None, <math.h>)
+SYMBOL(fdiml, , <cmath>)
+SYMBOL(fdiml, , <math.h>)
 SYMBOL(feclearexcept, std::, <cfenv>)
-SYMBOL(feclearexcept, None, <cfenv>)
-SYMBOL(feclearexcept, None, <fenv.h>)
+SYMBOL(feclearexcept, , <cfenv>)
+SYMBOL(feclearexcept, , <fenv.h>)
 SYMBOL(fegetenv, std::, <cfenv>)
-SYMBOL(fegetenv, None, <cfenv>)
-SYMBOL(fegetenv, None, <fenv.h>)
+SYMBOL(fegetenv, , <cfenv>)
+SYMBOL(fegetenv, , <fenv.h>)
 SYMBOL(fegetexceptflag, std::, <cfenv>)
-SYMBOL(fegetexceptflag, None, <cfenv>)
-SYMBOL(fegetexceptflag, None, <fenv.h>)
+SYMBOL(fegetexceptflag, , <cfenv>)
+SYMBOL(fegetexceptflag, , <fenv.h>)
 SYMBOL(fegetround, std::, <cfenv>)
-SYMBOL(fegetround, None, <cfenv>)
-SYMBOL(fegetround, None, <fenv.h>)
+SYMBOL(fegetround, , <cfenv>)
+SYMBOL(fegetround, , <fenv.h>)
 SYMBOL(feholdexcept, std::, <cfenv>)
-SYMBOL(feholdexcept, None, <cfenv>)
-SYMBOL(feholdexcept, None, <fenv.h>)
+SYMBOL(feholdexcept, , <cfenv>)
+SYMBOL(feholdexcept, , <fenv.h>)
 SYMBOL(femto, std::, <ratio>)
 SYMBOL(fenv_t, std::, <cfenv>)
-SYMBOL(fenv_t, None, <cfenv>)
-SYMBOL(fenv_t, None, <fenv.h>)
+SYMBOL(fenv_t, , <cfenv>)
+SYMBOL(fenv_t, , <fenv.h>)
 SYMBOL(feof, std::, <cstdio>)
-SYMBOL(feof, None, <cstdio>)
-SYMBOL(feof, None, <stdio.h>)
+SYMBOL(feof, , <cstdio>)
+SYMBOL(feof, , <stdio.h>)
 SYMBOL(feraiseexcept, std::, <cfenv>)
-SYMBOL(feraiseexcept, None, <cfenv>)
-SYMBOL(feraiseexcept, None, <fenv.h>)
+SYMBOL(feraiseexcept, , <cfenv>)
+SYMBOL(feraiseexcept, , <fenv.h>)
 SYMBOL(ferror, std::, <cstdio>)
-SYMBOL(ferror, None, <cstdio>)
-SYMBOL(ferror, None, <stdio.h>)
+SYMBOL(ferror, , <cstdio>)
+SYMBOL(ferror, , <stdio.h>)
 SYMBOL(fesetenv, std::, <cfenv>)
-SYMBOL(fesetenv, None, <cfenv>)
-SYMBOL(fesetenv, None, <fenv.h>)
+SYMBOL(fesetenv, , <cfenv>)
+SYMBOL(fesetenv, , <fenv.h>)
 SYMBOL(fesetexceptflag, std::, <cfenv>)
-SYMBOL(fesetexceptflag, None, <cfenv>)
-SYMBOL(fesetexceptflag, None, <fenv.h>)
+SYMBOL(fesetexceptflag, , <cfenv>)
+SYMBOL(fesetexceptflag, , <fenv.h>)
 SYMBOL(fesetround, std::, <cfenv>)
-SYMBOL(fesetround, None, <cfenv>)
-SYMBOL(fesetround, None, <fenv.h>)
+SYMBOL(fesetround, , <cfenv>)
+SYMBOL(fesetround, , <fenv.h>)
 SYMBOL(fetestexcept, std::, <cfenv>)
-SYMBOL(fetestexcept, None, <cfenv>)
-SYMBOL(fetestexcept, None, <fenv.h>)
+SYMBOL(fetestexcept, , <cfenv>)
+SYMBOL(fetestexcept, , <fenv.h>)
 SYMBOL(feupdateenv, std::, <cfenv>)
-SYMBOL(feupdateenv, None, <cfenv>)
-SYMBOL(feupdateenv, None, <fenv.h>)
+SYMBOL(feupdateenv, , <cfenv>)
+SYMBOL(feupdateenv, , <fenv.h>)
 SYMBOL(fexcept_t, std::, <cfenv>)
-SYMBOL(fexcept_t, None, <cfenv>)
-SYMBOL(fexcept_t, None, <fenv.h>)
+SYMBOL(fexcept_t, , <cfenv>)
+SYMBOL(fexcept_t, , <fenv.h>)
 SYMBOL(fflush, std::, <cstdio>)
-SYMBOL(fflush, None, <cstdio>)
-SYMBOL(fflush, None, <stdio.h>)
+SYMBOL(fflush, , <cstdio>)
+SYMBOL(fflush, , <stdio.h>)
 SYMBOL(fgetc, std::, <cstdio>)
-SYMBOL(fgetc, None, <cstdio>)
-SYMBOL(fgetc, None, <stdio.h>)
+SYMBOL(fgetc, , <cstdio>)
+SYMBOL(fgetc, , <stdio.h>)
 SYMBOL(fgetpos, std::, <cstdio>)
-SYMBOL(fgetpos, None, <cstdio>)
-SYMBOL(fgetpos, None, <stdio.h>)
+SYMBOL(fgetpos, , <cstdio>)
+SYMBOL(fgetpos, , <stdio.h>)
 SYMBOL(fgets, std::, <cstdio>)
-SYMBOL(fgets, None, <cstdio>)
-SYMBOL(fgets, None, <stdio.h>)
+SYMBOL(fgets, , <cstdio>)
+SYMBOL(fgets, , <stdio.h>)
 SYMBOL(fgetwc, std::, <cwchar>)
-SYMBOL(fgetwc, None, <cwchar>)
-SYMBOL(fgetwc, None, <wchar.h>)
+SYMBOL(fgetwc, , <cwchar>)
+SYMBOL(fgetwc, , <wchar.h>)
 SYMBOL(fgetws, std::, <cwchar>)
-SYMBOL(fgetws, None, <cwchar>)
-SYMBOL(fgetws, None, <wchar.h>)
+SYMBOL(fgetws, , <cwchar>)
+SYMBOL(fgetws, , <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(float_t, , <cmath>)
+SYMBOL(float_t, , <math.h>)
 SYMBOL(floating_point, std::, <concepts>)
 SYMBOL(floor, std::, <cmath>)
-SYMBOL(floor, None, <cmath>)
-SYMBOL(floor, None, <math.h>)
+SYMBOL(floor, , <cmath>)
+SYMBOL(floor, , <math.h>)
 SYMBOL(floorf, std::, <cmath>)
-SYMBOL(floorf, None, <cmath>)
-SYMBOL(floorf, None, <math.h>)
+SYMBOL(floorf, , <cmath>)
+SYMBOL(floorf, , <math.h>)
 SYMBOL(floorl, std::, <cmath>)
-SYMBOL(floorl, None, <cmath>)
-SYMBOL(floorl, None, <math.h>)
+SYMBOL(floorl, , <cmath>)
+SYMBOL(floorl, , <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(fma, , <cmath>)
+SYMBOL(fma, , <math.h>)
 SYMBOL(fmaf, std::, <cmath>)
-SYMBOL(fmaf, None, <cmath>)
-SYMBOL(fmaf, None, <math.h>)
+SYMBOL(fmaf, , <cmath>)
+SYMBOL(fmaf, , <math.h>)
 SYMBOL(fmal, std::, <cmath>)
-SYMBOL(fmal, None, <cmath>)
-SYMBOL(fmal, None, <math.h>)
+SYMBOL(fmal, , <cmath>)
+SYMBOL(fmal, , <math.h>)
 SYMBOL(fmax, std::, <cmath>)
-SYMBOL(fmax, None, <cmath>)
-SYMBOL(fmax, None, <math.h>)
+SYMBOL(fmax, , <cmath>)
+SYMBOL(fmax, , <math.h>)
 SYMBOL(fmaxf, std::, <cmath>)
-SYMBOL(fmaxf, None, <cmath>)
-SYMBOL(fmaxf, None, <math.h>)
+SYMBOL(fmaxf, , <cmath>)
+SYMBOL(fmaxf, , <math.h>)
 SYMBOL(fmaxl, std::, <cmath>)
-SYMBOL(fmaxl, None, <cmath>)
-SYMBOL(fmaxl, None, <math.h>)
+SYMBOL(fmaxl, , <cmath>)
+SYMBOL(fmaxl, , <math.h>)
 SYMBOL(fmin, std::, <cmath>)
-SYMBOL(fmin, None, <cmath>)
-SYMBOL(fmin, None, <math.h>)
+SYMBOL(fmin, , <cmath>)
+SYMBOL(fmin, , <math.h>)
 SYMBOL(fminf, std::, <cmath>)
-SYMBOL(fminf, None, <cmath>)
-SYMBOL(fminf, None, <math.h>)
+SYMBOL(fminf, , <cmath>)
+SYMBOL(fminf, , <math.h>)
 SYMBOL(fminl, std::, <cmath>)
-SYMBOL(fminl, None, <cmath>)
-SYMBOL(fminl, None, <math.h>)
+SYMBOL(fminl, , <cmath>)
+SYMBOL(fminl, , <math.h>)
 SYMBOL(fmod, std::, <cmath>)
-SYMBOL(fmod, None, <cmath>)
-SYMBOL(fmod, None, <math.h>)
+SYMBOL(fmod, , <cmath>)
+SYMBOL(fmod, , <math.h>)
 SYMBOL(fmodf, std::, <cmath>)
-SYMBOL(fmodf, None, <cmath>)
-SYMBOL(fmodf, None, <math.h>)
+SYMBOL(fmodf, , <cmath>)
+SYMBOL(fmodf, , <math.h>)
 SYMBOL(fmodl, std::, <cmath>)
-SYMBOL(fmodl, None, <cmath>)
-SYMBOL(fmodl, None, <math.h>)
+SYMBOL(fmodl, , <cmath>)
+SYMBOL(fmodl, , <math.h>)
 SYMBOL(fopen, std::, <cstdio>)
-SYMBOL(fopen, None, <cstdio>)
-SYMBOL(fopen, None, <stdio.h>)
+SYMBOL(fopen, , <cstdio>)
+SYMBOL(fopen, , <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(fpclassify, , <cmath>)
+SYMBOL(fpclassify, , <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(fpos_t, , <cstdio>)
+SYMBOL(fpos_t, , <stdio.h>)
 SYMBOL(fprintf, std::, <cstdio>)
-SYMBOL(fprintf, None, <cstdio>)
-SYMBOL(fprintf, None, <stdio.h>)
+SYMBOL(fprintf, , <cstdio>)
+SYMBOL(fprintf, , <stdio.h>)
 SYMBOL(fputc, std::, <cstdio>)
-SYMBOL(fputc, None, <cstdio>)
-SYMBOL(fputc, None, <stdio.h>)
+SYMBOL(fputc, , <cstdio>)
+SYMBOL(fputc, , <stdio.h>)
 SYMBOL(fputs, std::, <cstdio>)
-SYMBOL(fputs, None, <cstdio>)
-SYMBOL(fputs, None, <stdio.h>)
+SYMBOL(fputs, , <cstdio>)
+SYMBOL(fputs, , <stdio.h>)
 SYMBOL(fputwc, std::, <cwchar>)
-SYMBOL(fputwc, None, <cwchar>)
-SYMBOL(fputwc, None, <wchar.h>)
+SYMBOL(fputwc, , <cwchar>)
+SYMBOL(fputwc, , <wchar.h>)
 SYMBOL(fputws, std::, <cwchar>)
-SYMBOL(fputws, None, <cwchar>)
-SYMBOL(fputws, None, <wchar.h>)
+SYMBOL(fputws, , <cwchar>)
+SYMBOL(fputws, , <wchar.h>)
 SYMBOL(fread, std::, <cstdio>)
-SYMBOL(fread, None, <cstdio>)
-SYMBOL(fread, None, <stdio.h>)
+SYMBOL(fread, , <cstdio>)
+SYMBOL(fread, , <stdio.h>)
 SYMBOL(free, std::, <cstdlib>)
-SYMBOL(free, None, <cstdlib>)
-SYMBOL(free, None, <stdlib.h>)
+SYMBOL(free, , <cstdlib>)
+SYMBOL(free, , <stdlib.h>)
 SYMBOL(freopen, std::, <cstdio>)
-SYMBOL(freopen, None, <cstdio>)
-SYMBOL(freopen, None, <stdio.h>)
+SYMBOL(freopen, , <cstdio>)
+SYMBOL(freopen, , <stdio.h>)
 SYMBOL(frexp, std::, <cmath>)
-SYMBOL(frexp, None, <cmath>)
-SYMBOL(frexp, None, <math.h>)
+SYMBOL(frexp, , <cmath>)
+SYMBOL(frexp, , <math.h>)
 SYMBOL(frexpf, std::, <cmath>)
-SYMBOL(frexpf, None, <cmath>)
-SYMBOL(frexpf, None, <math.h>)
+SYMBOL(frexpf, , <cmath>)
+SYMBOL(frexpf, , <math.h>)
 SYMBOL(frexpl, std::, <cmath>)
-SYMBOL(frexpl, None, <cmath>)
-SYMBOL(frexpl, None, <math.h>)
+SYMBOL(frexpl, , <cmath>)
+SYMBOL(frexpl, , <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(fscanf, , <cstdio>)
+SYMBOL(fscanf, , <stdio.h>)
 SYMBOL(fseek, std::, <cstdio>)
-SYMBOL(fseek, None, <cstdio>)
-SYMBOL(fseek, None, <stdio.h>)
+SYMBOL(fseek, , <cstdio>)
+SYMBOL(fseek, , <stdio.h>)
 SYMBOL(fsetpos, std::, <cstdio>)
-SYMBOL(fsetpos, None, <cstdio>)
-SYMBOL(fsetpos, None, <stdio.h>)
+SYMBOL(fsetpos, , <cstdio>)
+SYMBOL(fsetpos, , <stdio.h>)
 SYMBOL(fstream, std::, <fstream>)
 SYMBOL(fstream, std::, <iosfwd>)
 SYMBOL(ftell, std::, <cstdio>)
-SYMBOL(ftell, None, <cstdio>)
-SYMBOL(ftell, None, <stdio.h>)
+SYMBOL(ftell, , <cstdio>)
+SYMBOL(ftell, , <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(fwide, , <cwchar>)
+SYMBOL(fwide, , <wchar.h>)
 SYMBOL(fwprintf, std::, <cwchar>)
-SYMBOL(fwprintf, None, <cwchar>)
-SYMBOL(fwprintf, None, <wchar.h>)
+SYMBOL(fwprintf, , <cwchar>)
+SYMBOL(fwprintf, , <wchar.h>)
 SYMBOL(fwrite, std::, <cstdio>)
-SYMBOL(fwrite, None, <cstdio>)
-SYMBOL(fwrite, None, <stdio.h>)
+SYMBOL(fwrite, , <cstdio>)
+SYMBOL(fwrite, , <stdio.h>)
 SYMBOL(fwscanf, std::, <cwchar>)
-SYMBOL(fwscanf, None, <cwchar>)
-SYMBOL(fwscanf, None, <wchar.h>)
+SYMBOL(fwscanf, , <cwchar>)
+SYMBOL(fwscanf, , <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(getc, , <cstdio>)
+SYMBOL(getc, , <stdio.h>)
 SYMBOL(getchar, std::, <cstdio>)
-SYMBOL(getchar, None, <cstdio>)
-SYMBOL(getchar, None, <stdio.h>)
+SYMBOL(getchar, , <cstdio>)
+SYMBOL(getchar, , <stdio.h>)
 SYMBOL(getenv, std::, <cstdlib>)
-SYMBOL(getenv, None, <cstdlib>)
-SYMBOL(getenv, None, <stdlib.h>)
+SYMBOL(getenv, , <cstdlib>)
+SYMBOL(getenv, , <stdlib.h>)
 SYMBOL(getline, std::, <string>)
 SYMBOL(gets, std::, <cstdio>)
-SYMBOL(gets, None, <cstdio>)
-SYMBOL(gets, None, <stdio.h>)
+SYMBOL(gets, , <cstdio>)
+SYMBOL(gets, , <stdio.h>)
 SYMBOL(getwc, std::, <cwchar>)
-SYMBOL(getwc, None, <cwchar>)
-SYMBOL(getwc, None, <wchar.h>)
+SYMBOL(getwc, , <cwchar>)
+SYMBOL(getwc, , <wchar.h>)
 SYMBOL(getwchar, std::, <cwchar>)
-SYMBOL(getwchar, None, <cwchar>)
-SYMBOL(getwchar, None, <wchar.h>)
+SYMBOL(getwchar, , <cwchar>)
+SYMBOL(getwchar, , <wchar.h>)
 SYMBOL(giga, std::, <ratio>)
 SYMBOL(gmtime, std::, <ctime>)
-SYMBOL(gmtime, None, <ctime>)
-SYMBOL(gmtime, None, <time.h>)
+SYMBOL(gmtime, , <ctime>)
+SYMBOL(gmtime, , <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(hypot, , <cmath>)
+SYMBOL(hypot, , <math.h>)
 SYMBOL(hypotf, std::, <cmath>)
-SYMBOL(hypotf, None, <cmath>)
-SYMBOL(hypotf, None, <math.h>)
+SYMBOL(hypotf, , <cmath>)
+SYMBOL(hypotf, , <math.h>)
 SYMBOL(hypotl, std::, <cmath>)
-SYMBOL(hypotl, None, <cmath>)
-SYMBOL(hypotl, None, <math.h>)
+SYMBOL(hypotl, , <cmath>)
+SYMBOL(hypotl, , <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(ilogb, , <cmath>)
+SYMBOL(ilogb, , <math.h>)
 SYMBOL(ilogbf, std::, <cmath>)
-SYMBOL(ilogbf, None, <cmath>)
-SYMBOL(ilogbf, None, <math.h>)
+SYMBOL(ilogbf, , <cmath>)
+SYMBOL(ilogbf, , <math.h>)
 SYMBOL(ilogbl, std::, <cmath>)
-SYMBOL(ilogbl, None, <cmath>)
-SYMBOL(ilogbl, None, <math.h>)
+SYMBOL(ilogbl, , <cmath>)
+SYMBOL(ilogbl, , <math.h>)
 SYMBOL(imag, std::, <complex>)
 SYMBOL(imaxabs, std::, <cinttypes>)
-SYMBOL(imaxabs, None, <cinttypes>)
-SYMBOL(imaxabs, None, <inttypes.h>)
+SYMBOL(imaxabs, , <cinttypes>)
+SYMBOL(imaxabs, , <inttypes.h>)
 SYMBOL(imaxdiv, std::, <cinttypes>)
-SYMBOL(imaxdiv, None, <cinttypes>)
-SYMBOL(imaxdiv, None, <inttypes.h>)
+SYMBOL(imaxdiv, , <cinttypes>)
+SYMBOL(imaxdiv, , <inttypes.h>)
 SYMBOL(imaxdiv_t, std::, <cinttypes>)
-SYMBOL(imaxdiv_t, None, <cinttypes>)
-SYMBOL(imaxdiv_t, None, <inttypes.h>)
+SYMBOL(imaxdiv_t, , <cinttypes>)
+SYMBOL(imaxdiv_t, , <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(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(int16_t, , <cstdint>)
+SYMBOL(int16_t, , <stdint.h>)
 SYMBOL(int32_t, std::, <cstdint>)
-SYMBOL(int32_t, None, <cstdint>)
-SYMBOL(int32_t, None, <stdint.h>)
+SYMBOL(int32_t, , <cstdint>)
+SYMBOL(int32_t, , <stdint.h>)
 SYMBOL(int64_t, std::, <cstdint>)
-SYMBOL(int64_t, None, <cstdint>)
-SYMBOL(int64_t, None, <stdint.h>)
+SYMBOL(int64_t, , <cstdint>)
+SYMBOL(int64_t, , <stdint.h>)
 SYMBOL(int8_t, std::, <cstdint>)
-SYMBOL(int8_t, None, <cstdint>)
-SYMBOL(int8_t, None, <stdint.h>)
+SYMBOL(int8_t, , <cstdint>)
+SYMBOL(int8_t, , <stdint.h>)
 SYMBOL(int_fast16_t, std::, <cstdint>)
-SYMBOL(int_fast16_t, None, <cstdint>)
-SYMBOL(int_fast16_t, None, <stdint.h>)
+SYMBOL(int_fast16_t, , <cstdint>)
+SYMBOL(int_fast16_t, , <stdint.h>)
 SYMBOL(int_fast32_t, std::, <cstdint>)
-SYMBOL(int_fast32_t, None, <cstdint>)
-SYMBOL(int_fast32_t, None, <stdint.h>)
+SYMBOL(int_fast32_t, , <cstdint>)
+SYMBOL(int_fast32_t, , <stdint.h>)
 SYMBOL(int_fast64_t, std::, <cstdint>)
-SYMBOL(int_fast64_t, None, <cstdint>)
-SYMBOL(int_fast64_t, None, <stdint.h>)
+SYMBOL(int_fast64_t, , <cstdint>)
+SYMBOL(int_fast64_t, , <stdint.h>)
 SYMBOL(int_fast8_t, std::, <cstdint>)
-SYMBOL(int_fast8_t, None, <cstdint>)
-SYMBOL(int_fast8_t, None, <stdint.h>)
+SYMBOL(int_fast8_t, , <cstdint>)
+SYMBOL(int_fast8_t, , <stdint.h>)
 SYMBOL(int_least16_t, std::, <cstdint>)
-SYMBOL(int_least16_t, None, <cstdint>)
-SYMBOL(int_least16_t, None, <stdint.h>)
+SYMBOL(int_least16_t, , <cstdint>)
+SYMBOL(int_least16_t, , <stdint.h>)
 SYMBOL(int_least32_t, std::, <cstdint>)
-SYMBOL(int_least32_t, None, <cstdint>)
-SYMBOL(int_least32_t, None, <stdint.h>)
+SYMBOL(int_least32_t, , <cstdint>)
+SYMBOL(int_least32_t, , <stdint.h>)
 SYMBOL(int_least64_t, std::, <cstdint>)
-SYMBOL(int_least64_t, None, <cstdint>)
-SYMBOL(int_least64_t, None, <stdint.h>)
+SYMBOL(int_least64_t, , <cstdint>)
+SYMBOL(int_least64_t, , <stdint.h>)
 SYMBOL(int_least8_t, std::, <cstdint>)
-SYMBOL(int_least8_t, None, <cstdint>)
-SYMBOL(int_least8_t, None, <stdint.h>)
+SYMBOL(int_least8_t, , <cstdint>)
+SYMBOL(int_least8_t, , <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(intmax_t, , <cstdint>)
+SYMBOL(intmax_t, , <stdint.h>)
 SYMBOL(intptr_t, std::, <cstdint>)
-SYMBOL(intptr_t, None, <cstdint>)
-SYMBOL(intptr_t, None, <stdint.h>)
+SYMBOL(intptr_t, , <cstdint>)
+SYMBOL(intptr_t, , <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(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(isalnum, , <cctype>)
+SYMBOL(isalnum, , <ctype.h>)
 SYMBOL(isalpha, std::, <cctype>)
-SYMBOL(isalpha, None, <cctype>)
-SYMBOL(isalpha, None, <ctype.h>)
+SYMBOL(isalpha, , <cctype>)
+SYMBOL(isalpha, , <ctype.h>)
 SYMBOL(isblank, std::, <cctype>)
-SYMBOL(isblank, None, <cctype>)
-SYMBOL(isblank, None, <ctype.h>)
+SYMBOL(isblank, , <cctype>)
+SYMBOL(isblank, , <ctype.h>)
 SYMBOL(iscntrl, std::, <cctype>)
-SYMBOL(iscntrl, None, <cctype>)
-SYMBOL(iscntrl, None, <ctype.h>)
+SYMBOL(iscntrl, , <cctype>)
+SYMBOL(iscntrl, , <ctype.h>)
 SYMBOL(isdigit, std::, <cctype>)
-SYMBOL(isdigit, None, <cctype>)
-SYMBOL(isdigit, None, <ctype.h>)
+SYMBOL(isdigit, , <cctype>)
+SYMBOL(isdigit, , <ctype.h>)
 SYMBOL(isfinite, std::, <cmath>)
-SYMBOL(isfinite, None, <cmath>)
-SYMBOL(isfinite, None, <math.h>)
+SYMBOL(isfinite, , <cmath>)
+SYMBOL(isfinite, , <math.h>)
 SYMBOL(isgraph, std::, <cctype>)
-SYMBOL(isgraph, None, <cctype>)
-SYMBOL(isgraph, None, <ctype.h>)
+SYMBOL(isgraph, , <cctype>)
+SYMBOL(isgraph, , <ctype.h>)
 SYMBOL(isgreater, std::, <cmath>)
-SYMBOL(isgreater, None, <cmath>)
-SYMBOL(isgreater, None, <math.h>)
+SYMBOL(isgreater, , <cmath>)
+SYMBOL(isgreater, , <math.h>)
 SYMBOL(isgreaterequal, std::, <cmath>)
-SYMBOL(isgreaterequal, None, <cmath>)
-SYMBOL(isgreaterequal, None, <math.h>)
+SYMBOL(isgreaterequal, , <cmath>)
+SYMBOL(isgreaterequal, , <math.h>)
 SYMBOL(isinf, std::, <cmath>)
-SYMBOL(isinf, None, <cmath>)
-SYMBOL(isinf, None, <math.h>)
+SYMBOL(isinf, , <cmath>)
+SYMBOL(isinf, , <math.h>)
 SYMBOL(isless, std::, <cmath>)
-SYMBOL(isless, None, <cmath>)
-SYMBOL(isless, None, <math.h>)
+SYMBOL(isless, , <cmath>)
+SYMBOL(isless, , <math.h>)
 SYMBOL(islessequal, std::, <cmath>)
-SYMBOL(islessequal, None, <cmath>)
-SYMBOL(islessequal, None, <math.h>)
+SYMBOL(islessequal, , <cmath>)
+SYMBOL(islessequal, , <math.h>)
 SYMBOL(islessgreater, std::, <cmath>)
-SYMBOL(islessgreater, None, <cmath>)
-SYMBOL(islessgreater, None, <math.h>)
+SYMBOL(islessgreater, , <cmath>)
+SYMBOL(islessgreater, , <math.h>)
 SYMBOL(islower, std::, <cctype>)
-SYMBOL(islower, None, <cctype>)
-SYMBOL(islower, None, <ctype.h>)
+SYMBOL(islower, , <cctype>)
+SYMBOL(islower, , <ctype.h>)
 SYMBOL(isnan, std::, <cmath>)
-SYMBOL(isnan, None, <cmath>)
-SYMBOL(isnan, None, <math.h>)
+SYMBOL(isnan, , <cmath>)
+SYMBOL(isnan, , <math.h>)
 SYMBOL(isnormal, std::, <cmath>)
-SYMBOL(isnormal, None, <cmath>)
-SYMBOL(isnormal, None, <math.h>)
+SYMBOL(isnormal, , <cmath>)
+SYMBOL(isnormal, , <math.h>)
 SYMBOL(ispanstream, std::, <spanstream>)
 SYMBOL(ispanstream, std::, <iosfwd>)
 SYMBOL(isprint, std::, <cctype>)
-SYMBOL(isprint, None, <cctype>)
-SYMBOL(isprint, None, <ctype.h>)
+SYMBOL(isprint, , <cctype>)
+SYMBOL(isprint, , <ctype.h>)
 SYMBOL(ispunct, std::, <cctype>)
-SYMBOL(ispunct, None, <cctype>)
-SYMBOL(ispunct, None, <ctype.h>)
+SYMBOL(ispunct, , <cctype>)
+SYMBOL(ispunct, , <ctype.h>)
 SYMBOL(isspace, std::, <cctype>)
-SYMBOL(isspace, None, <cctype>)
-SYMBOL(isspace, None, <ctype.h>)
+SYMBOL(isspace, , <cctype>)
+SYMBOL(isspace, , <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(isunordered, , <cmath>)
+SYMBOL(isunordered, , <math.h>)
 SYMBOL(isupper, std::, <cctype>)
-SYMBOL(isupper, None, <cctype>)
-SYMBOL(isupper, None, <ctype.h>)
+SYMBOL(isupper, , <cctype>)
+SYMBOL(isupper, , <ctype.h>)
 SYMBOL(iswalnum, std::, <cwctype>)
-SYMBOL(iswalnum, None, <cwctype>)
-SYMBOL(iswalnum, None, <wctype.h>)
+SYMBOL(iswalnum, , <cwctype>)
+SYMBOL(iswalnum, , <wctype.h>)
 SYMBOL(iswalpha, std::, <cwctype>)
-SYMBOL(iswalpha, None, <cwctype>)
-SYMBOL(iswalpha, None, <wctype.h>)
+SYMBOL(iswalpha, , <cwctype>)
+SYMBOL(iswalpha, , <wctype.h>)
 SYMBOL(iswblank, std::, <cwctype>)
-SYMBOL(iswblank, None, <cwctype>)
-SYMBOL(iswblank, None, <wctype.h>)
+SYMBOL(iswblank, , <cwctype>)
+SYMBOL(iswblank, , <wctype.h>)
 SYMBOL(iswcntrl, std::, <cwctype>)
-SYMBOL(iswcntrl, None, <cwctype>)
-SYMBOL(iswcntrl, None, <wctype.h>)
+SYMBOL(iswcntrl, , <cwctype>)
+SYMBOL(iswcntrl, , <wctype.h>)
 SYMBOL(iswctype, std::, <cwctype>)
-SYMBOL(iswctype, None, <cwctype>)
-SYMBOL(iswctype, None, <wctype.h>)
+SYMBOL(iswctype, , <cwctype>)
+SYMBOL(iswctype, , <wctype.h>)
 SYMBOL(iswdigit, std::, <cwctype>)
-SYMBOL(iswdigit, None, <cwctype>)
-SYMBOL(iswdigit, None, <wctype.h>)
+SYMBOL(iswdigit, , <cwctype>)
+SYMBOL(iswdigit, , <wctype.h>)
 SYMBOL(iswgraph, std::, <cwctype>)
-SYMBOL(iswgraph, None, <cwctype>)
-SYMBOL(iswgraph, None, <wctype.h>)
+SYMBOL(iswgraph, , <cwctype>)
+SYMBOL(iswgraph, , <wctype.h>)
 SYMBOL(iswlower, std::, <cwctype>)
-SYMBOL(iswlower, None, <cwctype>)
-SYMBOL(iswlower, None, <wctype.h>)
+SYMBOL(iswlower, , <cwctype>)
+SYMBOL(iswlower, , <wctype.h>)
 SYMBOL(iswprint, std::, <cwctype>)
-SYMBOL(iswprint, None, <cwctype>)
-SYMBOL(iswprint, None, <wctype.h>)
+SYMBOL(iswprint, , <cwctype>)
+SYMBOL(iswprint, , <wctype.h>)
 SYMBOL(iswpunct, std::, <cwctype>)
-SYMBOL(iswpunct, None, <cwctype>)
-SYMBOL(iswpunct, None, <wctype.h>)
+SYMBOL(iswpunct, , <cwctype>)
+SYMBOL(iswpunct, , <wctype.h>)
 SYMBOL(iswspace, std::, <cwctype>)
-SYMBOL(iswspace, None, <cwctype>)
-SYMBOL(iswspace, None, <wctype.h>)
+SYMBOL(iswspace, , <cwctype>)
+SYMBOL(iswspace, , <wctype.h>)
 SYMBOL(iswupper, std::, <cwctype>)
-SYMBOL(iswupper, None, <cwctype>)
-SYMBOL(iswupper, None, <wctype.h>)
+SYMBOL(iswupper, , <cwctype>)
+SYMBOL(iswupper, , <wctype.h>)
 SYMBOL(iswxdigit, std::, <cwctype>)
-SYMBOL(iswxdigit, None, <cwctype>)
-SYMBOL(iswxdigit, None, <wctype.h>)
+SYMBOL(iswxdigit, , <cwctype>)
+SYMBOL(iswxdigit, , <wctype.h>)
 SYMBOL(isxdigit, std::, <cctype>)
-SYMBOL(isxdigit, None, <cctype>)
-SYMBOL(isxdigit, None, <ctype.h>)
+SYMBOL(isxdigit, , <cctype>)
+SYMBOL(isxdigit, , <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(jmp_buf, , <csetjmp>)
+SYMBOL(jmp_buf, , <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(labs, , <cstdlib>)
+SYMBOL(labs, , <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(lconv, , <clocale>)
+SYMBOL(lconv, , <locale.h>)
 SYMBOL(ldexp, std::, <cmath>)
-SYMBOL(ldexp, None, <cmath>)
-SYMBOL(ldexp, None, <math.h>)
+SYMBOL(ldexp, , <cmath>)
+SYMBOL(ldexp, , <math.h>)
 SYMBOL(ldexpf, std::, <cmath>)
-SYMBOL(ldexpf, None, <cmath>)
-SYMBOL(ldexpf, None, <math.h>)
+SYMBOL(ldexpf, , <cmath>)
+SYMBOL(ldexpf, , <math.h>)
 SYMBOL(ldexpl, std::, <cmath>)
-SYMBOL(ldexpl, None, <cmath>)
-SYMBOL(ldexpl, None, <math.h>)
+SYMBOL(ldexpl, , <cmath>)
+SYMBOL(ldexpl, , <math.h>)
 SYMBOL(ldiv, std::, <cstdlib>)
-SYMBOL(ldiv, None, <cstdlib>)
-SYMBOL(ldiv, None, <stdlib.h>)
+SYMBOL(ldiv, , <cstdlib>)
+SYMBOL(ldiv, , <stdlib.h>)
 SYMBOL(ldiv_t, std::, <cstdlib>)
-SYMBOL(ldiv_t, None, <cstdlib>)
-SYMBOL(ldiv_t, None, <stdlib.h>)
+SYMBOL(ldiv_t, , <cstdlib>)
+SYMBOL(ldiv_t, , <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(lgamma, , <cmath>)
+SYMBOL(lgamma, , <math.h>)
 SYMBOL(lgammaf, std::, <cmath>)
-SYMBOL(lgammaf, None, <cmath>)
-SYMBOL(lgammaf, None, <math.h>)
+SYMBOL(lgammaf, , <cmath>)
+SYMBOL(lgammaf, , <math.h>)
 SYMBOL(lgammal, std::, <cmath>)
-SYMBOL(lgammal, None, <cmath>)
-SYMBOL(lgammal, None, <math.h>)
+SYMBOL(lgammal, , <cmath>)
+SYMBOL(lgammal, , <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(llabs, , <cstdlib>)
+SYMBOL(llabs, , <stdlib.h>)
 SYMBOL(lldiv, std::, <cstdlib>)
-SYMBOL(lldiv, None, <cstdlib>)
-SYMBOL(lldiv, None, <stdlib.h>)
+SYMBOL(lldiv, , <cstdlib>)
+SYMBOL(lldiv, , <stdlib.h>)
 SYMBOL(lldiv_t, std::, <cstdlib>)
-SYMBOL(lldiv_t, None, <cstdlib>)
-SYMBOL(lldiv_t, None, <stdlib.h>)
+SYMBOL(lldiv_t, , <cstdlib>)
+SYMBOL(lldiv_t, , <stdlib.h>)
 SYMBOL(llrint, std::, <cmath>)
-SYMBOL(llrint, None, <cmath>)
-SYMBOL(llrint, None, <math.h>)
+SYMBOL(llrint, , <cmath>)
+SYMBOL(llrint, , <math.h>)
 SYMBOL(llrintf, std::, <cmath>)
-SYMBOL(llrintf, None, <cmath>)
-SYMBOL(llrintf, None, <math.h>)
+SYMBOL(llrintf, , <cmath>)
+SYMBOL(llrintf, , <math.h>)
 SYMBOL(llrintl, std::, <cmath>)
-SYMBOL(llrintl, None, <cmath>)
-SYMBOL(llrintl, None, <math.h>)
+SYMBOL(llrintl, , <cmath>)
+SYMBOL(llrintl, , <math.h>)
 SYMBOL(llround, std::, <cmath>)
-SYMBOL(llround, None, <cmath>)
-SYMBOL(llround, None, <math.h>)
+SYMBOL(llround, , <cmath>)
+SYMBOL(llround, , <math.h>)
 SYMBOL(llroundf, std::, <cmath>)
-SYMBOL(llroundf, None, <cmath>)
-SYMBOL(llroundf, None, <math.h>)
+SYMBOL(llroundf, , <cmath>)
+SYMBOL(llroundf, , <math.h>)
 SYMBOL(llroundl, std::, <cmath>)
-SYMBOL(llroundl, None, <cmath>)
-SYMBOL(llroundl, None, <math.h>)
+SYMBOL(llroundl, , <cmath>)
+SYMBOL(llroundl, , <math.h>)
 SYMBOL(locale, std::, <locale>)
 SYMBOL(localeconv, std::, <clocale>)
-SYMBOL(localeconv, None, <clocale>)
-SYMBOL(localeconv, None, <locale.h>)
+SYMBOL(localeconv, , <clocale>)
+SYMBOL(localeconv, , <locale.h>)
 SYMBOL(localtime, std::, <ctime>)
-SYMBOL(localtime, None, <ctime>)
-SYMBOL(localtime, None, <time.h>)
+SYMBOL(localtime, , <ctime>)
+SYMBOL(localtime, , <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(log, , <cmath>)
+SYMBOL(log, , <math.h>)
 SYMBOL(log10, std::, <cmath>)
-SYMBOL(log10, None, <cmath>)
-SYMBOL(log10, None, <math.h>)
+SYMBOL(log10, , <cmath>)
+SYMBOL(log10, , <math.h>)
 SYMBOL(log10f, std::, <cmath>)
-SYMBOL(log10f, None, <cmath>)
-SYMBOL(log10f, None, <math.h>)
+SYMBOL(log10f, , <cmath>)
+SYMBOL(log10f, , <math.h>)
 SYMBOL(log10l, std::, <cmath>)
-SYMBOL(log10l, None, <cmath>)
-SYMBOL(log10l, None, <math.h>)
+SYMBOL(log10l, , <cmath>)
+SYMBOL(log10l, , <math.h>)
 SYMBOL(log1p, std::, <cmath>)
-SYMBOL(log1p, None, <cmath>)
-SYMBOL(log1p, None, <math.h>)
+SYMBOL(log1p, , <cmath>)
+SYMBOL(log1p, , <math.h>)
 SYMBOL(log1pf, std::, <cmath>)
-SYMBOL(log1pf, None, <cmath>)
-SYMBOL(log1pf, None, <math.h>)
+SYMBOL(log1pf, , <cmath>)
+SYMBOL(log1pf, , <math.h>)
 SYMBOL(log1pl, std::, <cmath>)
-SYMBOL(log1pl, None, <cmath>)
-SYMBOL(log1pl, None, <math.h>)
+SYMBOL(log1pl, , <cmath>)
+SYMBOL(log1pl, , <math.h>)
 SYMBOL(log2, std::, <cmath>)
-SYMBOL(log2, None, <cmath>)
-SYMBOL(log2, None, <math.h>)
+SYMBOL(log2, , <cmath>)
+SYMBOL(log2, , <math.h>)
 SYMBOL(log2f, std::, <cmath>)
-SYMBOL(log2f, None, <cmath>)
-SYMBOL(log2f, None, <math.h>)
+SYMBOL(log2f, , <cmath>)
+SYMBOL(log2f, , <math.h>)
 SYMBOL(log2l, std::, <cmath>)
-SYMBOL(log2l, None, <cmath>)
-SYMBOL(log2l, None, <math.h>)
+SYMBOL(log2l, , <cmath>)
+SYMBOL(log2l, , <math.h>)
 SYMBOL(logb, std::, <cmath>)
-SYMBOL(logb, None, <cmath>)
-SYMBOL(logb, None, <math.h>)
+SYMBOL(logb, , <cmath>)
+SYMBOL(logb, , <math.h>)
 SYMBOL(logbf, std::, <cmath>)
-SYMBOL(logbf, None, <cmath>)
-SYMBOL(logbf, None, <math.h>)
+SYMBOL(logbf, , <cmath>)
+SYMBOL(logbf, , <math.h>)
 SYMBOL(logbl, std::, <cmath>)
-SYMBOL(logbl, None, <cmath>)
-SYMBOL(logbl, None, <math.h>)
+SYMBOL(logbl, , <cmath>)
+SYMBOL(logbl, , <math.h>)
 SYMBOL(logf, std::, <cmath>)
-SYMBOL(logf, None, <cmath>)
-SYMBOL(logf, None, <math.h>)
+SYMBOL(logf, , <cmath>)
+SYMBOL(logf, , <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(logl, , <cmath>)
+SYMBOL(logl, , <math.h>)
 SYMBOL(lognormal_distribution, std::, <random>)
 SYMBOL(longjmp, std::, <csetjmp>)
-SYMBOL(longjmp, None, <csetjmp>)
-SYMBOL(longjmp, None, <setjmp.h>)
+SYMBOL(longjmp, , <csetjmp>)
+SYMBOL(longjmp, , <setjmp.h>)
 SYMBOL(lower_bound, std::, <algorithm>)
 SYMBOL(lrint, std::, <cmath>)
-SYMBOL(lrint, None, <cmath>)
-SYMBOL(lrint, None, <math.h>)
+SYMBOL(lrint, , <cmath>)
+SYMBOL(lrint, , <math.h>)
 SYMBOL(lrintf, std::, <cmath>)
-SYMBOL(lrintf, None, <cmath>)
-SYMBOL(lrintf, None, <math.h>)
+SYMBOL(lrintf, , <cmath>)
+SYMBOL(lrintf, , <math.h>)
 SYMBOL(lrintl, std::, <cmath>)
-SYMBOL(lrintl, None, <cmath>)
-SYMBOL(lrintl, None, <math.h>)
+SYMBOL(lrintl, , <cmath>)
+SYMBOL(lrintl, , <math.h>)
 SYMBOL(lround, std::, <cmath>)
-SYMBOL(lround, None, <cmath>)
-SYMBOL(lround, None, <math.h>)
+SYMBOL(lround, , <cmath>)
+SYMBOL(lround, , <math.h>)
 SYMBOL(lroundf, std::, <cmath>)
-SYMBOL(lroundf, None, <cmath>)
-SYMBOL(lroundf, None, <math.h>)
+SYMBOL(lroundf, , <cmath>)
+SYMBOL(lroundf, , <math.h>)
 SYMBOL(lroundl, std::, <cmath>)
-SYMBOL(lroundl, None, <cmath>)
-SYMBOL(lroundl, None, <math.h>)
+SYMBOL(lroundl, , <cmath>)
+SYMBOL(lroundl, , <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(malloc, , <cstdlib>)
+SYMBOL(malloc, , <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_align_t, , <cstddef>)
+SYMBOL(max_align_t, , <stddef.h>)
 SYMBOL(max_element, std::, <algorithm>)
 SYMBOL(mblen, std::, <cstdlib>)
-SYMBOL(mblen, None, <cstdlib>)
-SYMBOL(mblen, None, <stdlib.h>)
+SYMBOL(mblen, , <cstdlib>)
+SYMBOL(mblen, , <stdlib.h>)
 SYMBOL(mbrlen, std::, <cwchar>)
-SYMBOL(mbrlen, None, <cwchar>)
-SYMBOL(mbrlen, None, <wchar.h>)
+SYMBOL(mbrlen, , <cwchar>)
+SYMBOL(mbrlen, , <wchar.h>)
 SYMBOL(mbrtoc16, std::, <cuchar>)
-SYMBOL(mbrtoc16, None, <cuchar>)
-SYMBOL(mbrtoc16, None, <uchar.h>)
+SYMBOL(mbrtoc16, , <cuchar>)
+SYMBOL(mbrtoc16, , <uchar.h>)
 SYMBOL(mbrtoc32, std::, <cuchar>)
-SYMBOL(mbrtoc32, None, <cuchar>)
-SYMBOL(mbrtoc32, None, <uchar.h>)
+SYMBOL(mbrtoc32, , <cuchar>)
+SYMBOL(mbrtoc32, , <uchar.h>)
 SYMBOL(mbrtoc8, std::, <cuchar>)
-SYMBOL(mbrtoc8, None, <cuchar>)
-SYMBOL(mbrtoc8, None, <uchar.h>)
+SYMBOL(mbrtoc8, , <cuchar>)
+SYMBOL(mbrtoc8, , <uchar.h>)
 SYMBOL(mbrtowc, std::, <cwchar>)
-SYMBOL(mbrtowc, None, <cwchar>)
-SYMBOL(mbrtowc, None, <wchar.h>)
+SYMBOL(mbrtowc, , <cwchar>)
+SYMBOL(mbrtowc, , <wchar.h>)
 SYMBOL(mbsinit, std::, <cwchar>)
-SYMBOL(mbsinit, None, <cwchar>)
-SYMBOL(mbsinit, None, <wchar.h>)
+SYMBOL(mbsinit, , <cwchar>)
+SYMBOL(mbsinit, , <wchar.h>)
 SYMBOL(mbsrtowcs, std::, <cwchar>)
-SYMBOL(mbsrtowcs, None, <cwchar>)
-SYMBOL(mbsrtowcs, None, <wchar.h>)
+SYMBOL(mbsrtowcs, , <cwchar>)
+SYMBOL(mbsrtowcs, , <wchar.h>)
 SYMBOL(mbstowcs, std::, <cstdlib>)
-SYMBOL(mbstowcs, None, <cstdlib>)
-SYMBOL(mbstowcs, None, <stdlib.h>)
+SYMBOL(mbstowcs, , <cstdlib>)
+SYMBOL(mbstowcs, , <stdlib.h>)
 SYMBOL(mbtowc, std::, <cstdlib>)
-SYMBOL(mbtowc, None, <cstdlib>)
-SYMBOL(mbtowc, None, <stdlib.h>)
+SYMBOL(mbtowc, , <cstdlib>)
+SYMBOL(mbtowc, , <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(memchr, , <cstring>)
+SYMBOL(memchr, , <string.h>)
 SYMBOL(memcmp, std::, <cstring>)
-SYMBOL(memcmp, None, <cstring>)
-SYMBOL(memcmp, None, <string.h>)
+SYMBOL(memcmp, , <cstring>)
+SYMBOL(memcmp, , <string.h>)
 SYMBOL(memcpy, std::, <cstring>)
-SYMBOL(memcpy, None, <cstring>)
-SYMBOL(memcpy, None, <string.h>)
+SYMBOL(memcpy, , <cstring>)
+SYMBOL(memcpy, , <string.h>)
 SYMBOL(memmove, std::, <cstring>)
-SYMBOL(memmove, None, <cstring>)
-SYMBOL(memmove, None, <string.h>)
+SYMBOL(memmove, , <cstring>)
+SYMBOL(memmove, , <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(memset, , <cstring>)
+SYMBOL(memset, , <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(mktime, , <ctime>)
+SYMBOL(mktime, , <time.h>)
 SYMBOL(modf, std::, <cmath>)
-SYMBOL(modf, None, <cmath>)
-SYMBOL(modf, None, <math.h>)
+SYMBOL(modf, , <cmath>)
+SYMBOL(modf, , <math.h>)
 SYMBOL(modff, std::, <cmath>)
-SYMBOL(modff, None, <cmath>)
-SYMBOL(modff, None, <math.h>)
+SYMBOL(modff, , <cmath>)
+SYMBOL(modff, , <math.h>)
 SYMBOL(modfl, std::, <cmath>)
-SYMBOL(modfl, None, <cmath>)
-SYMBOL(modfl, None, <math.h>)
+SYMBOL(modfl, , <cmath>)
+SYMBOL(modfl, , <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(nan, , <cmath>)
+SYMBOL(nan, , <math.h>)
 SYMBOL(nanf, std::, <cmath>)
-SYMBOL(nanf, None, <cmath>)
-SYMBOL(nanf, None, <math.h>)
+SYMBOL(nanf, , <cmath>)
+SYMBOL(nanf, , <math.h>)
 SYMBOL(nanl, std::, <cmath>)
-SYMBOL(nanl, None, <cmath>)
-SYMBOL(nanl, None, <math.h>)
+SYMBOL(nanl, , <cmath>)
+SYMBOL(nanl, , <math.h>)
 SYMBOL(nano, std::, <ratio>)
 SYMBOL(nearbyint, std::, <cmath>)
-SYMBOL(nearbyint, None, <cmath>)
-SYMBOL(nearbyint, None, <math.h>)
+SYMBOL(nearbyint, , <cmath>)
+SYMBOL(nearbyint, , <math.h>)
 SYMBOL(nearbyintf, std::, <cmath>)
-SYMBOL(nearbyintf, None, <cmath>)
-SYMBOL(nearbyintf, None, <math.h>)
+SYMBOL(nearbyintf, , <cmath>)
+SYMBOL(nearbyintf, , <math.h>)
 SYMBOL(nearbyintl, std::, <cmath>)
-SYMBOL(nearbyintl, None, <cmath>)
-SYMBOL(nearbyintl, None, <math.h>)
+SYMBOL(nearbyintl, , <cmath>)
+SYMBOL(nearbyintl, , <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(nextafter, , <cmath>)
+SYMBOL(nextafter, , <math.h>)
 SYMBOL(nextafterf, std::, <cmath>)
-SYMBOL(nextafterf, None, <cmath>)
-SYMBOL(nextafterf, None, <math.h>)
+SYMBOL(nextafterf, , <cmath>)
+SYMBOL(nextafterf, , <math.h>)
 SYMBOL(nextafterl, std::, <cmath>)
-SYMBOL(nextafterl, None, <cmath>)
-SYMBOL(nextafterl, None, <math.h>)
+SYMBOL(nextafterl, , <cmath>)
+SYMBOL(nextafterl, , <math.h>)
 SYMBOL(nexttoward, std::, <cmath>)
-SYMBOL(nexttoward, None, <cmath>)
-SYMBOL(nexttoward, None, <math.h>)
+SYMBOL(nexttoward, , <cmath>)
+SYMBOL(nexttoward, , <math.h>)
 SYMBOL(nexttowardf, std::, <cmath>)
-SYMBOL(nexttowardf, None, <cmath>)
-SYMBOL(nexttowardf, None, <math.h>)
+SYMBOL(nexttowardf, , <cmath>)
+SYMBOL(nexttowardf, , <math.h>)
 SYMBOL(nexttowardl, std::, <cmath>)
-SYMBOL(nexttowardl, None, <cmath>)
-SYMBOL(nexttowardl, None, <math.h>)
+SYMBOL(nexttowardl, , <cmath>)
+SYMBOL(nexttowardl, , <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(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(nullptr_t, , <cstddef>)
+SYMBOL(nullptr_t, , <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(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(perror, , <cstdio>)
+SYMBOL(perror, , <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(pow, , <cmath>)
+SYMBOL(pow, , <math.h>)
 SYMBOL(powf, std::, <cmath>)
-SYMBOL(powf, None, <cmath>)
-SYMBOL(powf, None, <math.h>)
+SYMBOL(powf, , <cmath>)
+SYMBOL(powf, , <math.h>)
 SYMBOL(powl, std::, <cmath>)
-SYMBOL(powl, None, <cmath>)
-SYMBOL(powl, None, <math.h>)
+SYMBOL(powl, , <cmath>)
+SYMBOL(powl, , <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(printf, , <cstdio>)
+SYMBOL(printf, , <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(ptrdiff_t, , <cstddef>)
+SYMBOL(ptrdiff_t, , <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(putc, , <cstdio>)
+SYMBOL(putc, , <stdio.h>)
 SYMBOL(putchar, std::, <cstdio>)
-SYMBOL(putchar, None, <cstdio>)
-SYMBOL(putchar, None, <stdio.h>)
+SYMBOL(putchar, , <cstdio>)
+SYMBOL(putchar, , <stdio.h>)
 SYMBOL(puts, std::, <cstdio>)
-SYMBOL(puts, None, <cstdio>)
-SYMBOL(puts, None, <stdio.h>)
+SYMBOL(puts, , <cstdio>)
+SYMBOL(puts, , <stdio.h>)
 SYMBOL(putwc, std::, <cwchar>)
-SYMBOL(putwc, None, <cwchar>)
-SYMBOL(putwc, None, <wchar.h>)
+SYMBOL(putwc, , <cwchar>)
+SYMBOL(putwc, , <wchar.h>)
 SYMBOL(putwchar, std::, <cwchar>)
-SYMBOL(putwchar, None, <cwchar>)
-SYMBOL(putwchar, None, <wchar.h>)
+SYMBOL(putwchar, , <cwchar>)
+SYMBOL(putwchar, , <wchar.h>)
 SYMBOL(qsort, std::, <cstdlib>)
-SYMBOL(qsort, None, <cstdlib>)
-SYMBOL(qsort, None, <stdlib.h>)
+SYMBOL(qsort, , <cstdlib>)
+SYMBOL(qsort, , <stdlib.h>)
 SYMBOL(queue, std::, <queue>)
 SYMBOL(quick_exit, std::, <cstdlib>)
-SYMBOL(quick_exit, None, <cstdlib>)
-SYMBOL(quick_exit, None, <stdlib.h>)
+SYMBOL(quick_exit, , <cstdlib>)
+SYMBOL(quick_exit, , <stdlib.h>)
 SYMBOL(quoted, std::, <iomanip>)
 SYMBOL(raise, std::, <csignal>)
-SYMBOL(raise, None, <csignal>)
-SYMBOL(raise, None, <signal.h>)
+SYMBOL(raise, , <csignal>)
+SYMBOL(raise, , <signal.h>)
 SYMBOL(rand, std::, <cstdlib>)
-SYMBOL(rand, None, <cstdlib>)
-SYMBOL(rand, None, <stdlib.h>)
+SYMBOL(rand, , <cstdlib>)
+SYMBOL(rand, , <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(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(realloc, , <cstdlib>)
+SYMBOL(realloc, , <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(remainder, , <cmath>)
+SYMBOL(remainder, , <math.h>)
 SYMBOL(remainderf, std::, <cmath>)
-SYMBOL(remainderf, None, <cmath>)
-SYMBOL(remainderf, None, <math.h>)
+SYMBOL(remainderf, , <cmath>)
+SYMBOL(remainderf, , <math.h>)
 SYMBOL(remainderl, std::, <cmath>)
-SYMBOL(remainderl, None, <cmath>)
-SYMBOL(remainderl, None, <math.h>)
+SYMBOL(remainderl, , <cmath>)
+SYMBOL(remainderl, , <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(remquo, , <cmath>)
+SYMBOL(remquo, , <math.h>)
 SYMBOL(remquof, std::, <cmath>)
-SYMBOL(remquof, None, <cmath>)
-SYMBOL(remquof, None, <math.h>)
+SYMBOL(remquof, , <cmath>)
+SYMBOL(remquof, , <math.h>)
 SYMBOL(remquol, std::, <cmath>)
-SYMBOL(remquol, None, <cmath>)
-SYMBOL(remquol, None, <math.h>)
+SYMBOL(remquol, , <cmath>)
+SYMBOL(remquol, , <math.h>)
 SYMBOL(rename, std::, <cstdio>)
-SYMBOL(rename, None, <cstdio>)
-SYMBOL(rename, None, <stdio.h>)
+SYMBOL(rename, , <cstdio>)
+SYMBOL(rename, , <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(rewind, , <cstdio>)
+SYMBOL(rewind, , <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(rint, , <cmath>)
+SYMBOL(rint, , <math.h>)
 SYMBOL(rintf, std::, <cmath>)
-SYMBOL(rintf, None, <cmath>)
-SYMBOL(rintf, None, <math.h>)
+SYMBOL(rintf, , <cmath>)
+SYMBOL(rintf, , <math.h>)
 SYMBOL(rintl, std::, <cmath>)
-SYMBOL(rintl, None, <cmath>)
-SYMBOL(rintl, None, <math.h>)
+SYMBOL(rintl, , <cmath>)
+SYMBOL(rintl, , <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, , <cmath>)
+SYMBOL(round, , <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(roundf, , <cmath>)
+SYMBOL(roundf, , <math.h>)
 SYMBOL(roundl, std::, <cmath>)
-SYMBOL(roundl, None, <cmath>)
-SYMBOL(roundl, None, <math.h>)
+SYMBOL(roundl, , <cmath>)
+SYMBOL(roundl, , <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(scalbln, , <cmath>)
+SYMBOL(scalbln, , <math.h>)
 SYMBOL(scalblnf, std::, <cmath>)
-SYMBOL(scalblnf, None, <cmath>)
-SYMBOL(scalblnf, None, <math.h>)
+SYMBOL(scalblnf, , <cmath>)
+SYMBOL(scalblnf, , <math.h>)
 SYMBOL(scalblnl, std::, <cmath>)
-SYMBOL(scalblnl, None, <cmath>)
-SYMBOL(scalblnl, None, <math.h>)
+SYMBOL(scalblnl, , <cmath>)
+SYMBOL(scalblnl, , <math.h>)
 SYMBOL(scalbn, std::, <cmath>)
-SYMBOL(scalbn, None, <cmath>)
-SYMBOL(scalbn, None, <math.h>)
+SYMBOL(scalbn, , <cmath>)
+SYMBOL(scalbn, , <math.h>)
 SYMBOL(scalbnf, std::, <cmath>)
-SYMBOL(scalbnf, None, <cmath>)
-SYMBOL(scalbnf, None, <math.h>)
+SYMBOL(scalbnf, , <cmath>)
+SYMBOL(scalbnf, , <math.h>)
 SYMBOL(scalbnl, std::, <cmath>)
-SYMBOL(scalbnl, None, <cmath>)
-SYMBOL(scalbnl, None, <math.h>)
+SYMBOL(scalbnl, , <cmath>)
+SYMBOL(scalbnl, , <math.h>)
 SYMBOL(scanf, std::, <cstdio>)
-SYMBOL(scanf, None, <cstdio>)
-SYMBOL(scanf, None, <stdio.h>)
+SYMBOL(scanf, , <cstdio>)
+SYMBOL(scanf, , <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(setbuf, , <cstdio>)
+SYMBOL(setbuf, , <stdio.h>)
 SYMBOL(setfill, std::, <iomanip>)
 SYMBOL(setiosflags, std::, <iomanip>)
 SYMBOL(setlocale, std::, <clocale>)
-SYMBOL(setlocale, None, <clocale>)
-SYMBOL(setlocale, None, <locale.h>)
+SYMBOL(setlocale, , <clocale>)
+SYMBOL(setlocale, , <locale.h>)
 SYMBOL(setprecision, std::, <iomanip>)
 SYMBOL(setvbuf, std::, <cstdio>)
-SYMBOL(setvbuf, None, <cstdio>)
-SYMBOL(setvbuf, None, <stdio.h>)
+SYMBOL(setvbuf, , <cstdio>)
+SYMBOL(setvbuf, , <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(sig_atomic_t, , <csignal>)
+SYMBOL(sig_atomic_t, , <signal.h>)
 SYMBOL(signal, std::, <csignal>)
-SYMBOL(signal, None, <csignal>)
-SYMBOL(signal, None, <signal.h>)
+SYMBOL(signal, , <csignal>)
+SYMBOL(signal, , <signal.h>)
 SYMBOL(signbit, std::, <cmath>)
-SYMBOL(signbit, None, <cmath>)
-SYMBOL(signbit, None, <math.h>)
+SYMBOL(signbit, , <cmath>)
+SYMBOL(signbit, , <math.h>)
 SYMBOL(signed_integral, std::, <concepts>)
 SYMBOL(sin, std::, <cmath>)
-SYMBOL(sin, None, <cmath>)
-SYMBOL(sin, None, <math.h>)
+SYMBOL(sin, , <cmath>)
+SYMBOL(sin, , <math.h>)
 SYMBOL(sinf, std::, <cmath>)
-SYMBOL(sinf, None, <cmath>)
-SYMBOL(sinf, None, <math.h>)
+SYMBOL(sinf, , <cmath>)
+SYMBOL(sinf, , <math.h>)
 SYMBOL(sinh, std::, <cmath>)
-SYMBOL(sinh, None, <cmath>)
-SYMBOL(sinh, None, <math.h>)
+SYMBOL(sinh, , <cmath>)
+SYMBOL(sinh, , <math.h>)
 SYMBOL(sinhf, std::, <cmath>)
-SYMBOL(sinhf, None, <cmath>)
-SYMBOL(sinhf, None, <math.h>)
+SYMBOL(sinhf, , <cmath>)
+SYMBOL(sinhf, , <math.h>)
 SYMBOL(sinhl, std::, <cmath>)
-SYMBOL(sinhl, None, <cmath>)
-SYMBOL(sinhl, None, <math.h>)
+SYMBOL(sinhl, , <cmath>)
+SYMBOL(sinhl, , <math.h>)
 SYMBOL(sinl, std::, <cmath>)
-SYMBOL(sinl, None, <cmath>)
-SYMBOL(sinl, None, <math.h>)
+SYMBOL(sinl, , <cmath>)
+SYMBOL(sinl, , <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(snprintf, , <cstdio>)
+SYMBOL(snprintf, , <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_bessel, , <cmath>)
+SYMBOL(sph_bessel, , <math.h>)
 SYMBOL(sph_besself, std::, <cmath>)
-SYMBOL(sph_besself, None, <cmath>)
-SYMBOL(sph_besself, None, <math.h>)
+SYMBOL(sph_besself, , <cmath>)
+SYMBOL(sph_besself, , <math.h>)
 SYMBOL(sph_bessell, std::, <cmath>)
-SYMBOL(sph_bessell, None, <cmath>)
-SYMBOL(sph_bessell, None, <math.h>)
+SYMBOL(sph_bessell, , <cmath>)
+SYMBOL(sph_bessell, , <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(sprintf, , <cstdio>)
+SYMBOL(sprintf, , <stdio.h>)
 SYMBOL(sqrt, std::, <cmath>)
-SYMBOL(sqrt, None, <cmath>)
-SYMBOL(sqrt, None, <math.h>)
+SYMBOL(sqrt, , <cmath>)
+SYMBOL(sqrt, , <math.h>)
 SYMBOL(sqrtf, std::, <cmath>)
-SYMBOL(sqrtf, None, <cmath>)
-SYMBOL(sqrtf, None, <math.h>)
+SYMBOL(sqrtf, , <cmath>)
+SYMBOL(sqrtf, , <math.h>)
 SYMBOL(sqrtl, std::, <cmath>)
-SYMBOL(sqrtl, None, <cmath>)
-SYMBOL(sqrtl, None, <math.h>)
+SYMBOL(sqrtl, , <cmath>)
+SYMBOL(sqrtl, , <math.h>)
 SYMBOL(srand, std::, <cstdlib>)
-SYMBOL(srand, None, <cstdlib>)
-SYMBOL(srand, None, <stdlib.h>)
+SYMBOL(srand, , <cstdlib>)
+SYMBOL(srand, , <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(sscanf, , <cstdio>)
+SYMBOL(sscanf, , <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(strcat, , <cstring>)
+SYMBOL(strcat, , <string.h>)
 SYMBOL(strchr, std::, <cstring>)
-SYMBOL(strchr, None, <cstring>)
-SYMBOL(strchr, None, <string.h>)
+SYMBOL(strchr, , <cstring>)
+SYMBOL(strchr, , <string.h>)
 SYMBOL(strcmp, std::, <cstring>)
-SYMBOL(strcmp, None, <cstring>)
-SYMBOL(strcmp, None, <string.h>)
+SYMBOL(strcmp, , <cstring>)
+SYMBOL(strcmp, , <string.h>)
 SYMBOL(strcoll, std::, <cstring>)
-SYMBOL(strcoll, None, <cstring>)
-SYMBOL(strcoll, None, <string.h>)
+SYMBOL(strcoll, , <cstring>)
+SYMBOL(strcoll, , <string.h>)
 SYMBOL(strcpy, std::, <cstring>)
-SYMBOL(strcpy, None, <cstring>)
-SYMBOL(strcpy, None, <string.h>)
+SYMBOL(strcpy, , <cstring>)
+SYMBOL(strcpy, , <string.h>)
 SYMBOL(strcspn, std::, <cstring>)
-SYMBOL(strcspn, None, <cstring>)
-SYMBOL(strcspn, None, <string.h>)
+SYMBOL(strcspn, , <cstring>)
+SYMBOL(strcspn, , <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(strerror, , <cstring>)
+SYMBOL(strerror, , <string.h>)
 SYMBOL(strftime, std::, <ctime>)
-SYMBOL(strftime, None, <ctime>)
-SYMBOL(strftime, None, <time.h>)
+SYMBOL(strftime, , <ctime>)
+SYMBOL(strftime, , <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(strlen, , <cstring>)
+SYMBOL(strlen, , <string.h>)
 SYMBOL(strncat, std::, <cstring>)
-SYMBOL(strncat, None, <cstring>)
-SYMBOL(strncat, None, <string.h>)
+SYMBOL(strncat, , <cstring>)
+SYMBOL(strncat, , <string.h>)
 SYMBOL(strncmp, std::, <cstring>)
-SYMBOL(strncmp, None, <cstring>)
-SYMBOL(strncmp, None, <string.h>)
+SYMBOL(strncmp, , <cstring>)
+SYMBOL(strncmp, , <string.h>)
 SYMBOL(strncpy, std::, <cstring>)
-SYMBOL(strncpy, None, <cstring>)
-SYMBOL(strncpy, None, <string.h>)
+SYMBOL(strncpy, , <cstring>)
+SYMBOL(strncpy, , <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(strpbrk, , <cstring>)
+SYMBOL(strpbrk, , <string.h>)
 SYMBOL(strrchr, std::, <cstring>)
-SYMBOL(strrchr, None, <cstring>)
-SYMBOL(strrchr, None, <string.h>)
+SYMBOL(strrchr, , <cstring>)
+SYMBOL(strrchr, , <string.h>)
 SYMBOL(strspn, std::, <cstring>)
-SYMBOL(strspn, None, <cstring>)
-SYMBOL(strspn, None, <string.h>)
+SYMBOL(strspn, , <cstring>)
+SYMBOL(strspn, , <string.h>)
 SYMBOL(strstr, std::, <cstring>)
-SYMBOL(strstr, None, <cstring>)
-SYMBOL(strstr, None, <string.h>)
+SYMBOL(strstr, , <cstring>)
+SYMBOL(strstr, , <string.h>)
 SYMBOL(strstream, std::, <strstream>)
 SYMBOL(strstreambuf, std::, <strstream>)
 SYMBOL(strtod, std::, <cstdlib>)
-SYMBOL(strtod, None, <cstdlib>)
-SYMBOL(strtod, None, <stdlib.h>)
+SYMBOL(strtod, , <cstdlib>)
+SYMBOL(strtod, , <stdlib.h>)
 SYMBOL(strtof, std::, <cstdlib>)
-SYMBOL(strtof, None, <cstdlib>)
-SYMBOL(strtof, None, <stdlib.h>)
+SYMBOL(strtof, , <cstdlib>)
+SYMBOL(strtof, , <stdlib.h>)
 SYMBOL(strtoimax, std::, <cinttypes>)
-SYMBOL(strtoimax, None, <cinttypes>)
-SYMBOL(strtoimax, None, <inttypes.h>)
+SYMBOL(strtoimax, , <cinttypes>)
+SYMBOL(strtoimax, , <inttypes.h>)
 SYMBOL(strtok, std::, <cstring>)
-SYMBOL(strtok, None, <cstring>)
-SYMBOL(strtok, None, <string.h>)
+SYMBOL(strtok, , <cstring>)
+SYMBOL(strtok, , <string.h>)
 SYMBOL(strtol, std::, <cstdlib>)
-SYMBOL(strtol, None, <cstdlib>)
-SYMBOL(strtol, None, <stdlib.h>)
+SYMBOL(strtol, , <cstdlib>)
+SYMBOL(strtol, , <stdlib.h>)
 SYMBOL(strtold, std::, <cstdlib>)
-SYMBOL(strtold, None, <cstdlib>)
-SYMBOL(strtold, None, <stdlib.h>)
+SYMBOL(strtold, , <cstdlib>)
+SYMBOL(strtold, , <stdlib.h>)
 SYMBOL(strtoll, std::, <cstdlib>)
-SYMBOL(strtoll, None, <cstdlib>)
-SYMBOL(strtoll, None, <stdlib.h>)
+SYMBOL(strtoll, , <cstdlib>)
+SYMBOL(strtoll, , <stdlib.h>)
 SYMBOL(strtoul, std::, <cstdlib>)
-SYMBOL(strtoul, None, <cstdlib>)
-SYMBOL(strtoul, None, <stdlib.h>)
+SYMBOL(strtoul, , <cstdlib>)
+SYMBOL(strtoul, , <stdlib.h>)
 SYMBOL(strtoull, std::, <cstdlib>)
-SYMBOL(strtoull, None, <cstdlib>)
-SYMBOL(strtoull, None, <stdlib.h>)
+SYMBOL(strtoull, , <cstdlib>)
+SYMBOL(strtoull, , <stdlib.h>)
 SYMBOL(strtoumax, std::, <cinttypes>)
-SYMBOL(strtoumax, None, <cinttypes>)
-SYMBOL(strtoumax, None, <inttypes.h>)
+SYMBOL(strtoumax, , <cinttypes>)
+SYMBOL(strtoumax, , <inttypes.h>)
 SYMBOL(strxfrm, std::, <cstring>)
-SYMBOL(strxfrm, None, <cstring>)
-SYMBOL(strxfrm, None, <string.h>)
+SYMBOL(strxfrm, , <cstring>)
+SYMBOL(strxfrm, , <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(swprintf, , <cwchar>)
+SYMBOL(swprintf, , <wchar.h>)
 SYMBOL(swscanf, std::, <cwchar>)
-SYMBOL(swscanf, None, <cwchar>)
-SYMBOL(swscanf, None, <wchar.h>)
+SYMBOL(swscanf, , <cwchar>)
+SYMBOL(swscanf, , <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, , <cstdlib>)
+SYMBOL(system, , <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(tan, , <cmath>)
+SYMBOL(tan, , <math.h>)
 SYMBOL(tanf, std::, <cmath>)
-SYMBOL(tanf, None, <cmath>)
-SYMBOL(tanf, None, <math.h>)
+SYMBOL(tanf, , <cmath>)
+SYMBOL(tanf, , <math.h>)
 SYMBOL(tanh, std::, <cmath>)
-SYMBOL(tanh, None, <cmath>)
-SYMBOL(tanh, None, <math.h>)
+SYMBOL(tanh, , <cmath>)
+SYMBOL(tanh, , <math.h>)
 SYMBOL(tanhf, std::, <cmath>)
-SYMBOL(tanhf, None, <cmath>)
-SYMBOL(tanhf, None, <math.h>)
+SYMBOL(tanhf, , <cmath>)
+SYMBOL(tanhf, , <math.h>)
 SYMBOL(tanhl, std::, <cmath>)
-SYMBOL(tanhl, None, <cmath>)
-SYMBOL(tanhl, None, <math.h>)
+SYMBOL(tanhl, , <cmath>)
+SYMBOL(tanhl, , <math.h>)
 SYMBOL(tanl, std::, <cmath>)
-SYMBOL(tanl, None, <cmath>)
-SYMBOL(tanl, None, <math.h>)
+SYMBOL(tanl, , <cmath>)
+SYMBOL(tanl, , <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(tgamma, , <cmath>)
+SYMBOL(tgamma, , <math.h>)
 SYMBOL(tgammaf, std::, <cmath>)
-SYMBOL(tgammaf, None, <cmath>)
-SYMBOL(tgammaf, None, <math.h>)
+SYMBOL(tgammaf, , <cmath>)
+SYMBOL(tgammaf, , <math.h>)
 SYMBOL(tgammal, std::, <cmath>)
-SYMBOL(tgammal, None, <cmath>)
-SYMBOL(tgammal, None, <math.h>)
+SYMBOL(tgammal, , <cmath>)
+SYMBOL(tgammal, , <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, , <ctime>)
+SYMBOL(time, , <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(time_t, , <ctime>)
+SYMBOL(time_t, , <time.h>)
 SYMBOL(timed_mutex, std::, <mutex>)
 SYMBOL(timespec, std::, <ctime>)
-SYMBOL(timespec, None, <ctime>)
-SYMBOL(timespec, None, <time.h>)
+SYMBOL(timespec, , <ctime>)
+SYMBOL(timespec, , <time.h>)
 SYMBOL(timespec_get, std::, <ctime>)
-SYMBOL(timespec_get, None, <ctime>)
-SYMBOL(timespec_get, None, <time.h>)
+SYMBOL(timespec_get, , <ctime>)
+SYMBOL(timespec_get, , <time.h>)
 SYMBOL(tm, std::, <ctime>)
-SYMBOL(tm, None, <ctime>)
-SYMBOL(tm, None, <time.h>)
+SYMBOL(tm, , <ctime>)
+SYMBOL(tm, , <time.h>)
 SYMBOL(tmpfile, std::, <cstdio>)
-SYMBOL(tmpfile, None, <cstdio>)
-SYMBOL(tmpfile, None, <stdio.h>)
+SYMBOL(tmpfile, , <cstdio>)
+SYMBOL(tmpfile, , <stdio.h>)
 SYMBOL(tmpnam, std::, <cstdio>)
-SYMBOL(tmpnam, None, <cstdio>)
-SYMBOL(tmpnam, None, <stdio.h>)
+SYMBOL(tmpnam, , <cstdio>)
+SYMBOL(tmpnam, , <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_integer, , <cstddef>)
+SYMBOL(to_integer, , <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(tolower, , <cctype>)
+SYMBOL(tolower, , <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(toupper, , <cctype>)
+SYMBOL(toupper, , <ctype.h>)
 SYMBOL(towctrans, std::, <cwctype>)
-SYMBOL(towctrans, None, <cwctype>)
-SYMBOL(towctrans, None, <wctype.h>)
+SYMBOL(towctrans, , <cwctype>)
+SYMBOL(towctrans, , <wctype.h>)
 SYMBOL(towlower, std::, <cwctype>)
-SYMBOL(towlower, None, <cwctype>)
-SYMBOL(towlower, None, <wctype.h>)
+SYMBOL(towlower, , <cwctype>)
+SYMBOL(towlower, , <wctype.h>)
 SYMBOL(towupper, std::, <cwctype>)
-SYMBOL(towupper, None, <cwctype>)
-SYMBOL(towupper, None, <wctype.h>)
+SYMBOL(towupper, , <cwctype>)
+SYMBOL(towupper, , <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(trunc, , <cmath>)
+SYMBOL(trunc, , <math.h>)
 SYMBOL(truncf, std::, <cmath>)
-SYMBOL(truncf, None, <cmath>)
-SYMBOL(truncf, None, <math.h>)
+SYMBOL(truncf, , <cmath>)
+SYMBOL(truncf, , <math.h>)
 SYMBOL(truncl, std::, <cmath>)
-SYMBOL(truncl, None, <cmath>)
-SYMBOL(truncl, None, <math.h>)
+SYMBOL(truncl, , <cmath>)
+SYMBOL(truncl, , <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(uint16_t, , <cstdint>)
+SYMBOL(uint16_t, , <stdint.h>)
 SYMBOL(uint32_t, std::, <cstdint>)
-SYMBOL(uint32_t, None, <cstdint>)
-SYMBOL(uint32_t, None, <stdint.h>)
+SYMBOL(uint32_t, , <cstdint>)
+SYMBOL(uint32_t, , <stdint.h>)
 SYMBOL(uint64_t, std::, <cstdint>)
-SYMBOL(uint64_t, None, <cstdint>)
-SYMBOL(uint64_t, None, <stdint.h>)
+SYMBOL(uint64_t, , <cstdint>)
+SYMBOL(uint64_t, , <stdint.h>)
 SYMBOL(uint8_t, std::, <cstdint>)
-SYMBOL(uint8_t, None, <cstdint>)
-SYMBOL(uint8_t, None, <stdint.h>)
+SYMBOL(uint8_t, , <cstdint>)
+SYMBOL(uint8_t, , <stdint.h>)
 SYMBOL(uint_fast16_t, std::, <cstdint>)
-SYMBOL(uint_fast16_t, None, <cstdint>)
-SYMBOL(uint_fast16_t, None, <stdint.h>)
+SYMBOL(uint_fast16_t, , <cstdint>)
+SYMBOL(uint_fast16_t, , <stdint.h>)
 SYMBOL(uint_fast32_t, std::, <cstdint>)
-SYMBOL(uint_fast32_t, None, <cstdint>)
-SYMBOL(uint_fast32_t, None, <stdint.h>)
+SYMBOL(uint_fast32_t, , <cstdint>)
+SYMBOL(uint_fast32_t, , <stdint.h>)
 SYMBOL(uint_fast64_t, std::, <cstdint>)
-SYMBOL(uint_fast64_t, None, <cstdint>)
-SYMBOL(uint_fast64_t, None, <stdint.h>)
+SYMBOL(uint_fast64_t, , <cstdint>)
+SYMBOL(uint_fast64_t, , <stdint.h>)
 SYMBOL(uint_fast8_t, std::, <cstdint>)
-SYMBOL(uint_fast8_t, None, <cstdint>)
-SYMBOL(uint_fast8_t, None, <stdint.h>)
+SYMBOL(uint_fast8_t, , <cstdint>)
+SYMBOL(uint_fast8_t, , <stdint.h>)
 SYMBOL(uint_least16_t, std::, <cstdint>)
-SYMBOL(uint_least16_t, None, <cstdint>)
-SYMBOL(uint_least16_t, None, <stdint.h>)
+SYMBOL(uint_least16_t, , <cstdint>)
+SYMBOL(uint_least16_t, , <stdint.h>)
 SYMBOL(uint_least32_t, std::, <cstdint>)
-SYMBOL(uint_least32_t, None, <cstdint>)
-SYMBOL(uint_least32_t, None, <stdint.h>)
+SYMBOL(uint_least32_t, , <cstdint>)
+SYMBOL(uint_least32_t, , <stdint.h>)
 SYMBOL(uint_least64_t, std::, <cstdint>)
-SYMBOL(uint_least64_t, None, <cstdint>)
-SYMBOL(uint_least64_t, None, <stdint.h>)
+SYMBOL(uint_least64_t, , <cstdint>)
+SYMBOL(uint_least64_t, , <stdint.h>)
 SYMBOL(uint_least8_t, std::, <cstdint>)
-SYMBOL(uint_least8_t, None, <cstdint>)
-SYMBOL(uint_least8_t, None, <stdint.h>)
+SYMBOL(uint_least8_t, , <cstdint>)
+SYMBOL(uint_least8_t, , <stdint.h>)
 SYMBOL(uintmax_t, std::, <cstdint>)
-SYMBOL(uintmax_t, None, <cstdint>)
-SYMBOL(uintmax_t, None, <stdint.h>)
+SYMBOL(uintmax_t, , <cstdint>)
+SYMBOL(uintmax_t, , <stdint.h>)
 SYMBOL(uintptr_t, std::, <cstdint>)
-SYMBOL(uintptr_t, None, <cstdint>)
-SYMBOL(uintptr_t, None, <stdint.h>)
+SYMBOL(uintptr_t, , <cstdint>)
+SYMBOL(uintptr_t, , <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(ungetc, , <cstdio>)
+SYMBOL(ungetc, , <stdio.h>)
 SYMBOL(ungetwc, std::, <cwchar>)
-SYMBOL(ungetwc, None, <cwchar>)
-SYMBOL(ungetwc, None, <wchar.h>)
+SYMBOL(ungetwc, , <cwchar>)
+SYMBOL(ungetwc, , <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(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(va_list, , <cstdarg>)
+SYMBOL(va_list, , <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(vfprintf, , <cstdio>)
+SYMBOL(vfprintf, , <stdio.h>)
 SYMBOL(vfscanf, std::, <cstdio>)
-SYMBOL(vfscanf, None, <cstdio>)
-SYMBOL(vfscanf, None, <stdio.h>)
+SYMBOL(vfscanf, , <cstdio>)
+SYMBOL(vfscanf, , <stdio.h>)
 SYMBOL(vfwprintf, std::, <cwchar>)
-SYMBOL(vfwprintf, None, <cwchar>)
-SYMBOL(vfwprintf, None, <wchar.h>)
+SYMBOL(vfwprintf, , <cwchar>)
+SYMBOL(vfwprintf, , <wchar.h>)
 SYMBOL(vfwscanf, std::, <cwchar>)
-SYMBOL(vfwscanf, None, <cwchar>)
-SYMBOL(vfwscanf, None, <wchar.h>)
+SYMBOL(vfwscanf, , <cwchar>)
+SYMBOL(vfwscanf, , <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(vprintf, , <cstdio>)
+SYMBOL(vprintf, , <stdio.h>)
 SYMBOL(vscanf, std::, <cstdio>)
-SYMBOL(vscanf, None, <cstdio>)
-SYMBOL(vscanf, None, <stdio.h>)
+SYMBOL(vscanf, , <cstdio>)
+SYMBOL(vscanf, , <stdio.h>)
 SYMBOL(vsnprintf, std::, <cstdio>)
-SYMBOL(vsnprintf, None, <cstdio>)
-SYMBOL(vsnprintf, None, <stdio.h>)
+SYMBOL(vsnprintf, , <cstdio>)
+SYMBOL(vsnprintf, , <stdio.h>)
 SYMBOL(vsprintf, std::, <cstdio>)
-SYMBOL(vsprintf, None, <cstdio>)
-SYMBOL(vsprintf, None, <stdio.h>)
+SYMBOL(vsprintf, , <cstdio>)
+SYMBOL(vsprintf, , <stdio.h>)
 SYMBOL(vsscanf, std::, <cstdio>)
-SYMBOL(vsscanf, None, <cstdio>)
-SYMBOL(vsscanf, None, <stdio.h>)
+SYMBOL(vsscanf, , <cstdio>)
+SYMBOL(vsscanf, , <stdio.h>)
 SYMBOL(vswprintf, std::, <cwchar>)
-SYMBOL(vswprintf, None, <cwchar>)
-SYMBOL(vswprintf, None, <wchar.h>)
+SYMBOL(vswprintf, , <cwchar>)
+SYMBOL(vswprintf, , <wchar.h>)
 SYMBOL(vswscanf, std::, <cwchar>)
-SYMBOL(vswscanf, None, <cwchar>)
-SYMBOL(vswscanf, None, <wchar.h>)
+SYMBOL(vswscanf, , <cwchar>)
+SYMBOL(vswscanf, , <wchar.h>)
 SYMBOL(vwprintf, std::, <cwchar>)
-SYMBOL(vwprintf, None, <cwchar>)
-SYMBOL(vwprintf, None, <wchar.h>)
+SYMBOL(vwprintf, , <cwchar>)
+SYMBOL(vwprintf, , <wchar.h>)
 SYMBOL(vwscanf, std::, <cwchar>)
-SYMBOL(vwscanf, None, <cwchar>)
-SYMBOL(vwscanf, None, <wchar.h>)
+SYMBOL(vwscanf, , <cwchar>)
+SYMBOL(vwscanf, , <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(wcrtomb, , <cwchar>)
+SYMBOL(wcrtomb, , <wchar.h>)
 SYMBOL(wcscat, std::, <cwchar>)
-SYMBOL(wcscat, None, <cwchar>)
-SYMBOL(wcscat, None, <wchar.h>)
+SYMBOL(wcscat, , <cwchar>)
+SYMBOL(wcscat, , <wchar.h>)
 SYMBOL(wcschr, std::, <cwchar>)
-SYMBOL(wcschr, None, <cwchar>)
-SYMBOL(wcschr, None, <wchar.h>)
+SYMBOL(wcschr, , <cwchar>)
+SYMBOL(wcschr, , <wchar.h>)
 SYMBOL(wcscmp, std::, <cwchar>)
-SYMBOL(wcscmp, None, <cwchar>)
-SYMBOL(wcscmp, None, <wchar.h>)
+SYMBOL(wcscmp, , <cwchar>)
+SYMBOL(wcscmp, , <wchar.h>)
 SYMBOL(wcscoll, std::, <cwchar>)
-SYMBOL(wcscoll, None, <cwchar>)
-SYMBOL(wcscoll, None, <wchar.h>)
+SYMBOL(wcscoll, , <cwchar>)
+SYMBOL(wcscoll, , <wchar.h>)
 SYMBOL(wcscpy, std::, <cwchar>)
-SYMBOL(wcscpy, None, <cwchar>)
-SYMBOL(wcscpy, None, <wchar.h>)
+SYMBOL(wcscpy, , <cwchar>)
+SYMBOL(wcscpy, , <wchar.h>)
 SYMBOL(wcscspn, std::, <cwchar>)
-SYMBOL(wcscspn, None, <cwchar>)
-SYMBOL(wcscspn, None, <wchar.h>)
+SYMBOL(wcscspn, , <cwchar>)
+SYMBOL(wcscspn, , <wchar.h>)
 SYMBOL(wcsftime, std::, <cwchar>)
-SYMBOL(wcsftime, None, <cwchar>)
-SYMBOL(wcsftime, None, <wchar.h>)
+SYMBOL(wcsftime, , <cwchar>)
+SYMBOL(wcsftime, , <wchar.h>)
 SYMBOL(wcslen, std::, <cwchar>)
-SYMBOL(wcslen, None, <cwchar>)
-SYMBOL(wcslen, None, <wchar.h>)
+SYMBOL(wcslen, , <cwchar>)
+SYMBOL(wcslen, , <wchar.h>)
 SYMBOL(wcsncat, std::, <cwchar>)
-SYMBOL(wcsncat, None, <cwchar>)
-SYMBOL(wcsncat, None, <wchar.h>)
+SYMBOL(wcsncat, , <cwchar>)
+SYMBOL(wcsncat, , <wchar.h>)
 SYMBOL(wcsncmp, std::, <cwchar>)
-SYMBOL(wcsncmp, None, <cwchar>)
-SYMBOL(wcsncmp, None, <wchar.h>)
+SYMBOL(wcsncmp, , <cwchar>)
+SYMBOL(wcsncmp, , <wchar.h>)
 SYMBOL(wcsncpy, std::, <cwchar>)
-SYMBOL(wcsncpy, None, <cwchar>)
-SYMBOL(wcsncpy, None, <wchar.h>)
+SYMBOL(wcsncpy, , <cwchar>)
+SYMBOL(wcsncpy, , <wchar.h>)
 SYMBOL(wcspbrk, std::, <cwchar>)
-SYMBOL(wcspbrk, None, <cwchar>)
-SYMBOL(wcspbrk, None, <wchar.h>)
+SYMBOL(wcspbrk, , <cwchar>)
+SYMBOL(wcspbrk, , <wchar.h>)
 SYMBOL(wcsrchr, std::, <cwchar>)
-SYMBOL(wcsrchr, None, <cwchar>)
-SYMBOL(wcsrchr, None, <wchar.h>)
+SYMBOL(wcsrchr, , <cwchar>)
+SYMBOL(wcsrchr, , <wchar.h>)
 SYMBOL(wcsrtombs, std::, <cwchar>)
-SYMBOL(wcsrtombs, None, <cwchar>)
-SYMBOL(wcsrtombs, None, <wchar.h>)
+SYMBOL(wcsrtombs, , <cwchar>)
+SYMBOL(wcsrtombs, , <wchar.h>)
 SYMBOL(wcsspn, std::, <cwchar>)
-SYMBOL(wcsspn, None, <cwchar>)
-SYMBOL(wcsspn, None, <wchar.h>)
+SYMBOL(wcsspn, , <cwchar>)
+SYMBOL(wcsspn, , <wchar.h>)
 SYMBOL(wcsstr, std::, <cwchar>)
-SYMBOL(wcsstr, None, <cwchar>)
-SYMBOL(wcsstr, None, <wchar.h>)
+SYMBOL(wcsstr, , <cwchar>)
+SYMBOL(wcsstr, , <wchar.h>)
 SYMBOL(wcstod, std::, <cwchar>)
-SYMBOL(wcstod, None, <cwchar>)
-SYMBOL(wcstod, None, <wchar.h>)
+SYMBOL(wcstod, , <cwchar>)
+SYMBOL(wcstod, , <wchar.h>)
 SYMBOL(wcstof, std::, <cwchar>)
-SYMBOL(wcstof, None, <cwchar>)
-SYMBOL(wcstof, None, <wchar.h>)
+SYMBOL(wcstof, , <cwchar>)
+SYMBOL(wcstof, , <wchar.h>)
 SYMBOL(wcstoimax, std::, <cinttypes>)
-SYMBOL(wcstoimax, None, <cinttypes>)
-SYMBOL(wcstoimax, None, <inttypes.h>)
+SYMBOL(wcstoimax, , <cinttypes>)
+SYMBOL(wcstoimax, , <inttypes.h>)
 SYMBOL(wcstok, std::, <cwchar>)
-SYMBOL(wcstok, None, <cwchar>)
-SYMBOL(wcstok, None, <wchar.h>)
+SYMBOL(wcstok, , <cwchar>)
+SYMBOL(wcstok, , <wchar.h>)
 SYMBOL(wcstol, std::, <cwchar>)
-SYMBOL(wcstol, None, <cwchar>)
-SYMBOL(wcstol, None, <wchar.h>)
+SYMBOL(wcstol, , <cwchar>)
+SYMBOL(wcstol, , <wchar.h>)
 SYMBOL(wcstold, std::, <cwchar>)
-SYMBOL(wcstold, None, <cwchar>)
-SYMBOL(wcstold, None, <wchar.h>)
+SYMBOL(wcstold, , <cwchar>)
+SYMBOL(wcstold, , <wchar.h>)
 SYMBOL(wcstoll, std::, <cwchar>)
-SYMBOL(wcstoll, None, <cwchar>)
-SYMBOL(wcstoll, None, <wchar.h>)
+SYMBOL(wcstoll, , <cwchar>)
+SYMBOL(wcstoll, , <wchar.h>)
 SYMBOL(wcstombs, std::, <cstdlib>)
-SYMBOL(wcstombs, None, <cstdlib>)
-SYMBOL(wcstombs, None, <stdlib.h>)
+SYMBOL(wcstombs, , <cstdlib>)
+SYMBOL(wcstombs, , <stdlib.h>)
 SYMBOL(wcstoul, std::, <cwchar>)
-SYMBOL(wcstoul, None, <cwchar>)
-SYMBOL(wcstoul, None, <wchar.h>)
+SYMBOL(wcstoul, , <cwchar>)
+SYMBOL(wcstoul, , <wchar.h>)
 SYMBOL(wcstoull, std::, <cwchar>)
-SYMBOL(wcstoull, None, <cwchar>)
-SYMBOL(wcstoull, None, <wchar.h>)
+SYMBOL(wcstoull, , <cwchar>)
+SYMBOL(wcstoull, , <wchar.h>)
 SYMBOL(wcstoumax, std::, <cinttypes>)
-SYMBOL(wcstoumax, None, <cinttypes>)
-SYMBOL(wcstoumax, None, <inttypes.h>)
+SYMBOL(wcstoumax, , <cinttypes>)
+SYMBOL(wcstoumax, , <inttypes.h>)
 SYMBOL(wcsub_match, std::, <regex>)
 SYMBOL(wcsxfrm, std::, <cwchar>)
-SYMBOL(wcsxfrm, None, <cwchar>)
-SYMBOL(wcsxfrm, None, <wchar.h>)
+SYMBOL(wcsxfrm, , <cwchar>)
+SYMBOL(wcsxfrm, , <wchar.h>)
 SYMBOL(wctob, std::, <cwchar>)
-SYMBOL(wctob, None, <cwchar>)
-SYMBOL(wctob, None, <wchar.h>)
+SYMBOL(wctob, , <cwchar>)
+SYMBOL(wctob, , <wchar.h>)
 SYMBOL(wctomb, std::, <cstdlib>)
-SYMBOL(wctomb, None, <cstdlib>)
-SYMBOL(wctomb, None, <stdlib.h>)
+SYMBOL(wctomb, , <cstdlib>)
+SYMBOL(wctomb, , <stdlib.h>)
 SYMBOL(wctrans, std::, <cwctype>)
-SYMBOL(wctrans, None, <cwctype>)
-SYMBOL(wctrans, None, <wctype.h>)
+SYMBOL(wctrans, , <cwctype>)
+SYMBOL(wctrans, , <wctype.h>)
 SYMBOL(wctrans_t, std::, <cwctype>)
-SYMBOL(wctrans_t, None, <cwctype>)
-SYMBOL(wctrans_t, None, <wctype.h>)
+SYMBOL(wctrans_t, , <cwctype>)
+SYMBOL(wctrans_t, , <wctype.h>)
 SYMBOL(wctype, std::, <cwctype>)
-SYMBOL(wctype, None, <cwctype>)
-SYMBOL(wctype, None, <wctype.h>)
+SYMBOL(wctype, , <cwctype>)
+SYMBOL(wctype, , <wctype.h>)
 SYMBOL(wctype_t, std::, <cwctype>)
-SYMBOL(wctype_t, None, <cwctype>)
-SYMBOL(wctype_t, None, <wctype.h>)
+SYMBOL(wctype_t, , <cwctype>)
+SYMBOL(wctype_t, , <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(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(wmemchr, , <cwchar>)
+SYMBOL(wmemchr, , <wchar.h>)
 SYMBOL(wmemcmp, std::, <cwchar>)
-SYMBOL(wmemcmp, None, <cwchar>)
-SYMBOL(wmemcmp, None, <wchar.h>)
+SYMBOL(wmemcmp, , <cwchar>)
+SYMBOL(wmemcmp, , <wchar.h>)
 SYMBOL(wmemcpy, std::, <cwchar>)
-SYMBOL(wmemcpy, None, <cwchar>)
-SYMBOL(wmemcpy, None, <wchar.h>)
+SYMBOL(wmemcpy, , <cwchar>)
+SYMBOL(wmemcpy, , <wchar.h>)
 SYMBOL(wmemmove, std::, <cwchar>)
-SYMBOL(wmemmove, None, <cwchar>)
-SYMBOL(wmemmove, None, <wchar.h>)
+SYMBOL(wmemmove, , <cwchar>)
+SYMBOL(wmemmove, , <wchar.h>)
 SYMBOL(wmemset, std::, <cwchar>)
-SYMBOL(wmemset, None, <cwchar>)
-SYMBOL(wmemset, None, <wchar.h>)
+SYMBOL(wmemset, , <cwchar>)
+SYMBOL(wmemset, , <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(wprintf, , <cwchar>)
+SYMBOL(wprintf, , <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(wscanf, , <cwchar>)
+SYMBOL(wscanf, , <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>)

clang/tools/include-mapping/gen_std.py

def main():
   for symbol in symbols:
     if len(symbol.headers) == 1:
       augmented_symbols = [symbol]
       augmented_symbols.extend(GetCCompatibilitySymbols(symbol))
       for s in augmented_symbols:
         s.headers.extend(AdditionalHeadersForIOSymbols(s))
         for header in s.headers:
           # SYMBOL(unqualified_name, namespace, header)
+          if s.namespace:
             print("SYMBOL(%s, %s, %s)" % (s.name, s.namespace,
                                           header))
+          else:
+            print("SYMBOL(%s, , %s)" % (s.name, header))
     elif len(symbol.headers) == 0:
       sys.stderr.write("No header found for symbol %s\n" % symbol.name)
     else:
       # FIXME: support symbols with multiple headers (e.g. std::move).
       sys.stderr.write("Ambiguous header for symbol %s: %s\n" % (
           symbol.name, ', '.join(symbol.headers)))
 
 
 if __name__ == '__main__':
   main()