apitypes = {
}

api = {
    '*.__libc_start_main':( 'int', None, 'cdecl', '*.__libc_start_main', (('int', 'main'), ('int', 'argc'), ('int', 'argv')) ),
    'main':( 'int', None, 'stdcall', '*.main_entry', (('int', None), ('int', None), ('int', None)) ),
    '*.DTTOIF': ('mode_t', None, 'cdecl', '*.DTTOIF', (('int', 'dtype'),)),
    '*.IFTODT': ('int', None, 'cdecl', '*.IFTODT', (('mode_t', 'mode'),)),
    '*._Exit': ('void', None, 'cdecl', '*._Exit', (('int', 'status'),)),
    '*.__fbufsize': ('size_t', None, 'cdecl', '*.__fbufsize', (('FILE *', 'stream'),)),
    '*.__flbf': ('int', None, 'cdecl', '*.__flbf', (('FILE *', 'stream'),)),
    '*.__fpending': ('size_t', None, 'cdecl', '*.__fpending', (('FILE *', 'stream'),)),
    '*.__fpurge': ('void', None, 'cdecl', '*.__fpurge', (('FILE *', 'stream'),)),
    '*.__freadable': ('int', None, 'cdecl', '*.__freadable', (('FILE *', 'stream'),)),
    '*.__freading': ('int', None, 'cdecl', '*.__freading', (('FILE *', 'stream'),)),
    '*.__fsetlocking': ('int', None, 'cdecl', '*.__fsetlocking', (('FILE *', 'stream'), ('int', 'type'))),
    '*.__fwritable': ('int', None, 'cdecl', '*.__fwritable', (('FILE *', 'stream'),)),
    '*.__fwriting': ('int', None, 'cdecl', '*.__fwriting', (('FILE *', 'stream'),)),
    '*.__ppc_get_timebase': ('uint64_t', None, 'cdecl', '*.__ppc_get_timebase', ()),
    '*.__ppc_get_timebase_freq': ('uint64_t', None, 'cdecl', '*.__ppc_get_timebase_freq', ()),
    '*.__ppc_mdoio': ('void', None, 'cdecl', '*.__ppc_mdoio', ()),
    '*.__ppc_mdoom': ('void', None, 'cdecl', '*.__ppc_mdoom', ()),
    '*.__ppc_set_ppr_low': ('void', None, 'cdecl', '*.__ppc_set_ppr_low', ()),
    '*.__ppc_set_ppr_med': ('void', None, 'cdecl', '*.__ppc_set_ppr_med', ()),
    '*.__ppc_set_ppr_med_high': ('void', None, 'cdecl', '*.__ppc_set_ppr_med_high', ()),
    '*.__ppc_set_ppr_med_low': ('void', None, 'cdecl', '*.__ppc_set_ppr_med_low', ()),
    '*.__ppc_set_ppr_very_low': ('void', None, 'cdecl', '*.__ppc_set_ppr_very_low', ()),
    '*.__ppc_yield': ('void', None, 'cdecl', '*.__ppc_yield', ()),
    '*.__riscv_flush_icache': ('void', None, 'cdecl', '*.__riscv_flush_icache', (('void *', 'start'), ('void *', 'end'), ('unsigned long int', 'flags'))),
    '*._exit': ('void', None, 'cdecl', '*._exit', (('int', 'status'),)),
    '*._flushlbf': ('void', None, 'cdecl', '*._flushlbf', ()),
    '*._tolower': ('int', None, 'cdecl', '*._tolower', (('int', 'c'),)),
    '*._toupper': ('int', None, 'cdecl', '*._toupper', (('int', 'c'),)),
    '*.a64l': ('long int', None, 'cdecl', '*.a64l', (('const char *', 'string'),)),
    '*.abort': ('void', None, 'cdecl', '*.abort', ()),
    '*.abs': ('int', None, 'cdecl', '*.abs', (('int', 'number'),)),
    '*.accept': ('int', None, 'cdecl', '*.accept', (('int', 'socket'), ('struct sockaddr *', 'addr'), ('socklen_t *', 'length_ptr'))),
    '*.access': ('int', None, 'cdecl', '*.access', (('const char *', 'filename'), ('int', 'how'))),
    '*.acos': ('double', None, 'cdecl', '*.acos', (('double', 'x'),)),
    '*.acosf': ('float', None, 'cdecl', '*.acosf', (('float', 'x'),)),
    '*.acosfN': ('_FloatN', None, 'cdecl', '*.acosfN', (('_FloatN', 'x'),)),
    '*.acosfNx': ('_FloatNx', None, 'cdecl', '*.acosfNx', (('_FloatNx', 'x'),)),
    '*.acosh': ('double', None, 'cdecl', '*.acosh', (('double', 'x'),)),
    '*.acoshf': ('float', None, 'cdecl', '*.acoshf', (('float', 'x'),)),
    '*.acoshfN': ('_FloatN', None, 'cdecl', '*.acoshfN', (('_FloatN', 'x'),)),
    '*.acoshfNx': ('_FloatNx', None, 'cdecl', '*.acoshfNx', (('_FloatNx', 'x'),)),
    '*.acoshl': ('long double', None, 'cdecl', '*.acoshl', (('long double', 'x'),)),
    '*.acosl': ('long double', None, 'cdecl', '*.acosl', (('long double', 'x'),)),
    '*.addmntent': ('int', None, 'cdecl', '*.addmntent', (('FILE *', 'stream'), ('const struct mntent *', 'mnt'))),
    '*.addseverity': ('int', None, 'cdecl', '*.addseverity', (('int', 'severity'), ('const char *', 'string'))),
    '*.adjtime': ('int', None, 'cdecl', '*.adjtime', (('const struct timeval *', 'delta'), ('struct timeval *', 'olddelta'))),
    '*.adjtimex': ('int', None, 'cdecl', '*.adjtimex', (('struct timex *', 'timex'),)),
    '*.aio_cancel': ('int', None, 'cdecl', '*.aio_cancel', (('int', 'fildes'), ('struct aiocb *', 'aiocbp'))),
    '*.aio_cancel64': ('int', None, 'cdecl', '*.aio_cancel64', (('int', 'fildes'), ('struct aiocb64 *', 'aiocbp'))),
    '*.aio_error': ('int', None, 'cdecl', '*.aio_error', (('const struct aiocb *', 'aiocbp'),)),
    '*.aio_error64': ('int', None, 'cdecl', '*.aio_error64', (('const struct aiocb64 *', 'aiocbp'),)),
    '*.aio_fsync': ('int', None, 'cdecl', '*.aio_fsync', (('int', 'op'), ('struct aiocb *', 'aiocbp'))),
    '*.aio_fsync64': ('int', None, 'cdecl', '*.aio_fsync64', (('int', 'op'), ('struct aiocb64 *', 'aiocbp'))),
    '*.aio_init': ('void', None, 'cdecl', '*.aio_init', (('const struct aioinit *', 'init'),)),
    '*.aio_read': ('int', None, 'cdecl', '*.aio_read', (('struct aiocb *', 'aiocbp'),)),
    '*.aio_read64': ('int', None, 'cdecl', '*.aio_read64', (('struct aiocb64 *', 'aiocbp'),)),
    '*.aio_return': ('ssize_t', None, 'cdecl', '*.aio_return', (('struct aiocb *', 'aiocbp'),)),
    '*.aio_return64': ('ssize_t', None, 'cdecl', '*.aio_return64', (('struct aiocb64 *', 'aiocbp'),)),
    '*.aio_suspend': ('int', None, 'cdecl', '*.aio_suspend', (('const struct aiocb * const', 'list[]'), ('int', 'nent'), ('const struct timespec *', 'timeout'))),
    '*.aio_suspend64': ('int', None, 'cdecl', '*.aio_suspend64', (('const struct aiocb64 * const', 'list[]'), ('int', 'nent'), ('const struct timespec *', 'timeout'))),
    '*.aio_write': ('int', None, 'cdecl', '*.aio_write', (('struct aiocb *', 'aiocbp'),)),
    '*.aio_write64': ('int', None, 'cdecl', '*.aio_write64', (('struct aiocb64 *', 'aiocbp'),)),
    '*.alarm': ('unsigned int', None, 'cdecl', '*.alarm', (('unsigned int', 'seconds'),)),
    '*.aligned_alloc': ('void *', None, 'cdecl', '*.aligned_alloc', (('size_t', 'alignment'), ('size_t', 'size'))),
    '*.alloca': ('void *', None, 'cdecl', '*.alloca', (('size_t', 'size'),)),
    '*.alphasort': ('int', None, 'cdecl', '*.alphasort', (('const struct dirent * *', 'a'), ('const struct dirent * *', 'b'))),
    '*.alphasort64': ('int', None, 'cdecl', '*.alphasort64', (('const struct dirent64 * *', 'a'), ('const struct dirent * *', 'b'))),
    '*.argp_error': ('void', None, 'cdecl', '*.argp_error', (('const struct argp_state *', 'state'), ('const char *', 'fmt'), ('variadic', ''))),
    '*.argp_failure': ('void', None, 'cdecl', '*.argp_failure', (('const struct argp_state *', 'state'), ('int', 'status'), ('int', 'errnum'), ('const char *', 'fmt'), ('variadic', ''))),
    '*.argp_help': ('void', None, 'cdecl', '*.argp_help', (('const struct argp *', 'argp'), ('FILE *', 'stream'), ('unsigned', 'flags'), ('char *', 'name'))),
    '*.argp_parse': ('error_t', None, 'cdecl', '*.argp_parse', (('const struct argp *', 'argp'), ('int', 'argc'), ('char * *', 'argv'), ('unsigned', 'flags'), ('int *', 'arg_index'), ('void *', 'input'))),
    '*.argp_state_help': ('void', None, 'cdecl', '*.argp_state_help', (('const struct argp_state *', 'state'), ('FILE *', 'stream'), ('unsigned', 'flags'))),
    '*.argp_usage': ('void', None, 'cdecl', '*.argp_usage', (('const struct argp_state *', 'state'),)),
    '*.argz_add': ('error_t', None, 'cdecl', '*.argz_add', (('char * *', 'argz'), ('size_t *', 'argz_len'), ('const char *', 'str'))),
    '*.argz_add_sep': ('error_t', None, 'cdecl', '*.argz_add_sep', (('char * *', 'argz'), ('size_t *', 'argz_len'), ('const char *', 'str'), ('int', 'delim'))),
    '*.argz_append': ('error_t', None, 'cdecl', '*.argz_append', (('char * *', 'argz'), ('size_t *', 'argz_len'), ('const char *', 'buf'), ('size_t', 'buf_len'))),
    '*.argz_count': ('size_t', None, 'cdecl', '*.argz_count', (('const char *', 'argz'), ('size_t', 'argz_len'))),
    '*.argz_create': ('error_t', None, 'cdecl', '*.argz_create', (('char * const', 'argv[]'), ('char * *', 'argz'), ('size_t *', 'argz_len'))),
    '*.argz_create_sep': ('error_t', None, 'cdecl', '*.argz_create_sep', (('const char *', 'string'), ('int', 'sep'), ('char * *', 'argz'), ('size_t *', 'argz_len'))),
    '*.argz_delete': ('void', None, 'cdecl', '*.argz_delete', (('char * *', 'argz'), ('size_t *', 'argz_len'), ('char *', 'entry'))),
    '*.argz_extract': ('void', None, 'cdecl', '*.argz_extract', (('const char *', 'argz'), ('size_t', 'argz_len'), ('char * *', 'argv'))),
    '*.argz_insert': ('error_t', None, 'cdecl', '*.argz_insert', (('char * *', 'argz'), ('size_t *', 'argz_len'), ('char *', 'before'), ('const char *', 'entry'))),
    '*.argz_next': ('char *', None, 'cdecl', '*.argz_next', (('const char *', 'argz'), ('size_t', 'argz_len'), ('const char *', 'entry'))),
    '*.argz_replace': ('error_t', None, 'cdecl', '*.argz_replace', (('char\xa0* *', 'argz'), ('size_t\xa0*', 'argz_len'), ('const\xa0char\xa0*', 'str'), ('const\xa0char\xa0*', 'with'), ('unsigned\xa0*', 'replace_count'))),
    '*.argz_stringify': ('void', None, 'cdecl', '*.argz_stringify', (('char *', 'argz'), ('size_t', 'len'), ('int', 'sep'))),
    '*.asctime': ('char *', None, 'cdecl', '*.asctime', (('const struct tm *', 'brokentime'),)),
    '*.asctime_r': ('char *', None, 'cdecl', '*.asctime_r', (('const struct tm *', 'brokentime'), ('char *', 'buffer'))),
    '*.asin': ('double', None, 'cdecl', '*.asin', (('double', 'x'),)),
    '*.asinf': ('float', None, 'cdecl', '*.asinf', (('float', 'x'),)),
    '*.asinfN': ('_FloatN', None, 'cdecl', '*.asinfN', (('_FloatN', 'x'),)),
    '*.asinfNx': ('_FloatNx', None, 'cdecl', '*.asinfNx', (('_FloatNx', 'x'),)),
    '*.asinh': ('double', None, 'cdecl', '*.asinh', (('double', 'x'),)),
    '*.asinhf': ('float', None, 'cdecl', '*.asinhf', (('float', 'x'),)),
    '*.asinhfN': ('_FloatN', None, 'cdecl', '*.asinhfN', (('_FloatN', 'x'),)),
    '*.asinhfNx': ('_FloatNx', None, 'cdecl', '*.asinhfNx', (('_FloatNx', 'x'),)),
    '*.asinhl': ('long double', None, 'cdecl', '*.asinhl', (('long double', 'x'),)),
    '*.asinl': ('long double', None, 'cdecl', '*.asinl', (('long double', 'x'),)),
    '*.asprintf': ('int', None, 'cdecl', '*.asprintf', (('char * *', 'ptr'), ('const char *', 'template'), ('variadic', ''))),
    '*.atan': ('double', None, 'cdecl', '*.atan', (('double', 'x'),)),
    '*.atan2': ('double', None, 'cdecl', '*.atan2', (('double', 'y'), ('double', 'x'))),
    '*.atan2f': ('float', None, 'cdecl', '*.atan2f', (('float', 'y'), ('float', 'x'))),
    '*.atan2fN': ('_FloatN', None, 'cdecl', '*.atan2fN', (('_FloatN', 'y'), ('_FloatN', 'x'))),
    '*.atan2fNx': ('_FloatNx', None, 'cdecl', '*.atan2fNx', (('_FloatNx', 'y'), ('_FloatNx', 'x'))),
    '*.atan2l': ('long double', None, 'cdecl', '*.atan2l', (('long double', 'y'), ('long double', 'x'))),
    '*.atanf': ('float', None, 'cdecl', '*.atanf', (('float', 'x'),)),
    '*.atanfN': ('_FloatN', None, 'cdecl', '*.atanfN', (('_FloatN', 'x'),)),
    '*.atanfNx': ('_FloatNx', None, 'cdecl', '*.atanfNx', (('_FloatNx', 'x'),)),
    '*.atanh': ('double', None, 'cdecl', '*.atanh', (('double', 'x'),)),
    '*.atanhf': ('float', None, 'cdecl', '*.atanhf', (('float', 'x'),)),
    '*.atanhfN': ('_FloatN', None, 'cdecl', '*.atanhfN', (('_FloatN', 'x'),)),
    '*.atanhfNx': ('_FloatNx', None, 'cdecl', '*.atanhfNx', (('_FloatNx', 'x'),)),
    '*.atanhl': ('long double', None, 'cdecl', '*.atanhl', (('long double', 'x'),)),
    '*.atanl': ('long double', None, 'cdecl', '*.atanl', (('long double', 'x'),)),
    '*.atexit': ('int', None, 'cdecl', '*.atexit', (('void (* function', '(void'),)),
    '*.atof': ('double', None, 'cdecl', '*.atof', (('const char *', 'string'),)),
    '*.atoi': ('int', None, 'cdecl', '*.atoi', (('const char *', 'string'),)),
    '*.atol': ('long int', None, 'cdecl', '*.atol', (('const char *', 'string'),)),
    '*.atoll': ('long long int', None, 'cdecl', '*.atoll', (('const char *', 'string'),)),
    '*.backtrace': ('int', None, 'cdecl', '*.backtrace', (('void * *', 'buffer'), ('int', 'size'))),
    '*.backtrace_symbols': ('char * *', None, 'cdecl', '*.backtrace_symbols', (('void * const *', 'buffer'), ('int', 'size'))),
    '*.backtrace_symbols_fd': ('void', None, 'cdecl', '*.backtrace_symbols_fd', (('void * const *', 'buffer'), ('int', 'size'), ('int', 'fd'))),
    '*.basename': ('char *', None, 'cdecl', '*.basename', (('char *', 'path'),)),
    '*.bcmp': ('int', None, 'cdecl', '*.bcmp', (('const void *', 'a1'), ('const void *', 'a2'), ('size_t', 'size'))),
    '*.bcopy': ('void', None, 'cdecl', '*.bcopy', (('const void *', 'from'), ('void *', 'to'), ('size_t', 'size'))),
    '*.bind': ('int', None, 'cdecl', '*.bind', (('int', 'socket'), ('struct sockaddr *', 'addr'), ('socklen_t', 'length'))),
    '*.bind_textdomain_codeset': ('char *', None, 'cdecl', '*.bind_textdomain_codeset', (('const char *', 'domainname'), ('const char *', 'codeset'))),
    '*.bindtextdomain': ('char *', None, 'cdecl', '*.bindtextdomain', (('const char *', 'domainname'), ('const char *', 'dirname'))),
    '*.brk': ('int', None, 'cdecl', '*.brk', (('void *', 'addr'),)),
    '*.bsearch': ('void *', None, 'cdecl', '*.bsearch', (('const void *', 'key'), ('const void *', 'array'), ('size_t', 'count'), ('size_t', 'size'), ('comparison_fn_t', 'compare'))),
    '*.btowc': ('wint_t', None, 'cdecl', '*.btowc', (('int', 'c'),)),
    '*.bzero': ('void', None, 'cdecl', '*.bzero', (('void *', 'block'), ('size_t', 'size'))),
    '*.cabs': ('double', None, 'cdecl', '*.cabs', (('complex double', 'z'),)),
    '*.cabsf': ('float', None, 'cdecl', '*.cabsf', (('complex float', 'z'),)),
    '*.cabsfN': ('_FloatN', None, 'cdecl', '*.cabsfN', (('complex _FloatN', 'z'),)),
    '*.cabsfNx': ('_FloatNx', None, 'cdecl', '*.cabsfNx', (('complex _FloatNx', 'z'),)),
    '*.cabsl': ('long double', None, 'cdecl', '*.cabsl', (('complex long double', 'z'),)),
    '*.cacos': ('complex double', None, 'cdecl', '*.cacos', (('complex double', 'z'),)),
    '*.cacosf': ('complex float', None, 'cdecl', '*.cacosf', (('complex float', 'z'),)),
    '*.cacosfN': ('complex _FloatN', None, 'cdecl', '*.cacosfN', (('complex _FloatN', 'z'),)),
    '*.cacosfNx': ('complex _FloatNx', None, 'cdecl', '*.cacosfNx', (('complex _FloatNx', 'z'),)),
    '*.cacosh': ('complex double', None, 'cdecl', '*.cacosh', (('complex double', 'z'),)),
    '*.cacoshf': ('complex float', None, 'cdecl', '*.cacoshf', (('complex float', 'z'),)),
    '*.cacoshfN': ('complex _FloatN', None, 'cdecl', '*.cacoshfN', (('complex _FloatN', 'z'),)),
    '*.cacoshfNx': ('complex _FloatNx', None, 'cdecl', '*.cacoshfNx', (('complex _FloatNx', 'z'),)),
    '*.cacoshl': ('complex long double', None, 'cdecl', '*.cacoshl', (('complex long double', 'z'),)),
    '*.cacosl': ('complex long double', None, 'cdecl', '*.cacosl', (('complex long double', 'z'),)),
    '*.call_once': ('void', None, 'cdecl', '*.call_once', (('once_flag *', 'flag'), ('void (* func', '(void'))),
    '*.calloc': ('void *', None, 'cdecl', '*.calloc', (('size_t', 'count'), ('size_t', 'eltsize'))),
    '*.canonicalize': ('int', None, 'cdecl', '*.canonicalize', (('double *', 'cx'), ('const double *', 'x'))),
    '*.canonicalize_file_name': ('char *', None, 'cdecl', '*.canonicalize_file_name', (('const char *', 'name'),)),
    '*.canonicalizef': ('int', None, 'cdecl', '*.canonicalizef', (('float *', 'cx'), ('const float *', 'x'))),
    '*.canonicalizefN': ('int', None, 'cdecl', '*.canonicalizefN', (('_FloatN *', 'cx'), ('const _FloatN *', 'x'))),
    '*.canonicalizefNx': ('int', None, 'cdecl', '*.canonicalizefNx', (('_FloatNx *', 'cx'), ('const _FloatNx *', 'x'))),
    '*.canonicalizel': ('int', None, 'cdecl', '*.canonicalizel', (('long double *', 'cx'), ('const long double *', 'x'))),
    '*.carg': ('double', None, 'cdecl', '*.carg', (('complex double', 'z'),)),
    '*.cargf': ('float', None, 'cdecl', '*.cargf', (('complex float', 'z'),)),
    '*.cargfN': ('_FloatN', None, 'cdecl', '*.cargfN', (('complex _FloatN', 'z'),)),
    '*.cargfNx': ('_FloatNx', None, 'cdecl', '*.cargfNx', (('complex _FloatNx', 'z'),)),
    '*.cargl': ('long double', None, 'cdecl', '*.cargl', (('complex long double', 'z'),)),
    '*.casin': ('complex double', None, 'cdecl', '*.casin', (('complex double', 'z'),)),
    '*.casinf': ('complex float', None, 'cdecl', '*.casinf', (('complex float', 'z'),)),
    '*.casinfN': ('complex _FloatN', None, 'cdecl', '*.casinfN', (('complex _FloatN', 'z'),)),
    '*.casinfNx': ('complex _FloatNx', None, 'cdecl', '*.casinfNx', (('complex _FloatNx', 'z'),)),
    '*.casinh': ('complex double', None, 'cdecl', '*.casinh', (('complex double', 'z'),)),
    '*.casinhf': ('complex float', None, 'cdecl', '*.casinhf', (('complex float', 'z'),)),
    '*.casinhfN': ('complex _FloatN', None, 'cdecl', '*.casinhfN', (('complex _FloatN', 'z'),)),
    '*.casinhfNx': ('complex _FloatNx', None, 'cdecl', '*.casinhfNx', (('complex _FloatNx', 'z'),)),
    '*.casinhl': ('complex long double', None, 'cdecl', '*.casinhl', (('complex long double', 'z'),)),
    '*.casinl': ('complex long double', None, 'cdecl', '*.casinl', (('complex long double', 'z'),)),
    '*.catan': ('complex double', None, 'cdecl', '*.catan', (('complex double', 'z'),)),
    '*.catanf': ('complex float', None, 'cdecl', '*.catanf', (('complex float', 'z'),)),
    '*.catanfN': ('complex _FloatN', None, 'cdecl', '*.catanfN', (('complex _FloatN', 'z'),)),
    '*.catanfNx': ('complex _FloatNx', None, 'cdecl', '*.catanfNx', (('complex _FloatNx', 'z'),)),
    '*.catanh': ('complex double', None, 'cdecl', '*.catanh', (('complex double', 'z'),)),
    '*.catanhf': ('complex float', None, 'cdecl', '*.catanhf', (('complex float', 'z'),)),
    '*.catanhfN': ('complex _FloatN', None, 'cdecl', '*.catanhfN', (('complex _FloatN', 'z'),)),
    '*.catanhfNx': ('complex _FloatNx', None, 'cdecl', '*.catanhfNx', (('complex _FloatNx', 'z'),)),
    '*.catanhl': ('complex long double', None, 'cdecl', '*.catanhl', (('complex long double', 'z'),)),
    '*.catanl': ('complex long double', None, 'cdecl', '*.catanl', (('complex long double', 'z'),)),
    '*.catclose': ('int', None, 'cdecl', '*.catclose', (('nl_catd', 'catalog_desc'),)),
    '*.catgets': ('char *', None, 'cdecl', '*.catgets', (('nl_catd', 'catalog_desc'), ('int', 'set'), ('int', 'message'), ('const char *', 'string'))),
    '*.catopen': ('nl_catd', None, 'cdecl', '*.catopen', (('const char *', 'cat_name'), ('int', 'flag'))),
    '*.cbrt': ('double', None, 'cdecl', '*.cbrt', (('double', 'x'),)),
    '*.cbrtf': ('float', None, 'cdecl', '*.cbrtf', (('float', 'x'),)),
    '*.cbrtfN': ('_FloatN', None, 'cdecl', '*.cbrtfN', (('_FloatN', 'x'),)),
    '*.cbrtfNx': ('_FloatNx', None, 'cdecl', '*.cbrtfNx', (('_FloatNx', 'x'),)),
    '*.cbrtl': ('long double', None, 'cdecl', '*.cbrtl', (('long double', 'x'),)),
    '*.ccos': ('complex double', None, 'cdecl', '*.ccos', (('complex double', 'z'),)),
    '*.ccosf': ('complex float', None, 'cdecl', '*.ccosf', (('complex float', 'z'),)),
    '*.ccosfN': ('complex _FloatN', None, 'cdecl', '*.ccosfN', (('complex _FloatN', 'z'),)),
    '*.ccosfNx': ('complex _FloatNx', None, 'cdecl', '*.ccosfNx', (('complex _FloatNx', 'z'),)),
    '*.ccosh': ('complex double', None, 'cdecl', '*.ccosh', (('complex double', 'z'),)),
    '*.ccoshf': ('complex float', None, 'cdecl', '*.ccoshf', (('complex float', 'z'),)),
    '*.ccoshfN': ('complex _FloatN', None, 'cdecl', '*.ccoshfN', (('complex _FloatN', 'z'),)),
    '*.ccoshfNx': ('complex _FloatNx', None, 'cdecl', '*.ccoshfNx', (('complex _FloatNx', 'z'),)),
    '*.ccoshl': ('complex long double', None, 'cdecl', '*.ccoshl', (('complex long double', 'z'),)),
    '*.ccosl': ('complex long double', None, 'cdecl', '*.ccosl', (('complex long double', 'z'),)),
    '*.ceil': ('double', None, 'cdecl', '*.ceil', (('double', 'x'),)),
    '*.ceilf': ('float', None, 'cdecl', '*.ceilf', (('float', 'x'),)),
    '*.ceilfN': ('_FloatN', None, 'cdecl', '*.ceilfN', (('_FloatN', 'x'),)),
    '*.ceilfNx': ('_FloatNx', None, 'cdecl', '*.ceilfNx', (('_FloatNx', 'x'),)),
    '*.ceill': ('long double', None, 'cdecl', '*.ceill', (('long double', 'x'),)),
    '*.cexp': ('complex double', None, 'cdecl', '*.cexp', (('complex double', 'z'),)),
    '*.cexpf': ('complex float', None, 'cdecl', '*.cexpf', (('complex float', 'z'),)),
    '*.cexpfN': ('complex _FloatN', None, 'cdecl', '*.cexpfN', (('complex _FloatN', 'z'),)),
    '*.cexpfNx': ('complex _FloatNx', None, 'cdecl', '*.cexpfNx', (('complex _FloatNx', 'z'),)),
    '*.cexpl': ('complex long double', None, 'cdecl', '*.cexpl', (('complex long double', 'z'),)),
    '*.cfgetispeed': ('speed_t', None, 'cdecl', '*.cfgetispeed', (('const struct termios *', 'termios-p'),)),
    '*.cfgetospeed': ('speed_t', None, 'cdecl', '*.cfgetospeed', (('const struct termios *', 'termios-p'),)),
    '*.cfmakeraw': ('void', None, 'cdecl', '*.cfmakeraw', (('struct termios *', 'termios-p'),)),
    '*.cfsetispeed': ('int', None, 'cdecl', '*.cfsetispeed', (('struct termios *', 'termios-p'), ('speed_t', 'speed'))),
    '*.cfsetospeed': ('int', None, 'cdecl', '*.cfsetospeed', (('struct termios *', 'termios-p'), ('speed_t', 'speed'))),
    '*.cfsetspeed': ('int', None, 'cdecl', '*.cfsetspeed', (('struct termios *', 'termios-p'), ('speed_t', 'speed'))),
    '*.chdir': ('int', None, 'cdecl', '*.chdir', (('const char *', 'filename'),)),
    '*.chmod': ('int', None, 'cdecl', '*.chmod', (('const char *', 'filename'), ('mode_t', 'mode'))),
    '*.chown': ('int', None, 'cdecl', '*.chown', (('const char *', 'filename'), ('uid_t', 'owner'), ('gid_t', 'group'))),
    '*.cimag': ('double', None, 'cdecl', '*.cimag', (('complex double', 'z'),)),
    '*.cimagf': ('float', None, 'cdecl', '*.cimagf', (('complex float', 'z'),)),
    '*.cimagfN': ('_FloatN', None, 'cdecl', '*.cimagfN', (('complex _FloatN', 'z'),)),
    '*.cimagfNx': ('_FloatNx', None, 'cdecl', '*.cimagfNx', (('complex _FloatNx', 'z'),)),
    '*.cimagl': ('long double', None, 'cdecl', '*.cimagl', (('complex long double', 'z'),)),
    '*.clearenv': ('int', None, 'cdecl', '*.clearenv', ()),
    '*.clearerr': ('void', None, 'cdecl', '*.clearerr', (('FILE *', 'stream'),)),
    '*.clearerr_unlocked': ('void', None, 'cdecl', '*.clearerr_unlocked', (('FILE *', 'stream'),)),
    '*.clock': ('clock_t', None, 'cdecl', '*.clock', ()),
    '*.clock_getres': ('int', None, 'cdecl', '*.clock_getres', (('clockid_t', 'clock'), ('struct timespec *', 'res'))),
    '*.clock_gettime': ('int', None, 'cdecl', '*.clock_gettime', (('clockid_t', 'clock'), ('struct timespec *', 'ts'))),
    '*.clock_settime': ('int', None, 'cdecl', '*.clock_settime', (('clockid_t', 'clock'), ('const struct timespec *', 'ts'))),
    '*.clog': ('complex double', None, 'cdecl', '*.clog', (('complex double', 'z'),)),
    '*.clog10': ('complex double', None, 'cdecl', '*.clog10', (('complex double', 'z'),)),
    '*.clog10f': ('complex float', None, 'cdecl', '*.clog10f', (('complex float', 'z'),)),
    '*.clog10fN': ('complex _FloatN', None, 'cdecl', '*.clog10fN', (('complex _FloatN', 'z'),)),
    '*.clog10fNx': ('complex _FloatNx', None, 'cdecl', '*.clog10fNx', (('complex _FloatNx', 'z'),)),
    '*.clog10l': ('complex long double', None, 'cdecl', '*.clog10l', (('complex long double', 'z'),)),
    '*.clogf': ('complex float', None, 'cdecl', '*.clogf', (('complex float', 'z'),)),
    '*.clogfN': ('complex _FloatN', None, 'cdecl', '*.clogfN', (('complex _FloatN', 'z'),)),
    '*.clogfNx': ('complex _FloatNx', None, 'cdecl', '*.clogfNx', (('complex _FloatNx', 'z'),)),
    '*.clogl': ('complex long double', None, 'cdecl', '*.clogl', (('complex long double', 'z'),)),
    '*.close': ('int', None, 'cdecl', '*.close', (('int', 'filedes'),)),
    '*.closedir': ('int', None, 'cdecl', '*.closedir', (('DIR *', 'dirstream'),)),
    '*.closelog': ('void', None, 'cdecl', '*.closelog', ()),
    '*.cnd_broadcast': ('int', None, 'cdecl', '*.cnd_broadcast', (('cnd_t *', 'cond'),)),
    '*.cnd_destroy': ('void', None, 'cdecl', '*.cnd_destroy', (('cnd_t *', 'cond'),)),
    '*.cnd_init': ('int', None, 'cdecl', '*.cnd_init', (('cnd_t *', 'cond'),)),
    '*.cnd_signal': ('int', None, 'cdecl', '*.cnd_signal', (('cnd_t *', 'cond'),)),
    '*.cnd_timedwait': ('int', None, 'cdecl', '*.cnd_timedwait', (('cnd_t * restrict', 'cond'), ('mtx_t * restrict', 'mutex'), ('const struct timespec * restrict', 'time_point'))),
    '*.cnd_wait': ('int', None, 'cdecl', '*.cnd_wait', (('cnd_t *', 'cond'), ('mtx_t *', 'mutex'))),
    '*.confstr': ('size_t', None, 'cdecl', '*.confstr', (('int', 'parameter'), ('char *', 'buf'), ('size_t', 'len'))),
    '*.conj': ('complex double', None, 'cdecl', '*.conj', (('complex double', 'z'),)),
    '*.conjf': ('complex float', None, 'cdecl', '*.conjf', (('complex float', 'z'),)),
    '*.conjfN': ('complex _FloatN', None, 'cdecl', '*.conjfN', (('complex _FloatN', 'z'),)),
    '*.conjfNx': ('complex _FloatNx', None, 'cdecl', '*.conjfNx', (('complex _FloatNx', 'z'),)),
    '*.conjl': ('complex long double', None, 'cdecl', '*.conjl', (('complex long double', 'z'),)),
    '*.connect': ('int', None, 'cdecl', '*.connect', (('int', 'socket'), ('struct sockaddr *', 'addr'), ('socklen_t', 'length'))),
    '*.copy_file_range': ('ssize_t', None, 'cdecl', '*.copy_file_range', (('int', 'inputfd'), ('off64_t *', 'inputpos'), ('int', 'outputfd'), ('off64_t *', 'outputpos'), ('ssize_t', 'length'), ('unsigned int', 'flags'))),
    '*.copysign': ('double', None, 'cdecl', '*.copysign', (('double', 'x'), ('double', 'y'))),
    '*.copysignf': ('float', None, 'cdecl', '*.copysignf', (('float', 'x'), ('float', 'y'))),
    '*.copysignfN': ('_FloatN', None, 'cdecl', '*.copysignfN', (('_FloatN', 'x'), ('_FloatN', 'y'))),
    '*.copysignfNx': ('_FloatNx', None, 'cdecl', '*.copysignfNx', (('_FloatNx', 'x'), ('_FloatNx', 'y'))),
    '*.copysignl': ('long double', None, 'cdecl', '*.copysignl', (('long double', 'x'), ('long double', 'y'))),
    '*.cos': ('double', None, 'cdecl', '*.cos', (('double', 'x'),)),
    '*.cosf': ('float', None, 'cdecl', '*.cosf', (('float', 'x'),)),
    '*.cosfN': ('_FloatN', None, 'cdecl', '*.cosfN', (('_FloatN', 'x'),)),
    '*.cosfNx': ('_FloatNx', None, 'cdecl', '*.cosfNx', (('_FloatNx', 'x'),)),
    '*.cosh': ('double', None, 'cdecl', '*.cosh', (('double', 'x'),)),
    '*.coshf': ('float', None, 'cdecl', '*.coshf', (('float', 'x'),)),
    '*.coshfN': ('_FloatN', None, 'cdecl', '*.coshfN', (('_FloatN', 'x'),)),
    '*.coshfNx': ('_FloatNx', None, 'cdecl', '*.coshfNx', (('_FloatNx', 'x'),)),
    '*.coshl': ('long double', None, 'cdecl', '*.coshl', (('long double', 'x'),)),
    '*.cosl': ('long double', None, 'cdecl', '*.cosl', (('long double', 'x'),)),
    '*.cpow': ('complex double', None, 'cdecl', '*.cpow', (('complex double', 'base'), ('complex double', 'power'))),
    '*.cpowf': ('complex float', None, 'cdecl', '*.cpowf', (('complex float', 'base'), ('complex float', 'power'))),
    '*.cpowfN': ('complex _FloatN', None, 'cdecl', '*.cpowfN', (('complex _FloatN', 'base'), ('complex _FloatN', 'power'))),
    '*.cpowfNx': ('complex _FloatNx', None, 'cdecl', '*.cpowfNx', (('complex _FloatNx', 'base'), ('complex _FloatNx', 'power'))),
    '*.cpowl': ('complex long double', None, 'cdecl', '*.cpowl', (('complex long double', 'base'), ('complex long double', 'power'))),
    '*.cproj': ('complex double', None, 'cdecl', '*.cproj', (('complex double', 'z'),)),
    '*.cprojf': ('complex float', None, 'cdecl', '*.cprojf', (('complex float', 'z'),)),
    '*.cprojfN': ('complex _FloatN', None, 'cdecl', '*.cprojfN', (('complex _FloatN', 'z'),)),
    '*.cprojfNx': ('complex _FloatNx', None, 'cdecl', '*.cprojfNx', (('complex _FloatNx', 'z'),)),
    '*.cprojl': ('complex long double', None, 'cdecl', '*.cprojl', (('complex long double', 'z'),)),
    '*.creal': ('double', None, 'cdecl', '*.creal', (('complex double', 'z'),)),
    '*.crealf': ('float', None, 'cdecl', '*.crealf', (('complex float', 'z'),)),
    '*.crealfN': ('_FloatN', None, 'cdecl', '*.crealfN', (('complex _FloatN', 'z'),)),
    '*.crealfNx': ('_FloatNx', None, 'cdecl', '*.crealfNx', (('complex _FloatNx', 'z'),)),
    '*.creall': ('long double', None, 'cdecl', '*.creall', (('complex long double', 'z'),)),
    '*.crypt': ('char *', None, 'cdecl', '*.crypt', (('const char *', 'phrase'), ('const char *', 'salt'))),
    '*.crypt_r': ('char *', None, 'cdecl', '*.crypt_r', (('const char *', 'phrase'), ('const char *', 'salt'), ('struct crypt_data *', 'data'))),
    '*.csin': ('complex double', None, 'cdecl', '*.csin', (('complex double', 'z'),)),
    '*.csinf': ('complex float', None, 'cdecl', '*.csinf', (('complex float', 'z'),)),
    '*.csinfN': ('complex _FloatN', None, 'cdecl', '*.csinfN', (('complex _FloatN', 'z'),)),
    '*.csinfNx': ('complex _FloatNx', None, 'cdecl', '*.csinfNx', (('complex _FloatNx', 'z'),)),
    '*.csinh': ('complex double', None, 'cdecl', '*.csinh', (('complex double', 'z'),)),
    '*.csinhf': ('complex float', None, 'cdecl', '*.csinhf', (('complex float', 'z'),)),
    '*.csinhfN': ('complex _FloatN', None, 'cdecl', '*.csinhfN', (('complex _FloatN', 'z'),)),
    '*.csinhfNx': ('complex _FloatNx', None, 'cdecl', '*.csinhfNx', (('complex _FloatNx', 'z'),)),
    '*.csinhl': ('complex long double', None, 'cdecl', '*.csinhl', (('complex long double', 'z'),)),
    '*.csinl': ('complex long double', None, 'cdecl', '*.csinl', (('complex long double', 'z'),)),
    '*.csqrt': ('complex double', None, 'cdecl', '*.csqrt', (('complex double', 'z'),)),
    '*.csqrtf': ('complex float', None, 'cdecl', '*.csqrtf', (('complex float', 'z'),)),
    '*.csqrtfN': ('complex _FloatN', None, 'cdecl', '*.csqrtfN', (('_FloatN', 'z'),)),
    '*.csqrtfNx': ('complex _FloatNx', None, 'cdecl', '*.csqrtfNx', (('complex _FloatNx', 'z'),)),
    '*.csqrtl': ('complex long double', None, 'cdecl', '*.csqrtl', (('complex long double', 'z'),)),
    '*.ctan': ('complex double', None, 'cdecl', '*.ctan', (('complex double', 'z'),)),
    '*.ctanf': ('complex float', None, 'cdecl', '*.ctanf', (('complex float', 'z'),)),
    '*.ctanfN': ('complex _FloatN', None, 'cdecl', '*.ctanfN', (('complex _FloatN', 'z'),)),
    '*.ctanfNx': ('complex _FloatNx', None, 'cdecl', '*.ctanfNx', (('complex _FloatNx', 'z'),)),
    '*.ctanh': ('complex double', None, 'cdecl', '*.ctanh', (('complex double', 'z'),)),
    '*.ctanhf': ('complex float', None, 'cdecl', '*.ctanhf', (('complex float', 'z'),)),
    '*.ctanhfN': ('complex _FloatN', None, 'cdecl', '*.ctanhfN', (('complex _FloatN', 'z'),)),
    '*.ctanhfNx': ('complex _FloatNx', None, 'cdecl', '*.ctanhfNx', (('complex _FloatNx', 'z'),)),
    '*.ctanhl': ('complex long double', None, 'cdecl', '*.ctanhl', (('complex long double', 'z'),)),
    '*.ctanl': ('complex long double', None, 'cdecl', '*.ctanl', (('complex long double', 'z'),)),
    '*.ctermid': ('char *', None, 'cdecl', '*.ctermid', (('char *', 'string'),)),
    '*.ctime': ('char *', None, 'cdecl', '*.ctime', (('const time_t *', 'time'),)),
    '*.ctime_r': ('char *', None, 'cdecl', '*.ctime_r', (('const time_t *', 'time'), ('char *', 'buffer'))),
    '*.cuserid': ('char *', None, 'cdecl', '*.cuserid', (('char *', 'string'),)),
    '*.daddl': ('double', None, 'cdecl', '*.daddl', (('long double', 'x'), ('long double', 'y'))),
    '*.dcgettext': ('char *', None, 'cdecl', '*.dcgettext', (('const char *', 'domainname'), ('const char *', 'msgid'), ('int', 'category'))),
    '*.dcngettext': ('char *', None, 'cdecl', '*.dcngettext', (('const char *', 'domain'), ('const char *', 'msgid1'), ('const char *', 'msgid2'), ('unsigned long int', 'n'), ('int', 'category'))),
    '*.ddivl': ('double', None, 'cdecl', '*.ddivl', (('long double', 'x'), ('long double', 'y'))),
    '*.dgettext': ('char *', None, 'cdecl', '*.dgettext', (('const char *', 'domainname'), ('const char *', 'msgid'))),
    '*.difftime': ('double', None, 'cdecl', '*.difftime', (('time_t', 'end'), ('time_t', 'begin'))),
    '*.dirfd': ('int', None, 'cdecl', '*.dirfd', (('DIR *', 'dirstream'),)),
    '*.dirname': ('char *', None, 'cdecl', '*.dirname', (('char *', 'path'),)),
    '*.div': ('div_t', None, 'stdcall', '*.div', (('int', 'numerator'), ('int', 'denominator'))),
    '*.dmull': ('double', None, 'cdecl', '*.dmull', (('long double', 'x'), ('long double', 'y'))),
    '*.dngettext': ('char *', None, 'cdecl', '*.dngettext', (('const char *', 'domain'), ('const char *', 'msgid1'), ('const char *', 'msgid2'), ('unsigned long int', 'n'))),
    '*.drand48': ('double', None, 'cdecl', '*.drand48', ()),
    '*.drand48_r': ('int', None, 'cdecl', '*.drand48_r', (('struct drand48_data *', 'buffer'), ('double *', 'result'))),
    '*.drem': ('double', None, 'cdecl', '*.drem', (('double', 'numerator'), ('double', 'denominator'))),
    '*.dremf': ('float', None, 'cdecl', '*.dremf', (('float', 'numerator'), ('float', 'denominator'))),
    '*.dreml': ('long double', None, 'cdecl', '*.dreml', (('long double', 'numerator'), ('long double', 'denominator'))),
    '*.dsubl': ('double', None, 'cdecl', '*.dsubl', (('long double', 'x'), ('long double', 'y'))),
    '*.dup': ('int', None, 'cdecl', '*.dup', (('int', 'old'),)),
    '*.dup2': ('int', None, 'cdecl', '*.dup2', (('int', 'old'), ('int', 'new'))),
    '*.ecvt': ('char *', None, 'cdecl', '*.ecvt', (('double', 'value'), ('int', 'ndigit'), ('int *', 'decpt'), ('int *', 'neg'))),
    '*.ecvt_r': ('int', None, 'cdecl', '*.ecvt_r', (('double', 'value'), ('int', 'ndigit'), ('int *', 'decpt'), ('int *', 'neg'), ('char *', 'buf'), ('size_t', 'len'))),
    '*.endfsent': ('void', None, 'cdecl', '*.endfsent', ()),
    '*.endgrent': ('void', None, 'cdecl', '*.endgrent', ()),
    '*.endhostent': ('void', None, 'cdecl', '*.endhostent', ()),
    '*.endmntent': ('int', None, 'cdecl', '*.endmntent', (('FILE *', 'stream'),)),
    '*.endnetent': ('void', None, 'cdecl', '*.endnetent', ()),
    '*.endnetgrent': ('void', None, 'cdecl', '*.endnetgrent', ()),
    '*.endprotoent': ('void', None, 'cdecl', '*.endprotoent', ()),
    '*.endpwent': ('void', None, 'cdecl', '*.endpwent', ()),
    '*.endservent': ('void', None, 'cdecl', '*.endservent', ()),
    '*.endutent': ('void', None, 'cdecl', '*.endutent', ()),
    '*.endutxent': ('void', None, 'cdecl', '*.endutxent', ()),
    '*.envz_add': ('error_t', None, 'cdecl', '*.envz_add', (('char * *', 'envz'), ('size_t *', 'envz_len'), ('const char *', 'name'), ('const char *', 'value'))),
    '*.envz_entry': ('char *', None, 'cdecl', '*.envz_entry', (('const char *', 'envz'), ('size_t', 'envz_len'), ('const char *', 'name'))),
    '*.envz_get': ('char *', None, 'cdecl', '*.envz_get', (('const char *', 'envz'), ('size_t', 'envz_len'), ('const char *', 'name'))),
    '*.envz_merge': ('error_t', None, 'cdecl', '*.envz_merge', (('char * *', 'envz'), ('size_t *', 'envz_len'), ('const char *', 'envz2'), ('size_t', 'envz2_len'), ('int', 'override'))),
    '*.envz_remove': ('void', None, 'cdecl', '*.envz_remove', (('char * *', 'envz'), ('size_t *', 'envz_len'), ('const char *', 'name'))),
    '*.envz_strip': ('void', None, 'cdecl', '*.envz_strip', (('char * *', 'envz'), ('size_t *', 'envz_len'))),
    '*.erand48': ('double', None, 'cdecl', '*.erand48', (('unsigned short int', 'xsubi[3]'),)),
    '*.erand48_r': ('int', None, 'cdecl', '*.erand48_r', (('unsigned short int', 'xsubi[3]'), ('struct drand48_data *', 'buffer'), ('double *', 'result'))),
    '*.erf': ('double', None, 'cdecl', '*.erf', (('double', 'x'),)),
    '*.erfc': ('double', None, 'cdecl', '*.erfc', (('double', 'x'),)),
    '*.erfcf': ('float', None, 'cdecl', '*.erfcf', (('float', 'x'),)),
    '*.erfcfN': ('_FloatN', None, 'cdecl', '*.erfcfN', (('_FloatN', 'x'),)),
    '*.erfcfNx': ('_FloatNx', None, 'cdecl', '*.erfcfNx', (('_FloatNx', 'x'),)),
    '*.erfcl': ('long double', None, 'cdecl', '*.erfcl', (('long double', 'x'),)),
    '*.erff': ('float', None, 'cdecl', '*.erff', (('float', 'x'),)),
    '*.erffN': ('_FloatN', None, 'cdecl', '*.erffN', (('_FloatN', 'x'),)),
    '*.erffNx': ('_FloatNx', None, 'cdecl', '*.erffNx', (('_FloatNx', 'x'),)),
    '*.erfl': ('long double', None, 'cdecl', '*.erfl', (('long double', 'x'),)),
    '*.err': ('void', None, 'cdecl', '*.err', (('int', 'status'), ('const char *', 'format'), ('variadic', ''))),
    '*.error': ('void', None, 'cdecl', '*.error', (('int', 'status'), ('int', 'errnum'), ('const char *', 'format'), ('variadic', ''))),
    '*.error_at_line': ('void', None, 'cdecl', '*.error_at_line', (('int', 'status'), ('int', 'errnum'), ('const char *', 'fname'), ('unsigned int', 'lineno'), ('const char *', 'format'), ('variadic', ''))),
    '*.errx': ('void', None, 'cdecl', '*.errx', (('int', 'status'), ('const char *', 'format'), ('variadic', ''))),
    '*.execl': ('int', None, 'cdecl', '*.execl', (('const char *', 'filename'), ('const char *', 'arg0'), ('variadic', ''))),
    '*.execle': ('int', None, 'cdecl', '*.execle', (('const char *', 'filename'), ('const char *', 'arg0'), ('variadic', ''), ('char * const', 'env[]'))),
    '*.execlp': ('int', None, 'cdecl', '*.execlp', (('const char *', 'filename'), ('const char *', 'arg0'), ('variadic', ''))),
    '*.execv': ('int', None, 'cdecl', '*.execv', (('const char *', 'filename'), ('char * const', 'argv[]'))),
    '*.execve': ('int', None, 'cdecl', '*.execve', (('const char *', 'filename'), ('char * const', 'argv[]'), ('char * const', 'env[]'))),
    '*.execvp': ('int', None, 'cdecl', '*.execvp', (('const char *', 'filename'), ('char * const', 'argv[]'))),
    '*.exit': ('void', None, 'cdecl', '*.exit', (('int', 'status'),)),
    '*.exp': ('double', None, 'cdecl', '*.exp', (('double', 'x'),)),
    '*.exp10': ('double', None, 'cdecl', '*.exp10', (('double', 'x'),)),
    '*.exp10f': ('float', None, 'cdecl', '*.exp10f', (('float', 'x'),)),
    '*.exp10fN': ('_FloatN', None, 'cdecl', '*.exp10fN', (('_FloatN', 'x'),)),
    '*.exp10fNx': ('_FloatNx', None, 'cdecl', '*.exp10fNx', (('_FloatNx', 'x'),)),
    '*.exp10l': ('long double', None, 'cdecl', '*.exp10l', (('long double', 'x'),)),
    '*.exp2': ('double', None, 'cdecl', '*.exp2', (('double', 'x'),)),
    '*.exp2f': ('float', None, 'cdecl', '*.exp2f', (('float', 'x'),)),
    '*.exp2fN': ('_FloatN', None, 'cdecl', '*.exp2fN', (('_FloatN', 'x'),)),
    '*.exp2fNx': ('_FloatNx', None, 'cdecl', '*.exp2fNx', (('_FloatNx', 'x'),)),
    '*.exp2l': ('long double', None, 'cdecl', '*.exp2l', (('long double', 'x'),)),
    '*.expf': ('float', None, 'cdecl', '*.expf', (('float', 'x'),)),
    '*.expfN': ('_FloatN', None, 'cdecl', '*.expfN', (('_FloatN', 'x'),)),
    '*.expfNx': ('_FloatNx', None, 'cdecl', '*.expfNx', (('_FloatNx', 'x'),)),
    '*.expl': ('long double', None, 'cdecl', '*.expl', (('long double', 'x'),)),
    '*.explicit_bzero': ('void', None, 'cdecl', '*.explicit_bzero', (('void *', 'block'), ('size_t', 'len'))),
    '*.expm1': ('double', None, 'cdecl', '*.expm1', (('double', 'x'),)),
    '*.expm1f': ('float', None, 'cdecl', '*.expm1f', (('float', 'x'),)),
    '*.expm1fN': ('_FloatN', None, 'cdecl', '*.expm1fN', (('_FloatN', 'x'),)),
    '*.expm1fNx': ('_FloatNx', None, 'cdecl', '*.expm1fNx', (('_FloatNx', 'x'),)),
    '*.expm1l': ('long double', None, 'cdecl', '*.expm1l', (('long double', 'x'),)),
    '*.fMaddfN': ('_FloatM', None, 'cdecl', '*.fMaddfN', (('_FloatN', 'x'), ('_FloatN', 'y'))),
    '*.fMaddfNx': ('_FloatM', None, 'cdecl', '*.fMaddfNx', (('_FloatNx', 'x'), ('_FloatNx', 'y'))),
    '*.fMdivfN': ('_FloatM', None, 'cdecl', '*.fMdivfN', (('_FloatN', 'x'), ('_FloatN', 'y'))),
    '*.fMdivfNx': ('_FloatM', None, 'cdecl', '*.fMdivfNx', (('_FloatNx', 'x'), ('_FloatNx', 'y'))),
    '*.fMmulfN': ('_FloatM', None, 'cdecl', '*.fMmulfN', (('_FloatN', 'x'), ('_FloatN', 'y'))),
    '*.fMmulfNx': ('_FloatM', None, 'cdecl', '*.fMmulfNx', (('_FloatNx', 'x'), ('_FloatNx', 'y'))),
    '*.fMsubfN': ('_FloatM', None, 'cdecl', '*.fMsubfN', (('_FloatN', 'x'), ('_FloatN', 'y'))),
    '*.fMsubfNx': ('_FloatM', None, 'cdecl', '*.fMsubfNx', (('_FloatNx', 'x'), ('_FloatNx', 'y'))),
    '*.fMxaddfN': ('_FloatMx', None, 'cdecl', '*.fMxaddfN', (('_FloatN', 'x'), ('_FloatN', 'y'))),
    '*.fMxaddfNx': ('_FloatMx', None, 'cdecl', '*.fMxaddfNx', (('_FloatNx', 'x'), ('_FloatNx', 'y'))),
    '*.fMxdivfN': ('_FloatMx', None, 'cdecl', '*.fMxdivfN', (('_FloatN', 'x'), ('_FloatN', 'y'))),
    '*.fMxdivfNx': ('_FloatMx', None, 'cdecl', '*.fMxdivfNx', (('_FloatNx', 'x'), ('_FloatNx', 'y'))),
    '*.fMxmulfN': ('_FloatMx', None, 'cdecl', '*.fMxmulfN', (('_FloatN', 'x'), ('_FloatN', 'y'))),
    '*.fMxmulfNx': ('_FloatMx', None, 'cdecl', '*.fMxmulfNx', (('_FloatNx', 'x'), ('_FloatNx', 'y'))),
    '*.fMxsubfN': ('_FloatMx', None, 'cdecl', '*.fMxsubfN', (('_FloatN', 'x'), ('_FloatN', 'y'))),
    '*.fMxsubfNx': ('_FloatMx', None, 'cdecl', '*.fMxsubfNx', (('_FloatNx', 'x'), ('_FloatNx', 'y'))),
    '*.fabs': ('double', None, 'cdecl', '*.fabs', (('double', 'number'),)),
    '*.fabsf': ('float', None, 'cdecl', '*.fabsf', (('float', 'number'),)),
    '*.fabsfN': ('_FloatN', None, 'cdecl', '*.fabsfN', (('_FloatN', 'number'),)),
    '*.fabsfNx': ('_FloatNx', None, 'cdecl', '*.fabsfNx', (('_FloatNx', 'number'),)),
    '*.fabsl': ('long double', None, 'cdecl', '*.fabsl', (('long double', 'number'),)),
    '*.fadd': ('float', None, 'cdecl', '*.fadd', (('double', 'x'), ('double', 'y'))),
    '*.faddl': ('float', None, 'cdecl', '*.faddl', (('long double', 'x'), ('long double', 'y'))),
    '*.fchdir': ('int', None, 'cdecl', '*.fchdir', (('int', 'filedes'),)),
    '*.fchmod': ('int', None, 'cdecl', '*.fchmod', (('int', 'filedes'), ('mode_t', 'mode'))),
    '*.fchown': ('int', None, 'cdecl', '*.fchown', (('int', 'filedes'), ('uid_t', 'owner'), ('gid_t', 'group'))),
    '*.fclose': ('int', None, 'cdecl', '*.fclose', (('FILE *', 'stream'),)),
    '*.fcloseall': ('int', None, 'cdecl', '*.fcloseall', ()),
    '*.fcntl': ('int', None, 'cdecl', '*.fcntl', (('int', 'filedes'), ('int', 'command'), ('variadic', ''))),
    '*.fcvt': ('char *', None, 'cdecl', '*.fcvt', (('double', 'value'), ('int', 'ndigit'), ('int *', 'decpt'), ('int *', 'neg'))),
    '*.fcvt_r': ('int', None, 'cdecl', '*.fcvt_r', (('double', 'value'), ('int', 'ndigit'), ('int *', 'decpt'), ('int *', 'neg'), ('char *', 'buf'), ('size_t', 'len'))),
    '*.fdatasync': ('int', None, 'cdecl', '*.fdatasync', (('int', 'fildes'),)),
    '*.fdim': ('double', None, 'cdecl', '*.fdim', (('double', 'x'), ('double', 'y'))),
    '*.fdimf': ('float', None, 'cdecl', '*.fdimf', (('float', 'x'), ('float', 'y'))),
    '*.fdimfN': ('_FloatN', None, 'cdecl', '*.fdimfN', (('_FloatN', 'x'), ('_FloatN', 'y'))),
    '*.fdimfNx': ('_FloatNx', None, 'cdecl', '*.fdimfNx', (('_FloatNx', 'x'), ('_FloatNx', 'y'))),
    '*.fdiml': ('long double', None, 'cdecl', '*.fdiml', (('long double', 'x'), ('long double', 'y'))),
    '*.fdiv': ('float', None, 'cdecl', '*.fdiv', (('double', 'x'), ('double', 'y'))),
    '*.fdivl': ('float', None, 'cdecl', '*.fdivl', (('long double', 'x'), ('long double', 'y'))),
    '*.fdopen': ('FILE *', None, 'cdecl', '*.fdopen', (('int', 'filedes'), ('const char *', 'opentype'))),
    '*.fdopendir': ('DIR *', None, 'cdecl', '*.fdopendir', (('int', 'fd'),)),
    '*.feclearexcept': ('int', None, 'cdecl', '*.feclearexcept', (('int', 'excepts'),)),
    '*.fedisableexcept': ('int', None, 'cdecl', '*.fedisableexcept', (('int', 'excepts'),)),
    '*.feenableexcept': ('int', None, 'cdecl', '*.feenableexcept', (('int', 'excepts'),)),
    '*.fegetenv': ('int', None, 'cdecl', '*.fegetenv', (('fenv_t *', 'envp'),)),
    '*.fegetexcept': ('int', None, 'cdecl', '*.fegetexcept', ()),
    '*.fegetexceptflag': ('int', None, 'cdecl', '*.fegetexceptflag', (('fexcept_t *', 'flagp'), ('int', 'excepts'))),
    '*.fegetmode': ('int', None, 'cdecl', '*.fegetmode', (('femode_t *', 'modep'),)),
    '*.fegetround': ('int', None, 'cdecl', '*.fegetround', ()),
    '*.feholdexcept': ('int', None, 'cdecl', '*.feholdexcept', (('fenv_t *', 'envp'),)),
    '*.feof': ('int', None, 'cdecl', '*.feof', (('FILE *', 'stream'),)),
    '*.feof_unlocked': ('int', None, 'cdecl', '*.feof_unlocked', (('FILE *', 'stream'),)),
    '*.feraiseexcept': ('int', None, 'cdecl', '*.feraiseexcept', (('int', 'excepts'),)),
    '*.ferror': ('int', None, 'cdecl', '*.ferror', (('FILE *', 'stream'),)),
    '*.ferror_unlocked': ('int', None, 'cdecl', '*.ferror_unlocked', (('FILE *', 'stream'),)),
    '*.fesetenv': ('int', None, 'cdecl', '*.fesetenv', (('const fenv_t *', 'envp'),)),
    '*.fesetexcept': ('int', None, 'cdecl', '*.fesetexcept', (('int', 'excepts'),)),
    '*.fesetexceptflag': ('int', None, 'cdecl', '*.fesetexceptflag', (('const fexcept_t *', 'flagp'), ('int', 'excepts'))),
    '*.fesetmode': ('int', None, 'cdecl', '*.fesetmode', (('const femode_t *', 'modep'),)),
    '*.fesetround': ('int', None, 'cdecl', '*.fesetround', (('int', 'round'),)),
    '*.fetestexcept': ('int', None, 'cdecl', '*.fetestexcept', (('int', 'excepts'),)),
    '*.fetestexceptflag': ('int', None, 'cdecl', '*.fetestexceptflag', (('const fexcept_t *', 'flagp'), ('int', 'excepts'))),
    '*.feupdateenv': ('int', None, 'cdecl', '*.feupdateenv', (('const fenv_t *', 'envp'),)),
    '*.fexecve': ('int', None, 'cdecl', '*.fexecve', (('int', 'fd'), ('char * const', 'argv[]'), ('char * const', 'env[]'))),
    '*.fflush': ('int', None, 'cdecl', '*.fflush', (('FILE *', 'stream'),)),
    '*.fflush_unlocked': ('int', None, 'cdecl', '*.fflush_unlocked', (('FILE *', 'stream'),)),
    '*.fgetc': ('int', None, 'cdecl', '*.fgetc', (('FILE *', 'stream'),)),
    '*.fgetc_unlocked': ('int', None, 'cdecl', '*.fgetc_unlocked', (('FILE *', 'stream'),)),
    '*.fgetgrent': ('struct group *', None, 'cdecl', '*.fgetgrent', (('FILE *', 'stream'),)),
    '*.fgetgrent_r': ('int', None, 'cdecl', '*.fgetgrent_r', (('FILE *', 'stream'), ('struct group *', 'result_buf'), ('char *', 'buffer'), ('size_t', 'buflen'), ('struct group * *', 'result'))),
    '*.fgetpos': ('int', None, 'cdecl', '*.fgetpos', (('FILE *', 'stream'), ('fpos_t *', 'position'))),
    '*.fgetpos64': ('int', None, 'cdecl', '*.fgetpos64', (('FILE *', 'stream'), ('fpos64_t *', 'position'))),
    '*.fgetpwent': ('struct passwd *', None, 'cdecl', '*.fgetpwent', (('FILE *', 'stream'),)),
    '*.fgetpwent_r': ('int', None, 'cdecl', '*.fgetpwent_r', (('FILE *', 'stream'), ('struct passwd *', 'result_buf'), ('char *', 'buffer'), ('size_t', 'buflen'), ('struct passwd * *', 'result'))),
    '*.fgets': ('char *', None, 'cdecl', '*.fgets', (('char *', 's'), ('int', 'count'), ('FILE *', 'stream'))),
    '*.fgets_unlocked': ('char *', None, 'cdecl', '*.fgets_unlocked', (('char *', 's'), ('int', 'count'), ('FILE *', 'stream'))),
    '*.fgetwc': ('wint_t', None, 'cdecl', '*.fgetwc', (('FILE *', 'stream'),)),
    '*.fgetwc_unlocked': ('wint_t', None, 'cdecl', '*.fgetwc_unlocked', (('FILE *', 'stream'),)),
    '*.fgetws': ('wchar_t *', None, 'cdecl', '*.fgetws', (('wchar_t *', 'ws'), ('int', 'count'), ('FILE *', 'stream'))),
    '*.fgetws_unlocked': ('wchar_t *', None, 'cdecl', '*.fgetws_unlocked', (('wchar_t *', 'ws'), ('int', 'count'), ('FILE *', 'stream'))),
    '*.fileno': ('int', None, 'cdecl', '*.fileno', (('FILE *', 'stream'),)),
    '*.fileno_unlocked': ('int', None, 'cdecl', '*.fileno_unlocked', (('FILE *', 'stream'),)),
    '*.finite': ('int', None, 'cdecl', '*.finite', (('double', 'x'),)),
    '*.finitef': ('int', None, 'cdecl', '*.finitef', (('float', 'x'),)),
    '*.finitel': ('int', None, 'cdecl', '*.finitel', (('long double', 'x'),)),
    '*.flockfile': ('void', None, 'cdecl', '*.flockfile', (('FILE *', 'stream'),)),
    '*.floor': ('double', None, 'cdecl', '*.floor', (('double', 'x'),)),
    '*.floorf': ('float', None, 'cdecl', '*.floorf', (('float', 'x'),)),
    '*.floorfN': ('_FloatN', None, 'cdecl', '*.floorfN', (('_FloatN', 'x'),)),
    '*.floorfNx': ('_FloatNx', None, 'cdecl', '*.floorfNx', (('_FloatNx', 'x'),)),
    '*.floorl': ('long double', None, 'cdecl', '*.floorl', (('long double', 'x'),)),
    '*.fma': ('double', None, 'cdecl', '*.fma', (('double', 'x'), ('double', 'y'), ('double', 'z'))),
    '*.fmaf': ('float', None, 'cdecl', '*.fmaf', (('float', 'x'), ('float', 'y'), ('float', 'z'))),
    '*.fmafN': ('_FloatN', None, 'cdecl', '*.fmafN', (('_FloatN', 'x'), ('_FloatN', 'y'), ('_FloatN', 'z'))),
    '*.fmafNx': ('_FloatNx', None, 'cdecl', '*.fmafNx', (('_FloatNx', 'x'), ('_FloatNx', 'y'), ('_FloatNx', 'z'))),
    '*.fmal': ('long double', None, 'cdecl', '*.fmal', (('long double', 'x'), ('long double', 'y'), ('long double', 'z'))),
    '*.fmax': ('double', None, 'cdecl', '*.fmax', (('double', 'x'), ('double', 'y'))),
    '*.fmaxf': ('float', None, 'cdecl', '*.fmaxf', (('float', 'x'), ('float', 'y'))),
    '*.fmaxfN': ('_FloatN', None, 'cdecl', '*.fmaxfN', (('_FloatN', 'x'), ('_FloatN', 'y'))),
    '*.fmaxfNx': ('_FloatNx', None, 'cdecl', '*.fmaxfNx', (('_FloatNx', 'x'), ('_FloatNx', 'y'))),
    '*.fmaxl': ('long double', None, 'cdecl', '*.fmaxl', (('long double', 'x'), ('long double', 'y'))),
    '*.fmaxmag': ('double', None, 'cdecl', '*.fmaxmag', (('double', 'x'), ('double', 'y'))),
    '*.fmaxmagf': ('float', None, 'cdecl', '*.fmaxmagf', (('float', 'x'), ('float', 'y'))),
    '*.fmaxmagfN': ('_FloatN', None, 'cdecl', '*.fmaxmagfN', (('_FloatN', 'x'), ('_FloatN', 'y'))),
    '*.fmaxmagfNx': ('_FloatNx', None, 'cdecl', '*.fmaxmagfNx', (('_FloatNx', 'x'), ('_FloatNx', 'y'))),
    '*.fmaxmagl': ('long double', None, 'cdecl', '*.fmaxmagl', (('long double', 'x'), ('long double', 'y'))),
    '*.fmemopen': ('FILE *', None, 'cdecl', '*.fmemopen', (('void *', 'buf'), ('size_t', 'size'), ('const char *', 'opentype'))),
    '*.fmin': ('double', None, 'cdecl', '*.fmin', (('double', 'x'), ('double', 'y'))),
    '*.fminf': ('float', None, 'cdecl', '*.fminf', (('float', 'x'), ('float', 'y'))),
    '*.fminfN': ('_FloatN', None, 'cdecl', '*.fminfN', (('_FloatN', 'x'), ('_FloatN', 'y'))),
    '*.fminfNx': ('_FloatNx', None, 'cdecl', '*.fminfNx', (('_FloatNx', 'x'), ('_FloatNx', 'y'))),
    '*.fminl': ('long double', None, 'cdecl', '*.fminl', (('long double', 'x'), ('long double', 'y'))),
    '*.fminmag': ('double', None, 'cdecl', '*.fminmag', (('double', 'x'), ('double', 'y'))),
    '*.fminmagf': ('float', None, 'cdecl', '*.fminmagf', (('float', 'x'), ('float', 'y'))),
    '*.fminmagfN': ('_FloatN', None, 'cdecl', '*.fminmagfN', (('_FloatN', 'x'), ('_FloatN', 'y'))),
    '*.fminmagfNx': ('_FloatNx', None, 'cdecl', '*.fminmagfNx', (('_FloatNx', 'x'), ('_FloatNx', 'y'))),
    '*.fminmagl': ('long double', None, 'cdecl', '*.fminmagl', (('long double', 'x'), ('long double', 'y'))),
    '*.fmod': ('double', None, 'cdecl', '*.fmod', (('double', 'numerator'), ('double', 'denominator'))),
    '*.fmodf': ('float', None, 'cdecl', '*.fmodf', (('float', 'numerator'), ('float', 'denominator'))),
    '*.fmodfN': ('_FloatN', None, 'cdecl', '*.fmodfN', (('_FloatN', 'numerator'), ('_FloatN', 'denominator'))),
    '*.fmodfNx': ('_FloatNx', None, 'cdecl', '*.fmodfNx', (('_FloatNx', 'numerator'), ('_FloatNx', 'denominator'))),
    '*.fmodl': ('long double', None, 'cdecl', '*.fmodl', (('long double', 'numerator'), ('long double', 'denominator'))),
    '*.fmtmsg': ('int', None, 'cdecl', '*.fmtmsg', (('long int', 'classification'), ('const char *', 'label'), ('int', 'severity'), ('const char *', 'text'), ('const char *', 'action'), ('const char *', 'tag'))),
    '*.fmul': ('float', None, 'cdecl', '*.fmul', (('double', 'x'), ('double', 'y'))),
    '*.fmull': ('float', None, 'cdecl', '*.fmull', (('long double', 'x'), ('long double', 'y'))),
    '*.fnmatch': ('int', None, 'cdecl', '*.fnmatch', (('const char *', 'pattern'), ('const char *', 'string'), ('int', 'flags'))),
    '*.fopen': ('FILE *', None, 'cdecl', '*.fopen', (('const char *', 'filename'), ('const char *', 'opentype'))),
    '*.fopen64': ('FILE *', None, 'cdecl', '*.fopen64', (('const char *', 'filename'), ('const char *', 'opentype'))),
    '*.fopencookie': ('FILE *', None, 'cdecl', '*.fopencookie', (('void *', 'cookie'), ('const char *', 'opentype'), ('cookie_io_functions_t', 'io-functions'))),
    '*.fork': ('pid_t', None, 'cdecl', '*.fork', ()),
    '*.forkpty': ('int', None, 'cdecl', '*.forkpty', (('int *', 'amaster'), ('char *', 'name'), ('const struct termios *', 'termp'), ('const struct winsize *', 'winp'))),
    '*.fpathconf': ('long int', None, 'cdecl', '*.fpathconf', (('int', 'filedes'), ('int', 'parameter'))),
    '*.fprintf': ('int', None, 'cdecl', '*.fprintf', (('FILE *', 'stream'), ('const char *', 'template'), ('variadic', ''))),
    '*.fputc': ('int', None, 'cdecl', '*.fputc', (('int', 'c'), ('FILE *', 'stream'))),
    '*.fputc_unlocked': ('int', None, 'cdecl', '*.fputc_unlocked', (('int', 'c'), ('FILE *', 'stream'))),
    '*.fputs': ('int', None, 'cdecl', '*.fputs', (('const char *', 's'), ('FILE *', 'stream'))),
    '*.fputs_unlocked': ('int', None, 'cdecl', '*.fputs_unlocked', (('const char *', 's'), ('FILE *', 'stream'))),
    '*.fputwc': ('wint_t', None, 'cdecl', '*.fputwc', (('wchar_t', 'wc'), ('FILE *', 'stream'))),
    '*.fputwc_unlocked': ('wint_t', None, 'cdecl', '*.fputwc_unlocked', (('wchar_t', 'wc'), ('FILE *', 'stream'))),
    '*.fputws': ('int', None, 'cdecl', '*.fputws', (('const wchar_t *', 'ws'), ('FILE *', 'stream'))),
    '*.fputws_unlocked': ('int', None, 'cdecl', '*.fputws_unlocked', (('const wchar_t *', 'ws'), ('FILE *', 'stream'))),
    '*.fread': ('size_t', None, 'cdecl', '*.fread', (('void *', 'data'), ('size_t', 'size'), ('size_t', 'count'), ('FILE *', 'stream'))),
    '*.fread_unlocked': ('size_t', None, 'cdecl', '*.fread_unlocked', (('void *', 'data'), ('size_t', 'size'), ('size_t', 'count'), ('FILE *', 'stream'))),
    '*.free': ('void', None, 'cdecl', '*.free', (('void *', 'ptr'),)),
    '*.freopen': ('FILE *', None, 'cdecl', '*.freopen', (('const char *', 'filename'), ('const char *', 'opentype'), ('FILE *', 'stream'))),
    '*.freopen64': ('FILE *', None, 'cdecl', '*.freopen64', (('const char *', 'filename'), ('const char *', 'opentype'), ('FILE *', 'stream'))),
    '*.frexp': ('double', None, 'cdecl', '*.frexp', (('double', 'value'), ('int *', 'exponent'))),
    '*.frexpf': ('float', None, 'cdecl', '*.frexpf', (('float', 'value'), ('int *', 'exponent'))),
    '*.frexpfN': ('_FloatN', None, 'cdecl', '*.frexpfN', (('_FloatN', 'value'), ('int *', 'exponent'))),
    '*.frexpfNx': ('_FloatNx', None, 'cdecl', '*.frexpfNx', (('_FloatNx', 'value'), ('int *', 'exponent'))),
    '*.frexpl': ('long double', None, 'cdecl', '*.frexpl', (('long double', 'value'), ('int *', 'exponent'))),
    '*.fromfp': ('intmax_t', None, 'cdecl', '*.fromfp', (('double', 'x'), ('int', 'round'), ('unsigned int', 'width'))),
    '*.fromfpf': ('intmax_t', None, 'cdecl', '*.fromfpf', (('float', 'x'), ('int', 'round'), ('unsigned int', 'width'))),
    '*.fromfpfN': ('intmax_t', None, 'cdecl', '*.fromfpfN', (('_FloatN', 'x'), ('int', 'round'), ('unsigned int', 'width'))),
    '*.fromfpfNx': ('intmax_t', None, 'cdecl', '*.fromfpfNx', (('_FloatNx', 'x'), ('int', 'round'), ('unsigned int', 'width'))),
    '*.fromfpl': ('intmax_t', None, 'cdecl', '*.fromfpl', (('long double', 'x'), ('int', 'round'), ('unsigned int', 'width'))),
    '*.fromfpx': ('intmax_t', None, 'cdecl', '*.fromfpx', (('double', 'x'), ('int', 'round'), ('unsigned int', 'width'))),
    '*.fromfpxf': ('intmax_t', None, 'cdecl', '*.fromfpxf', (('float', 'x'), ('int', 'round'), ('unsigned int', 'width'))),
    '*.fromfpxfN': ('intmax_t', None, 'cdecl', '*.fromfpxfN', (('_FloatN', 'x'), ('int', 'round'), ('unsigned int', 'width'))),
    '*.fromfpxfNx': ('intmax_t', None, 'cdecl', '*.fromfpxfNx', (('_FloatNx', 'x'), ('int', 'round'), ('unsigned int', 'width'))),
    '*.fromfpxl': ('intmax_t', None, 'cdecl', '*.fromfpxl', (('long double', 'x'), ('int', 'round'), ('unsigned int', 'width'))),
    '*.fscanf': ('int', None, 'cdecl', '*.fscanf', (('FILE *', 'stream'), ('const char *', 'template'), ('variadic', ''))),
    '*.fseek': ('int', None, 'cdecl', '*.fseek', (('FILE *', 'stream'), ('long int', 'offset'), ('int', 'whence'))),
    '*.fseeko': ('int', None, 'cdecl', '*.fseeko', (('FILE *', 'stream'), ('off_t', 'offset'), ('int', 'whence'))),
    '*.fseeko64': ('int', None, 'cdecl', '*.fseeko64', (('FILE *', 'stream'), ('off64_t', 'offset'), ('int', 'whence'))),
    '*.fsetpos': ('int', None, 'cdecl', '*.fsetpos', (('FILE *', 'stream'), ('const fpos_t *', 'position'))),
    '*.fsetpos64': ('int', None, 'cdecl', '*.fsetpos64', (('FILE *', 'stream'), ('const fpos64_t *', 'position'))),
    '*.fstat': ('int', None, 'cdecl', '*.fstat', (('int', 'filedes'), ('struct stat *', 'buf'))),
    '*.fstat64': ('int', None, 'cdecl', '*.fstat64', (('int', 'filedes'), ('struct stat64 *', 'buf'))),
    '*.fsub': ('float', None, 'cdecl', '*.fsub', (('double', 'x'), ('double', 'y'))),
    '*.fsubl': ('float', None, 'cdecl', '*.fsubl', (('long double', 'x'), ('long double', 'y'))),
    '*.fsync': ('int', None, 'cdecl', '*.fsync', (('int', 'fildes'),)),
    '*.ftell': ('long int', None, 'cdecl', '*.ftell', (('FILE *', 'stream'),)),
    '*.ftello': ('off_t', None, 'cdecl', '*.ftello', (('FILE *', 'stream'),)),
    '*.ftello64': ('off64_t', None, 'cdecl', '*.ftello64', (('FILE *', 'stream'),)),
    '*.ftruncate': ('int', None, 'cdecl', '*.ftruncate', (('int', 'fd'), ('off_t', 'length'))),
    '*.ftruncate64': ('int', None, 'cdecl', '*.ftruncate64', (('int', 'id'), ('off64_t', 'length'))),
    '*.ftrylockfile': ('int', None, 'cdecl', '*.ftrylockfile', (('FILE *', 'stream'),)),
    '*.ftw': ('int', None, 'cdecl', '*.ftw', (('const char *', 'filename'), ('__ftw_func_t', 'func'), ('int', 'descriptors'))),
    '*.ftw64': ('int', None, 'cdecl', '*.ftw64', (('const char *', 'filename'), ('__ftw64_func_t', 'func'), ('int', 'descriptors'))),
    '*.funlockfile': ('void', None, 'cdecl', '*.funlockfile', (('FILE *', 'stream'),)),
    '*.futimes': ('int', None, 'cdecl', '*.futimes', (('int', 'fd'), ('const struct timeval', 'tvp[2]'))),
    '*.fwide': ('int', None, 'cdecl', '*.fwide', (('FILE *', 'stream'), ('int', 'mode'))),
    '*.fwprintf': ('int', None, 'cdecl', '*.fwprintf', (('FILE *', 'stream'), ('const wchar_t *', 'template'), ('variadic', ''))),
    '*.fwrite': ('size_t', None, 'cdecl', '*.fwrite', (('const void *', 'data'), ('size_t', 'size'), ('size_t', 'count'), ('FILE *', 'stream'))),
    '*.fwrite_unlocked': ('size_t', None, 'cdecl', '*.fwrite_unlocked', (('const void *', 'data'), ('size_t', 'size'), ('size_t', 'count'), ('FILE *', 'stream'))),
    '*.fwscanf': ('int', None, 'cdecl', '*.fwscanf', (('FILE *', 'stream'), ('const wchar_t *', 'template'), ('variadic', ''))),
    '*.gamma': ('double', None, 'cdecl', '*.gamma', (('double', 'x'),)),
    '*.gammaf': ('float', None, 'cdecl', '*.gammaf', (('float', 'x'),)),
    '*.gammal': ('long double', None, 'cdecl', '*.gammal', (('long double', 'x'),)),
    '*.gcvt': ('char *', None, 'cdecl', '*.gcvt', (('double', 'value'), ('int', 'ndigit'), ('char *', 'buf'))),
    '*.get_avphys_pages': ('long int', None, 'cdecl', '*.get_avphys_pages', ()),
    '*.get_current_dir_name': ('char *', None, 'cdecl', '*.get_current_dir_name', ()),
    '*.get_nprocs': ('int', None, 'cdecl', '*.get_nprocs', ()),
    '*.get_nprocs_conf': ('int', None, 'cdecl', '*.get_nprocs_conf', ()),
    '*.get_phys_pages': ('long int', None, 'cdecl', '*.get_phys_pages', ()),
    '*.getauxval': ('unsigned long int', None, 'cdecl', '*.getauxval', (('unsigned long int', 'type'),)),
    '*.getc': ('int', None, 'cdecl', '*.getc', (('FILE *', 'stream'),)),
    '*.getc_unlocked': ('int', None, 'cdecl', '*.getc_unlocked', (('FILE *', 'stream'),)),
    '*.getchar': ('int', None, 'cdecl', '*.getchar', ()),
    '*.getchar_unlocked': ('int', None, 'cdecl', '*.getchar_unlocked', ()),
    '*.getcontext': ('int', None, 'cdecl', '*.getcontext', (('ucontext_t *', 'ucp'),)),
    '*.getcpu': ('int', None, 'cdecl', '*.getcpu', (('unsigned int *', 'cpu'), ('unsigned int *', 'node'))),
    '*.getcwd': ('char *', None, 'cdecl', '*.getcwd', (('char *', 'buffer'), ('size_t', 'size'))),
    '*.getdate': ('struct tm *', None, 'cdecl', '*.getdate', (('const char *', 'string'),)),
    '*.getdate_r': ('int', None, 'cdecl', '*.getdate_r', (('const char *', 'string'), ('struct tm *', 'tp'))),
    '*.getdelim': ('ssize_t', None, 'cdecl', '*.getdelim', (('char * *', 'lineptr'), ('size_t *', 'n'), ('int', 'delimiter'), ('FILE *', 'stream'))),
    '*.getdents64': ('ssize_t', None, 'cdecl', '*.getdents64', (('int', 'fd'), ('void *', 'buffer'), ('size_t', 'length'))),
    '*.getdomainnname': ('int', None, 'cdecl', '*.getdomainnname', (('char *', 'name'), ('size_t', 'length'))),
    '*.getegid': ('gid_t', None, 'cdecl', '*.getegid', ()),
    '*.getentropy': ('int', None, 'cdecl', '*.getentropy', (('void *', 'buffer'), ('size_t', 'length'))),
    '*.getenv': ('char *', None, 'cdecl', '*.getenv', (('const char *', 'name'),)),
    '*.geteuid': ('uid_t', None, 'cdecl', '*.geteuid', ()),
    '*.getfsent': ('struct fstab *', None, 'cdecl', '*.getfsent', ()),
    '*.getfsfile': ('struct fstab *', None, 'cdecl', '*.getfsfile', (('const char *', 'name'),)),
    '*.getfsspec': ('struct fstab *', None, 'cdecl', '*.getfsspec', (('const char *', 'name'),)),
    '*.getgid': ('gid_t', None, 'cdecl', '*.getgid', ()),
    '*.getgrent': ('struct group *', None, 'cdecl', '*.getgrent', ()),
    '*.getgrent_r': ('int', None, 'cdecl', '*.getgrent_r', (('struct group *', 'result_buf'), ('char *', 'buffer'), ('size_t', 'buflen'), ('struct group * *', 'result'))),
    '*.getgrgid': ('struct group *', None, 'cdecl', '*.getgrgid', (('gid_t', 'gid'),)),
    '*.getgrgid_r': ('int', None, 'cdecl', '*.getgrgid_r', (('gid_t', 'gid'), ('struct group *', 'result_buf'), ('char *', 'buffer'), ('size_t', 'buflen'), ('struct group * *', 'result'))),
    '*.getgrnam': ('struct group *', None, 'cdecl', '*.getgrnam', (('const char *', 'name'),)),
    '*.getgrnam_r': ('int', None, 'cdecl', '*.getgrnam_r', (('const char *', 'name'), ('struct group *', 'result_buf'), ('char *', 'buffer'), ('size_t', 'buflen'), ('struct group * *', 'result'))),
    '*.getgrouplist': ('int', None, 'cdecl', '*.getgrouplist', (('const char *', 'user'), ('gid_t', 'group'), ('gid_t *', 'groups'), ('int *', 'ngroups'))),
    '*.getgroups': ('int', None, 'cdecl', '*.getgroups', (('int', 'count'), ('gid_t *', 'groups'))),
    '*.gethostbyaddr': ('struct hostent *', None, 'cdecl', '*.gethostbyaddr', (('const void *', 'addr'), ('socklen_t', 'length'), ('int', 'format'))),
    '*.gethostbyaddr_r': ('int', None, 'cdecl', '*.gethostbyaddr_r', (('const void *', 'addr'), ('socklen_t', 'length'), ('int', 'format'), ('struct hostent * restrict', 'result_buf'), ('char * restrict', 'buf'), ('size_t', 'buflen'), ('struct hostent * * restrict', 'result'), ('int * restrict', 'h_errnop'))),
    '*.gethostbyname': ('struct hostent *', None, 'cdecl', '*.gethostbyname', (('const char *', 'name'),)),
    '*.gethostbyname2': ('struct hostent *', None, 'cdecl', '*.gethostbyname2', (('const char *', 'name'), ('int', 'af'))),
    '*.gethostbyname2_r': ('int', None, 'cdecl', '*.gethostbyname2_r', (('const char *', 'name'), ('int', 'af'), ('struct hostent * restrict', 'result_buf'), ('char * restrict', 'buf'), ('size_t', 'buflen'), ('struct hostent * * restrict', 'result'), ('int * restrict', 'h_errnop'))),
    '*.gethostbyname_r': ('int', None, 'cdecl', '*.gethostbyname_r', (('const char * restrict', 'name'), ('struct hostent * restrict', 'result_buf'), ('char * restrict', 'buf'), ('size_t', 'buflen'), ('struct hostent * * restrict', 'result'), ('int * restrict', 'h_errnop'))),
    '*.gethostent': ('struct hostent *', None, 'cdecl', '*.gethostent', ()),
    '*.gethostid': ('long int', None, 'cdecl', '*.gethostid', ()),
    '*.gethostname': ('int', None, 'cdecl', '*.gethostname', (('char *', 'name'), ('size_t', 'size'))),
    '*.getitimer': ('int', None, 'cdecl', '*.getitimer', (('int', 'which'), ('struct itimerval *', 'old'))),
    '*.getline': ('ssize_t', None, 'cdecl', '*.getline', (('char * *', 'lineptr'), ('size_t *', 'n'), ('FILE *', 'stream'))),
    '*.getloadavg': ('int', None, 'cdecl', '*.getloadavg', (('double', 'loadavg[]'), ('int', 'nelem'))),
    '*.getlogin': ('char *', None, 'cdecl', '*.getlogin', ()),
    '*.getmntent': ('struct mntent *', None, 'cdecl', '*.getmntent', (('FILE *', 'stream'),)),
    '*.getmntent_r': ('struct mntent *', None, 'cdecl', '*.getmntent_r', (('FILE *', 'stream'), ('struct mntent *', 'result'), ('char *', 'buffer'), ('int', 'bufsize'))),
    '*.getnetbyaddr': ('struct netent *', None, 'cdecl', '*.getnetbyaddr', (('uint32_t', 'net'), ('int', 'type'))),
    '*.getnetbyname': ('struct netent *', None, 'cdecl', '*.getnetbyname', (('const char *', 'name'),)),
    '*.getnetent': ('struct netent *', None, 'cdecl', '*.getnetent', ()),
    '*.getnetgrent': ('int', None, 'cdecl', '*.getnetgrent', (('char * *', 'hostp'), ('char * *', 'userp'), ('char * *', 'domainp'))),
    '*.getnetgrent_r': ('int', None, 'cdecl', '*.getnetgrent_r', (('char * *', 'hostp'), ('char * *', 'userp'), ('char * *', 'domainp'), ('char *', 'buffer'), ('size_t', 'buflen'))),
    '*.getopt': ('int', None, 'cdecl', '*.getopt', (('int', 'argc'), ('char * const *', 'argv'), ('const char *', 'options'))),
    '*.getopt_long': ('int', None, 'cdecl', '*.getopt_long', (('int', 'argc'), ('char * const *', 'argv'), ('const char *', 'shortopts'), ('const struct option *', 'longopts'), ('int *', 'indexptr'))),
    '*.getopt_long_only': ('int', None, 'cdecl', '*.getopt_long_only', (('int', 'argc'), ('char * const *', 'argv'), ('const char *', 'shortopts'), ('const struct option *', 'longopts'), ('int *', 'indexptr'))),
    '*.getpagesize': ('int', None, 'cdecl', '*.getpagesize', ()),
    '*.getpass': ('char *', None, 'cdecl', '*.getpass', (('const char *', 'prompt'),)),
    '*.getpayload': ('double', None, 'cdecl', '*.getpayload', (('const double *', 'x'),)),
    '*.getpayloadf': ('float', None, 'cdecl', '*.getpayloadf', (('const float *', 'x'),)),
    '*.getpayloadfN': ('_FloatN', None, 'cdecl', '*.getpayloadfN', (('const _FloatN *', 'x'),)),
    '*.getpayloadfNx': ('_FloatNx', None, 'cdecl', '*.getpayloadfNx', (('const _FloatNx *', 'x'),)),
    '*.getpayloadl': ('long double', None, 'cdecl', '*.getpayloadl', (('const long double *', 'x'),)),
    '*.getpeername': ('int', None, 'cdecl', '*.getpeername', (('int', 'socket'), ('struct sockaddr *', 'addr'), ('socklen_t *', 'length-ptr'))),
    '*.getpgid': ('int', None, 'cdecl', '*.getpgid', (('pid_t', 'pid'),)),
    '*.getpgrp': ('pid_t', None, 'cdecl', '*.getpgrp', ()),
    '*.getpid': ('pid_t', None, 'cdecl', '*.getpid', ()),
    '*.getppid': ('pid_t', None, 'cdecl', '*.getppid', ()),
    '*.getpriority': ('int', None, 'cdecl', '*.getpriority', (('int', 'class'), ('int', 'id'))),
    '*.getprotobyname': ('struct protoent *', None, 'cdecl', '*.getprotobyname', (('const char *', 'name'),)),
    '*.getprotobynumber': ('struct protoent *', None, 'cdecl', '*.getprotobynumber', (('int', 'protocol'),)),
    '*.getprotoent': ('struct protoent *', None, 'cdecl', '*.getprotoent', ()),
    '*.getpt': ('int', None, 'cdecl', '*.getpt', ()),
    '*.getpwent': ('struct passwd *', None, 'cdecl', '*.getpwent', ()),
    '*.getpwent_r': ('int', None, 'cdecl', '*.getpwent_r', (('struct passwd *', 'result_buf'), ('char *', 'buffer'), ('size_t', 'buflen'), ('struct passwd * *', 'result'))),
    '*.getpwnam': ('struct passwd *', None, 'cdecl', '*.getpwnam', (('const char *', 'name'),)),
    '*.getpwnam_r': ('int', None, 'cdecl', '*.getpwnam_r', (('const char *', 'name'), ('struct passwd *', 'result_buf'), ('char *', 'buffer'), ('size_t', 'buflen'), ('struct passwd * *', 'result'))),
    '*.getpwuid': ('struct passwd *', None, 'cdecl', '*.getpwuid', (('uid_t', 'uid'),)),
    '*.getpwuid_r': ('int', None, 'cdecl', '*.getpwuid_r', (('uid_t', 'uid'), ('struct passwd *', 'result_buf'), ('char *', 'buffer'), ('size_t', 'buflen'), ('struct passwd * *', 'result'))),
    '*.getrandom': ('ssize_t', None, 'cdecl', '*.getrandom', (('void *', 'buffer'), ('size_t', 'length'), ('unsigned int', 'flags'))),
    '*.getrlimit': ('int', None, 'cdecl', '*.getrlimit', (('int', 'resource'), ('struct rlimit *', 'rlp'))),
    '*.getrlimit64': ('int', None, 'cdecl', '*.getrlimit64', (('int', 'resource'), ('struct rlimit64 *', 'rlp'))),
    '*.getrusage': ('int', None, 'cdecl', '*.getrusage', (('int', 'processes'), ('struct rusage *', 'rusage'))),
    '*.getservbyname': ('struct servent *', None, 'cdecl', '*.getservbyname', (('const char *', 'name'), ('const char *', 'proto'))),
    '*.getservbyport': ('struct servent *', None, 'cdecl', '*.getservbyport', (('int', 'port'), ('const char *', 'proto'))),
    '*.getservent': ('struct servent *', None, 'cdecl', '*.getservent', ()),
    '*.getsid': ('pid_t', None, 'cdecl', '*.getsid', (('pid_t', 'pid'),)),
    '*.getsockname': ('int', None, 'cdecl', '*.getsockname', (('int', 'socket'), ('struct sockaddr *', 'addr'), ('socklen_t *', 'length-ptr'))),
    '*.getsockopt': ('int', None, 'cdecl', '*.getsockopt', (('int', 'socket'), ('int', 'level'), ('int', 'optname'), ('void *', 'optval'), ('socklen_t *', 'optlen-ptr'))),
    '*.getsubopt': ('int', None, 'cdecl', '*.getsubopt', (('char * *', 'optionp'), ('char * const *', 'tokens'), ('char * *', 'valuep'))),
    '*.gettext': ('char *', None, 'cdecl', '*.gettext', (('const char *', 'msgid'),)),
    '*.gettid': ('pid_t', None, 'cdecl', '*.gettid', ()),
    '*.gettimeofday': ('int', None, 'cdecl', '*.gettimeofday', (('struct timeval *', 'tp'), ('void *', 'tzp'))),
    '*.getuid': ('uid_t', None, 'cdecl', '*.getuid', ()),
    '*.getumask': ('mode_t', None, 'cdecl', '*.getumask', ()),
    '*.getutent': ('struct utmp *', None, 'cdecl', '*.getutent', ()),
    '*.getutent_r': ('int', None, 'cdecl', '*.getutent_r', (('struct utmp *', 'buffer'), ('struct utmp * *', 'result'))),
    '*.getutid': ('struct utmp *', None, 'cdecl', '*.getutid', (('const struct utmp *', 'id'),)),
    '*.getutid_r': ('int', None, 'cdecl', '*.getutid_r', (('const struct utmp *', 'id'), ('struct utmp *', 'buffer'), ('struct utmp * *', 'result'))),
    '*.getutline': ('struct utmp *', None, 'cdecl', '*.getutline', (('const struct utmp *', 'line'),)),
    '*.getutline_r': ('int', None, 'cdecl', '*.getutline_r', (('const struct utmp *', 'line'), ('struct utmp *', 'buffer'), ('struct utmp * *', 'result'))),
    '*.getutmp': ('int', None, 'cdecl', '*.getutmp', (('const struct utmpx *', 'utmpx'), ('struct utmp *', 'utmp'))),
    '*.getutmpx': ('int', None, 'cdecl', '*.getutmpx', (('const struct utmp *', 'utmp'), ('struct utmpx *', 'utmpx'))),
    '*.getutxent': ('struct utmpx *', None, 'cdecl', '*.getutxent', ()),
    '*.getutxid': ('struct utmpx *', None, 'cdecl', '*.getutxid', (('const struct utmpx *', 'id'),)),
    '*.getutxline': ('struct utmpx *', None, 'cdecl', '*.getutxline', (('const struct utmpx *', 'line'),)),
    '*.getw': ('int', None, 'cdecl', '*.getw', (('FILE *', 'stream'),)),
    '*.getwc': ('wint_t', None, 'cdecl', '*.getwc', (('FILE *', 'stream'),)),
    '*.getwc_unlocked': ('wint_t', None, 'cdecl', '*.getwc_unlocked', (('FILE *', 'stream'),)),
    '*.getwchar': ('wint_t', None, 'cdecl', '*.getwchar', ()),
    '*.getwchar_unlocked': ('wint_t', None, 'cdecl', '*.getwchar_unlocked', ()),
    '*.getwd': ('Function: char *', None, 'cdecl', '*.getwd', (('char *', 'buffer'),)),
    '*.glob': ('int', None, 'cdecl', '*.glob', (('const char *', 'pattern'), ('int', 'flags'), ('int (* errfunc (const char *', 'filename'), ('int', 'error-code'), ('glob_t *', 'vector-ptr'))),
    '*.glob64': ('int', None, 'cdecl', '*.glob64', (('const char *', 'pattern'), ('int', 'flags'), ('int (* errfunc (const char *', 'filename'), ('int', 'error-code'), ('glob64_t *', 'vector-ptr'))),
    '*.globfree': ('void', None, 'cdecl', '*.globfree', (('glob_t *', 'pglob'),)),
    '*.globfree64': ('void', None, 'cdecl', '*.globfree64', (('glob64_t *', 'pglob'),)),
    '*.gmtime': ('struct tm *', None, 'cdecl', '*.gmtime', (('const time_t *', 'time'),)),
    '*.gmtime_r': ('struct tm *', None, 'cdecl', '*.gmtime_r', (('const time_t *', 'time'), ('struct tm *', 'resultp'))),
    '*.grantpt': ('int', None, 'cdecl', '*.grantpt', (('int', 'filedes'),)),
    '*.gsignal': ('int', None, 'cdecl', '*.gsignal', (('int', 'signum'),)),
    '*.gtty': ('int', None, 'cdecl', '*.gtty', (('int', 'filedes'), ('struct sgttyb *', 'attributes'))),
    '*.hasmntopt': ('char *', None, 'cdecl', '*.hasmntopt', (('const struct mntent *', 'mnt'), ('const char *', 'opt'))),
    '*.hcreate': ('int', None, 'cdecl', '*.hcreate', (('size_t', 'nel'),)),
    '*.hcreate_r': ('int', None, 'cdecl', '*.hcreate_r', (('size_t', 'nel'), ('struct hsearch_data *', 'htab'))),
    '*.hdestroy': ('void', None, 'cdecl', '*.hdestroy', ()),
    '*.hdestroy_r': ('void', None, 'cdecl', '*.hdestroy_r', (('struct hsearch_data *', 'htab'),)),
    '*.hsearch': ('ENTRY *', None, 'cdecl', '*.hsearch', (('ENTRY', 'item'), ('ACTION', 'action'))),
    '*.hsearch_r': ('int', None, 'cdecl', '*.hsearch_r', (('ENTRY', 'item'), ('ACTION', 'action'), ('ENTRY * *', 'retval'), ('struct hsearch_data *', 'htab'))),
    '*.htonl': ('uint32_t', None, 'cdecl', '*.htonl', (('uint32_t', 'hostlong'),)),
    '*.htons': ('uint16_t', None, 'cdecl', '*.htons', (('uint16_t', 'hostshort'),)),
    '*.hypot': ('double', None, 'cdecl', '*.hypot', (('double', 'x'), ('double', 'y'))),
    '*.hypotf': ('float', None, 'cdecl', '*.hypotf', (('float', 'x'), ('float', 'y'))),
    '*.hypotfN': ('_FloatN', None, 'cdecl', '*.hypotfN', (('_FloatN', 'x'), ('_FloatN', 'y'))),
    '*.hypotfNx': ('_FloatNx', None, 'cdecl', '*.hypotfNx', (('_FloatNx', 'x'), ('_FloatNx', 'y'))),
    '*.hypotl': ('long double', None, 'cdecl', '*.hypotl', (('long double', 'x'), ('long double', 'y'))),
    '*.iconv': ('size_t', None, 'cdecl', '*.iconv', (('iconv_t', 'cd'), ('char * *', 'inbuf'), ('size_t *', 'inbytesleft'), ('char * *', 'outbuf'), ('size_t *', 'outbytesleft'))),
    '*.iconv_close': ('int', None, 'cdecl', '*.iconv_close', (('iconv_t', 'cd'),)),
    '*.iconv_open': ('iconv_t', None, 'cdecl', '*.iconv_open', (('const char *', 'tocode'), ('const char *', 'fromcode'))),
    '*.if_freenameindex': ('void', None, 'cdecl', '*.if_freenameindex', (('struct if_nameindex *', 'ptr'),)),
    '*.if_indextoname': ('char *', None, 'cdecl', '*.if_indextoname', (('unsigned int', 'ifindex'), ('char *', 'ifname'))),
    '*.if_nameindex': ('struct if_nameindex *', None, 'cdecl', '*.if_nameindex', ()),
    '*.if_nametoindex': ('unsigned int', None, 'cdecl', '*.if_nametoindex', (('const char *', 'ifname'),)),
    '*.ilogb': ('int', None, 'cdecl', '*.ilogb', (('double', 'x'),)),
    '*.ilogbf': ('int', None, 'cdecl', '*.ilogbf', (('float', 'x'),)),
    '*.ilogbfN': ('int', None, 'cdecl', '*.ilogbfN', (('_FloatN', 'x'),)),
    '*.ilogbfNx': ('int', None, 'cdecl', '*.ilogbfNx', (('_FloatNx', 'x'),)),
    '*.ilogbl': ('int', None, 'cdecl', '*.ilogbl', (('long double', 'x'),)),
    '*.imaxabs': ('intmax_t', None, 'cdecl', '*.imaxabs', (('intmax_t', 'number'),)),
    '*.imaxdiv': ('imaxdiv_t', None, 'cdecl', '*.imaxdiv', (('intmax_t', 'numerator'), ('intmax_t', 'denominator'))),
    '*.index': ('char *', None, 'cdecl', '*.index', (('const char *', 'string'), ('int', 'c'))),
    '*.inet_addr': ('uint32_t', None, 'cdecl', '*.inet_addr', (('const char *', 'name'),)),
    '*.inet_aton': ('int', None, 'cdecl', '*.inet_aton', (('const char *', 'name'), ('struct in_addr *', 'addr'))),
    '*.inet_lnaof': ('uint32_t', None, 'cdecl', '*.inet_lnaof', (('struct in_addr', 'addr'),)),
    '*.inet_makeaddr': ('struct in_addr', None, 'stdcall', '*.inet_makeaddr', (('uint32_t', 'net'), ('uint32_t', 'local'))),
    '*.inet_netof': ('uint32_t', None, 'cdecl', '*.inet_netof', (('struct in_addr', 'addr'),)),
    '*.inet_network': ('uint32_t', None, 'cdecl', '*.inet_network', (('const char *', 'name'),)),
    '*.inet_ntoa': ('char *', None, 'cdecl', '*.inet_ntoa', (('struct in_addr', 'addr'),)),
    '*.inet_ntop': ('const char *', None, 'cdecl', '*.inet_ntop', (('int', 'af'), ('const void *', 'cp'), ('char *', 'buf'), ('socklen_t', 'len'))),
    '*.inet_pton': ('int', None, 'cdecl', '*.inet_pton', (('int', 'af'), ('const char *', 'cp'), ('void *', 'buf'))),
    '*.initgroups': ('int', None, 'cdecl', '*.initgroups', (('const char *', 'user'), ('gid_t', 'group'))),
    '*.initstate': ('char *', None, 'cdecl', '*.initstate', (('unsigned int', 'seed'), ('char *', 'state'), ('size_t', 'size'))),
    '*.initstate_r': ('int', None, 'cdecl', '*.initstate_r', (('unsigned int', 'seed'), ('char * restrict', 'statebuf'), ('size_t', 'statelen'), ('struct random_data * restrict', 'buf'))),
    '*.innetgr': ('int', None, 'cdecl', '*.innetgr', (('const char *', 'netgroup'), ('const char *', 'host'), ('const char *', 'user'), ('const char *', 'domain'))),
    '*.ioctl': ('int', None, 'cdecl', '*.ioctl', (('int', 'filedes'), ('int', 'command'), ('variadic', ''))),
    '*.isalnum': ('int', None, 'cdecl', '*.isalnum', (('int', 'c'),)),
    '*.isalpha': ('int', None, 'cdecl', '*.isalpha', (('int', 'c'),)),
    '*.isascii': ('int', None, 'cdecl', '*.isascii', (('int', 'c'),)),
    '*.isatty': ('int', None, 'cdecl', '*.isatty', (('int', 'filedes'),)),
    '*.isblank': ('int', None, 'cdecl', '*.isblank', (('int', 'c'),)),
    '*.iscntrl': ('int', None, 'cdecl', '*.iscntrl', (('int', 'c'),)),
    '*.isdigit': ('int', None, 'cdecl', '*.isdigit', (('int', 'c'),)),
    '*.isgraph': ('int', None, 'cdecl', '*.isgraph', (('int', 'c'),)),
    '*.isinf': ('int', None, 'cdecl', '*.isinf', (('double', 'x'),)),
    '*.isinff': ('int', None, 'cdecl', '*.isinff', (('float', 'x'),)),
    '*.isinfl': ('int', None, 'cdecl', '*.isinfl', (('long double', 'x'),)),
    '*.islower': ('int', None, 'cdecl', '*.islower', (('int', 'c'),)),
    '*.isnan': ('int', None, 'cdecl', '*.isnan', (('double', 'x'),)),
    '*.isnanf': ('int', None, 'cdecl', '*.isnanf', (('float', 'x'),)),
    '*.isnanl': ('int', None, 'cdecl', '*.isnanl', (('long double', 'x'),)),
    '*.isprint': ('int', None, 'cdecl', '*.isprint', (('int', 'c'),)),
    '*.ispunct': ('int', None, 'cdecl', '*.ispunct', (('int', 'c'),)),
    '*.isspace': ('int', None, 'cdecl', '*.isspace', (('int', 'c'),)),
    '*.isupper': ('int', None, 'cdecl', '*.isupper', (('int', 'c'),)),
    '*.iswalnum': ('int', None, 'cdecl', '*.iswalnum', (('wint_t', 'wc'),)),
    '*.iswalpha': ('int', None, 'cdecl', '*.iswalpha', (('wint_t', 'wc'),)),
    '*.iswblank': ('int', None, 'cdecl', '*.iswblank', (('wint_t', 'wc'),)),
    '*.iswcntrl': ('int', None, 'cdecl', '*.iswcntrl', (('wint_t', 'wc'),)),
    '*.iswctype': ('int', None, 'cdecl', '*.iswctype', (('wint_t', 'wc'), ('wctype_t', 'desc'))),
    '*.iswdigit': ('int', None, 'cdecl', '*.iswdigit', (('wint_t', 'wc'),)),
    '*.iswgraph': ('int', None, 'cdecl', '*.iswgraph', (('wint_t', 'wc'),)),
    '*.iswlower': ('int', None, 'cdecl', '*.iswlower', (('wint_t', 'wc'),)),
    '*.iswprint': ('int', None, 'cdecl', '*.iswprint', (('wint_t', 'wc'),)),
    '*.iswpunct': ('int', None, 'cdecl', '*.iswpunct', (('wint_t', 'wc'),)),
    '*.iswspace': ('int', None, 'cdecl', '*.iswspace', (('wint_t', 'wc'),)),
    '*.iswupper': ('int', None, 'cdecl', '*.iswupper', (('wint_t', 'wc'),)),
    '*.iswxdigit': ('int', None, 'cdecl', '*.iswxdigit', (('wint_t', 'wc'),)),
    '*.isxdigit': ('int', None, 'cdecl', '*.isxdigit', (('int', 'c'),)),
    '*.j0': ('double', None, 'cdecl', '*.j0', (('double', 'x'),)),
    '*.j0f': ('float', None, 'cdecl', '*.j0f', (('float', 'x'),)),
    '*.j0fN': ('_FloatN', None, 'cdecl', '*.j0fN', (('_FloatN', 'x'),)),
    '*.j0fNx': ('_FloatNx', None, 'cdecl', '*.j0fNx', (('_FloatNx', 'x'),)),
    '*.j0l': ('long double', None, 'cdecl', '*.j0l', (('long double', 'x'),)),
    '*.j1': ('double', None, 'cdecl', '*.j1', (('double', 'x'),)),
    '*.j1f': ('float', None, 'cdecl', '*.j1f', (('float', 'x'),)),
    '*.j1fN': ('_FloatN', None, 'cdecl', '*.j1fN', (('_FloatN', 'x'),)),
    '*.j1fNx': ('_FloatNx', None, 'cdecl', '*.j1fNx', (('_FloatNx', 'x'),)),
    '*.j1l': ('long double', None, 'cdecl', '*.j1l', (('long double', 'x'),)),
    '*.jn': ('double', None, 'cdecl', '*.jn', (('int', 'n'), ('double', 'x'))),
    '*.jnf': ('float', None, 'cdecl', '*.jnf', (('int', 'n'), ('float', 'x'))),
    '*.jnfN': ('_FloatN', None, 'cdecl', '*.jnfN', (('int', 'n'), ('_FloatN', 'x'))),
    '*.jnfNx': ('_FloatNx', None, 'cdecl', '*.jnfNx', (('int', 'n'), ('_FloatNx', 'x'))),
    '*.jnl': ('long double', None, 'cdecl', '*.jnl', (('int', 'n'), ('long double', 'x'))),
    '*.jrand48': ('long int', None, 'cdecl', '*.jrand48', (('unsigned short int', 'xsubi[3]'),)),
    '*.jrand48_r': ('int', None, 'cdecl', '*.jrand48_r', (('unsigned short int', 'xsubi[3]'), ('struct drand48_data *', 'buffer'), ('long int *', 'result'))),
    '*.kill': ('int', None, 'cdecl', '*.kill', (('pid_t', 'pid'), ('int', 'signum'))),
    '*.killpg': ('int', None, 'cdecl', '*.killpg', (('int', 'pgid'), ('int', 'signum'))),
    '*.l64a': ('char *', None, 'cdecl', '*.l64a', (('long int', 'n'),)),
    '*.labs': ('long int', None, 'cdecl', '*.labs', (('long int', 'number'),)),
    '*.lcong48': ('void', None, 'cdecl', '*.lcong48', (('unsigned short int', 'param[7]'),)),
    '*.lcong48_r': ('int', None, 'cdecl', '*.lcong48_r', (('unsigned short int', 'param[7]'), ('struct drand48_data *', 'buffer'))),
    '*.ldexp': ('double', None, 'cdecl', '*.ldexp', (('double', 'value'), ('int', 'exponent'))),
    '*.ldexpf': ('float', None, 'cdecl', '*.ldexpf', (('float', 'value'), ('int', 'exponent'))),
    '*.ldexpfN': ('_FloatN', None, 'cdecl', '*.ldexpfN', (('_FloatN', 'value'), ('int', 'exponent'))),
    '*.ldexpfNx': ('_FloatNx', None, 'cdecl', '*.ldexpfNx', (('_FloatNx', 'value'), ('int', 'exponent'))),
    '*.ldexpl': ('long double', None, 'cdecl', '*.ldexpl', (('long double', 'value'), ('int', 'exponent'))),
    '*.ldiv': ('ldiv_t', None, 'stdcall', '*.ldiv', (('long int', 'numerator'), ('long int', 'denominator'))),
    '*.lfind': ('void *', None, 'cdecl', '*.lfind', (('const void *', 'key'), ('const void *', 'base'), ('size_t *', 'nmemb'), ('size_t', 'size'), ('comparison_fn_t', 'compar'))),
    '*.lgamma': ('double', None, 'cdecl', '*.lgamma', (('double', 'x'),)),
    '*.lgamma_r': ('double', None, 'cdecl', '*.lgamma_r', (('double', 'x'), ('int *', 'signp'))),
    '*.lgammaf': ('float', None, 'cdecl', '*.lgammaf', (('float', 'x'),)),
    '*.lgammafN': ('_FloatN', None, 'cdecl', '*.lgammafN', (('_FloatN', 'x'),)),
    '*.lgammafN_r': ('_FloatN', None, 'cdecl', '*.lgammafN_r', (('_FloatN', 'x'), ('int *', 'signp'))),
    '*.lgammafNx': ('_FloatNx', None, 'cdecl', '*.lgammafNx', (('_FloatNx', 'x'),)),
    '*.lgammafNx_r': ('_FloatNx', None, 'cdecl', '*.lgammafNx_r', (('_FloatNx', 'x'), ('int *', 'signp'))),
    '*.lgammaf_r': ('float', None, 'cdecl', '*.lgammaf_r', (('float', 'x'), ('int *', 'signp'))),
    '*.lgammal': ('long double', None, 'cdecl', '*.lgammal', (('long double', 'x'),)),
    '*.lgammal_r': ('long double', None, 'cdecl', '*.lgammal_r', (('long double', 'x'), ('int *', 'signp'))),
    '*.link': ('int', None, 'cdecl', '*.link', (('const char *', 'oldname'), ('const char *', 'newname'))),
    '*.linkat': ('int', None, 'cdecl', '*.linkat', (('int', 'oldfd'), ('const char *', 'oldname'), ('int', 'newfd'), ('const char *', 'newname'), ('int', 'flags'))),
    '*.lio_listio': ('int', None, 'cdecl', '*.lio_listio', (('int', 'mode'), ('struct aiocb * const', 'list[]'), ('int', 'nent'), ('struct sigevent *', 'sig'))),
    '*.lio_listio64': ('int', None, 'cdecl', '*.lio_listio64', (('int', 'mode'), ('struct aiocb64 * const', 'list[]'), ('int', 'nent'), ('struct sigevent *', 'sig'))),
    '*.listen': ('int', None, 'cdecl', '*.listen', (('int', 'socket'), ('int', 'n'))),
    '*.llabs': ('long long int', None, 'cdecl', '*.llabs', (('long long int', 'number'),)),
    '*.lldiv': ('lldiv_t', None, 'stdcall', '*.lldiv', (('long long int', 'numerator'), ('long long int', 'denominator'))),
    '*.llogb': ('long int', None, 'cdecl', '*.llogb', (('double', 'x'),)),
    '*.llogbf': ('long int', None, 'cdecl', '*.llogbf', (('float', 'x'),)),
    '*.llogbfN': ('long int', None, 'cdecl', '*.llogbfN', (('_FloatN', 'x'),)),
    '*.llogbfNx': ('long int', None, 'cdecl', '*.llogbfNx', (('_FloatNx', 'x'),)),
    '*.llogbl': ('long int', None, 'cdecl', '*.llogbl', (('long double', 'x'),)),
    '*.llrint': ('long long int', None, 'cdecl', '*.llrint', (('double', 'x'),)),
    '*.llrintf': ('long long int', None, 'cdecl', '*.llrintf', (('float', 'x'),)),
    '*.llrintfN': ('long long int', None, 'cdecl', '*.llrintfN', (('_FloatN', 'x'),)),
    '*.llrintfNx': ('long long int', None, 'cdecl', '*.llrintfNx', (('_FloatNx', 'x'),)),
    '*.llrintl': ('long long int', None, 'cdecl', '*.llrintl', (('long double', 'x'),)),
    '*.llround': ('long long int', None, 'cdecl', '*.llround', (('double', 'x'),)),
    '*.llroundf': ('long long int', None, 'cdecl', '*.llroundf', (('float', 'x'),)),
    '*.llroundfN': ('long long int', None, 'cdecl', '*.llroundfN', (('_FloatN', 'x'),)),
    '*.llroundfNx': ('long long int', None, 'cdecl', '*.llroundfNx', (('_FloatNx', 'x'),)),
    '*.llroundl': ('long long int', None, 'cdecl', '*.llroundl', (('long double', 'x'),)),
    '*.localeconv': ('struct lconv *', None, 'cdecl', '*.localeconv', ()),
    '*.localtime': ('struct tm *', None, 'cdecl', '*.localtime', (('const time_t *', 'time'),)),
    '*.localtime_r': ('struct tm *', None, 'cdecl', '*.localtime_r', (('const time_t *', 'time'), ('struct tm *', 'resultp'))),
    '*.log': ('double', None, 'cdecl', '*.log', (('double', 'x'),)),
    '*.log10': ('double', None, 'cdecl', '*.log10', (('double', 'x'),)),
    '*.log10f': ('float', None, 'cdecl', '*.log10f', (('float', 'x'),)),
    '*.log10fN': ('_FloatN', None, 'cdecl', '*.log10fN', (('_FloatN', 'x'),)),
    '*.log10fNx': ('_FloatNx', None, 'cdecl', '*.log10fNx', (('_FloatNx', 'x'),)),
    '*.log10l': ('long double', None, 'cdecl', '*.log10l', (('long double', 'x'),)),
    '*.log1p': ('double', None, 'cdecl', '*.log1p', (('double', 'x'),)),
    '*.log1pf': ('float', None, 'cdecl', '*.log1pf', (('float', 'x'),)),
    '*.log1pfN': ('_FloatN', None, 'cdecl', '*.log1pfN', (('_FloatN', 'x'),)),
    '*.log1pfNx': ('_FloatNx', None, 'cdecl', '*.log1pfNx', (('_FloatNx', 'x'),)),
    '*.log1pl': ('long double', None, 'cdecl', '*.log1pl', (('long double', 'x'),)),
    '*.log2': ('double', None, 'cdecl', '*.log2', (('double', 'x'),)),
    '*.log2f': ('float', None, 'cdecl', '*.log2f', (('float', 'x'),)),
    '*.log2fN': ('_FloatN', None, 'cdecl', '*.log2fN', (('_FloatN', 'x'),)),
    '*.log2fNx': ('_FloatNx', None, 'cdecl', '*.log2fNx', (('_FloatNx', 'x'),)),
    '*.log2l': ('long double', None, 'cdecl', '*.log2l', (('long double', 'x'),)),
    '*.logb': ('double', None, 'cdecl', '*.logb', (('double', 'x'),)),
    '*.logbf': ('float', None, 'cdecl', '*.logbf', (('float', 'x'),)),
    '*.logbfN': ('_FloatN', None, 'cdecl', '*.logbfN', (('_FloatN', 'x'),)),
    '*.logbfNx': ('_FloatNx', None, 'cdecl', '*.logbfNx', (('_FloatNx', 'x'),)),
    '*.logbl': ('long double', None, 'cdecl', '*.logbl', (('long double', 'x'),)),
    '*.logf': ('float', None, 'cdecl', '*.logf', (('float', 'x'),)),
    '*.logfN': ('_FloatN', None, 'cdecl', '*.logfN', (('_FloatN', 'x'),)),
    '*.logfNx': ('_FloatNx', None, 'cdecl', '*.logfNx', (('_FloatNx', 'x'),)),
    '*.login': ('void', None, 'cdecl', '*.login', (('const struct utmp *', 'entry'),)),
    '*.login_tty': ('int', None, 'cdecl', '*.login_tty', (('int', 'filedes'),)),
    '*.logl': ('long double', None, 'cdecl', '*.logl', (('long double', 'x'),)),
    '*.logout': ('int', None, 'cdecl', '*.logout', (('const char *', 'ut_line'),)),
    '*.logwtmp': ('void', None, 'cdecl', '*.logwtmp', (('const char *', 'ut_line'), ('const char *', 'ut_name'), ('const char *', 'ut_host'))),
    '*.longjmp': ('void', None, 'cdecl', '*.longjmp', (('jmp_buf', 'state'), ('int', 'value'))),
    '*.lrand48': ('long int', None, 'cdecl', '*.lrand48', ()),
    '*.lrand48_r': ('int', None, 'cdecl', '*.lrand48_r', (('struct drand48_data *', 'buffer'), ('long int *', 'result'))),
    '*.lrint': ('long int', None, 'cdecl', '*.lrint', (('double', 'x'),)),
    '*.lrintf': ('long int', None, 'cdecl', '*.lrintf', (('float', 'x'),)),
    '*.lrintfN': ('long int', None, 'cdecl', '*.lrintfN', (('_FloatN', 'x'),)),
    '*.lrintfNx': ('long int', None, 'cdecl', '*.lrintfNx', (('_FloatNx', 'x'),)),
    '*.lrintl': ('long int', None, 'cdecl', '*.lrintl', (('long double', 'x'),)),
    '*.lround': ('long int', None, 'cdecl', '*.lround', (('double', 'x'),)),
    '*.lroundf': ('long int', None, 'cdecl', '*.lroundf', (('float', 'x'),)),
    '*.lroundfN': ('long int', None, 'cdecl', '*.lroundfN', (('_FloatN', 'x'),)),
    '*.lroundfNx': ('long int', None, 'cdecl', '*.lroundfNx', (('_FloatNx', 'x'),)),
    '*.lroundl': ('long int', None, 'cdecl', '*.lroundl', (('long double', 'x'),)),
    '*.lsearch': ('void *', None, 'cdecl', '*.lsearch', (('const void *', 'key'), ('void *', 'base'), ('size_t *', 'nmemb'), ('size_t', 'size'), ('comparison_fn_t', 'compar'))),
    '*.lseek': ('off_t', None, 'cdecl', '*.lseek', (('int', 'filedes'), ('off_t', 'offset'), ('int', 'whence'))),
    '*.lseek64': ('off64_t', None, 'cdecl', '*.lseek64', (('int', 'filedes'), ('off64_t', 'offset'), ('int', 'whence'))),
    '*.lstat': ('int', None, 'cdecl', '*.lstat', (('const char *', 'filename'), ('struct stat *', 'buf'))),
    '*.lstat64': ('int', None, 'cdecl', '*.lstat64', (('const char *', 'filename'), ('struct stat64 *', 'buf'))),
    '*.lutimes': ('int', None, 'cdecl', '*.lutimes', (('const char *', 'filename'), ('const struct timeval', 'tvp[2]'))),
    '*.madvise': ('int', None, 'cdecl', '*.madvise', (('void *', 'addr'), ('size_t', 'length'), ('int', 'advice'))),
    '*.makecontext': ('void', None, 'cdecl', '*.makecontext', (('ucontext_t *', 'ucp'), ('void (* func', '(void'), ('int', 'argc'), ('variadic', ''))),
    '*.mallinfo': ('struct mallinfo', None, 'stdcall', '*.mallinfo', ()),
    '*.malloc': ('void *', None, 'cdecl', '*.malloc', (('size_t', 'size'),)),
    '*.mallopt': ('int', None, 'cdecl', '*.mallopt', (('int', 'param'), ('int', 'value'))),
    '*.mblen': ('int', None, 'cdecl', '*.mblen', (('const char *', 'string'), ('size_t', 'size'))),
    '*.mbrlen': ('size_t', None, 'cdecl', '*.mbrlen', (('const char * restrict', 's'), ('size_t', 'n'), ('mbstate_t *', 'ps'))),
    '*.mbrtowc': ('size_t', None, 'cdecl', '*.mbrtowc', (('wchar_t * restrict', 'pwc'), ('const char * restrict', 's'), ('size_t', 'n'), ('mbstate_t * restrict', 'ps'))),
    '*.mbsinit': ('int', None, 'cdecl', '*.mbsinit', (('const mbstate_t *', 'ps'),)),
    '*.mbsnrtowcs': ('size_t', None, 'cdecl', '*.mbsnrtowcs', (('wchar_t * restrict', 'dst'), ('const char * * restrict', 'src'), ('size_t', 'nmc'), ('size_t', 'len'), ('mbstate_t * restrict', 'ps'))),
    '*.mbsrtowcs': ('size_t', None, 'cdecl', '*.mbsrtowcs', (('wchar_t * restrict', 'dst'), ('const char * * restrict', 'src'), ('size_t', 'len'), ('mbstate_t * restrict', 'ps'))),
    '*.mbstowcs': ('size_t', None, 'cdecl', '*.mbstowcs', (('wchar_t *', 'wstring'), ('const char *', 'string'), ('size_t', 'size'))),
    '*.mbtowc': ('int', None, 'cdecl', '*.mbtowc', (('wchar_t * restrict', 'result'), ('const char * restrict', 'string'), ('size_t', 'size'))),
    '*.mcheck': ('int', None, 'cdecl', '*.mcheck', (('void (* abortfn (enum mcheck_status', 'status'),)),
    '*.memalign': ('void *', None, 'cdecl', '*.memalign', (('size_t', 'boundary'), ('size_t', 'size'))),
    '*.memccpy': ('void *', None, 'cdecl', '*.memccpy', (('void * restrict', 'to'), ('const void * restrict', 'from'), ('int', 'c'), ('size_t', 'size'))),
    '*.memchr': ('void *', None, 'cdecl', '*.memchr', (('const void *', 'block'), ('int', 'c'), ('size_t', 'size'))),
    '*.memcmp': ('int', None, 'cdecl', '*.memcmp', (('const void *', 'a1'), ('const void *', 'a2'), ('size_t', 'size'))),
    '*.memcpy': ('void *', None, 'cdecl', '*.memcpy', (('void * restrict', 'to'), ('const void * restrict', 'from'), ('size_t', 'size'))),
    '*.memfd_create': ('int', None, 'cdecl', '*.memfd_create', (('const char *', 'name'), ('unsigned int', 'flags'))),
    '*.memfrob': ('void *', None, 'cdecl', '*.memfrob', (('void *', 'mem'), ('size_t', 'length'))),
    '*.memmem': ('void *', None, 'cdecl', '*.memmem', (('const void *', 'haystack'), ('size_t', 'haystack-len'), ('const void *', 'needle'), ('size_t', 'needle-len'))),
    '*.memmove': ('void *', None, 'cdecl', '*.memmove', (('void *', 'to'), ('const void *', 'from'), ('size_t', 'size'))),
    '*.mempcpy': ('void *', None, 'cdecl', '*.mempcpy', (('void * restrict', 'to'), ('const void * restrict', 'from'), ('size_t', 'size'))),
    '*.memrchr': ('void *', None, 'cdecl', '*.memrchr', (('const void *', 'block'), ('int', 'c'), ('size_t', 'size'))),
    '*.memset': ('void *', None, 'cdecl', '*.memset', (('void *', 'block'), ('int', 'c'), ('size_t', 'size'))),
    '*.mkdir': ('int', None, 'cdecl', '*.mkdir', (('const char *', 'filename'), ('mode_t', 'mode'))),
    '*.mkdtemp': ('char *', None, 'cdecl', '*.mkdtemp', (('char *', 'template'),)),
    '*.mkfifo': ('int', None, 'cdecl', '*.mkfifo', (('const char *', 'filename'), ('mode_t', 'mode'))),
    '*.mknod': ('int', None, 'cdecl', '*.mknod', (('const char *', 'filename'), ('mode_t', 'mode'), ('dev_t', 'dev'))),
    '*.mkstemp': ('int', None, 'cdecl', '*.mkstemp', (('char *', 'template'),)),
    '*.mktemp': ('char *', None, 'cdecl', '*.mktemp', (('char *', 'template'),)),
    '*.mktime': ('time_t', None, 'cdecl', '*.mktime', (('struct tm *', 'brokentime'),)),
    '*.mlock': ('int', None, 'cdecl', '*.mlock', (('const void *', 'addr'), ('size_t', 'len'))),
    '*.mlock2': ('int', None, 'cdecl', '*.mlock2', (('const void *', 'addr'), ('size_t', 'len'), ('unsigned int', 'flags'))),
    '*.mlockall': ('int', None, 'cdecl', '*.mlockall', (('int', 'flags'),)),
    '*.mmap': ('void *', None, 'cdecl', '*.mmap', (('void *', 'address'), ('size_t', 'length'), ('int', 'protect'), ('int', 'flags'), ('int', 'filedes'), ('off_t', 'offset'))),
    '*.mmap64': ('void *', None, 'cdecl', '*.mmap64', (('void *', 'address'), ('size_t', 'length'), ('int', 'protect'), ('int', 'flags'), ('int', 'filedes'), ('off64_t', 'offset'))),
    '*.modf': ('double', None, 'cdecl', '*.modf', (('double', 'value'), ('double *', 'integer-part'))),
    '*.modff': ('float', None, 'cdecl', '*.modff', (('float', 'value'), ('float *', 'integer-part'))),
    '*.modffN': ('_FloatN', None, 'cdecl', '*.modffN', (('_FloatN', 'value'), ('_FloatN *', 'integer-part'))),
    '*.modffNx': ('_FloatNx', None, 'cdecl', '*.modffNx', (('_FloatNx', 'value'), ('_FloatNx *', 'integer-part'))),
    '*.modfl': ('long double', None, 'cdecl', '*.modfl', (('long double', 'value'), ('long double *', 'integer-part'))),
    '*.mount': ('int', None, 'cdecl', '*.mount', (('const char *', 'special_file'), ('const char *', 'dir'), ('const char *', 'fstype'), ('unsigned long int', 'options'), ('const void *', 'data'))),
    '*.mprobe': ('enum mcheck_status', None, 'cdecl', '*.mprobe', (('void *', 'pointer'),)),
    '*.mprotect': ('int', None, 'cdecl', '*.mprotect', (('void *', 'address'), ('size_t', 'length'), ('int', 'protection'))),
    '*.mrand48': ('long int', None, 'cdecl', '*.mrand48', ()),
    '*.mrand48_r': ('int', None, 'cdecl', '*.mrand48_r', (('struct drand48_data *', 'buffer'), ('long int *', 'result'))),
    '*.mremap': ('void *', None, 'cdecl', '*.mremap', (('void *', 'address'), ('size_t', 'length'), ('size_t', 'new_length'), ('int', 'flag'))),
    '*.msync': ('int', None, 'cdecl', '*.msync', (('void *', 'address'), ('size_t', 'length'), ('int', 'flags'))),
    '*.mtrace': ('void', None, 'cdecl', '*.mtrace', ()),
    '*.mtx_destroy': ('void', None, 'cdecl', '*.mtx_destroy', (('mtx_t *', 'mutex'),)),
    '*.mtx_init': ('int', None, 'cdecl', '*.mtx_init', (('mtx_t *', 'mutex'), ('int', 'type'))),
    '*.mtx_lock': ('int', None, 'cdecl', '*.mtx_lock', (('mtx_t *', 'mutex'),)),
    '*.mtx_timedlock': ('int', None, 'cdecl', '*.mtx_timedlock', (('mtx_t * restrict', 'mutex'), ('const struct timespec * restrict', 'time_point'))),
    '*.mtx_trylock': ('int', None, 'cdecl', '*.mtx_trylock', (('mtx_t *', 'mutex'),)),
    '*.mtx_unlock': ('int', None, 'cdecl', '*.mtx_unlock', (('mtx_t *', 'mutex'),)),
    '*.munlock': ('int', None, 'cdecl', '*.munlock', (('const void *', 'addr'), ('size_t', 'len'))),
    '*.munlockall': ('int', None, 'cdecl', '*.munlockall', ()),
    '*.munmap': ('int', None, 'cdecl', '*.munmap', (('void *', 'addr'), ('size_t', 'length'))),
    '*.muntrace': ('void', None, 'cdecl', '*.muntrace', ()),
    '*.nan': ('double', None, 'cdecl', '*.nan', (('const char *', 'tagp'),)),
    '*.nanf': ('float', None, 'cdecl', '*.nanf', (('const char *', 'tagp'),)),
    '*.nanfN': ('_FloatN', None, 'cdecl', '*.nanfN', (('const char *', 'tagp'),)),
    '*.nanfNx': ('_FloatNx', None, 'cdecl', '*.nanfNx', (('const char *', 'tagp'),)),
    '*.nanl': ('long double', None, 'cdecl', '*.nanl', (('const char *', 'tagp'),)),
    '*.nanosleep': ('int', None, 'cdecl', '*.nanosleep', (('const struct timespec *', 'requested_time'), ('struct timespec *', 'remaining'))),
    '*.nearbyint': ('double', None, 'cdecl', '*.nearbyint', (('double', 'x'),)),
    '*.nearbyintf': ('float', None, 'cdecl', '*.nearbyintf', (('float', 'x'),)),
    '*.nearbyintfN': ('_FloatN', None, 'cdecl', '*.nearbyintfN', (('_FloatN', 'x'),)),
    '*.nearbyintfNx': ('_FloatNx', None, 'cdecl', '*.nearbyintfNx', (('_FloatNx', 'x'),)),
    '*.nearbyintl': ('long double', None, 'cdecl', '*.nearbyintl', (('long double', 'x'),)),
    '*.nextafter': ('double', None, 'cdecl', '*.nextafter', (('double', 'x'), ('double', 'y'))),
    '*.nextafterf': ('float', None, 'cdecl', '*.nextafterf', (('float', 'x'), ('float', 'y'))),
    '*.nextafterfN': ('_FloatN', None, 'cdecl', '*.nextafterfN', (('_FloatN', 'x'), ('_FloatN', 'y'))),
    '*.nextafterfNx': ('_FloatNx', None, 'cdecl', '*.nextafterfNx', (('_FloatNx', 'x'), ('_FloatNx', 'y'))),
    '*.nextafterl': ('long double', None, 'cdecl', '*.nextafterl', (('long double', 'x'), ('long double', 'y'))),
    '*.nextdown': ('double', None, 'cdecl', '*.nextdown', (('double', 'x'),)),
    '*.nextdownf': ('float', None, 'cdecl', '*.nextdownf', (('float', 'x'),)),
    '*.nextdownfN': ('_FloatN', None, 'cdecl', '*.nextdownfN', (('_FloatN', 'x'),)),
    '*.nextdownfNx': ('_FloatNx', None, 'cdecl', '*.nextdownfNx', (('_FloatNx', 'x'),)),
    '*.nextdownl': ('long double', None, 'cdecl', '*.nextdownl', (('long double', 'x'),)),
    '*.nexttoward': ('double', None, 'cdecl', '*.nexttoward', (('double', 'x'), ('long double', 'y'))),
    '*.nexttowardf': ('float', None, 'cdecl', '*.nexttowardf', (('float', 'x'), ('long double', 'y'))),
    '*.nexttowardl': ('long double', None, 'cdecl', '*.nexttowardl', (('long double', 'x'), ('long double', 'y'))),
    '*.nextup': ('double', None, 'cdecl', '*.nextup', (('double', 'x'),)),
    '*.nextupf': ('float', None, 'cdecl', '*.nextupf', (('float', 'x'),)),
    '*.nextupfN': ('_FloatN', None, 'cdecl', '*.nextupfN', (('_FloatN', 'x'),)),
    '*.nextupfNx': ('_FloatNx', None, 'cdecl', '*.nextupfNx', (('_FloatNx', 'x'),)),
    '*.nextupl': ('long double', None, 'cdecl', '*.nextupl', (('long double', 'x'),)),
    '*.nftw': ('int', None, 'cdecl', '*.nftw', (('const char *', 'filename'), ('__nftw_func_t', 'func'), ('int', 'descriptors'), ('int', 'flag'))),
    '*.nftw64': ('int', None, 'cdecl', '*.nftw64', (('const char *', 'filename'), ('__nftw64_func_t', 'func'), ('int', 'descriptors'), ('int', 'flag'))),
    '*.ngettext': ('char *', None, 'cdecl', '*.ngettext', (('const char *', 'msgid1'), ('const char *', 'msgid2'), ('unsigned long int', 'n'))),
    '*.nice': ('int', None, 'cdecl', '*.nice', (('int', 'increment'),)),
    '*.nl_langinfo': ('char *', None, 'cdecl', '*.nl_langinfo', (('nl_item', 'item'),)),
    '*.nrand48': ('long int', None, 'cdecl', '*.nrand48', (('unsigned short int', 'xsubi[3]'),)),
    '*.nrand48_r': ('int', None, 'cdecl', '*.nrand48_r', (('unsigned short int', 'xsubi[3]'), ('struct drand48_data *', 'buffer'), ('long int *', 'result'))),
    '*.ntohl': ('uint32_t', None, 'cdecl', '*.ntohl', (('uint32_t', 'netlong'),)),
    '*.ntohs': ('uint16_t', None, 'cdecl', '*.ntohs', (('uint16_t', 'netshort'),)),
    '*.ntp_adjtime': ('int', None, 'cdecl', '*.ntp_adjtime', (('struct timex *', 'tptr'),)),
    '*.ntp_gettime': ('int', None, 'cdecl', '*.ntp_gettime', (('struct ntptimeval *', 'tptr'),)),
    '*.obstack_1grow': ('void', None, 'cdecl', '*.obstack_1grow', (('struct obstack *', 'obstack-ptr'), ('char', 'c'))),
    '*.obstack_1grow_fast': ('void', None, 'cdecl', '*.obstack_1grow_fast', (('struct obstack *', 'obstack-ptr'), ('char', 'c'))),
    '*.obstack_alloc': ('void *', None, 'cdecl', '*.obstack_alloc', (('struct obstack *', 'obstack-ptr'), ('int', 'size'))),
    '*.obstack_base': ('void *', None, 'cdecl', '*.obstack_base', (('struct obstack *', 'obstack-ptr'),)),
    '*.obstack_blank': ('void', None, 'cdecl', '*.obstack_blank', (('struct obstack *', 'obstack-ptr'), ('int', 'size'))),
    '*.obstack_blank_fast': ('void', None, 'cdecl', '*.obstack_blank_fast', (('struct obstack *', 'obstack-ptr'), ('int', 'size'))),
    '*.obstack_copy': ('void *', None, 'cdecl', '*.obstack_copy', (('struct obstack *', 'obstack-ptr'), ('void *', 'address'), ('int', 'size'))),
    '*.obstack_copy0': ('void *', None, 'cdecl', '*.obstack_copy0', (('struct obstack *', 'obstack-ptr'), ('void *', 'address'), ('int', 'size'))),
    '*.obstack_finish': ('void *', None, 'cdecl', '*.obstack_finish', (('struct obstack *', 'obstack-ptr'),)),
    '*.obstack_free': ('void', None, 'cdecl', '*.obstack_free', (('struct obstack *', 'obstack-ptr'), ('void *', 'object'))),
    '*.obstack_grow': ('void', None, 'cdecl', '*.obstack_grow', (('struct obstack *', 'obstack-ptr'), ('void *', 'data'), ('int', 'size'))),
    '*.obstack_grow0': ('void', None, 'cdecl', '*.obstack_grow0', (('struct obstack *', 'obstack-ptr'), ('void *', 'data'), ('int', 'size'))),
    '*.obstack_init': ('int', None, 'cdecl', '*.obstack_init', (('struct obstack *', 'obstack-ptr'),)),
    '*.obstack_int_grow': ('void', None, 'cdecl', '*.obstack_int_grow', (('struct obstack *', 'obstack-ptr'), ('int', 'data'))),
    '*.obstack_int_grow_fast': ('void', None, 'cdecl', '*.obstack_int_grow_fast', (('struct obstack *', 'obstack-ptr'), ('int', 'data'))),
    '*.obstack_next_free': ('void *', None, 'cdecl', '*.obstack_next_free', (('struct obstack *', 'obstack-ptr'),)),
    '*.obstack_object_size': ('int', None, 'cdecl', '*.obstack_object_size', (('struct obstack *', 'obstack-ptr'),)),
    '*.obstack_printf': ('int', None, 'cdecl', '*.obstack_printf', (('struct obstack *', 'obstack'), ('const char *', 'template'), ('variadic', ''))),
    '*.obstack_ptr_grow': ('void', None, 'cdecl', '*.obstack_ptr_grow', (('struct obstack *', 'obstack-ptr'), ('void *', 'data'))),
    '*.obstack_ptr_grow_fast': ('void', None, 'cdecl', '*.obstack_ptr_grow_fast', (('struct obstack *', 'obstack-ptr'), ('void *', 'data'))),
    '*.obstack_room': ('int', None, 'cdecl', '*.obstack_room', (('struct obstack *', 'obstack-ptr'),)),
    '*.obstack_vprintf': ('int', None, 'cdecl', '*.obstack_vprintf', (('struct obstack *', 'obstack'), ('const char *', 'template'), ('va_list', 'ap'))),
    '*.on_exit': ('int', None, 'cdecl', '*.on_exit', (('void (* function(int', 'status'), ('void *', 'arg'), ('void *', 'arg'))),
    '*.open': ('int', None, 'cdecl', '*.open', (('const char *', 'filename'), ('int', 'flags['), ('mode_t', 'mode]'))),
    '*.open64': ('int', None, 'cdecl', '*.open64', (('const char *', 'filename'), ('int', 'flags['), ('mode_t', 'mode]'))),
    '*.open_memstream': ('FILE *', None, 'cdecl', '*.open_memstream', (('char * *', 'ptr'), ('size_t *', 'sizeloc'))),
    '*.opendir': ('DIR *', None, 'cdecl', '*.opendir', (('const char *', 'dirname'),)),
    '*.openlog': ('void', None, 'cdecl', '*.openlog', (('const char *', 'ident'), ('int', 'option'), ('int', 'facility'))),
    '*.openpty': ('int', None, 'cdecl', '*.openpty', (('int *', 'amaster'), ('int *', 'aslave'), ('char *', 'name'), ('const struct termios *', 'termp'), ('const struct winsize *', 'winp'))),
    '*.parse_printf_format': ('size_t', None, 'cdecl', '*.parse_printf_format', (('const char *', 'template'), ('size_t', 'n'), ('int *', 'argtypes'))),
    '*.pathconf': ('long int', None, 'cdecl', '*.pathconf', (('const char *', 'filename'), ('int', 'parameter'))),
    '*.pause': ('int', None, 'cdecl', '*.pause', ()),
    '*.pclose': ('int', None, 'cdecl', '*.pclose', (('FILE *', 'stream'),)),
    '*.perror': ('void', None, 'cdecl', '*.perror', (('const char *', 'message'),)),
    '*.pipe': ('int', None, 'cdecl', '*.pipe', (('int', 'filedes[2]'),)),
    '*.pkey_alloc': ('int', None, 'cdecl', '*.pkey_alloc', (('unsigned int', 'flags'), ('unsigned int', 'restrictions'))),
    '*.pkey_free': ('int', None, 'cdecl', '*.pkey_free', (('int', 'key'),)),
    '*.pkey_get': ('int', None, 'cdecl', '*.pkey_get', (('int', 'key'),)),
    '*.pkey_mprotect': ('int', None, 'cdecl', '*.pkey_mprotect', (('void *', 'address'), ('size_t', 'length'), ('int', 'protection'), ('int', 'key'))),
    '*.pkey_set': ('int', None, 'cdecl', '*.pkey_set', (('int', 'key'), ('unsigned int', 'rights'))),
    '*.popen': ('FILE *', None, 'cdecl', '*.popen', (('const char *', 'command'), ('const char *', 'mode'))),
    '*.posix_fallocate': ('int', None, 'cdecl', '*.posix_fallocate', (('int', 'fd'), ('off_t', 'offset'), ('off_t', 'length'))),
    '*.posix_fallocate64': ('int', None, 'cdecl', '*.posix_fallocate64', (('int', 'fd'), ('off64_t', 'offset'), ('off64_t', 'length'))),
    '*.posix_memalign': ('int', None, 'cdecl', '*.posix_memalign', (('void * *', 'memptr'), ('size_t', 'alignment'), ('size_t', 'size'))),
    '*.pow': ('double', None, 'cdecl', '*.pow', (('double', 'base'), ('double', 'power'))),
    '*.powf': ('float', None, 'cdecl', '*.powf', (('float', 'base'), ('float', 'power'))),
    '*.powfN': ('_FloatN', None, 'cdecl', '*.powfN', (('_FloatN', 'base'), ('_FloatN', 'power'))),
    '*.powfNx': ('_FloatNx', None, 'cdecl', '*.powfNx', (('_FloatNx', 'base'), ('_FloatNx', 'power'))),
    '*.powl': ('long double', None, 'cdecl', '*.powl', (('long double', 'base'), ('long double', 'power'))),
    '*.pread': ('ssize_t', None, 'cdecl', '*.pread', (('int', 'filedes'), ('void *', 'buffer'), ('size_t', 'size'), ('off_t', 'offset'))),
    '*.pread64': ('ssize_t', None, 'cdecl', '*.pread64', (('int', 'filedes'), ('void *', 'buffer'), ('size_t', 'size'), ('off64_t', 'offset'))),
    '*.preadv': ('ssize_t', None, 'cdecl', '*.preadv', (('int', 'fd'), ('const struct iovec *', 'iov'), ('int', 'iovcnt'), ('off_t', 'offset'))),
    '*.preadv2': ('ssize_t', None, 'cdecl', '*.preadv2', (('int', 'fd'), ('const struct iovec *', 'iov'), ('int', 'iovcnt'), ('off_t', 'offset'), ('int', 'flags'))),
    '*.preadv64': ('ssize_t', None, 'cdecl', '*.preadv64', (('int', 'fd'), ('const struct iovec *', 'iov'), ('int', 'iovcnt'), ('off64_t', 'offset'))),
    '*.preadv64v2': ('ssize_t', None, 'cdecl', '*.preadv64v2', (('int', 'fd'), ('const struct iovec *', 'iov'), ('int', 'iovcnt'), ('off64_t', 'offset'), ('int', 'flags'))),
    '*.printf': ('int', None, 'cdecl', '*.printf', (('const char *', 'template'), ('variadic', ''))),
    '*.printf_size': ('int', None, 'cdecl', '*.printf_size', (('FILE *', 'fp'), ('const struct printf_info *', 'info'), ('const void * const *', 'args'))),
    '*.printf_size_info': ('int', None, 'cdecl', '*.printf_size_info', (('const struct printf_info *', 'info'), ('size_t', 'n'), ('int *', 'argtypes'))),
    '*.psignal': ('void', None, 'cdecl', '*.psignal', (('int', 'signum'), ('const char *', 'message'))),
    '*.pthread_attr_getsigmask_np': ('int', None, 'cdecl', '*.pthread_attr_getsigmask_np', (('const pthread_attr_t *', 'attr'), ('sigset_t *', 'sigmask'))),
    '*.pthread_attr_setsigmask_np': ('int', None, 'cdecl', '*.pthread_attr_setsigmask_np', (('pthread_attr_t *', 'attr'), ('const sigset_t *', 'sigmask'))),
    '*.pthread_clockjoin_np': ('int', None, 'cdecl', '*.pthread_clockjoin_np', (('pthread_t *', 'thread'),('void **', 'thread_return'), ('clockid_t', 'clockid'), ('const struct timespec *', 'abstime'))),
    '*.pthread_cond_clockwait': ('int', None, 'cdecl', '*.pthread_cond_clockwait', (('pthread_cond_t *', 'cond'), ('pthread_mutex_t *', 'mutex'), ('clockid_t', 'clockid'), ('const struct timespec *', 'abstime'))),
    '*.pthread_getattr_default_np': ('int', None, 'cdecl', '*.pthread_getattr_default_np', (('pthread_attr_t *', 'attr'),)),
    '*.pthread_getspecific': ('void *', None, 'cdecl', '*.pthread_getspecific', (('pthread_key_t', 'key'),)),
    '*.pthread_key_create': ('int', None, 'cdecl', '*.pthread_key_create', (('pthread_key_t *', 'key'), ('void (*', 'destructor(void*'))),
    '*.pthread_key_delete': ('int', None, 'cdecl', '*.pthread_key_delete', (('pthread_key_t', 'key'),)),
    '*.pthread_rwlock_clockrdlock': ('int', None, 'cdecl', '*.pthread_rwlock_clockrdlock', (('pthread_rwlock_t *', 'rwlock'), ('clockid_t', 'clockid'), ('const struct timespec *', 'abstime'),)),
    '*.pthread_rwlock_clockwrlock': ('int', None, 'cdecl', '*.pthread_rwlock_clockwrlock', (('pthread_rwlock_t *', 'rwlock'), ('clockid_t', 'clockid'), ('const struct timespec *', 'abstime'),)),
    '*.pthread_setattr_default_np': ('int', None, 'cdecl', '*.pthread_setattr_default_np', (('pthread_attr_t *', 'attr'),)),
    '*.pthread_setspecific': ('int', None, 'cdecl', '*.pthread_setspecific', (('pthread_key_t', 'key'), ('const void *', 'value'))),
    '*.pthread_timedjoin_np': ('int', None, 'cdecl', '*.pthread_timedjoin_np', (('pthread_t *', 'thread'),('void **', 'thread_return'), ('const struct timespec *', 'abstime'))),
    '*.pthread_tryjoin_np': ('int', None, 'cdecl', '*.pthread_tryjoin_np', (('pthread_t *', 'thread'),('void **', 'thread_return'))),
    '*.ptsname': ('char *', None, 'cdecl', '*.ptsname', (('int', 'filedes'),)),
    '*.ptsname_r': ('int', None, 'cdecl', '*.ptsname_r', (('int', 'filedes'), ('char *', 'buf'), ('size_t', 'len'))),
    '*.putc': ('int', None, 'cdecl', '*.putc', (('int', 'c'), ('FILE *', 'stream'))),
    '*.putc_unlocked': ('int', None, 'cdecl', '*.putc_unlocked', (('int', 'c'), ('FILE *', 'stream'))),
    '*.putchar': ('int', None, 'cdecl', '*.putchar', (('int', 'c'),)),
    '*.putchar_unlocked': ('int', None, 'cdecl', '*.putchar_unlocked', (('int', 'c'),)),
    '*.putenv': ('int', None, 'cdecl', '*.putenv', (('char *', 'string'),)),
    '*.putpwent': ('int', None, 'cdecl', '*.putpwent', (('const struct passwd *', 'p'), ('FILE *', 'stream'))),
    '*.puts': ('int', None, 'cdecl', '*.puts', (('const char *', 's'),)),
    '*.pututline': ('struct utmp *', None, 'cdecl', '*.pututline', (('const struct utmp *', 'utmp'),)),
    '*.pututxline': ('struct utmpx *', None, 'cdecl', '*.pututxline', (('const struct utmpx *', 'utmp'),)),
    '*.putw': ('int', None, 'cdecl', '*.putw', (('int', 'w'), ('FILE *', 'stream'))),
    '*.putwc': ('wint_t', None, 'cdecl', '*.putwc', (('wchar_t', 'wc'), ('FILE *', 'stream'))),
    '*.putwc_unlocked': ('wint_t', None, 'cdecl', '*.putwc_unlocked', (('wchar_t', 'wc'), ('FILE *', 'stream'))),
    '*.putwchar': ('wint_t', None, 'cdecl', '*.putwchar', (('wchar_t', 'wc'),)),
    '*.putwchar_unlocked': ('wint_t', None, 'cdecl', '*.putwchar_unlocked', (('wchar_t', 'wc'),)),
    '*.pwrite': ('ssize_t', None, 'cdecl', '*.pwrite', (('int', 'filedes'), ('const void *', 'buffer'), ('size_t', 'size'), ('off_t', 'offset'))),
    '*.pwrite64': ('ssize_t', None, 'cdecl', '*.pwrite64', (('int', 'filedes'), ('const void *', 'buffer'), ('size_t', 'size'), ('off64_t', 'offset'))),
    '*.pwritev': ('ssize_t', None, 'cdecl', '*.pwritev', (('int', 'fd'), ('const struct iovec *', 'iov'), ('int', 'iovcnt'), ('off_t', 'offset'))),
    '*.pwritev2': ('ssize_t', None, 'cdecl', '*.pwritev2', (('int', 'fd'), ('const struct iovec *', 'iov'), ('int', 'iovcnt'), ('off_t', 'offset'), ('int', 'flags'))),
    '*.pwritev64': ('ssize_t', None, 'cdecl', '*.pwritev64', (('int', 'fd'), ('const struct iovec *', 'iov'), ('int', 'iovcnt'), ('off64_t', 'offset'))),
    '*.pwritev64v2': ('ssize_t', None, 'cdecl', '*.pwritev64v2', (('int', 'fd'), ('const struct iovec *', 'iov'), ('int', 'iovcnt'), ('off64_t', 'offset'), ('int', 'flags'))),
    '*.qecvt': ('char *', None, 'cdecl', '*.qecvt', (('long double', 'value'), ('int', 'ndigit'), ('int *', 'decpt'), ('int *', 'neg'))),
    '*.qecvt_r': ('int', None, 'cdecl', '*.qecvt_r', (('long double', 'value'), ('int', 'ndigit'), ('int *', 'decpt'), ('int *', 'neg'), ('char *', 'buf'), ('size_t', 'len'))),
    '*.qfcvt': ('char *', None, 'cdecl', '*.qfcvt', (('long double', 'value'), ('int', 'ndigit'), ('int *', 'decpt'), ('int *', 'neg'))),
    '*.qfcvt_r': ('int', None, 'cdecl', '*.qfcvt_r', (('long double', 'value'), ('int', 'ndigit'), ('int *', 'decpt'), ('int *', 'neg'), ('char *', 'buf'), ('size_t', 'len'))),
    '*.qgcvt': ('char *', None, 'cdecl', '*.qgcvt', (('long double', 'value'), ('int', 'ndigit'), ('char *', 'buf'))),
    '*.qsort': ('void', None, 'cdecl', '*.qsort', (('void *', 'array'), ('size_t', 'count'), ('size_t', 'size'), ('comparison_fn_t', 'compare'))),
    '*.raise': ('int', None, 'cdecl', '*.raise', (('int', 'signum'),)),
    '*.rand': ('int', None, 'cdecl', '*.rand', ()),
    '*.rand_r': ('int', None, 'cdecl', '*.rand_r', (('unsigned int *', 'seed'),)),
    '*.random': ('long int', None, 'cdecl', '*.random', ()),
    '*.random_r': ('int', None, 'cdecl', '*.random_r', (('struct random_data * restrict', 'buf'), ('int32_t * restrict', 'result'))),
    '*.rawmemchr': ('void *', None, 'cdecl', '*.rawmemchr', (('const void *', 'block'), ('int', 'c'))),
    '*.read': ('ssize_t', None, 'cdecl', '*.read', (('int', 'filedes'), ('void *', 'buffer'), ('size_t', 'size'))),
    '*.readdir': ('struct dirent *', None, 'cdecl', '*.readdir', (('DIR *', 'dirstream'),)),
    '*.readdir64': ('struct dirent64 *', None, 'cdecl', '*.readdir64', (('DIR *', 'dirstream'),)),
    '*.readdir64_r': ('int', None, 'cdecl', '*.readdir64_r', (('DIR *', 'dirstream'), ('struct dirent64 *', 'entry'), ('struct dirent64 * *', 'result'))),
    '*.readdir_r': ('int', None, 'cdecl', '*.readdir_r', (('DIR *', 'dirstream'), ('struct dirent *', 'entry'), ('struct dirent * *', 'result'))),
    '*.readlink': ('ssize_t', None, 'cdecl', '*.readlink', (('const char *', 'filename'), ('char *', 'buffer'), ('size_t', 'size'))),
    '*.readv': ('ssize_t', None, 'cdecl', '*.readv', (('int', 'filedes'), ('const struct iovec *', 'vector'), ('int', 'count'))),
    '*.__read_chk': ('ssize_t', None, 'cdecl', '*.__read_chk', (('int', 'filedes'), ('void *', 'buffer'), ('size_t', 'nbytes'), ('size_t', 'buflen'))),
    '*.realloc': ('void *', None, 'cdecl', '*.realloc', (('void *', 'ptr'), ('size_t', 'newsize'))),
    '*.reallocarray': ('void *', None, 'cdecl', '*.reallocarray', (('void *', 'ptr'), ('size_t', 'nmemb'), ('size_t', 'size'))),
    '*.realpath': ('char *', None, 'cdecl', '*.realpath', (('const char * restrict', 'name'), ('char * restrict', 'resolved'))),
    '*.recv': ('ssize_t', None, 'cdecl', '*.recv', (('int', 'socket'), ('void *', 'buffer'), ('size_t', 'size'), ('int', 'flags'))),
    '*.recvfrom': ('ssize_t', None, 'cdecl', '*.recvfrom', (('int', 'socket'), ('void *', 'buffer'), ('size_t', 'size'), ('int', 'flags'), ('struct sockaddr *', 'addr'), ('socklen_t *', 'length-ptr'))),
    '*.regcomp': ('int', None, 'cdecl', '*.regcomp', (('regex_t * restrict', 'compiled'), ('const char * restrict', 'pattern'), ('int', 'cflags'))),
    '*.regerror': ('size_t', None, 'cdecl', '*.regerror', (('int', 'errcode'), ('const regex_t * restrict', 'compiled'), ('char * restrict', 'buffer'), ('size_t', 'length'))),
    '*.regexec': ('int', None, 'cdecl', '*.regexec', (('const regex_t * restrict', 'compiled'), ('const char * restrict', 'string'), ('size_t', 'nmatch'), ('regmatch_t', 'matchptr[restrict]'), ('int', 'eflags'))),
    '*.regfree': ('void', None, 'cdecl', '*.regfree', (('regex_t *', 'compiled'),)),
    '*.register_printf_function': ('int', None, 'cdecl', '*.register_printf_function', (('int', 'spec'), ('printf_function', 'handler-function'), ('printf_arginfo_function', 'arginfo-function'))),
    '*.remainder': ('double', None, 'cdecl', '*.remainder', (('double', 'numerator'), ('double', 'denominator'))),
    '*.remainderf': ('float', None, 'cdecl', '*.remainderf', (('float', 'numerator'), ('float', 'denominator'))),
    '*.remainderfN': ('_FloatN', None, 'cdecl', '*.remainderfN', (('_FloatN', 'numerator'), ('_FloatN', 'denominator'))),
    '*.remainderfNx': ('_FloatNx', None, 'cdecl', '*.remainderfNx', (('_FloatNx', 'numerator'), ('_FloatNx', 'denominator'))),
    '*.remainderl': ('long double', None, 'cdecl', '*.remainderl', (('long double', 'numerator'), ('long double', 'denominator'))),
    '*.remove': ('int', None, 'cdecl', '*.remove', (('const char *', 'filename'),)),
    '*.rename': ('int', None, 'cdecl', '*.rename', (('const char *', 'oldname'), ('const char *', 'newname'))),
    '*.rewind': ('void', None, 'cdecl', '*.rewind', (('FILE *', 'stream'),)),
    '*.rewinddir': ('void', None, 'cdecl', '*.rewinddir', (('DIR *', 'dirstream'),)),
    '*.rindex': ('char *', None, 'cdecl', '*.rindex', (('const char *', 'string'), ('int', 'c'))),
    '*.rint': ('double', None, 'cdecl', '*.rint', (('double', 'x'),)),
    '*.rintf': ('float', None, 'cdecl', '*.rintf', (('float', 'x'),)),
    '*.rintfN': ('_FloatN', None, 'cdecl', '*.rintfN', (('_FloatN', 'x'),)),
    '*.rintfNx': ('_FloatNx', None, 'cdecl', '*.rintfNx', (('_FloatNx', 'x'),)),
    '*.rintl': ('long double', None, 'cdecl', '*.rintl', (('long double', 'x'),)),
    '*.rmdir': ('int', None, 'cdecl', '*.rmdir', (('const char *', 'filename'),)),
    '*.round': ('double', None, 'cdecl', '*.round', (('double', 'x'),)),
    '*.roundeven': ('double', None, 'cdecl', '*.roundeven', (('double', 'x'),)),
    '*.roundevenf': ('float', None, 'cdecl', '*.roundevenf', (('float', 'x'),)),
    '*.roundevenfN': ('_FloatN', None, 'cdecl', '*.roundevenfN', (('_FloatN', 'x'),)),
    '*.roundevenfNx': ('_FloatNx', None, 'cdecl', '*.roundevenfNx', (('_FloatNx', 'x'),)),
    '*.roundevenl': ('long double', None, 'cdecl', '*.roundevenl', (('long double', 'x'),)),
    '*.roundf': ('float', None, 'cdecl', '*.roundf', (('float', 'x'),)),
    '*.roundfN': ('_FloatN', None, 'cdecl', '*.roundfN', (('_FloatN', 'x'),)),
    '*.roundfNx': ('_FloatNx', None, 'cdecl', '*.roundfNx', (('_FloatNx', 'x'),)),
    '*.roundl': ('long double', None, 'cdecl', '*.roundl', (('long double', 'x'),)),
    '*.rpmatch': ('int', None, 'cdecl', '*.rpmatch', (('const char *', 'response'),)),
    '*.sbrk': ('void *', None, 'cdecl', '*.sbrk', (('ptrdiff_t', 'delta'),)),
    '*.scalb': ('double', None, 'cdecl', '*.scalb', (('double', 'value'), ('double', 'exponent'))),
    '*.scalbf': ('float', None, 'cdecl', '*.scalbf', (('float', 'value'), ('float', 'exponent'))),
    '*.scalbl': ('long double', None, 'cdecl', '*.scalbl', (('long double', 'value'), ('long double', 'exponent'))),
    '*.scalbln': ('double', None, 'cdecl', '*.scalbln', (('double', 'x'), ('long int', 'n'))),
    '*.scalblnf': ('float', None, 'cdecl', '*.scalblnf', (('float', 'x'), ('long int', 'n'))),
    '*.scalblnfN': ('_FloatN', None, 'cdecl', '*.scalblnfN', (('_FloatN', 'x'), ('long int', 'n'))),
    '*.scalblnfNx': ('_FloatNx', None, 'cdecl', '*.scalblnfNx', (('_FloatNx', 'x'), ('long int', 'n'))),
    '*.scalblnl': ('long double', None, 'cdecl', '*.scalblnl', (('long double', 'x'), ('long int', 'n'))),
    '*.scalbn': ('double', None, 'cdecl', '*.scalbn', (('double', 'x'), ('int', 'n'))),
    '*.scalbnf': ('float', None, 'cdecl', '*.scalbnf', (('float', 'x'), ('int', 'n'))),
    '*.scalbnfN': ('_FloatN', None, 'cdecl', '*.scalbnfN', (('_FloatN', 'x'), ('int', 'n'))),
    '*.scalbnfNx': ('_FloatNx', None, 'cdecl', '*.scalbnfNx', (('_FloatNx', 'x'), ('int', 'n'))),
    '*.scalbnl': ('long double', None, 'cdecl', '*.scalbnl', (('long double', 'x'), ('int', 'n'))),
    '*.scandir': ('int', None, 'cdecl', '*.scandir', (('const char *', 'dir'), ('struct dirent * * *', 'namelist'), ('int (* selector (const struct dirent', '*'), ('int (* cmp (const struct dirent *', '*'), ('const struct dirent *', '*'))),
    '*.scandir64': ('int', None, 'cdecl', '*.scandir64', (('const char *', 'dir'), ('struct dirent64 * * *', 'namelist'), ('int (* selector (const struct dirent64', '*'), ('int (* cmp (const struct dirent64 *', '*'), ('const struct dirent64 *', '*'))),
    '*.scanf': ('int', None, 'cdecl', '*.scanf', (('const char *', 'template'), ('variadic', ''))),
    '*.sched_get_priority_max': ('int', None, 'cdecl', '*.sched_get_priority_max', (('int', 'policy'),)),
    '*.sched_get_priority_min': ('int', None, 'cdecl', '*.sched_get_priority_min', (('int', 'policy'),)),
    '*.sched_getaffinity': ('int', None, 'cdecl', '*.sched_getaffinity', (('pid_t', 'pid'), ('size_t', 'cpusetsize'), ('cpu_set_t *', 'cpuset'))),
    '*.sched_getparam': ('int', None, 'cdecl', '*.sched_getparam', (('pid_t', 'pid'), ('struct sched_param *', 'param'))),
    '*.sched_getscheduler': ('int', None, 'cdecl', '*.sched_getscheduler', (('pid_t', 'pid'),)),
    '*.sched_rr_get_interval': ('int', None, 'cdecl', '*.sched_rr_get_interval', (('pid_t', 'pid'), ('struct timespec *', 'interval'))),
    '*.sched_setaffinity': ('int', None, 'cdecl', '*.sched_setaffinity', (('pid_t', 'pid'), ('size_t', 'cpusetsize'), ('const cpu_set_t *', 'cpuset'))),
    '*.sched_setparam': ('int', None, 'cdecl', '*.sched_setparam', (('pid_t', 'pid'), ('const struct sched_param *', 'param'))),
    '*.sched_setscheduler': ('int', None, 'cdecl', '*.sched_setscheduler', (('pid_t', 'pid'), ('int', 'policy'), ('const struct sched_param *', 'param'))),
    '*.sched_yield': ('int', None, 'cdecl', '*.sched_yield', ()),
    '*.secure_getenv': ('char *', None, 'cdecl', '*.secure_getenv', (('const char *', 'name'),)),
    '*.seed48': ('unsigned short int *', None, 'cdecl', '*.seed48', (('unsigned short int', 'seed16v[3]'),)),
    '*.seed48_r': ('int', None, 'cdecl', '*.seed48_r', (('unsigned short int', 'seed16v[3]'), ('struct drand48_data *', 'buffer'))),
    '*.seekdir': ('void', None, 'cdecl', '*.seekdir', (('DIR *', 'dirstream'), ('long int', 'pos'))),
    '*.select': ('int', None, 'cdecl', '*.select', (('int', 'nfds'), ('fd_set *', 'read-fds'), ('fd_set *', 'write-fds'), ('fd_set *', 'except-fds'), ('struct timeval *', 'timeout'))),
    '*.sem_clockwait': ('int', None, 'cdecl', '*.sem_clockwait', (('sem_t *', 'sem'), ('clockid_t', 'clockid'), ('const struct timespec *', 'abstime'))),
    '*.sem_close': ('int', None, 'cdecl', '*.sem_close', (('sem_t *', 'sem'),)),
    '*.sem_destroy': ('int', None, 'cdecl', '*.sem_destroy', (('sem_t *', 'sem'),)),
    '*.sem_getvalue': ('int', None, 'cdecl', '*.sem_getvalue', (('sem_t *', 'sem'), ('int *', 'sval'))),
    '*.sem_init': ('int', None, 'cdecl', '*.sem_init', (('sem_t *', 'sem'), ('int', 'pshared'), ('unsigned int', 'value'))),
    '*.sem_open': ('sem_t *', None, 'cdecl', '*.sem_open', (('const char *', 'name'), ('int', 'oflag'), ('variadic', ''))),
    '*.sem_post': ('int', None, 'cdecl', '*.sem_post', (('sem_t *', 'sem'),)),
    '*.sem_timedwait': ('int', None, 'cdecl', '*.sem_timedwait', (('sem_t *', 'sem'), ('const struct timespec *', 'abstime'))),
    '*.sem_trywait': ('int', None, 'cdecl', '*.sem_trywait', (('sem_t *', 'sem'),)),
    '*.sem_unlink': ('int', None, 'cdecl', '*.sem_unlink', (('const char *', 'name'),)),
    '*.sem_wait': ('int', None, 'cdecl', '*.sem_wait', (('sem_t *', 'sem'),)),
    '*.semctl': ('int', None, 'cdecl', '*.semctl', (('int', 'semid'), ('int', 'semnum'), ('int', 'cmd'))),
    '*.semget': ('int', None, 'cdecl', '*.semget', (('key_t', 'key'), ('int', 'nsems'), ('int', 'semflg'))),
    '*.semop': ('int', None, 'cdecl', '*.semop', (('int', 'semid'), ('struct sembuf *', 'sops'), ('size_t', 'nsops'))),
    '*.semtimedop': ('int', None, 'cdecl', '*.semtimedop', (('int', 'semid'), ('struct sembuf *', 'sops'), ('size_t', 'nsops'), ('const struct timespec *', 'timeout'))),
    '*.send': ('ssize_t', None, 'cdecl', '*.send', (('int', 'socket'), ('const void *', 'buffer'), ('size_t', 'size'), ('int', 'flags'))),
    '*.sendto': ('ssize_t', None, 'cdecl', '*.sendto', (('int', 'socket'), ('const void *', 'buffer'), ('size_t', 'size'), ('int', 'flags'), ('struct sockaddr *', 'addr'), ('socklen_t', 'length'))),
    '*.setbuf': ('void', None, 'cdecl', '*.setbuf', (('FILE *', 'stream'), ('char *', 'buf'))),
    '*.setbuffer': ('void', None, 'cdecl', '*.setbuffer', (('FILE *', 'stream'), ('char *', 'buf'), ('size_t', 'size'))),
    '*.setcontext': ('int', None, 'cdecl', '*.setcontext', (('const ucontext_t *', 'ucp'),)),
    '*.setdomainname': ('int', None, 'cdecl', '*.setdomainname', (('const char *', 'name'), ('size_t', 'length'))),
    '*.setegid': ('int', None, 'cdecl', '*.setegid', (('gid_t', 'newgid'),)),
    '*.setenv': ('int', None, 'cdecl', '*.setenv', (('const char *', 'name'), ('const char *', 'value'), ('int', 'replace'))),
    '*.seteuid': ('int', None, 'cdecl', '*.seteuid', (('uid_t', 'neweuid'),)),
    '*.setfsent': ('int', None, 'cdecl', '*.setfsent', ()),
    '*.setgid': ('int', None, 'cdecl', '*.setgid', (('gid_t', 'newgid'),)),
    '*.setgrent': ('void', None, 'cdecl', '*.setgrent', ()),
    '*.setgroups': ('int', None, 'cdecl', '*.setgroups', (('size_t', 'count'), ('const gid_t *', 'groups'))),
    '*.sethostent': ('void', None, 'cdecl', '*.sethostent', (('int', 'stayopen'),)),
    '*.sethostid': ('int', None, 'cdecl', '*.sethostid', (('long int', 'id'),)),
    '*.sethostname': ('int', None, 'cdecl', '*.sethostname', (('const char *', 'name'), ('size_t', 'length'))),
    '*.setitimer': ('int', None, 'cdecl', '*.setitimer', (('int', 'which'), ('const struct itimerval *', 'new'), ('struct itimerval *', 'old'))),
    '*.setlinebuf': ('void', None, 'cdecl', '*.setlinebuf', (('FILE *', 'stream'),)),
    '*.setlocale': ('char *', None, 'cdecl', '*.setlocale', (('int', 'category'), ('const char *', 'locale'))),
    '*.setlogmask': ('int', None, 'cdecl', '*.setlogmask', (('int', 'mask'),)),
    '*.setmntent': ('FILE *', None, 'cdecl', '*.setmntent', (('const char *', 'file'), ('const char *', 'mode'))),
    '*.setnetent': ('void', None, 'cdecl', '*.setnetent', (('int', 'stayopen'),)),
    '*.setnetgrent': ('int', None, 'cdecl', '*.setnetgrent', (('const char *', 'netgroup'),)),
    '*.setpayload': ('int', None, 'cdecl', '*.setpayload', (('double *', 'x'), ('double', 'payload'))),
    '*.setpayloadf': ('int', None, 'cdecl', '*.setpayloadf', (('float *', 'x'), ('float', 'payload'))),
    '*.setpayloadfN': ('int', None, 'cdecl', '*.setpayloadfN', (('_FloatN *', 'x'), ('_FloatN', 'payload'))),
    '*.setpayloadfNx': ('int', None, 'cdecl', '*.setpayloadfNx', (('_FloatNx *', 'x'), ('_FloatNx', 'payload'))),
    '*.setpayloadl': ('int', None, 'cdecl', '*.setpayloadl', (('long double *', 'x'), ('long double', 'payload'))),
    '*.setpayloadsig': ('int', None, 'cdecl', '*.setpayloadsig', (('double *', 'x'), ('double', 'payload'))),
    '*.setpayloadsigf': ('int', None, 'cdecl', '*.setpayloadsigf', (('float *', 'x'), ('float', 'payload'))),
    '*.setpayloadsigfN': ('int', None, 'cdecl', '*.setpayloadsigfN', (('_FloatN *', 'x'), ('_FloatN', 'payload'))),
    '*.setpayloadsigfNx': ('int', None, 'cdecl', '*.setpayloadsigfNx', (('_FloatNx *', 'x'), ('_FloatNx', 'payload'))),
    '*.setpayloadsigl': ('int', None, 'cdecl', '*.setpayloadsigl', (('long double *', 'x'), ('long double', 'payload'))),
    '*.setpgid': ('int', None, 'cdecl', '*.setpgid', (('pid_t', 'pid'), ('pid_t', 'pgid'))),
    '*.setpgrp': ('int', None, 'cdecl', '*.setpgrp', (('pid_t', 'pid'), ('pid_t', 'pgid'))),
    '*.setpriority': ('int', None, 'cdecl', '*.setpriority', (('int', 'class'), ('int', 'id'), ('int', 'niceval'))),
    '*.setprotoent': ('void', None, 'cdecl', '*.setprotoent', (('int', 'stayopen'),)),
    '*.setpwent': ('void', None, 'cdecl', '*.setpwent', ()),
    '*.setregid': ('int', None, 'cdecl', '*.setregid', (('gid_t', 'rgid'), ('gid_t', 'egid'))),
    '*.setreuid': ('int', None, 'cdecl', '*.setreuid', (('uid_t', 'ruid'), ('uid_t', 'euid'))),
    '*.setrlimit': ('int', None, 'cdecl', '*.setrlimit', (('int', 'resource'), ('const struct rlimit *', 'rlp'))),
    '*.setrlimit64': ('int', None, 'cdecl', '*.setrlimit64', (('int', 'resource'), ('const struct rlimit64 *', 'rlp'))),
    '*.setservent': ('void', None, 'cdecl', '*.setservent', (('int', 'stayopen'),)),
    '*.setsid': ('pid_t', None, 'cdecl', '*.setsid', ()),
    '*.setsockopt': ('int', None, 'cdecl', '*.setsockopt', (('int', 'socket'), ('int', 'level'), ('int', 'optname'), ('const void *', 'optval'), ('socklen_t', 'optlen'))),
    '*.setstate': ('char *', None, 'cdecl', '*.setstate', (('char *', 'state'),)),
    '*.setstate_r': ('int', None, 'cdecl', '*.setstate_r', (('char * restrict', 'statebuf'), ('struct random_data * restrict', 'buf'))),
    '*.settimeofday': ('int', None, 'cdecl', '*.settimeofday', (('const struct timeval *', 'tp'), ('const void *', 'tzp'))),
    '*.setuid': ('int', None, 'cdecl', '*.setuid', (('uid_t', 'newuid'),)),
    '*.setutent': ('void', None, 'cdecl', '*.setutent', ()),
    '*.setutxent': ('void', None, 'cdecl', '*.setutxent', ()),
    '*.setvbuf': ('int', None, 'cdecl', '*.setvbuf', (('FILE *', 'stream'), ('char *', 'buf'), ('int', 'mode'), ('size_t', 'size'))),
    '*.shm_open': ('int', None, 'cdecl', '*.shm_open', (('const char *', 'name'), ('int', 'oflag'), ('mode_t', 'mode'))),
    '*.shm_unlink': ('int', None, 'cdecl', '*.shm_unlink', (('const char *', 'name'),)),
    '*.shutdown': ('int', None, 'cdecl', '*.shutdown', (('int', 'socket'), ('int', 'how'))),
    '*.sigabbrev_np': ('void', None, 'cdecl', '*.sigabbrev_np', (('int', 'signum'),)),
    '*.sigaction': ('int', None, 'cdecl', '*.sigaction', (('int', 'signum'), ('const struct sigaction * restrict', 'action'), ('struct sigaction * restrict', 'old-action'))),
    '*.sigaddset': ('int', None, 'cdecl', '*.sigaddset', (('sigset_t *', 'set'), ('int', 'signum'))),
    '*.sigaltstack': ('int', None, 'cdecl', '*.sigaltstack', (('const stack_t * restrict', 'stack'), ('stack_t * restrict', 'oldstack'))),
    '*.sigblock': ('int', None, 'cdecl', '*.sigblock', (('int', 'mask'),)),
    '*.sigdelset': ('int', None, 'cdecl', '*.sigdelset', (('sigset_t *', 'set'), ('int', 'signum'))),
    '*.sigdescr_np': ('void', None, 'cdecl', '*.sigdescr_np', (('int', 'signum'),)),
    '*.sigemptyset': ('int', None, 'cdecl', '*.sigemptyset', (('sigset_t *', 'set'),)),
    '*.sigfillset': ('int', None, 'cdecl', '*.sigfillset', (('sigset_t *', 'set'),)),
    '*.siginterrupt': ('int', None, 'cdecl', '*.siginterrupt', (('int', 'signum'), ('int', 'failflag'))),
    '*.sigismember': ('int', None, 'cdecl', '*.sigismember', (('const sigset_t *', 'set'), ('int', 'signum'))),
    '*.siglongjmp': ('void', None, 'cdecl', '*.siglongjmp', (('sigjmp_buf', 'state'), ('int', 'value'))),
    '*.signal': ('sighandler_t', None, 'cdecl', '*.signal', (('int', 'signum'), ('sighandler_t', 'action'))),
    '*.signbit': ('int', None, 'cdecl', '*.signbit', (('float-type', 'x'),)),
    '*.significand': ('double', None, 'cdecl', '*.significand', (('double', 'x'),)),
    '*.significandf': ('float', None, 'cdecl', '*.significandf', (('float', 'x'),)),
    '*.significandl': ('long double', None, 'cdecl', '*.significandl', (('long double', 'x'),)),
    '*.sigpause': ('int', None, 'cdecl', '*.sigpause', (('int', 'mask'),)),
    '*.sigpending': ('int', None, 'cdecl', '*.sigpending', (('sigset_t *', 'set'),)),
    '*.sigprocmask': ('int', None, 'cdecl', '*.sigprocmask', (('int', 'how'), ('const sigset_t * restrict', 'set'), ('sigset_t * restrict', 'oldset'))),
    '*.sigsetjmp': ('int', None, 'cdecl', '*.sigsetjmp', (('sigjmp_buf', 'state'), ('int', 'savesigs'))),
    '*.sigsetmask': ('int', None, 'cdecl', '*.sigsetmask', (('int', 'mask'),)),
    '*.sigstack': ('int', None, 'cdecl', '*.sigstack', (('struct sigstack *', 'stack'), ('struct sigstack *', 'oldstack'))),
    '*.sigsuspend': ('int', None, 'cdecl', '*.sigsuspend', (('const sigset_t *', 'set'),)),
    '*.sin': ('double', None, 'cdecl', '*.sin', (('double', 'x'),)),
    '*.sincos': ('void', None, 'cdecl', '*.sincos', (('double', 'x'), ('double *', 'sinx'), ('double *', 'cosx'))),
    '*.sincosf': ('void', None, 'cdecl', '*.sincosf', (('float', 'x'), ('float *', 'sinx'), ('float *', 'cosx'))),
    '*.sincosfN': ('_FloatN', None, 'cdecl', '*.sincosfN', (('_FloatN', 'x'), ('_FloatN *', 'sinx'), ('_FloatN *', 'cosx'))),
    '*.sincosfNx': ('_FloatNx', None, 'cdecl', '*.sincosfNx', (('_FloatNx', 'x'), ('_FloatNx *', 'sinx'), ('_FloatNx *', 'cosx'))),
    '*.sincosl': ('void', None, 'cdecl', '*.sincosl', (('long double', 'x'), ('long double *', 'sinx'), ('long double *', 'cosx'))),
    '*.sinf': ('float', None, 'cdecl', '*.sinf', (('float', 'x'),)),
    '*.sinfN': ('_FloatN', None, 'cdecl', '*.sinfN', (('_FloatN', 'x'),)),
    '*.sinfNx': ('_FloatNx', None, 'cdecl', '*.sinfNx', (('_FloatNx', 'x'),)),
    '*.sinh': ('double', None, 'cdecl', '*.sinh', (('double', 'x'),)),
    '*.sinhf': ('float', None, 'cdecl', '*.sinhf', (('float', 'x'),)),
    '*.sinhfN': ('_FloatN', None, 'cdecl', '*.sinhfN', (('_FloatN', 'x'),)),
    '*.sinhfNx': ('_FloatNx', None, 'cdecl', '*.sinhfNx', (('_FloatNx', 'x'),)),
    '*.sinhl': ('long double', None, 'cdecl', '*.sinhl', (('long double', 'x'),)),
    '*.sinl': ('long double', None, 'cdecl', '*.sinl', (('long double', 'x'),)),
    '*.sleep': ('unsigned int', None, 'cdecl', '*.sleep', (('unsigned int', 'seconds'),)),
    '*.snprintf': ('int', None, 'cdecl', '*.snprintf', (('char *', 's'), ('size_t', 'size'), ('const char *', 'template'), ('variadic', ''))),
    '*.socket': ('int', None, 'cdecl', '*.socket', (('int', 'namespace'), ('int', 'style'), ('int', 'protocol'))),
    '*.socketpair': ('int', None, 'cdecl', '*.socketpair', (('int', 'namespace'), ('int', 'style'), ('int', 'protocol'), ('int', 'filedes[2]'))),
    '*.sprintf': ('int', None, 'cdecl', '*.sprintf', (('char *', 's'), ('const char *', 'template'), ('variadic', ''))),
    '*.sqrt': ('double', None, 'cdecl', '*.sqrt', (('double', 'x'),)),
    '*.sqrtf': ('float', None, 'cdecl', '*.sqrtf', (('float', 'x'),)),
    '*.sqrtfN': ('_FloatN', None, 'cdecl', '*.sqrtfN', (('_FloatN', 'x'),)),
    '*.sqrtfNx': ('_FloatNx', None, 'cdecl', '*.sqrtfNx', (('_FloatNx', 'x'),)),
    '*.sqrtl': ('long double', None, 'cdecl', '*.sqrtl', (('long double', 'x'),)),
    '*.srand': ('void', None, 'cdecl', '*.srand', (('unsigned int', 'seed'),)),
    '*.srand48': ('void', None, 'cdecl', '*.srand48', (('long int', 'seedval'),)),
    '*.srand48_r': ('int', None, 'cdecl', '*.srand48_r', (('long int', 'seedval'), ('struct drand48_data *', 'buffer'))),
    '*.srandom': ('void', None, 'cdecl', '*.srandom', (('unsigned int', 'seed'),)),
    '*.srandom_r': ('int', None, 'cdecl', '*.srandom_r', (('unsigned int', 'seed'), ('struct random_data *', 'buf'))),
    '*.sscanf': ('int', None, 'cdecl', '*.sscanf', (('const char *', 's'), ('const char *', 'template'), ('variadic', ''))),
    '*.ssignal': ('sighandler_t', None, 'cdecl', '*.ssignal', (('int', 'signum'), ('sighandler_t', 'action'))),
    '*.stat': ('int', None, 'cdecl', '*.stat', (('const char *', 'filename'), ('struct stat *', 'buf'))),
    '*.stat64': ('int', None, 'cdecl', '*.stat64', (('const char *', 'filename'), ('struct stat64 *', 'buf'))),
    '*.stime': ('int', None, 'cdecl', '*.stime', (('const time_t *', 'newtime'),)),
    '*.stpcpy': ('char *', None, 'cdecl', '*.stpcpy', (('char * restrict', 'to'), ('const char * restrict', 'from'))),
    '*.stpncpy': ('char *', None, 'cdecl', '*.stpncpy', (('char * restrict', 'to'), ('const char * restrict', 'from'), ('size_t', 'size'))),
    '*.strcasecmp': ('int', None, 'cdecl', '*.strcasecmp', (('const char *', 's1'), ('const char *', 's2'))),
    '*.strcasestr': ('char *', None, 'cdecl', '*.strcasestr', (('const char *', 'haystack'), ('const char *', 'needle'))),
    '*.strcat': ('char *', None, 'cdecl', '*.strcat', (('char * restrict', 'to'), ('const char * restrict', 'from'))),
    '*.strchr': ('char *', None, 'cdecl', '*.strchr', (('const char *', 'string'), ('int', 'c'))),
    '*.strchrnul': ('char *', None, 'cdecl', '*.strchrnul', (('const char *', 'string'), ('int', 'c'))),
    '*.strcmp': ('int', None, 'cdecl', '*.strcmp', (('const char *', 's1'), ('const char *', 's2'))),
    '*.strcoll': ('int', None, 'cdecl', '*.strcoll', (('const char *', 's1'), ('const char *', 's2'))),
    '*.strcpy': ('char *', None, 'cdecl', '*.strcpy', (('char * restrict', 'to'), ('const char * restrict', 'from'))),
    '*.strcspn': ('size_t', None, 'cdecl', '*.strcspn', (('const char *', 'string'), ('const char *', 'stopset'))),
    '*.strdup': ('char *', None, 'cdecl', '*.strdup', (('const char *', 's'),)),
    '*.strerror': ('char *', None, 'cdecl', '*.strerror', (('int', 'errnum'),)),
    '*.strerror_r': ('char *', None, 'cdecl', '*.strerror_r', (('int', 'errnum'), ('char *', 'buf'), ('size_t', 'n'))),
    '*.strerrordesc_np': ('void', None, 'cdecl', '*.strerrordesc_np', (('int', 'errnum'),)),
    '*.strerrorname_np': ('void', None, 'cdecl', '*.strerrorname_np', (('int', 'errnum'),)),
    '*.strfmon': ('ssize_t', None, 'cdecl', '*.strfmon', (('char *', 's'), ('size_t', 'maxsize'), ('const char *', 'format'), ('variadic', ''))),
    '*.strfromd': ('int', None, 'cdecl', '*.strfromd', (('char * restrict', 'string'), ('size_t', 'size'), ('const char * restrict', 'format'), ('double', 'value'))),
    '*.strfromf': ('int', None, 'cdecl', '*.strfromf', (('char * restrict', 'string'), ('size_t', 'size'), ('const char * restrict', 'format'), ('float', 'value'))),
    '*.strfromfN': ('int', None, 'cdecl', '*.strfromfN', (('char * restrict', 'string'), ('size_t', 'size'), ('const char * restrict', 'format'), ('_FloatN', 'value'))),
    '*.strfromfNx': ('int', None, 'cdecl', '*.strfromfNx', (('char * restrict', 'string'), ('size_t', 'size'), ('const char * restrict', 'format'), ('_FloatNx', 'value'))),
    '*.strfroml': ('int', None, 'cdecl', '*.strfroml', (('char * restrict', 'string'), ('size_t', 'size'), ('const char * restrict', 'format'), ('long double', 'value'))),
    '*.strfry': ('char *', None, 'cdecl', '*.strfry', (('char *', 'string'),)),
    '*.strftime': ('size_t', None, 'cdecl', '*.strftime', (('char *', 's'), ('size_t', 'size'), ('const char *', 'template'), ('const struct tm *', 'brokentime'))),
    '*.strlen': ('size_t', None, 'cdecl', '*.strlen', (('const char *', 's'),)),
    '*.strncasecmp': ('int', None, 'cdecl', '*.strncasecmp', (('const char *', 's1'), ('const char *', 's2'), ('size_t', 'n'))),
    '*.strncat': ('char *', None, 'cdecl', '*.strncat', (('char * restrict', 'to'), ('const char * restrict', 'from'), ('size_t', 'size'))),
    '*.strncmp': ('int', None, 'cdecl', '*.strncmp', (('const char *', 's1'), ('const char *', 's2'), ('size_t', 'size'))),
    '*.strncpy': ('char *', None, 'cdecl', '*.strncpy', (('char * restrict', 'to'), ('const char * restrict', 'from'), ('size_t', 'size'))),
    '*.strndup': ('char *', None, 'cdecl', '*.strndup', (('const char *', 's'), ('size_t', 'size'))),
    '*.strnlen': ('size_t', None, 'cdecl', '*.strnlen', (('const char *', 's'), ('size_t', 'maxlen'))),
    '*.strpbrk': ('char *', None, 'cdecl', '*.strpbrk', (('const char *', 'string'), ('const char *', 'stopset'))),
    '*.strptime': ('char *', None, 'cdecl', '*.strptime', (('const char *', 's'), ('const char *', 'fmt'), ('struct tm *', 'tp'))),
    '*.strrchr': ('char *', None, 'cdecl', '*.strrchr', (('const char *', 'string'), ('int', 'c'))),
    '*.strsep': ('char *', None, 'cdecl', '*.strsep', (('char * *', 'string_ptr'), ('const char *', 'delimiter'))),
    '*.strsignal': ('char *', None, 'cdecl', '*.strsignal', (('int', 'signum'),)),
    '*.strspn': ('size_t', None, 'cdecl', '*.strspn', (('const char *', 'string'), ('const char *', 'skipset'))),
    '*.strstr': ('char *', None, 'cdecl', '*.strstr', (('const char *', 'haystack'), ('const char *', 'needle'))),
    '*.strtod': ('double', None, 'cdecl', '*.strtod', (('const char * restrict', 'string'), ('char * * restrict', 'tailptr'))),
    '*.strtof': ('float', None, 'cdecl', '*.strtof', (('const char *', 'string'), ('char * *', 'tailptr'))),
    '*.strtofN': ('_FloatN', None, 'cdecl', '*.strtofN', (('const char *', 'string'), ('char * *', 'tailptr'))),
    '*.strtofNx': ('_FloatNx', None, 'cdecl', '*.strtofNx', (('const char *', 'string'), ('char * *', 'tailptr'))),
    '*.strtoimax': ('intmax_t', None, 'cdecl', '*.strtoimax', (('const char * restrict', 'string'), ('char * * restrict', 'tailptr'), ('int', 'base'))),
    '*.strtok': ('char *', None, 'cdecl', '*.strtok', (('char * restrict', 'newstring'), ('const char * restrict', 'delimiters'))),
    '*.strtok_r': ('char *', None, 'cdecl', '*.strtok_r', (('char *', 'newstring'), ('const char *', 'delimiters'), ('char * *', 'save_ptr'))),
    '*.strtol': ('long int', None, 'cdecl', '*.strtol', (('const char * restrict', 'string'), ('char * * restrict', 'tailptr'), ('int', 'base'))),
    '*.strtold': ('long double', None, 'cdecl', '*.strtold', (('const char *', 'string'), ('char * *', 'tailptr'))),
    '*.strtoll': ('long long int', None, 'cdecl', '*.strtoll', (('const char * restrict', 'string'), ('char * * restrict', 'tailptr'), ('int', 'base'))),
    '*.strtoq': ('long long int', None, 'cdecl', '*.strtoq', (('const char * restrict', 'string'), ('char * * restrict', 'tailptr'), ('int', 'base'))),
    '*.strtoul': ('unsigned long int', None, 'cdecl', '*.strtoul', (('const char * restrict', 'string'), ('char * * restrict', 'tailptr'), ('int', 'base'))),
    '*.strtoull': ('unsigned long long int', None, 'cdecl', '*.strtoull', (('const char * restrict', 'string'), ('char * * restrict', 'tailptr'), ('int', 'base'))),
    '*.strtoumax': ('uintmax_t', None, 'cdecl', '*.strtoumax', (('const char * restrict', 'string'), ('char * * restrict', 'tailptr'), ('int', 'base'))),
    '*.strtouq': ('unsigned long long int', None, 'cdecl', '*.strtouq', (('const char * restrict', 'string'), ('char * * restrict', 'tailptr'), ('int', 'base'))),
    '*.strverscmp': ('int', None, 'cdecl', '*.strverscmp', (('const char *', 's1'), ('const char *', 's2'))),
    '*.strxfrm': ('size_t', None, 'cdecl', '*.strxfrm', (('char * restrict', 'to'), ('const char * restrict', 'from'), ('size_t', 'size'))),
    '*.stty': ('int', None, 'cdecl', '*.stty', (('int', 'filedes'), ('const struct sgttyb *', 'attributes'))),
    '*.swapcontext': ('int', None, 'cdecl', '*.swapcontext', (('ucontext_t * restrict', 'oucp'), ('const ucontext_t * restrict', 'ucp'))),
    '*.swprintf': ('int', None, 'cdecl', '*.swprintf', (('wchar_t *', 'ws'), ('size_t', 'size'), ('const wchar_t *', 'template'), ('variadic', ''))),
    '*.swscanf': ('int', None, 'cdecl', '*.swscanf', (('const wchar_t *', 'ws'), ('const wchar_t *', 'template'), ('variadic', ''))),
    '*.symlink': ('int', None, 'cdecl', '*.symlink', (('const char *', 'oldname'), ('const char *', 'newname'))),
    '*.sync': ('void', None, 'cdecl', '*.sync', ()),
    '*.syscall': ('long int', None, 'cdecl', '*.syscall', (('long int', 'sysno'), ('variadic', ''))),
    '*.sysconf': ('long int', None, 'cdecl', '*.sysconf', (('int', 'parameter'),)),
    '*.syslog': ('void', None, 'cdecl', '*.syslog', (('int', 'facility_priority'), ('const char *', 'format'), ('variadic', ''))),
    '*.system': ('int', None, 'cdecl', '*.system', (('const char *', 'command'),)),
    '*.sysv_signal': ('sighandler_t', None, 'cdecl', '*.sysv_signal', (('int', 'signum'), ('sighandler_t', 'action'))),
    '*.tan': ('double', None, 'cdecl', '*.tan', (('double', 'x'),)),
    '*.tanf': ('float', None, 'cdecl', '*.tanf', (('float', 'x'),)),
    '*.tanfN': ('_FloatN', None, 'cdecl', '*.tanfN', (('_FloatN', 'x'),)),
    '*.tanfNx': ('_FloatNx', None, 'cdecl', '*.tanfNx', (('_FloatNx', 'x'),)),
    '*.tanh': ('double', None, 'cdecl', '*.tanh', (('double', 'x'),)),
    '*.tanhf': ('float', None, 'cdecl', '*.tanhf', (('float', 'x'),)),
    '*.tanhfN': ('_FloatN', None, 'cdecl', '*.tanhfN', (('_FloatN', 'x'),)),
    '*.tanhfNx': ('_FloatNx', None, 'cdecl', '*.tanhfNx', (('_FloatNx', 'x'),)),
    '*.tanhl': ('long double', None, 'cdecl', '*.tanhl', (('long double', 'x'),)),
    '*.tanl': ('long double', None, 'cdecl', '*.tanl', (('long double', 'x'),)),
    '*.tcdrain': ('int', None, 'cdecl', '*.tcdrain', (('int', 'filedes'),)),
    '*.tcflow': ('int', None, 'cdecl', '*.tcflow', (('int', 'filedes'), ('int', 'action'))),
    '*.tcflush': ('int', None, 'cdecl', '*.tcflush', (('int', 'filedes'), ('int', 'queue'))),
    '*.tcgetattr': ('int', None, 'cdecl', '*.tcgetattr', (('int', 'filedes'), ('struct termios *', 'termios-p'))),
    '*.tcgetpgrp': ('pid_t', None, 'cdecl', '*.tcgetpgrp', (('int', 'filedes'),)),
    '*.tcgetsid': ('pid_t', None, 'cdecl', '*.tcgetsid', (('int', 'fildes'),)),
    '*.tcsendbreak': ('int', None, 'cdecl', '*.tcsendbreak', (('int', 'filedes'), ('int', 'duration'))),
    '*.tcsetattr': ('int', None, 'cdecl', '*.tcsetattr', (('int', 'filedes'), ('int', 'when'), ('const struct termios *', 'termios-p'))),
    '*.tcsetpgrp': ('int', None, 'cdecl', '*.tcsetpgrp', (('int', 'filedes'), ('pid_t', 'pgid'))),
    '*.tdelete': ('void *', None, 'cdecl', '*.tdelete', (('const void *', 'key'), ('void * *', 'rootp'), ('comparison_fn_t', 'compar'))),
    '*.tdestroy': ('void', None, 'cdecl', '*.tdestroy', (('void *', 'vroot'), ('__free_fn_t', 'freefct'))),
    '*.telldir': ('long int', None, 'cdecl', '*.telldir', (('DIR *', 'dirstream'),)),
    '*.tempnam': ('char *', None, 'cdecl', '*.tempnam', (('const char *', 'dir'), ('const char *', 'prefix'))),
    '*.textdomain': ('char *', None, 'cdecl', '*.textdomain', (('const char *', 'domainname'),)),
    '*.tfind': ('void *', None, 'cdecl', '*.tfind', (('const void *', 'key'), ('void * const *', 'rootp'), ('comparison_fn_t', 'compar'))),
    '*.tgamma': ('double', None, 'cdecl', '*.tgamma', (('double', 'x'),)),
    '*.tgammaf': ('float', None, 'cdecl', '*.tgammaf', (('float', 'x'),)),
    '*.tgammafN': ('_FloatN', None, 'cdecl', '*.tgammafN', (('_FloatN', 'x'),)),
    '*.tgammafNx': ('_FloatNx', None, 'cdecl', '*.tgammafNx', (('_FloatNx', 'x'),)),
    '*.tgammal': ('long double', None, 'cdecl', '*.tgammal', (('long double', 'x'),)),
    '*.tgkill': ('int', None, 'cdecl', '*.tgkill', (('pid_t', 'pid'), ('pid_t', 'tid'), ('int', 'signum'))),
    '*.thrd_create': ('int', None, 'cdecl', '*.thrd_create', (('thrd_t *', 'thr'), ('thrd_start_t', 'func'), ('void *', 'arg'))),
    '*.thrd_current': ('thrd_t', None, 'cdecl', '*.thrd_current', ()),
    '*.thrd_detach': ('int', None, 'cdecl', '*.thrd_detach', (('thrd_t', 'thr'),)),
    '*.thrd_equal': ('int', None, 'cdecl', '*.thrd_equal', (('thrd_t', 'lhs'), ('thrd_t', 'rhs'))),
    '*.thrd_exit': ('_Noreturn void', None, 'cdecl', '*.thrd_exit', (('int', 'res'),)),
    '*.thrd_join': ('int', None, 'cdecl', '*.thrd_join', (('thrd_t', 'thr'), ('int *', 'res'))),
    '*.thrd_sleep': ('int', None, 'cdecl', '*.thrd_sleep', (('const struct timespec *', 'time_point'), ('struct timespec *', 'remaining'))),
    '*.thrd_yield': ('void', None, 'cdecl', '*.thrd_yield', ()),
    '*.time': ('time_t', None, 'cdecl', '*.time', (('time_t *', 'result'),)),
    '*.timegm': ('time_t', None, 'cdecl', '*.timegm', (('struct tm *', 'brokentime'),)),
    '*.timelocal': ('time_t', None, 'cdecl', '*.timelocal', (('struct tm *', 'brokentime'),)),
    '*.times': ('clock_t', None, 'cdecl', '*.times', (('struct tms *', 'buffer'),)),
    '*.tmpfile': ('FILE *', None, 'cdecl', '*.tmpfile', ()),
    '*.tmpfile64': ('FILE *', None, 'cdecl', '*.tmpfile64', ()),
    '*.tmpnam': ('char *', None, 'cdecl', '*.tmpnam', (('char *', 'result'),)),
    '*.tmpnam_r': ('char *', None, 'cdecl', '*.tmpnam_r', (('char *', 'result'),)),
    '*.toascii': ('int', None, 'cdecl', '*.toascii', (('int', 'c'),)),
    '*.tolower': ('int', None, 'cdecl', '*.tolower', (('int', 'c'),)),
    '*.totalorder': ('int', None, 'cdecl', '*.totalorder', (('const double *', 'x'), ('const double *', 'y'))),
    '*.totalorderf': ('int', None, 'cdecl', '*.totalorderf', (('const float *', 'x'), ('const float *', 'y'))),
    '*.totalorderfN': ('int', None, 'cdecl', '*.totalorderfN', (('const _FloatN *', 'x'), ('const _FloatN *', 'y'))),
    '*.totalorderfNx': ('int', None, 'cdecl', '*.totalorderfNx', (('const _FloatNx *', 'x'), ('const _FloatNx *', 'y'))),
    '*.totalorderl': ('int', None, 'cdecl', '*.totalorderl', (('const long double *', 'x'), ('const long double *', 'y'))),
    '*.totalordermag': ('int', None, 'cdecl', '*.totalordermag', (('const double *', 'x'), ('const double *', 'y'))),
    '*.totalordermagf': ('int', None, 'cdecl', '*.totalordermagf', (('const float *', 'x'), ('const float *', 'y'))),
    '*.totalordermagfN': ('int', None, 'cdecl', '*.totalordermagfN', (('const _FloatN *', 'x'), ('const _FloatN *', 'y'))),
    '*.totalordermagfNx': ('int', None, 'cdecl', '*.totalordermagfNx', (('const _FloatNx *', 'x'), ('const _FloatNx *', 'y'))),
    '*.totalordermagl': ('int', None, 'cdecl', '*.totalordermagl', (('const long double *', 'x'), ('const long double *', 'y'))),
    '*.toupper': ('int', None, 'cdecl', '*.toupper', (('int', 'c'),)),
    '*.towctrans': ('wint_t', None, 'cdecl', '*.towctrans', (('wint_t', 'wc'), ('wctrans_t', 'desc'))),
    '*.towlower': ('wint_t', None, 'cdecl', '*.towlower', (('wint_t', 'wc'),)),
    '*.towupper': ('wint_t', None, 'cdecl', '*.towupper', (('wint_t', 'wc'),)),
    '*.trunc': ('double', None, 'cdecl', '*.trunc', (('double', 'x'),)),
    '*.truncate': ('int', None, 'cdecl', '*.truncate', (('const char *', 'filename'), ('off_t', 'length'))),
    '*.truncate64': ('int', None, 'cdecl', '*.truncate64', (('const char *', 'name'), ('off64_t', 'length'))),
    '*.truncf': ('float', None, 'cdecl', '*.truncf', (('float', 'x'),)),
    '*.truncfN': ('_FloatN', None, 'cdecl', '*.truncfN', (('_FloatN', 'x'),)),
    '*.truncfNx': ('_FloatNx', None, 'cdecl', '*.truncfNx', (('_FloatNx', 'x'),)),
    '*.truncl': ('long double', None, 'cdecl', '*.truncl', (('long double', 'x'),)),
    '*.tsearch': ('void *', None, 'cdecl', '*.tsearch', (('const void *', 'key'), ('void * *', 'rootp'), ('comparison_fn_t', 'compar'))),
    '*.tss_create': ('int', None, 'cdecl', '*.tss_create', (('tss_t *', 'tss_key'), ('tss_dtor_t', 'destructor'))),
    '*.tss_delete': ('void', None, 'cdecl', '*.tss_delete', (('tss_t', 'tss_key'),)),
    '*.tss_get': ('void *', None, 'cdecl', '*.tss_get', (('tss_t', 'tss_key'),)),
    '*.tss_set': ('int', None, 'cdecl', '*.tss_set', (('tss_t', 'tss_key'), ('void *', 'val'))),
    '*.ttyname': ('char *', None, 'cdecl', '*.ttyname', (('int', 'filedes'),)),
    '*.ttyname_r': ('int', None, 'cdecl', '*.ttyname_r', (('int', 'filedes'), ('char *', 'buf'), ('size_t', 'len'))),
    '*.twalk': ('void', None, 'cdecl', '*.twalk', (('const void *', 'root'), ('__action_fn_t', 'action'))),
    '*.twalk_r': ('void', None, 'cdecl', '*.twalk_r', (('const void *', 'root'), ('void (* action (const void *', 'key'), ('VISIT', 'which'), ('void *', 'closure'), ('void *', 'closure'))),
    '*.tzset': ('void', None, 'cdecl', '*.tzset', ()),
    '*.ufromfp': ('uintmax_t', None, 'cdecl', '*.ufromfp', (('double', 'x'), ('int', 'round'), ('unsigned int', 'width'))),
    '*.ufromfpf': ('uintmax_t', None, 'cdecl', '*.ufromfpf', (('float', 'x'), ('int', 'round'), ('unsigned int', 'width'))),
    '*.ufromfpfN': ('uintmax_t', None, 'cdecl', '*.ufromfpfN', (('_FloatN', 'x'), ('int', 'round'), ('unsigned int', 'width'))),
    '*.ufromfpfNx': ('uintmax_t', None, 'cdecl', '*.ufromfpfNx', (('_FloatNx', 'x'), ('int', 'round'), ('unsigned int', 'width'))),
    '*.ufromfpl': ('uintmax_t', None, 'cdecl', '*.ufromfpl', (('long double', 'x'), ('int', 'round'), ('unsigned int', 'width'))),
    '*.ufromfpx': ('uintmax_t', None, 'cdecl', '*.ufromfpx', (('double', 'x'), ('int', 'round'), ('unsigned int', 'width'))),
    '*.ufromfpxf': ('uintmax_t', None, 'cdecl', '*.ufromfpxf', (('float', 'x'), ('int', 'round'), ('unsigned int', 'width'))),
    '*.ufromfpxfN': ('uintmax_t', None, 'cdecl', '*.ufromfpxfN', (('_FloatN', 'x'), ('int', 'round'), ('unsigned int', 'width'))),
    '*.ufromfpxfNx': ('uintmax_t', None, 'cdecl', '*.ufromfpxfNx', (('_FloatNx', 'x'), ('int', 'round'), ('unsigned int', 'width'))),
    '*.ufromfpxl': ('uintmax_t', None, 'cdecl', '*.ufromfpxl', (('long double', 'x'), ('int', 'round'), ('unsigned int', 'width'))),
    '*.ulimit': ('long int', None, 'cdecl', '*.ulimit', (('int', 'cmd'), ('variadic', ''))),
    '*.umask': ('mode_t', None, 'cdecl', '*.umask', (('mode_t', 'mask'),)),
    '*.umount': ('int', None, 'cdecl', '*.umount', (('const char *', 'file'),)),
    '*.umount2': ('int', None, 'cdecl', '*.umount2', (('const char *', 'file'), ('int', 'flags'))),
    '*.uname': ('int', None, 'cdecl', '*.uname', (('struct utsname *', 'info'),)),
    '*.ungetc': ('int', None, 'cdecl', '*.ungetc', (('int', 'c'), ('FILE *', 'stream'))),
    '*.ungetwc': ('wint_t', None, 'cdecl', '*.ungetwc', (('wint_t', 'wc'), ('FILE *', 'stream'))),
    '*.unlink': ('int', None, 'cdecl', '*.unlink', (('const char *', 'filename'),)),
    '*.unlockpt': ('int', None, 'cdecl', '*.unlockpt', (('int', 'filedes'),)),
    '*.unsetenv': ('int', None, 'cdecl', '*.unsetenv', (('const char *', 'name'),)),
    '*.updwtmp': ('void', None, 'cdecl', '*.updwtmp', (('const char *', 'wtmp_file'), ('const struct utmp *', 'utmp'))),
    '*.utime': ('int', None, 'cdecl', '*.utime', (('const char *', 'filename'), ('const struct utimbuf *', 'times'))),
    '*.utimes': ('int', None, 'cdecl', '*.utimes', (('const char *', 'filename'), ('const struct timeval', 'tvp[2]'))),
    '*.utmpname': ('int', None, 'cdecl', '*.utmpname', (('const char *', 'file'),)),
    '*.utmpxname': ('int', None, 'cdecl', '*.utmpxname', (('const char *', 'file'),)),
    '*.valloc': ('void *', None, 'cdecl', '*.valloc', (('size_t', 'size'),)),
    '*.vasprintf': ('int', None, 'cdecl', '*.vasprintf', (('char * *', 'ptr'), ('const char *', 'template'), ('va_list', 'ap'))),
    '*.verr': ('void', None, 'cdecl', '*.verr', (('int', 'status'), ('const char *', 'format'), ('va_list', 'ap'))),
    '*.verrx': ('void', None, 'cdecl', '*.verrx', (('int', 'status'), ('const char *', 'format'), ('va_list', 'ap'))),
    '*.versionsort': ('int', None, 'cdecl', '*.versionsort', (('const struct dirent * *', 'a'), ('const struct dirent * *', 'b'))),
    '*.versionsort64': ('int', None, 'cdecl', '*.versionsort64', (('const struct dirent64 * *', 'a'), ('const struct dirent64 * *', 'b'))),
    '*.vfork': ('pid_t', None, 'cdecl', '*.vfork', ()),
    '*.vfprintf': ('int', None, 'cdecl', '*.vfprintf', (('FILE *', 'stream'), ('const char *', 'template'), ('va_list', 'ap'))),
    '*.vfscanf': ('int', None, 'cdecl', '*.vfscanf', (('FILE *', 'stream'), ('const char *', 'template'), ('va_list', 'ap'))),
    '*.vfwprintf': ('int', None, 'cdecl', '*.vfwprintf', (('FILE *', 'stream'), ('const wchar_t *', 'template'), ('va_list', 'ap'))),
    '*.vfwscanf': ('int', None, 'cdecl', '*.vfwscanf', (('FILE *', 'stream'), ('const wchar_t *', 'template'), ('va_list', 'ap'))),
    '*.vlimit': ('int', None, 'cdecl', '*.vlimit', (('int', 'resource'), ('int', 'limit'))),
    '*.vprintf': ('int', None, 'cdecl', '*.vprintf', (('const char *', 'template'), ('va_list', 'ap'))),
    '*.vscanf': ('int', None, 'cdecl', '*.vscanf', (('const char *', 'template'), ('va_list', 'ap'))),
    '*.vsnprintf': ('int', None, 'cdecl', '*.vsnprintf', (('char *', 's'), ('size_t', 'size'), ('const char *', 'template'), ('va_list', 'ap'))),
    '*.vsprintf': ('int', None, 'cdecl', '*.vsprintf', (('char *', 's'), ('const char *', 'template'), ('va_list', 'ap'))),
    '*.vsscanf': ('int', None, 'cdecl', '*.vsscanf', (('const char *', 's'), ('const char *', 'template'), ('va_list', 'ap'))),
    '*.vswprintf': ('int', None, 'cdecl', '*.vswprintf', (('wchar_t *', 'ws'), ('size_t', 'size'), ('const wchar_t *', 'template'), ('va_list', 'ap'))),
    '*.vswscanf': ('int', None, 'cdecl', '*.vswscanf', (('const wchar_t *', 's'), ('const wchar_t *', 'template'), ('va_list', 'ap'))),
    '*.vsyslog': ('void', None, 'cdecl', '*.vsyslog', (('int', 'facility_priority'), ('const char *', 'format'), ('va_list', 'arglist'))),
    '*.vtimes': ('int', None, 'cdecl', '*.vtimes', (('struct vtimes *', 'current'), ('struct vtimes *', 'child'))),
    '*.vwarn': ('void', None, 'cdecl', '*.vwarn', (('const char *', 'format'), ('va_list', 'ap'))),
    '*.vwarnx': ('void', None, 'cdecl', '*.vwarnx', (('const char *', 'format'), ('va_list', 'ap'))),
    '*.vwprintf': ('int', None, 'cdecl', '*.vwprintf', (('const wchar_t *', 'template'), ('va_list', 'ap'))),
    '*.vwscanf': ('int', None, 'cdecl', '*.vwscanf', (('const wchar_t *', 'template'), ('va_list', 'ap'))),
    '*.wait': ('pid_t', None, 'cdecl', '*.wait', (('int *', 'status-ptr'),)),
    '*.wait3': ('pid_t', None, 'cdecl', '*.wait3', (('int *', 'status-ptr'), ('int', 'options'), ('struct rusage *', 'usage'))),
    '*.wait4': ('pid_t', None, 'cdecl', '*.wait4', (('pid_t', 'pid'), ('int *', 'status-ptr'), ('int', 'options'), ('struct rusage *', 'usage'))),
    '*.waitpid': ('pid_t', None, 'cdecl', '*.waitpid', (('pid_t', 'pid'), ('int *', 'status-ptr'), ('int', 'options'))),
    '*.warn': ('void', None, 'cdecl', '*.warn', (('const char *', 'format'), ('variadic', ''))),
    '*.warnx': ('void', None, 'cdecl', '*.warnx', (('const char *', 'format'), ('variadic', ''))),
    '*.wcpcpy': ('wchar_t *', None, 'cdecl', '*.wcpcpy', (('wchar_t * restrict', 'wto'), ('const wchar_t * restrict', 'wfrom'))),
    '*.wcpncpy': ('wchar_t *', None, 'cdecl', '*.wcpncpy', (('wchar_t * restrict', 'wto'), ('const wchar_t * restrict', 'wfrom'), ('size_t', 'size'))),
    '*.wcrtomb': ('size_t', None, 'cdecl', '*.wcrtomb', (('char * restrict', 's'), ('wchar_t', 'wc'), ('mbstate_t * restrict', 'ps'))),
    '*.wcscasecmp': ('int', None, 'cdecl', '*.wcscasecmp', (('const wchar_t *', 'ws1'), ('const wchar_t *', 'ws2'))),
    '*.wcscat': ('wchar_t *', None, 'cdecl', '*.wcscat', (('wchar_t * restrict', 'wto'), ('const wchar_t * restrict', 'wfrom'))),
    '*.wcschr': ('wchar_t *', None, 'cdecl', '*.wcschr', (('const wchar_t *', 'wstring'), ('wchar_t', 'wc'))),
    '*.wcschrnul': ('wchar_t *', None, 'cdecl', '*.wcschrnul', (('const wchar_t *', 'wstring'), ('wchar_t', 'wc'))),
    '*.wcscmp': ('int', None, 'cdecl', '*.wcscmp', (('const wchar_t *', 'ws1'), ('const wchar_t *', 'ws2'))),
    '*.wcscoll': ('int', None, 'cdecl', '*.wcscoll', (('const wchar_t *', 'ws1'), ('const wchar_t *', 'ws2'))),
    '*.wcscpy': ('wchar_t *', None, 'cdecl', '*.wcscpy', (('wchar_t * restrict', 'wto'), ('const wchar_t * restrict', 'wfrom'))),
    '*.wcscspn': ('size_t', None, 'cdecl', '*.wcscspn', (('const wchar_t *', 'wstring'), ('const wchar_t *', 'stopset'))),
    '*.wcsdup': ('wchar_t *', None, 'cdecl', '*.wcsdup', (('const wchar_t *', 'ws'),)),
    '*.wcsftime': ('size_t', None, 'cdecl', '*.wcsftime', (('wchar_t *', 's'), ('size_t', 'size'), ('const wchar_t *', 'template'), ('const struct tm *', 'brokentime'))),
    '*.wcslen': ('size_t', None, 'cdecl', '*.wcslen', (('const wchar_t *', 'ws'),)),
    '*.wcsncasecmp': ('int', None, 'cdecl', '*.wcsncasecmp', (('const wchar_t *', 'ws1'), ('const wchar_t *', 's2'), ('size_t', 'n'))),
    '*.wcsncat': ('wchar_t *', None, 'cdecl', '*.wcsncat', (('wchar_t * restrict', 'wto'), ('const wchar_t * restrict', 'wfrom'), ('size_t', 'size'))),
    '*.wcsncmp': ('int', None, 'cdecl', '*.wcsncmp', (('const wchar_t *', 'ws1'), ('const wchar_t *', 'ws2'), ('size_t', 'size'))),
    '*.wcsncpy': ('wchar_t *', None, 'cdecl', '*.wcsncpy', (('wchar_t * restrict', 'wto'), ('const wchar_t * restrict', 'wfrom'), ('size_t', 'size'))),
    '*.wcsnlen': ('size_t', None, 'cdecl', '*.wcsnlen', (('const wchar_t *', 'ws'), ('size_t', 'maxlen'))),
    '*.wcsnrtombs': ('size_t', None, 'cdecl', '*.wcsnrtombs', (('char * restrict', 'dst'), ('const wchar_t * * restrict', 'src'), ('size_t', 'nwc'), ('size_t', 'len'), ('mbstate_t * restrict', 'ps'))),
    '*.wcspbrk': ('wchar_t *', None, 'cdecl', '*.wcspbrk', (('const wchar_t *', 'wstring'), ('const wchar_t *', 'stopset'))),
    '*.wcsrchr': ('wchar_t *', None, 'cdecl', '*.wcsrchr', (('const wchar_t *', 'wstring'), ('wchar_t', 'wc'))),
    '*.wcsrtombs': ('size_t', None, 'cdecl', '*.wcsrtombs', (('char * restrict', 'dst'), ('const wchar_t * * restrict', 'src'), ('size_t', 'len'), ('mbstate_t * restrict', 'ps'))),
    '*.wcsspn': ('size_t', None, 'cdecl', '*.wcsspn', (('const wchar_t *', 'wstring'), ('const wchar_t *', 'skipset'))),
    '*.wcsstr': ('wchar_t *', None, 'cdecl', '*.wcsstr', (('const wchar_t *', 'haystack'), ('const wchar_t *', 'needle'))),
    '*.wcstod': ('double', None, 'cdecl', '*.wcstod', (('const wchar_t * restrict', 'string'), ('wchar_t * * restrict', 'tailptr'))),
    '*.wcstof': ('float', None, 'cdecl', '*.wcstof', (('const wchar_t *', 'string'), ('wchar_t * *', 'tailptr'))),
    '*.wcstofN': ('_FloatN', None, 'cdecl', '*.wcstofN', (('const wchar_t *', 'string'), ('wchar_t * *', 'tailptr'))),
    '*.wcstofNx': ('_FloatNx', None, 'cdecl', '*.wcstofNx', (('const wchar_t *', 'string'), ('wchar_t * *', 'tailptr'))),
    '*.wcstoimax': ('intmax_t', None, 'cdecl', '*.wcstoimax', (('const wchar_t * restrict', 'string'), ('wchar_t * * restrict', 'tailptr'), ('int', 'base'))),
    '*.wcstok': ('wchar_t *', None, 'cdecl', '*.wcstok', (('wchar_t *', 'newstring'), ('const wchar_t *', 'delimiters'), ('wchar_t * *', 'save_ptr'))),
    '*.wcstol': ('long int', None, 'cdecl', '*.wcstol', (('const wchar_t * restrict', 'string'), ('wchar_t * * restrict', 'tailptr'), ('int', 'base'))),
    '*.wcstold': ('long double', None, 'cdecl', '*.wcstold', (('const wchar_t *', 'string'), ('wchar_t * *', 'tailptr'))),
    '*.wcstoll': ('long long int', None, 'cdecl', '*.wcstoll', (('const wchar_t * restrict', 'string'), ('wchar_t * * restrict', 'tailptr'), ('int', 'base'))),
    '*.wcstombs': ('size_t', None, 'cdecl', '*.wcstombs', (('char *', 'string'), ('const wchar_t *', 'wstring'), ('size_t', 'size'))),
    '*.wcstoq': ('long long int', None, 'cdecl', '*.wcstoq', (('const wchar_t * restrict', 'string'), ('wchar_t * * restrict', 'tailptr'), ('int', 'base'))),
    '*.wcstoul': ('unsigned long int', None, 'cdecl', '*.wcstoul', (('const wchar_t * restrict', 'string'), ('wchar_t * * restrict', 'tailptr'), ('int', 'base'))),
    '*.wcstoull': ('unsigned long long int', None, 'cdecl', '*.wcstoull', (('const wchar_t * restrict', 'string'), ('wchar_t * * restrict', 'tailptr'), ('int', 'base'))),
    '*.wcstoumax': ('uintmax_t', None, 'cdecl', '*.wcstoumax', (('const wchar_t * restrict', 'string'), ('wchar_t * * restrict', 'tailptr'), ('int', 'base'))),
    '*.wcstouq': ('unsigned long long int', None, 'cdecl', '*.wcstouq', (('const wchar_t * restrict', 'string'), ('wchar_t * * restrict', 'tailptr'), ('int', 'base'))),
    '*.wcswcs': ('wchar_t *', None, 'cdecl', '*.wcswcs', (('const wchar_t *', 'haystack'), ('const wchar_t *', 'needle'))),
    '*.wcsxfrm': ('size_t', None, 'cdecl', '*.wcsxfrm', (('wchar_t * restrict', 'wto'), ('const wchar_t *', 'wfrom'), ('size_t', 'size'))),
    '*.wctob': ('int', None, 'cdecl', '*.wctob', (('wint_t', 'c'),)),
    '*.wctomb': ('int', None, 'cdecl', '*.wctomb', (('char *', 'string'), ('wchar_t', 'wchar'))),
    '*.wctrans': ('wctrans_t', None, 'cdecl', '*.wctrans', (('const char *', 'property'),)),
    '*.wctype': ('wctype_t', None, 'cdecl', '*.wctype', (('const char *', 'property'),)),
    '*.wmemchr': ('wchar_t *', None, 'cdecl', '*.wmemchr', (('const wchar_t *', 'block'), ('wchar_t', 'wc'), ('size_t', 'size'))),
    '*.wmemcmp': ('int', None, 'cdecl', '*.wmemcmp', (('const wchar_t *', 'a1'), ('const wchar_t *', 'a2'), ('size_t', 'size'))),
    '*.wmemcpy': ('wchar_t *', None, 'cdecl', '*.wmemcpy', (('wchar_t * restrict', 'wto'), ('const wchar_t * restrict', 'wfrom'), ('size_t', 'size'))),
    '*.wmemmove': ('wchar_t *', None, 'cdecl', '*.wmemmove', (('wchar_t *', 'wto'), ('const wchar_t *', 'wfrom'), ('size_t', 'size'))),
    '*.wmempcpy': ('wchar_t *', None, 'cdecl', '*.wmempcpy', (('wchar_t * restrict', 'wto'), ('const wchar_t * restrict', 'wfrom'), ('size_t', 'size'))),
    '*.wmemset': ('wchar_t *', None, 'cdecl', '*.wmemset', (('wchar_t *', 'block'), ('wchar_t', 'wc'), ('size_t', 'size'))),
    '*.wordexp': ('int', None, 'cdecl', '*.wordexp', (('const char *', 'words'), ('wordexp_t *', 'word-vector-ptr'), ('int', 'flags'))),
    '*.wordfree': ('void', None, 'cdecl', '*.wordfree', (('wordexp_t *', 'word-vector-ptr'),)),
    '*.wprintf': ('int', None, 'cdecl', '*.wprintf', (('const wchar_t *', 'template'), ('variadic', ''))),
    '*.write': ('ssize_t', None, 'cdecl', '*.write', (('int', 'filedes'), ('const void *', 'buffer'), ('size_t', 'size'))),
    '*.writev': ('ssize_t', None, 'cdecl', '*.writev', (('int', 'filedes'), ('const struct iovec *', 'vector'), ('int', 'count'))),
    '*.wscanf': ('int', None, 'cdecl', '*.wscanf', (('const wchar_t *', 'template'), ('variadic', ''))),
    '*.y0': ('double', None, 'cdecl', '*.y0', (('double', 'x'),)),
    '*.y0f': ('float', None, 'cdecl', '*.y0f', (('float', 'x'),)),
    '*.y0fN': ('_FloatN', None, 'cdecl', '*.y0fN', (('_FloatN', 'x'),)),
    '*.y0fNx': ('_FloatNx', None, 'cdecl', '*.y0fNx', (('_FloatNx', 'x'),)),
    '*.y0l': ('long double', None, 'cdecl', '*.y0l', (('long double', 'x'),)),
    '*.y1': ('double', None, 'cdecl', '*.y1', (('double', 'x'),)),
    '*.y1f': ('float', None, 'cdecl', '*.y1f', (('float', 'x'),)),
    '*.y1fN': ('_FloatN', None, 'cdecl', '*.y1fN', (('_FloatN', 'x'),)),
    '*.y1fNx': ('_FloatNx', None, 'cdecl', '*.y1fNx', (('_FloatNx', 'x'),)),
    '*.y1l': ('long double', None, 'cdecl', '*.y1l', (('long double', 'x'),)),
    '*.yn': ('double', None, 'cdecl', '*.yn', (('int', 'n'), ('double', 'x'))),
    '*.ynf': ('float', None, 'cdecl', '*.ynf', (('int', 'n'), ('float', 'x'))),
    '*.ynfN': ('_FloatN', None, 'cdecl', '*.ynfN', (('int', 'n'), ('_FloatN', 'x'))),
    '*.ynfNx': ('_FloatNx', None, 'cdecl', '*.ynfNx', (('int', 'n'), ('_FloatNx', 'x'))),
    '*.ynl': ('long double', None, 'cdecl', '*.ynl', (('int', 'n'), ('long double', 'x'))),
    # taken from libc directly:
    '*.__libc_rpc_getport': ('int', None, 'stdcall', '*.__libc_rpc_getport', (('int', 'arg0'), ('int', 'arg1'), ('int', 'arg2'))),
    '*.__nss_services_lookup2': ('int', None, 'stdcall', '*.__nss_services_lookup2', (('int', 'arg0'),)),
    '*.__nss_passwd_lookup2': ('int', None, 'stdcall', '*.__nss_passwd_lookup2', (('int', 'arg0'),)),
    '*._dl_addr': ('int', None, 'stdcall', '*._dl_addr', (('int', 'arg0'),)),
    '*._dl_vsym': ('int', None, 'stdcall', None, (('int', 'arg0'),)),
    '*.__nss_group_lookup2': ('int', None, 'stdcall', '*.__nss_group_lookup2', (('int', 'arg0'),)),
    '*.__nss_hosts_lookup2': ('int', None, 'stdcall', '*.__nss_hosts_lookup2', (('int', 'arg0'),)),
    
}
