// SDB-CGEN V2.6.2
#include <ctype.h>
#include <stdio.h>
#include <string.h>

struct kv { const char *name; const char *value; };
static const struct kv kvs[] = {
// gcc -DMAIN=1 types.c ; ./a.out > types.h
	{"*aligned_alloc", "func"},
	{"FILE", "type"},
	{"Unwind_Resume", "func"},
	{"Unwind_SjLj_Resume", "func"},
	{"ZSt9terminatev", "func"},
	{"_sSS10FoundationE19_bridgeToObjectiveCSo8NSStringCyF", "func"},
	{"abs", "func"},
	{"acos", "func"},
	{"acosf", "func"},
	{"acosh", "func"},
	{"acoshf", "func"},
	{"acoshl", "func"},
	{"acosl", "func"},
	{"arc4random", "func"},
	{"asctime", "func"},
	{"asin", "func"},
	{"asinf", "func"},
	{"asinh", "func"},
	{"asinhf", "func"},
	{"asinhl", "func"},
	{"asinl", "func"},
	{"asprintf", "func"},
	{"at_quick_exit", "func"},
	{"atan", "func"},
	{"atan2", "func"},
	{"atan2f", "func"},
	{"atan2l", "func"},
	{"atanf", "func"},
	{"atanh", "func"},
	{"atanhf", "func"},
	{"atanhl", "func"},
	{"atanl", "func"},
	{"atof", "func"},
	{"atoi", "func"},
	{"atol", "func"},
	{"atoll", "func"},
	{"basename", "func"},
	{"bind", "func"},
	{"bind_textdomain_codeset", "func"},
	{"bindtextdomain", "func"},
	{"bsearch", "func"},
	{"btowc", "func"},
	{"bzero", "func"},
	{"calloc", "func"},
	{"cbrt", "func"},
	{"cbrtf", "func"},
	{"cbrtl", "func"},
	{"ceil", "func"},
	{"ceilf", "func"},
	{"ceill", "func"},
	{"char", "type"},
	{"char *", "type"},
	{"char **", "type"},
	{"chmod", "func"},
	{"clearerr", "func"},
	{"clock", "func"},
	{"close", "func"},
	{"compat_mode", "func"},
	{"connect", "func"},
	{"copysign", "func"},
	{"copysignf", "func"},
	{"copysignl", "func"},
	{"cos", "func"},
	{"cosf", "func"},
	{"cosh", "func"},
	{"coshf", "func"},
	{"coshl", "func"},
	{"cosl", "func"},
	{"ctime", "func"},
	{"cxa_bad_cast", "func"},
	{"cxa_bad_typeid", "func"},
	{"cxa_call_unexpected", "func"},
	{"cxa_end_cleanup", "func"},
	{"cxa_pure_virtual", "func"},
	{"cxa_rethrow", "func"},
	{"cxa_throw", "func"},
	{"cxa_throw_bad_array_new_length", "func"},
	{"dcgettext", "func"},
	{"dcngettext", "func"},
	{"dgettext", "func"},
	{"difftime", "func"},
	{"div", "func"},
	{"dngettext", "func"},
	{"double", "type"},
	{"dprintf", "func"},
	{"erf", "func"},
	{"erfc", "func"},
	{"erfcf", "func"},
	{"erfcl", "func"},
	{"erff", "func"},
	{"erfl", "func"},
	{"err", "func"},
	{"errc", "func"},
	{"error", "func"},
	{"errx", "func"},
	{"exp", "func"},
	{"exp2", "func"},
	{"exp2f", "func"},
	{"exp2l", "func"},
	{"expf", "func"},
	{"expl", "func"},
	{"expm1", "func"},
	{"expm1f", "func"},
	{"expm1l", "func"},
	{"fabs", "func"},
	{"fabsf", "func"},
	{"fabsl", "func"},
	{"fchmod", "func"},
	{"fchown", "func"},
	{"fclose", "func"},
	{"fdim", "func"},
	{"fdimf", "func"},
	{"fdiml", "func"},
	{"fdopen", "func"},
	{"feclearexcept", "func"},
	{"fegetenv", "func"},
	{"fegetexceptflag", "func"},
	{"fegetround", "func"},
	{"feholdexcept", "func"},
	{"feof", "func"},
	{"feraiseexcept", "func"},
	{"ferror", "func"},
	{"fesetenv", "func"},
	{"fesetexceptflag", "func"},
	{"fesetround", "func"},
	{"fetestexcept", "func"},
	{"feupdateenv", "func"},
	{"fflagtostr", "func"},
	{"fflush", "func"},
	{"fflush_unlocked", "func"},
	{"fgetc", "func"},
	{"fgetpos", "func"},
	{"fgets", "func"},
	{"fgetwc", "func"},
	{"fgetws", "func"},
	{"fileno", "func"},
	{"float", "type"},
	{"floor", "func"},
	{"floorf", "func"},
	{"floorl", "func"},
	{"fma", "func"},
	{"fmaf", "func"},
	{"fmal", "func"},
	{"fmax", "func"},
	{"fmaxf", "func"},
	{"fmaxl", "func"},
	{"fmin", "func"},
	{"fminf", "func"},
	{"fminl", "func"},
	{"fmod", "func"},
	{"fmodf", "func"},
	{"fmodl", "func"},
	{"fopen", "func"},
	{"fpclassify", "func"},
	{"fprintf", "func"},
	{"fputc", "func"},
	{"fputs", "func"},
	{"fputwc", "func"},
	{"fputws", "func"},
	{"fread", "func"},
	{"free", "func"},
	{"freopen", "func"},
	{"frexp", "func"},
	{"frexpf", "func"},
	{"frexpl", "func"},
	{"fscanf", "func"},
	{"fseek", "func"},
	{"fseeko", "func"},
	{"fsetpos", "func"},
	{"fstat", "func"},
	{"ftell", "func"},
	{"ftello", "func"},
	{"fts_children_INODE64", "func"},
	{"fts_close_INODE64", "func"},
	{"fts_open_INODE64", "func"},
	{"fts_read_INODE64", "func"},
	{"fts_set_INODE64", "func"},
	{"func", "type"},
	{"func.*aligned_alloc.arg.0", "size_t,alignment"},
	{"func.*aligned_alloc.arg.1", "size_t,size"},
	{"func.*aligned_alloc.args", "2"},
	{"func.*aligned_alloc.ret", "void"},
	{"func.Unwind_Resume.arg.0", "void *,exception_object"},
	{"func.Unwind_Resume.args", "1"},
	{"func.Unwind_Resume.noreturn", "true"},
	{"func.Unwind_Resume.ret", "void"},
	{"func.Unwind_SjLj_Resume.arg.0", "void *,exception_object"},
	{"func.Unwind_SjLj_Resume.args", "1"},
	{"func.Unwind_SjLj_Resume.noreturn", "true"},
	{"func.Unwind_SjLj_Resume.ret", "void"},
	{"func.ZSt9terminatev.args", "0"},
	{"func.ZSt9terminatev.noreturn", "true"},
	{"func.ZSt9terminatev.ret", "void"},
	{"func._sSS10FoundationE19_bridgeToObjectiveCSo8NSStringCyF.arg.0", "void *"},
	{"func._sSS10FoundationE19_bridgeToObjectiveCSo8NSStringCyF.args", "1"},
	{"func._sSS10FoundationE19_bridgeToObjectiveCSo8NSStringCyF.ret", "void *"},
	{"func.abs.arg.0", "int,j"},
	{"func.abs.args", "1"},
	{"func.abs.ret", "int"},
	{"func.acos.arg.0", "arithmetic,x"},
	{"func.acos.args", "1"},
	{"func.acos.ret", "floating_point"},
	{"func.acosf.arg.0", "float,x"},
	{"func.acosf.args", "1"},
	{"func.acosf.ret", "float"},
	{"func.acosh.arg.0", "arithmetic,x"},
	{"func.acosh.args", "1"},
	{"func.acosh.ret", "floating_point"},
	{"func.acoshf.arg.0", "float,x"},
	{"func.acoshf.args", "1"},
	{"func.acoshf.ret", "float"},
	{"func.acoshl.arg.0", "long double,x"},
	{"func.acoshl.args", "1"},
	{"func.acoshl.ret", "long double"},
	{"func.acosl.arg.0", "long double,x"},
	{"func.acosl.args", "1"},
	{"func.acosl.ret", "long double"},
	{"func.arc4random.args", "0"},
	{"func.arc4random.ret", "uint32_t"},
	{"func.asctime.arg.0", "const tm *,timeptr"},
	{"func.asctime.args", "1"},
	{"func.asctime.ret", "char *"},
	{"func.asin.arg.0", "arithmetic,x"},
	{"func.asin.args", "1"},
	{"func.asin.ret", "floating_point"},
	{"func.asinf.arg.0", "float,x"},
	{"func.asinf.args", "1"},
	{"func.asinf.ret", "float"},
	{"func.asinh.arg.0", "arithmetic,x"},
	{"func.asinh.args", "1"},
	{"func.asinh.ret", "floating_point"},
	{"func.asinhf.arg.0", "float,x"},
	{"func.asinhf.args", "1"},
	{"func.asinhf.ret", "float"},
	{"func.asinhl.arg.0", "long double,x"},
	{"func.asinhl.args", "1"},
	{"func.asinhl.ret", "long double"},
	{"func.asinl.arg.0", "long double,x"},
	{"func.asinl.args", "1"},
	{"func.asinl.ret", "long double"},
	{"func.asprintf.arg.0", "char **,ptr"},
	{"func.asprintf.arg.1", "const char *,format"},
	{"func.asprintf.arg.2", ",..."},
	{"func.asprintf.args", "3"},
	{"func.asprintf.ret", "int"},
	{"func.at_quick_exit.args", "0"},
	{"func.at_quick_exit.ret", "int"},
	{"func.atan.arg.0", "arithmetic,x"},
	{"func.atan.args", "1"},
	{"func.atan.ret", "floating_point"},
	{"func.atan2.arg.0", "arithmetic,y"},
	{"func.atan2.arg.1", "arithmetic,x"},
	{"func.atan2.args", "2"},
	{"func.atan2.ret", "floating_point"},
	{"func.atan2f.arg.0", "float,y"},
	{"func.atan2f.arg.1", "float,x"},
	{"func.atan2f.args", "2"},
	{"func.atan2f.ret", "float"},
	{"func.atan2l.arg.0", "long double,y"},
	{"func.atan2l.arg.1", "long double,x"},
	{"func.atan2l.args", "2"},
	{"func.atan2l.ret", "long double"},
	{"func.atanf.arg.0", "float,x"},
	{"func.atanf.args", "1"},
	{"func.atanf.ret", "float"},
	{"func.atanh.arg.0", "arithmetic,x"},
	{"func.atanh.args", "1"},
	{"func.atanh.ret", "floating_point"},
	{"func.atanhf.arg.0", "float,x"},
	{"func.atanhf.args", "1"},
	{"func.atanhf.ret", "float"},
	{"func.atanhl.arg.0", "long double,x"},
	{"func.atanhl.args", "1"},
	{"func.atanhl.ret", "long double"},
	{"func.atanl.arg.0", "long double,x"},
	{"func.atanl.args", "1"},
	{"func.atanl.ret", "long double"},
	{"func.atof.arg.0", "const char *,str"},
	{"func.atof.args", "1"},
	{"func.atof.ret", "double"},
	{"func.atoi.arg.0", "const char *,str"},
	{"func.atoi.args", "1"},
	{"func.atoi.ret", "int"},
	{"func.atol.arg.0", "const char *,str"},
	{"func.atol.args", "1"},
	{"func.atol.ret", "long"},
	{"func.atoll.arg.0", "const char *,str"},
	{"func.atoll.args", "1"},
	{"func.atoll.ret", "long long"},
	{"func.basename.arg.0", "char *,path"},
	{"func.basename.args", "1"},
	{"func.basename.ret", "char *"},
	{"func.bind.arg.0", "int,socket"},
	{"func.bind.arg.1", "struct sockaddr*,address"},
	{"func.bind.arg.2", "socklen_t,address_len"},
	{"func.bind.args", "3"},
	{"func.bind.ret", "int"},
	{"func.bind_textdomain_codeset.arg.0", "const char *,domainname"},
	{"func.bind_textdomain_codeset.arg.1", "const char *,codeset"},
	{"func.bind_textdomain_codeset.args", "2"},
	{"func.bind_textdomain_codeset.ret", "char *"},
	{"func.bindtextdomain.arg.0", "char *,domainname"},
	{"func.bindtextdomain.arg.1", "char *,dirname"},
	{"func.bindtextdomain.args", "2"},
	{"func.bindtextdomain.ret", "char *"},
	{"func.bsearch.arg.0", "const void *,key"},
	{"func.bsearch.arg.1", "const void *,base"},
	{"func.bsearch.arg.2", "size_t,nmemb"},
	{"func.bsearch.arg.3", "size_t,size"},
	{"func.bsearch.arg.4", "int,(*compar)(const void *,const void *)"},
	{"func.bsearch.args", "5"},
	{"func.btowc.arg.0", "int,c"},
	{"func.btowc.args", "1"},
	{"func.btowc.ret", "wint_t"},
	{"func.bzero.arg.0", "void *,s"},
	{"func.bzero.arg.1", "size_t,n"},
	{"func.bzero.args", "2"},
	{"func.bzero.ret", "void"},
	{"func.calloc.arg.0", "size_t,nmeb"},
	{"func.calloc.arg.1", "size_t,size"},
	{"func.calloc.args", "2"},
	{"func.calloc.ret", "void *"},
	{"func.cbrt.arg.0", "arithmetic,x"},
	{"func.cbrt.args", "1"},
	{"func.cbrt.ret", "floating_point"},
	{"func.cbrtf.arg.0", "float,x"},
	{"func.cbrtf.args", "1"},
	{"func.cbrtf.ret", "float"},
	{"func.cbrtl.arg.0", "long double,x"},
	{"func.cbrtl.args", "1"},
	{"func.cbrtl.ret", "long double"},
	{"func.ceil.arg.0", "arithmetic,x"},
	{"func.ceil.args", "1"},
	{"func.ceil.ret", "floating_point"},
	{"func.ceilf.arg.0", "float,x"},
	{"func.ceilf.args", "1"},
	{"func.ceilf.ret", "float"},
	{"func.ceill.arg.0", "long double,x"},
	{"func.ceill.args", "1"},
	{"func.ceill.ret", "long double"},
	{"func.chmod.arg.0", "const char *,path"},
	{"func.chmod.arg.1", "int,mode"},
	{"func.chmod.args", "2"},
	{"func.chmod.ret", "int"},
	{"func.clearerr.arg.0", "FILE *,stream"},
	{"func.clearerr.args", "1"},
	{"func.clearerr.ret", "void"},
	{"func.clock.args", "0"},
	{"func.clock.ret", "clock_t"},
	{"func.close.arg.0", "int,fildes"},
	{"func.close.args", "1"},
	{"func.close.ret", "int"},
	{"func.compat_mode.arg.0", "const char *,function"},
	{"func.compat_mode.arg.1", "const char *,mode"},
	{"func.compat_mode.args", "2"},
	{"func.compat_mode.ret", "bool"},
	{"func.connect.arg.0", "int,socket"},
	{"func.connect.arg.1", "void *,addr"},
	{"func.connect.arg.2", "size_t,addrlen"},
	{"func.connect.args", "3"},
	{"func.connect.ret", "ssize_t"},
	{"func.copysign.arg.0", "arithmetic,x"},
	{"func.copysign.arg.1", "arithmetic,y"},
	{"func.copysign.args", "2"},
	{"func.copysign.ret", "floating_point"},
	{"func.copysignf.arg.0", "float,x"},
	{"func.copysignf.arg.1", "float,y"},
	{"func.copysignf.args", "2"},
	{"func.copysignf.ret", "float"},
	{"func.copysignl.arg.0", "long double,x"},
	{"func.copysignl.arg.1", "long double,y"},
	{"func.copysignl.args", "2"},
	{"func.copysignl.ret", "long double"},
	{"func.cos.arg.0", "arithmetic,x"},
	{"func.cos.args", "1"},
	{"func.cos.ret", "floating_point"},
	{"func.cosf.arg.0", "float,x"},
	{"func.cosf.args", "1"},
	{"func.cosf.ret", "float"},
	{"func.cosh.arg.0", "arithmetic,x"},
	{"func.cosh.args", "1"},
	{"func.cosh.ret", "floating_point"},
	{"func.coshf.arg.0", "float,x"},
	{"func.coshf.args", "1"},
	{"func.coshf.ret", "float"},
	{"func.coshl.arg.0", "long double,x"},
	{"func.coshl.args", "1"},
	{"func.coshl.ret", "long double"},
	{"func.cosl.arg.0", "long double,x"},
	{"func.cosl.args", "1"},
	{"func.cosl.ret", "long double"},
	{"func.ctime.arg.0", "const time_t *,timer"},
	{"func.ctime.args", "1"},
	{"func.ctime.ret", "char *"},
	{"func.cxa_bad_cast.args", "0"},
	{"func.cxa_bad_cast.noreturn", "true"},
	{"func.cxa_bad_cast.ret", "void"},
	{"func.cxa_bad_typeid.args", "0"},
	{"func.cxa_bad_typeid.noreturn", "true"},
	{"func.cxa_bad_typeid.ret", "void"},
	{"func.cxa_call_unexpected.arg.0", "void *,exception_object"},
	{"func.cxa_call_unexpected.args", "1"},
	{"func.cxa_call_unexpected.noreturn", "true"},
	{"func.cxa_call_unexpected.ret", "void"},
	{"func.cxa_end_cleanup.args", "0"},
	{"func.cxa_end_cleanup.noreturn", "true"},
	{"func.cxa_end_cleanup.ret", "void"},
	{"func.cxa_pure_virtual.args", "0"},
	{"func.cxa_pure_virtual.noreturn", "true"},
	{"func.cxa_pure_virtual.ret", "void"},
	{"func.cxa_rethrow.args", "0"},
	{"func.cxa_rethrow.noreturn", "true"},
	{"func.cxa_rethrow.ret", "void"},
	{"func.cxa_throw.arg.0", "void *,thrown_exception"},
	{"func.cxa_throw.arg.1", "struct std::type_info *,tinfo"},
	{"func.cxa_throw.arg.2", "void *,dest"},
	{"func.cxa_throw.args", "3"},
	{"func.cxa_throw.noreturn", "true"},
	{"func.cxa_throw.ret", "void"},
	{"func.cxa_throw_bad_array_new_length.args", "0"},
	{"func.cxa_throw_bad_array_new_length.noreturn", "true"},
	{"func.cxa_throw_bad_array_new_length.ret", "void"},
	{"func.dcgettext.arg.0", "const char *,domainname"},
	{"func.dcgettext.arg.1", "const char *,msgid"},
	{"func.dcgettext.arg.2", "int,category"},
	{"func.dcgettext.args", "3"},
	{"func.dcgettext.include", "libintl.h"},
	{"func.dcgettext.ret", "char *"},
	{"func.dcngettext.arg.0", "const char *,domainname"},
	{"func.dcngettext.arg.1", "const char *,msgid1"},
	{"func.dcngettext.arg.2", "const char *,msgid2"},
	{"func.dcngettext.arg.3", "unsigned long int,n"},
	{"func.dcngettext.arg.4", "int,category"},
	{"func.dcngettext.args", "5"},
	{"func.dcngettext.include", "libintl.h"},
	{"func.dcngettext.ret", "char *"},
	{"func.dgettext.arg.0", "const char *,domainname"},
	{"func.dgettext.arg.1", "const char *,msgid"},
	{"func.dgettext.args", "2"},
	{"func.dgettext.include", "libintl.h"},
	{"func.dgettext.ret", "char *"},
	{"func.difftime.arg.0", "time_t,time1"},
	{"func.difftime.arg.1", "time_t,time0"},
	{"func.difftime.args", "2"},
	{"func.difftime.ret", "double"},
	{"func.div.arg.0", "int,numer"},
	{"func.div.arg.1", "int,denom"},
	{"func.div.args", "2"},
	{"func.div.ret", "div_t"},
	{"func.dngettext.arg.0", "const char *,domainname"},
	{"func.dngettext.arg.1", "const char *,msgid1"},
	{"func.dngettext.arg.2", "const char *,msgid2"},
	{"func.dngettext.arg.3", "unsigned long int,n"},
	{"func.dngettext.args", "4"},
	{"func.dngettext.include", "libintl.h"},
	{"func.dngettext.ret", "char *"},
	{"func.dprintf.arg.0", "int,fd"},
	{"func.dprintf.arg.1", "const char *,format"},
	{"func.dprintf.arg.2", ",..."},
	{"func.dprintf.args", "3"},
	{"func.dprintf.ret", "int"},
	{"func.erf.arg.0", "arithmetic,x"},
	{"func.erf.args", "1"},
	{"func.erf.ret", "floating_point"},
	{"func.erfc.arg.0", "arithmetic,x"},
	{"func.erfc.args", "1"},
	{"func.erfc.ret", "floating_point"},
	{"func.erfcf.arg.0", "float,x"},
	{"func.erfcf.args", "1"},
	{"func.erfcf.ret", "float"},
	{"func.erfcl.arg.0", "long double,x"},
	{"func.erfcl.args", "1"},
	{"func.erfcl.ret", "long double"},
	{"func.erff.arg.0", "float,x"},
	{"func.erff.args", "1"},
	{"func.erff.ret", "float"},
	{"func.erfl.arg.0", "long double,x"},
	{"func.erfl.args", "1"},
	{"func.erfl.ret", "long double"},
	{"func.err.arg.0", "int,eval"},
	{"func.err.arg.1", "const char *,fmt"},
	{"func.err.arg.2", ",..."},
	{"func.err.args", "3"},
	{"func.err.noreturn", "true"},
	{"func.err.ret", "void"},
	{"func.errc.arg.0", "int,eval"},
	{"func.errc.arg.1", "int,code"},
	{"func.errc.arg.2", "const char *,fmt"},
	{"func.errc.args", "3"},
	{"func.errc.noreturn", "true"},
	{"func.errc.ret", "void"},
	{"func.error.arg.0", "int,status"},
	{"func.error.arg.1", "int,errname"},
	{"func.error.arg.2", "char *,format"},
	{"func.error.args", "3"},
	{"func.error.ret", "void"},
	{"func.errx.arg.0", "int,eval"},
	{"func.errx.arg.1", "const char *,fmt"},
	{"func.errx.arg.2", ",..."},
	{"func.errx.args", "3"},
	{"func.errx.noreturn", "true"},
	{"func.errx.ret", "void"},
	{"func.exp.arg.0", "arithmetic,x"},
	{"func.exp.args", "1"},
	{"func.exp.ret", "floating_point"},
	{"func.exp2.arg.0", "arithmetic,x"},
	{"func.exp2.args", "1"},
	{"func.exp2.ret", "floating_point"},
	{"func.exp2f.arg.0", "float,x"},
	{"func.exp2f.args", "1"},
	{"func.exp2f.ret", "float"},
	{"func.exp2l.arg.0", "long double,x"},
	{"func.exp2l.args", "1"},
	{"func.exp2l.ret", "long double"},
	{"func.expf.arg.0", "float,x"},
	{"func.expf.args", "1"},
	{"func.expf.ret", "float"},
	{"func.expl.arg.0", "long double,x"},
	{"func.expl.args", "1"},
	{"func.expl.ret", "long double"},
	{"func.expm1.arg.0", "arithmetic,x"},
	{"func.expm1.args", "1"},
	{"func.expm1.ret", "floating_point"},
	{"func.expm1f.arg.0", "float,x"},
	{"func.expm1f.args", "1"},
	{"func.expm1f.ret", "float"},
	{"func.expm1l.arg.0", "long double,x"},
	{"func.expm1l.args", "1"},
	{"func.expm1l.ret", "long double"},
	{"func.fabs.arg.0", "arithmetic,x"},
	{"func.fabs.args", "1"},
	{"func.fabs.ret", "floating_point"},
	{"func.fabsf.arg.0", "float,x"},
	{"func.fabsf.args", "1"},
	{"func.fabsf.ret", "float"},
	{"func.fabsl.arg.0", "long double,x"},
	{"func.fabsl.args", "1"},
	{"func.fabsl.ret", "long double"},
	{"func.fchmod.arg.0", "int,fd"},
	{"func.fchmod.arg.1", "int,mode"},
	{"func.fchmod.args", "2"},
	{"func.fchmod.ret", "int"},
	{"func.fchown.arg.0", "int,fd"},
	{"func.fchown.arg.1", "uid_t,owner"},
	{"func.fchown.arg.2", "gid_t,group"},
	{"func.fchown.args", "3"},
	{"func.fchown.ret", "int"},
	{"func.fclose.arg.0", "FILE *,stream"},
	{"func.fclose.args", "1"},
	{"func.fclose.ret", "int"},
	{"func.fdim.arg.0", "arithmetic,x"},
	{"func.fdim.arg.1", "arithmetic,y"},
	{"func.fdim.args", "2"},
	{"func.fdim.ret", "floating_point"},
	{"func.fdimf.arg.0", "float,x"},
	{"func.fdimf.arg.1", "float,y"},
	{"func.fdimf.args", "2"},
	{"func.fdimf.ret", "float"},
	{"func.fdiml.arg.0", "long double,x"},
	{"func.fdiml.arg.1", "long double,y"},
	{"func.fdiml.args", "2"},
	{"func.fdiml.ret", "long double"},
	{"func.fdopen.arg.0", "int,fd"},
	{"func.fdopen.arg.1", "const char *,mode"},
	{"func.fdopen.args", "2"},
	{"func.fdopen.ret", "file*"},
	{"func.feclearexcept.arg.0", "int,excepts"},
	{"func.feclearexcept.args", "1"},
	{"func.feclearexcept.ret", "int"},
	{"func.fegetenv.arg.0", "fenv_t *,envp"},
	{"func.fegetenv.args", "1"},
	{"func.fegetenv.ret", "int"},
	{"func.fegetexceptflag.arg.0", "fexcept_t *,flagp"},
	{"func.fegetexceptflag.arg.1", "int,excepts"},
	{"func.fegetexceptflag.args", "2"},
	{"func.fegetexceptflag.ret", "int"},
	{"func.fegetround.args", "0"},
	{"func.fegetround.ret", "int"},
	{"func.feholdexcept.arg.0", "fenv_t *,envp"},
	{"func.feholdexcept.args", "1"},
	{"func.feholdexcept.ret", "int"},
	{"func.feof.arg.0", "FILE *,stream"},
	{"func.feof.args", "1"},
	{"func.feof.ret", "int"},
	{"func.feraiseexcept.arg.0", "int,excepts"},
	{"func.feraiseexcept.args", "1"},
	{"func.feraiseexcept.ret", "int"},
	{"func.ferror.arg.0", "FILE *,stream"},
	{"func.ferror.args", "1"},
	{"func.ferror.ret", "int"},
	{"func.fesetenv.arg.0", "const,fenv_t*"},
	{"func.fesetenv.args", "1"},
	{"func.fesetenv.ret", "int"},
	{"func.fesetexceptflag.arg.0", "const,fexcept_t*"},
	{"func.fesetexceptflag.arg.1", "int,excepts"},
	{"func.fesetexceptflag.args", "2"},
	{"func.fesetexceptflag.ret", "int"},
	{"func.fesetround.arg.0", "int,round"},
	{"func.fesetround.args", "1"},
	{"func.fesetround.ret", "int"},
	{"func.fetestexcept.arg.0", "int,excepts"},
	{"func.fetestexcept.args", "1"},
	{"func.fetestexcept.ret", "int"},
	{"func.feupdateenv.arg.0", "const,fenv_t*"},
	{"func.feupdateenv.args", "1"},
	{"func.feupdateenv.ret", "int"},
	{"func.fflagtostr.arg.0", "int,flags"},
	{"func.fflagtostr.args", "1"},
	{"func.fflagtostr.ret", "char*"},
	{"func.fflush.arg.0", "FILE *,stream"},
	{"func.fflush.args", "1"},
	{"func.fflush.ret", "int"},
	{"func.fflush_unlocked.arg.0", "FILE *,stream"},
	{"func.fflush_unlocked.args", "1"},
	{"func.fflush_unlocked.ret", "int"},
	{"func.fgetc.arg.0", "FILE *,stream"},
	{"func.fgetc.args", "1"},
	{"func.fgetc.ret", "int"},
	{"func.fgetpos.arg.0", "FILE *,stream"},
	{"func.fgetpos.arg.1", "fpos_t*,pos"},
	{"func.fgetpos.args", "2"},
	{"func.fgetpos.ret", "int"},
	{"func.fgets.arg.0", "char *,s"},
	{"func.fgets.arg.1", "int,size"},
	{"func.fgets.arg.2", "FILE *,stream"},
	{"func.fgets.args", "3"},
	{"func.fgets.ret", "char *"},
	{"func.fgetwc.arg.0", "FILE *,stream"},
	{"func.fgetwc.args", "1"},
	{"func.fgetwc.ret", "wint_t"},
	{"func.fgetws.arg.0", "wchar_t *,s"},
	{"func.fgetws.arg.1", "int,n"},
	{"func.fgetws.arg.2", "FILE *,stream"},
	{"func.fgetws.args", "3"},
	{"func.fgetws.ret", "wchar_t*"},
	{"func.fileno.arg.0", "FILE *,stream"},
	{"func.fileno.args", "1"},
	{"func.fileno.ret", "int"},
	{"func.floor.arg.0", "arithmetic,x"},
	{"func.floor.args", "1"},
	{"func.floor.ret", "floating_point"},
	{"func.floorf.arg.0", "float,x"},
	{"func.floorf.args", "1"},
	{"func.floorf.ret", "float"},
	{"func.floorl.arg.0", "long double,x"},
	{"func.floorl.args", "1"},
	{"func.floorl.ret", "long double"},
	{"func.fma.arg.0", "arithmetic,x"},
	{"func.fma.arg.1", "arithmetic,y"},
	{"func.fma.arg.2", "arithmetic,z"},
	{"func.fma.args", "3"},
	{"func.fma.ret", "floating_point"},
	{"func.fmaf.arg.0", "float,x"},
	{"func.fmaf.arg.1", "float,y"},
	{"func.fmaf.arg.2", "float,z"},
	{"func.fmaf.args", "3"},
	{"func.fmaf.ret", "float"},
	{"func.fmal.arg.0", "long double,x"},
	{"func.fmal.arg.1", "long double,y"},
	{"func.fmal.arg.2", "long double,z"},
	{"func.fmal.args", "3"},
	{"func.fmal.ret", "long double"},
	{"func.fmax.arg.0", "arithmetic,x"},
	{"func.fmax.arg.1", "arithmetic,y"},
	{"func.fmax.args", "2"},
	{"func.fmax.ret", "floating_point"},
	{"func.fmaxf.arg.0", "float,x"},
	{"func.fmaxf.arg.1", "float,y"},
	{"func.fmaxf.args", "2"},
	{"func.fmaxf.ret", "float"},
	{"func.fmaxl.arg.0", "long double,x"},
	{"func.fmaxl.arg.1", "long double,y"},
	{"func.fmaxl.args", "2"},
	{"func.fmaxl.ret", "long double"},
	{"func.fmin.arg.0", "arithmetic,x"},
	{"func.fmin.arg.1", "arithmetic,y"},
	{"func.fmin.args", "2"},
	{"func.fmin.ret", "floating_point"},
	{"func.fminf.arg.0", "float,x"},
	{"func.fminf.arg.1", "float,y"},
	{"func.fminf.args", "2"},
	{"func.fminf.ret", "float"},
	{"func.fminl.arg.0", "long double,x"},
	{"func.fminl.arg.1", "long double,y"},
	{"func.fminl.args", "2"},
	{"func.fminl.ret", "long double"},
	{"func.fmod.arg.0", "arithmetic,x"},
	{"func.fmod.arg.1", "arithmetic,y"},
	{"func.fmod.args", "2"},
	{"func.fmod.ret", "floating_point"},
	{"func.fmodf.arg.0", "float,x"},
	{"func.fmodf.arg.1", "float,y"},
	{"func.fmodf.args", "2"},
	{"func.fmodf.ret", "float"},
	{"func.fmodl.arg.0", "long double,x"},
	{"func.fmodl.arg.1", "long double,y"},
	{"func.fmodl.args", "2"},
	{"func.fmodl.ret", "long double"},
	{"func.fopen.arg.0", "const char *,filename"},
	{"func.fopen.arg.1", "const char *,mode"},
	{"func.fopen.args", "2"},
	{"func.fopen.ret", "file*"},
	{"func.fpclassify.arg.0", "arithmetic,x"},
	{"func.fpclassify.args", "1"},
	{"func.fpclassify.ret", "int"},
	{"func.fprintf.arg.0", "FILE *,stream"},
	{"func.fprintf.arg.1", "const char *,format"},
	{"func.fprintf.arg.2", " ,..."},
	{"func.fprintf.args", "3"},
	{"func.fprintf.ret", "int"},
	{"func.fputc.arg.0", "int,c"},
	{"func.fputc.arg.1", "FILE *,stream"},
	{"func.fputc.args", "2"},
	{"func.fputc.ret", "int"},
	{"func.fputs.arg.0", "const char *,s"},
	{"func.fputs.arg.1", "FILE *,stream"},
	{"func.fputs.args", "2"},
	{"func.fputs.ret", "int"},
	{"func.fputwc.arg.0", "wchar_t,c"},
	{"func.fputwc.arg.1", "FILE *,stream"},
	{"func.fputwc.args", "2"},
	{"func.fputwc.ret", "wint_t"},
	{"func.fputws.arg.0", "const wchar_t *,s"},
	{"func.fputws.arg.1", "FILE *,stream"},
	{"func.fputws.args", "2"},
	{"func.fputws.ret", "int"},
	{"func.fread.arg.0", "void *,ptr"},
	{"func.fread.arg.1", "size_t,size"},
	{"func.fread.arg.2", "size_t,nmemb"},
	{"func.fread.arg.3", "FILE *,stream"},
	{"func.fread.args", "4"},
	{"func.fread.ret", "size_t"},
	{"func.free.arg.0", "void *,ptr"},
	{"func.free.args", "1"},
	{"func.free.ret", "void"},
	{"func.freopen.arg.0", "const char *,filename"},
	{"func.freopen.arg.1", "const char *,mode"},
	{"func.freopen.arg.2", "FILE *,stream"},
	{"func.freopen.args", "3"},
	{"func.freopen.ret", "file*"},
	{"func.frexp.arg.0", "arithmetic,value"},
	{"func.frexp.arg.1", "int *,exp"},
	{"func.frexp.args", "2"},
	{"func.frexp.ret", "floating_point"},
	{"func.frexpf.arg.0", "float,value"},
	{"func.frexpf.arg.1", "int *,exp"},
	{"func.frexpf.args", "2"},
	{"func.frexpf.ret", "float"},
	{"func.frexpl.arg.0", "long double,value"},
	{"func.frexpl.arg.1", "int *,exp"},
	{"func.frexpl.args", "2"},
	{"func.frexpl.ret", "long double"},
	{"func.fscanf.arg.0", "FILE *,stream"},
	{"func.fscanf.arg.1", "const char *,format"},
	{"func.fscanf.arg.2", ",..."},
	{"func.fscanf.args", "3"},
	{"func.fscanf.ret", "int"},
	{"func.fseek.arg.0", "FILE *,stream"},
	{"func.fseek.arg.1", "long,offset"},
	{"func.fseek.arg.2", "int,whence"},
	{"func.fseek.args", "3"},
	{"func.fseek.ret", "int"},
	{"func.fseeko.arg.0", "FILE *,stream"},
	{"func.fseeko.arg.1", "off_t,offset"},
	{"func.fseeko.arg.2", "int,whence"},
	{"func.fseeko.args", "3"},
	{"func.fseeko.ret", "int"},
	{"func.fsetpos.arg.0", "FILE *,stream"},
	{"func.fsetpos.arg.1", "const fpos_t*,pos"},
	{"func.fsetpos.args", "2"},
	{"func.fsetpos.ret", "int"},
	{"func.fstat.arg.0", "int,fildes"},
	{"func.fstat.arg.1", "void *,buf"},
	{"func.fstat.args", "2"},
	{"func.fstat.ret", "int"},
	{"func.ftell.arg.0", "FILE *,stream"},
	{"func.ftell.args", "1"},
	{"func.ftell.ret", "long"},
	{"func.ftello.arg.0", "FILE *,stream"},
	{"func.ftello.args", "1"},
	{"func.ftello.ret", "off_t"},
	{"func.fts_children_INODE64.arg.0", "void*,ftsp"},
	{"func.fts_children_INODE64.arg.1", "int,opotions"},
	{"func.fts_children_INODE64.args", "2"},
	{"func.fts_children_INODE64.ret", "void *"},
	{"func.fts_close_INODE64.arg.0", "void*,ftsp"},
	{"func.fts_close_INODE64.args", "1"},
	{"func.fts_close_INODE64.ret", "int"},
	{"func.fts_open_INODE64.arg.0", "const char *,path_argv"},
	{"func.fts_open_INODE64.arg.1", "int,options"},
	{"func.fts_open_INODE64.arg.2", "void *,compar"},
	{"func.fts_open_INODE64.arg.3", "void *,ftsen$INODE64t"},
	{"func.fts_open_INODE64.args", "4"},
	{"func.fts_open_INODE64.ret", "void *"},
	{"func.fts_read_INODE64.arg.0", "void*,ftsp"},
	{"func.fts_read_INODE64.args", "1"},
	{"func.fts_read_INODE64.ret", "void *"},
	{"func.fts_set_INODE64.arg.0", "void*,ftsp"},
	{"func.fts_set_INODE64.arg.1", "void*,f"},
	{"func.fts_set_INODE64.arg.2", "int,options"},
	{"func.fts_set_INODE64.args", "3"},
	{"func.fts_set_INODE64.ret", "int"},
	{"func.fwide.arg.0", "FILE *,stream"},
	{"func.fwide.arg.1", "int,mode"},
	{"func.fwide.args", "2"},
	{"func.fwide.ret", "int"},
	{"func.fwprintf.arg.0", "FILE *,stream"},
	{"func.fwprintf.arg.1", "const wchar_t *,format"},
	{"func.fwprintf.arg.2", ",..."},
	{"func.fwprintf.args", "3"},
	{"func.fwprintf.ret", "int"},
	{"func.fwrite.arg.0", "const void *,ptr"},
	{"func.fwrite.arg.1", "size_t,size"},
	{"func.fwrite.arg.2", "size_t,nitems"},
	{"func.fwrite.arg.3", "FILE *,stream"},
	{"func.fwrite.args", "4"},
	{"func.fwrite.ret", "size_t"},
	{"func.fwscanf.arg.0", "FILE *,stream"},
	{"func.fwscanf.arg.1", "const wchar_t *,format"},
	{"func.fwscanf.args", "2"},
	{"func.fwscanf.ret", "int"},
	{"func.getbsize.arg.0", "int *,hdrlenp"},
	{"func.getbsize.arg.1", "int *,bsizep"},
	{"func.getbsize.args", "2"},
	{"func.getbsize.ret", "char *"},
	{"func.getc.arg.0", "FILE *,stream"},
	{"func.getc.args", "1"},
	{"func.getc.ret", "int"},
	{"func.getchar.args", "0"},
	{"func.getchar.ret", "int"},
	{"func.getenv.arg.0", "const char *,name"},
	{"func.getenv.args", "1"},
	{"func.getenv.ret", "char *"},
	{"func.geteuid.args", "0"},
	{"func.geteuid.ret", "uid_t"},
	{"func.getopt.arg.0", "int,argc"},
	{"func.getopt.arg.1", "const char * *,argv"},
	{"func.getopt.arg.2", "const char *,optstring"},
	{"func.getopt.args", "3"},
	{"func.getopt.ret", "int"},
	{"func.getopt_long.arg.0", "int,argc"},
	{"func.getopt_long.arg.1", "char **,argv"},
	{"func.getopt_long.arg.2", "const char*,optstring"},
	{"func.getopt_long.arg.3", "void *,longopts"},
	{"func.getopt_long.arg.4", "int,longidx"},
	{"func.getopt_long.args", "5"},
	{"func.getopt_long.ret", "int"},
	{"func.getpid.args", "0"},
	{"func.getpid.ret", "int"},
	{"func.getprogname.args", "0"},
	{"func.getprogname.ret", "const char *"},
	{"func.gets.arg.0", "char *,s"},
	{"func.gets.args", "1"},
	{"func.gets.ret", "char *"},
	{"func.gettext.arg.0", "const char *,msgid"},
	{"func.gettext.args", "1"},
	{"func.gettext.include", "libintl.h"},
	{"func.gettext.ret", "char *"},
	{"func.getuid.args", "0"},
	{"func.getuid.ret", "uid_t"},
	{"func.getwc.arg.0", "FILE *,stream"},
	{"func.getwc.args", "1"},
	{"func.getwc.ret", "wint_t"},
	{"func.getwchar.args", "0"},
	{"func.getwchar.ret", "wint_t"},
	{"func.gmtime.arg.0", "const time_t *,timer"},
	{"func.gmtime.args", "1"},
	{"func.gmtime.ret", "tm*"},
	{"func.group_from_gid.arg.0", "gid_t,gid"},
	{"func.group_from_gid.arg.1", "int,nogroup"},
	{"func.group_from_gid.args", "2"},
	{"func.group_from_gid.ret", "char *"},
	{"func.group_from_uid.include", "grp.h"},
	{"func.humanize_number.arg.0", "char *,buf"},
	{"func.humanize_number.arg.1", "size_t,len"},
	{"func.humanize_number.arg.2", "int64_t,number"},
	{"func.humanize_number.arg.3", "const char *,suffix"},
	{"func.humanize_number.arg.4", "int,scale"},
	{"func.humanize_number.arg.5", "int,flags"},
	{"func.humanize_number.args", "1"},
	{"func.humanize_number.ret", "int"},
	{"func.hypot.arg.0", "arithmetic,x"},
	{"func.hypot.arg.1", "arithmetic,y"},
	{"func.hypot.args", "2"},
	{"func.hypot.ret", "floating_point"},
	{"func.hypotf.arg.0", "float,x"},
	{"func.hypotf.arg.1", "float,y"},
	{"func.hypotf.args", "2"},
	{"func.hypotf.ret", "float"},
	{"func.hypotl.arg.0", "long double,x"},
	{"func.hypotl.arg.1", "long double,y"},
	{"func.hypotl.args", "2"},
	{"func.hypotl.ret", "long double"},
	{"func.ilogb.arg.0", "arithmetic,x"},
	{"func.ilogb.args", "1"},
	{"func.ilogb.ret", "int"},
	{"func.ilogbf.arg.0", "float,x"},
	{"func.ilogbf.args", "1"},
	{"func.ilogbf.ret", "int"},
	{"func.ilogbl.arg.0", "long double,x"},
	{"func.ilogbl.args", "1"},
	{"func.ilogbl.ret", "int"},
	{"func.imaxabs.arg.0", "intmax_t,j"},
	{"func.imaxabs.args", "1"},
	{"func.imaxabs.ret", "intmax_t"},
	{"func.imaxdiv.arg.0", "intmax_t,numer"},
	{"func.imaxdiv.arg.1", "intmax_t,denom"},
	{"func.imaxdiv.args", "2"},
	{"func.imaxdiv.ret", "imaxdiv_t"},
	{"func.inet_aton.arg.0", "const char *,cp"},
	{"func.inet_aton.arg.1", "void *,pin"},
	{"func.inet_aton.args", "2"},
	{"func.inet_aton.ret", "int"},
	{"func.inet_ntoa.arg.0", "void *,in"},
	{"func.inet_ntoa.args", "1"},
	{"func.inet_ntoa.ret", "char *"},
	{"func.initstate.arg.0", "uint32_t,seed"},
	{"func.initstate.arg.1", "char *,state"},
	{"func.initstate.arg.2", "size_t,size"},
	{"func.initstate.args", "3"},
	{"func.initstate.ret", "char *"},
	{"func.ioctl.arg.0", "int,fd"},
	{"func.ioctl.arg.1", "unsigned long,request"},
	{"func.ioctl.arg.2", ",..."},
	{"func.ioctl.args", "3"},
	{"func.ioctl.ret", "int"},
	{"func.isalnum.arg.0", "int,c"},
	{"func.isalnum.args", "1"},
	{"func.isalnum.ret", "int"},
	{"func.isalpha.arg.0", "int,c"},
	{"func.isalpha.args", "1"},
	{"func.isalpha.ret", "int"},
	{"func.isatty.arg.0", "int,fd"},
	{"func.isatty.args", "1"},
	{"func.isatty.ret", "int"},
	{"func.isblank.arg.0", "int,c"},
	{"func.isblank.args", "1"},
	{"func.isblank.ret", "int"},
	{"func.iscntrl.arg.0", "int,c"},
	{"func.iscntrl.args", "1"},
	{"func.iscntrl.ret", "int"},
	{"func.isdigit.arg.0", "int,c"},
	{"func.isdigit.args", "1"},
	{"func.isdigit.ret", "int"},
	{"func.isfinite.arg.0", "arithmetic,x"},
	{"func.isfinite.args", "1"},
	{"func.isfinite.ret", "bool"},
	{"func.isgraph.arg.0", "int,c"},
	{"func.isgraph.args", "1"},
	{"func.isgraph.ret", "int"},
	{"func.isgreater.arg.0", "arithmetic,x"},
	{"func.isgreater.arg.1", "arithmetic,y"},
	{"func.isgreater.args", "2"},
	{"func.isgreater.ret", "bool"},
	{"func.isgreaterequal.arg.0", "arithmetic,x"},
	{"func.isgreaterequal.arg.1", "arithmetic,y"},
	{"func.isgreaterequal.args", "2"},
	{"func.isgreaterequal.ret", "bool"},
	{"func.isinf.arg.0", "arithmetic,x"},
	{"func.isinf.args", "1"},
	{"func.isinf.ret", "bool"},
	{"func.isless.arg.0", "arithmetic,x"},
	{"func.isless.arg.1", "arithmetic,y"},
	{"func.isless.args", "2"},
	{"func.isless.ret", "bool"},
	{"func.islessequal.arg.0", "arithmetic,x"},
	{"func.islessequal.arg.1", "arithmetic,y"},
	{"func.islessequal.args", "2"},
	{"func.islessequal.ret", "bool"},
	{"func.islessgreater.arg.0", "arithmetic,x"},
	{"func.islessgreater.arg.1", "arithmetic,y"},
	{"func.islessgreater.args", "2"},
	{"func.islessgreater.ret", "bool"},
	{"func.islower.arg.0", "int,c"},
	{"func.islower.args", "1"},
	{"func.islower.ret", "int"},
	{"func.isnan.arg.0", "arithmetic,x"},
	{"func.isnan.args", "1"},
	{"func.isnan.ret", "bool"},
	{"func.isnormal.arg.0", "arithmetic,x"},
	{"func.isnormal.args", "1"},
	{"func.isnormal.ret", "bool"},
	{"func.isprint.arg.0", "int,c"},
	{"func.isprint.args", "1"},
	{"func.isprint.ret", "int"},
	{"func.ispunct.arg.0", "int,c"},
	{"func.ispunct.args", "1"},
	{"func.ispunct.ret", "int"},
	{"func.isspace.arg.0", "int,c"},
	{"func.isspace.args", "1"},
	{"func.isspace.ret", "int"},
	{"func.isunordered.arg.0", "arithmetic,x"},
	{"func.isunordered.arg.1", "arithmetic,y"},
	{"func.isunordered.args", "2"},
	{"func.isunordered.ret", "bool"},
	{"func.isupper.arg.0", "int,c"},
	{"func.isupper.args", "1"},
	{"func.isupper.ret", "int"},
	{"func.iswalnum.arg.0", "wint_t,wc"},
	{"func.iswalnum.args", "1"},
	{"func.iswalnum.ret", "int"},
	{"func.iswalpha.arg.0", "wint_t,wc"},
	{"func.iswalpha.args", "1"},
	{"func.iswalpha.ret", "int"},
	{"func.iswblank.arg.0", "wint_t,wc"},
	{"func.iswblank.args", "1"},
	{"func.iswblank.ret", "int"},
	{"func.iswcntrl.arg.0", "wint_t,wc"},
	{"func.iswcntrl.args", "1"},
	{"func.iswcntrl.ret", "int"},
	{"func.iswctype.arg.0", "wint_t,wc"},
	{"func.iswctype.arg.1", "wctype_t,desc"},
	{"func.iswctype.args", "2"},
	{"func.iswctype.ret", "int"},
	{"func.iswdigit.arg.0", "wint_t,wc"},
	{"func.iswdigit.args", "1"},
	{"func.iswdigit.ret", "int"},
	{"func.iswgraph.arg.0", "wint_t,wc"},
	{"func.iswgraph.args", "1"},
	{"func.iswgraph.ret", "int"},
	{"func.iswlower.arg.0", "wint_t,wc"},
	{"func.iswlower.args", "1"},
	{"func.iswlower.ret", "int"},
	{"func.iswprint.arg.0", "wint_t,wc"},
	{"func.iswprint.args", "1"},
	{"func.iswprint.ret", "int"},
	{"func.iswpunct.arg.0", "wint_t,wc"},
	{"func.iswpunct.args", "1"},
	{"func.iswpunct.ret", "int"},
	{"func.iswspace.arg.0", "wint_t,wc"},
	{"func.iswspace.args", "1"},
	{"func.iswspace.ret", "int"},
	{"func.iswupper.arg.0", "wint_t,wc"},
	{"func.iswupper.args", "1"},
	{"func.iswupper.ret", "int"},
	{"func.iswxdigit.arg.0", "wint_t,wc"},
	{"func.iswxdigit.args", "1"},
	{"func.iswxdigit.ret", "int"},
	{"func.isxdigit.arg.0", "int,c"},
	{"func.isxdigit.args", "1"},
	{"func.isxdigit.ret", "int"},
	{"func.kill.arg.0", "pid_t,pid"},
	{"func.kill.arg.1", "int,sig"},
	{"func.kill.args", "2"},
	{"func.kill.ret", "int"},
	{"func.labs.arg.0", "long,j"},
	{"func.labs.args", "1"},
	{"func.labs.ret", "long"},
	{"func.ldexp.arg.0", "arithmetic,value"},
	{"func.ldexp.arg.1", "int,exp"},
	{"func.ldexp.args", "2"},
	{"func.ldexp.ret", "floating_point"},
	{"func.ldexpf.arg.0", "float,value"},
	{"func.ldexpf.arg.1", "int,exp"},
	{"func.ldexpf.args", "2"},
	{"func.ldexpf.ret", "float"},
	{"func.ldexpl.arg.0", "long double,value"},
	{"func.ldexpl.arg.1", "int,exp"},
	{"func.ldexpl.args", "2"},
	{"func.ldexpl.ret", "long double"},
	{"func.ldiv.arg.0", "long,numer"},
	{"func.ldiv.arg.1", "long,denom"},
	{"func.ldiv.args", "2"},
	{"func.ldiv.ret", "ldiv_t"},
	{"func.lgamma.arg.0", "arithmetic,x"},
	{"func.lgamma.args", "1"},
	{"func.lgamma.ret", "floating_point"},
	{"func.lgammaf.arg.0", "float,x"},
	{"func.lgammaf.args", "1"},
	{"func.lgammaf.ret", "float"},
	{"func.lgammal.arg.0", "long double,x"},
	{"func.lgammal.args", "1"},
	{"func.lgammal.ret", "long double"},
	{"func.listxattr.arg.0", "const char *,path"},
	{"func.listxattr.arg.1", "char*,namebuf"},
	{"func.listxattr.arg.2", "int,fsize"},
	{"func.listxattr.arg.3", "int,options"},
	{"func.listxattr.args", "4"},
	{"func.listxattr.ret", "int"},
	{"func.llabs.arg.0", "long long,j"},
	{"func.llabs.args", "1"},
	{"func.llabs.ret", "long long"},
	{"func.lldiv.arg.0", "long long,numer"},
	{"func.lldiv.arg.1", "long long,denom"},
	{"func.lldiv.args", "2"},
	{"func.lldiv.ret", "lldiv_t"},
	{"func.llrint.arg.0", "arithmetic,x"},
	{"func.llrint.args", "1"},
	{"func.llrint.ret", "long long"},
	{"func.llrintf.arg.0", "float,x"},
	{"func.llrintf.args", "1"},
	{"func.llrintf.ret", "long long"},
	{"func.llrintl.arg.0", "long double,x"},
	{"func.llrintl.args", "1"},
	{"func.llrintl.ret", "long long"},
	{"func.llround.arg.0", "arithmetic,x"},
	{"func.llround.args", "1"},
	{"func.llround.ret", "long long"},
	{"func.llroundf.arg.0", "float,x"},
	{"func.llroundf.args", "1"},
	{"func.llroundf.ret", "long long"},
	{"func.llroundl.arg.0", "long double,x"},
	{"func.llroundl.args", "1"},
	{"func.llroundl.ret", "long long"},
	{"func.localeconv.args", "0"},
	{"func.localeconv.ret", "lconv*"},
	{"func.localtime.arg.0", "const time_t *,timer"},
	{"func.localtime.args", "1"},
	{"func.localtime.ret", "tm*"},
	{"func.log.arg.0", "arithmetic,x"},
	{"func.log.args", "1"},
	{"func.log.ret", "floating_point"},
	{"func.log10.arg.0", "arithmetic,x"},
	{"func.log10.args", "1"},
	{"func.log10.ret", "floating_point"},
	{"func.log10f.arg.0", "float,x"},
	{"func.log10f.args", "1"},
	{"func.log10f.ret", "float"},
	{"func.log10l.arg.0", "long double,x"},
	{"func.log10l.args", "1"},
	{"func.log10l.ret", "long double"},
	{"func.log1p.arg.0", "arithmetic,x"},
	{"func.log1p.args", "1"},
	{"func.log1p.ret", "floating_point"},
	{"func.log1pf.arg.0", "float,x"},
	{"func.log1pf.args", "1"},
	{"func.log1pf.ret", "float"},
	{"func.log1pl.arg.0", "long double,x"},
	{"func.log1pl.args", "1"},
	{"func.log1pl.ret", "long double"},
	{"func.log2.arg.0", "arithmetic,x"},
	{"func.log2.args", "1"},
	{"func.log2.ret", "floating_point"},
	{"func.log2f.arg.0", "float,x"},
	{"func.log2f.args", "1"},
	{"func.log2f.ret", "float"},
	{"func.log2l.arg.0", "long double,x"},
	{"func.log2l.args", "1"},
	{"func.log2l.ret", "long double"},
	{"func.logb.arg.0", "arithmetic,x"},
	{"func.logb.args", "1"},
	{"func.logb.ret", "floating_point"},
	{"func.logbf.arg.0", "float,x"},
	{"func.logbf.args", "1"},
	{"func.logbf.ret", "float"},
	{"func.logbl.arg.0", "long double,x"},
	{"func.logbl.args", "1"},
	{"func.logbl.ret", "long double"},
	{"func.logf.arg.0", "float,x"},
	{"func.logf.args", "1"},
	{"func.logf.ret", "float"},
	{"func.logl.arg.0", "long double,x"},
	{"func.logl.args", "1"},
	{"func.logl.ret", "long double"},
	{"func.longjmp.arg.0", "jmp_buf,env"},
	{"func.longjmp.arg.1", "int,val"},
	{"func.longjmp.args", "2"},
	{"func.longjmp.ret", "void"},
	{"func.lrint.arg.0", "arithmetic,x"},
	{"func.lrint.args", "1"},
	{"func.lrint.ret", "long"},
	{"func.lrintf.arg.0", "float,x"},
	{"func.lrintf.args", "1"},
	{"func.lrintf.ret", "long"},
	{"func.lrintl.arg.0", "long double,x"},
	{"func.lrintl.args", "1"},
	{"func.lrintl.ret", "long"},
	{"func.lround.arg.0", "arithmetic,x"},
	{"func.lround.args", "1"},
	{"func.lround.ret", "long"},
	{"func.lroundf.arg.0", "float,x"},
	{"func.lroundf.args", "1"},
	{"func.lroundf.ret", "long"},
	{"func.lroundl.arg.0", "long double,x"},
	{"func.lroundl.args", "1"},
	{"func.lroundl.ret", "long"},
	{"func.lseek.arg.0", "int,fd"},
	{"func.lseek.arg.1", "off_t,offset"},
	{"func.lseek.arg.2", "int,whence"},
	{"func.lseek.args", "3"},
	{"func.lseek.ret", "off_t"},
	{"func.lstat.arg.0", "const char *,path"},
	{"func.lstat.arg.1", "void *,buf"},
	{"func.lstat.args", "2"},
	{"func.lstat.ret", "int"},
	{"func.main.arg.0", "int,argc"},
	{"func.main.arg.1", "char **,argv"},
	{"func.main.arg.2", "char **,envp"},
	{"func.main.args", "3"},
	{"func.main.ret", "int"},
	{"func.malloc.arg.0", "size_t,size"},
	{"func.malloc.args", "1"},
	{"func.malloc.ret", " void *"},
	{"func.maskrune.arg.0", "uint32_t,c"},
	{"func.maskrune.arg.1", "unsigned long,f"},
	{"func.maskrune.args", "2"},
	{"func.maskrune.ret", "int"},
	{"func.mblen.arg.0", "const char *,s"},
	{"func.mblen.arg.1", "size_t,n"},
	{"func.mblen.args", "2"},
	{"func.mblen.ret", "int"},
	{"func.mbrlen.arg.0", "const char *,s"},
	{"func.mbrlen.arg.1", "size_t,n"},
	{"func.mbrlen.arg.2", "mbstate_t *,ps"},
	{"func.mbrlen.args", "3"},
	{"func.mbrlen.ret", "size_t"},
	{"func.mbrtowc.arg.0", "wchar_t *,pwc"},
	{"func.mbrtowc.arg.1", "const char *,s"},
	{"func.mbrtowc.arg.2", "size_t,n"},
	{"func.mbrtowc.arg.3", "mbstate_t *,ps"},
	{"func.mbrtowc.args", "4"},
	{"func.mbrtowc.ret", "size_t"},
	{"func.mbsinit.arg.0", "const mbstate_t *,ps"},
	{"func.mbsinit.args", "1"},
	{"func.mbsinit.ret", "int"},
	{"func.mbsrtowcs.arg.0", "wchar_t *,dst"},
	{"func.mbsrtowcs.arg.1", "const char * *,src"},
	{"func.mbsrtowcs.arg.2", "size_t,len"},
	{"func.mbsrtowcs.arg.3", "mbstate_t *,ps"},
	{"func.mbsrtowcs.args", "4"},
	{"func.mbsrtowcs.ret", "size_t"},
	{"func.mbstowcs.arg.0", "wchar_t *,pwcs"},
	{"func.mbstowcs.arg.1", "const char *,s"},
	{"func.mbstowcs.arg.2", "size_t,n"},
	{"func.mbstowcs.args", "3"},
	{"func.mbstowcs.ret", "size_t"},
	{"func.mbtowc.arg.0", "wchar_t *,pwc"},
	{"func.mbtowc.arg.1", "const char *,s"},
	{"func.mbtowc.arg.2", "size_t,n"},
	{"func.mbtowc.args", "3"},
	{"func.mbtowc.ret", "int"},
	{"func.memchr.arg.0", "void *,s"},
	{"func.memchr.arg.1", "int,c"},
	{"func.memchr.arg.2", "size_t,n"},
	{"func.memchr.args", "3"},
	{"func.memchr.ret", "void *"},
	{"func.memcmp.arg.0", "const void *,s1"},
	{"func.memcmp.arg.1", "const void *,s2"},
	{"func.memcmp.arg.2", "size_t,n"},
	{"func.memcmp.args", "3"},
	{"func.memcmp.ret", "int"},
	{"func.memcpy.arg.0", "void *,s1"},
	{"func.memcpy.arg.1", "const void *,s2"},
	{"func.memcpy.arg.2", "size_t,n"},
	{"func.memcpy.args", "3"},
	{"func.memcpy.ret", "void *"},
	{"func.memcpy_chk.arg.0", "void *,dest"},
	{"func.memcpy_chk.arg.1", "const void *,src"},
	{"func.memcpy_chk.arg.2", "size_t,len"},
	{"func.memcpy_chk.arg.3", "size_t,destlen"},
	{"func.memcpy_chk.args", "4"},
	{"func.memcpy_chk.ret", "void *"},
	{"func.memmem.arg.0", "const void *,big"},
	{"func.memmem.arg.1", "int,big_len"},
	{"func.memmem.arg.2", "const void *,little"},
	{"func.memmem.arg.3", "int,little_len"},
	{"func.memmem.args", "4"},
	{"func.memmem.ret", "void *"},
	{"func.memmove.arg.0", "void *,s1"},
	{"func.memmove.arg.1", "const void *,s2"},
	{"func.memmove.arg.2", "size_t,n"},
	{"func.memmove.args", "3"},
	{"func.memmove.ret", "void *"},
	{"func.memmove_chk.arg.0", "void *,dest"},
	{"func.memmove_chk.arg.1", "const void *,src"},
	{"func.memmove_chk.arg.2", "size_t,len"},
	{"func.memmove_chk.arg.3", "size_t,destlen"},
	{"func.memmove_chk.args", "4"},
	{"func.memmove_chk.ret", "void *"},
	{"func.memset.arg.0", "void *,s"},
	{"func.memset.arg.1", "int,c"},
	{"func.memset.arg.2", "size_t,n"},
	{"func.memset.args", "3"},
	{"func.memset.ret", "void *"},
	{"func.memset_chk.arg.0", "void *,dest"},
	{"func.memset_chk.arg.1", "int,c"},
	{"func.memset_chk.arg.2", "size_t,len"},
	{"func.memset_chk.arg.3", "size_t,destlen"},
	{"func.memset_chk.args", "4"},
	{"func.memset_chk.ret", "void *"},
	{"func.mkstemp.arg.0", "char *,template"},
	{"func.mkstemp.args", "1"},
	{"func.mkstemp.ret", "int"},
	{"func.mktemp.arg.0", "char *,template"},
	{"func.mktemp.args", "1"},
	{"func.mktemp.ret", "char *"},
	{"func.mktime.arg.0", "tm *,timeptr"},
	{"func.mktime.args", "1"},
	{"func.mktime.ret", "time_t"},
	{"func.mmap.arg.0", "void*,addr"},
	{"func.mmap.arg.1", "size_t,length"},
	{"func.mmap.arg.2", "int,prot"},
	{"func.mmap.arg.3", "int,flags"},
	{"func.mmap.arg.4", "int,fd"},
	{"func.mmap.arg.5", "size_t,offset"},
	{"func.mmap.args", "6"},
	{"func.mmap.ret", "void*"},
	{"func.modf.arg.0", "floating_point,value"},
	{"func.modf.arg.1", "floating_point *,iptr"},
	{"func.modf.args", "2"},
	{"func.modf.ret", "floating_point"},
	{"func.modff.arg.0", "float,value"},
	{"func.modff.arg.1", "float *,iptr"},
	{"func.modff.args", "2"},
	{"func.modff.ret", "float"},
	{"func.modfl.arg.0", "long double,value"},
	{"func.modfl.arg.1", "long double *,iptr"},
	{"func.modfl.args", "2"},
	{"func.modfl.ret", "long double"},
	{"func.munmap.arg.0", "void*,addr"},
	{"func.munmap.arg.1", "size_t,length"},
	{"func.munmap.args", "2"},
	{"func.munmap.ret", "int"},
	{"func.nan.arg.0", "const char *,str"},
	{"func.nan.args", "1"},
	{"func.nan.ret", "double"},
	{"func.nanf.arg.0", "const char *,str"},
	{"func.nanf.args", "1"},
	{"func.nanf.ret", "float"},
	{"func.nanl.arg.0", "const char *,str"},
	{"func.nanl.args", "1"},
	{"func.nanl.ret", "long double"},
	{"func.nearbyint.arg.0", "arithmetic,x"},
	{"func.nearbyint.args", "1"},
	{"func.nearbyint.ret", "floating_point"},
	{"func.nearbyintf.arg.0", "float,x"},
	{"func.nearbyintf.args", "1"},
	{"func.nearbyintf.ret", "float"},
	{"func.nearbyintl.arg.0", "long double,x"},
	{"func.nearbyintl.args", "1"},
	{"func.nearbyintl.ret", "long double"},
	{"func.nextafter.arg.0", "arithmetic,x"},
	{"func.nextafter.arg.1", "arithmetic,y"},
	{"func.nextafter.args", "2"},
	{"func.nextafter.ret", "floating_point"},
	{"func.nextafterf.arg.0", "float,x"},
	{"func.nextafterf.arg.1", "float,y"},
	{"func.nextafterf.args", "2"},
	{"func.nextafterf.ret", "float"},
	{"func.nextafterl.arg.0", "long double,x"},
	{"func.nextafterl.arg.1", "long double,y"},
	{"func.nextafterl.args", "2"},
	{"func.nextafterl.ret", "long double"},
	{"func.nexttoward.arg.0", "arithmetic,x"},
	{"func.nexttoward.arg.1", "long double,y"},
	{"func.nexttoward.args", "2"},
	{"func.nexttoward.ret", "floating_point"},
	{"func.nexttowardf.arg.0", "float,x"},
	{"func.nexttowardf.arg.1", "long double,y"},
	{"func.nexttowardf.args", "2"},
	{"func.nexttowardf.ret", "float"},
	{"func.nexttowardl.arg.0", "long double,x"},
	{"func.nexttowardl.arg.1", "long double,y"},
	{"func.nexttowardl.args", "2"},
	{"func.nexttowardl.ret", "long double"},
	{"func.ngettext.arg.0", "const char *,msgid1"},
	{"func.ngettext.arg.1", "const char *,msgid2"},
	{"func.ngettext.arg.2", "unsigned long int,n"},
	{"func.ngettext.args", "3"},
	{"func.ngettext.include", "libintl.h"},
	{"func.ngettext.ret", "char *"},
	{"func.nl_langinfo.arg.0", "nl_item,item"},
	{"func.nl_langinfo.args", "1"},
	{"func.nl_langinfo.ret", "char *"},
	{"func.nl_langinfo_l.arg.0", "nl_item,item"},
	{"func.nl_langinfo_l.arg.1", "locale_t locale"},
	{"func.nl_langinfo_l.args", "2"},
	{"func.nl_langinfo_l.ret", "char *"},
	{"func.objc_allocWithZone.arg.0", "void *"},
	{"func.objc_allocWithZone.args", "1"},
	{"func.objc_allocWithZone.ret", "void *"},
	{"func.objc_enumerationMutation.arg.0", "void *,instance"},
	{"func.objc_enumerationMutation.args", "1"},
	{"func.objc_enumerationMutation.ret", "void"},
	{"func.objc_exception_rethrow.args", "0"},
	{"func.objc_exception_rethrow.noreturn", "true"},
	{"func.objc_exception_rethrow.ret", "void"},
	{"func.objc_exception_throw.arg.0", "void *,exception"},
	{"func.objc_exception_throw.args", "1"},
	{"func.objc_exception_throw.noreturn", "true"},
	{"func.objc_exception_throw.ret", "void"},
	{"func.objc_msgSend.arg.0", "void *,self"},
	{"func.objc_msgSend.arg.1", "char *,op"},
	{"func.objc_msgSend.arg.2", ",..."},
	{"func.objc_msgSend.args", "3"},
	{"func.objc_msgSend.ret", "void *"},
	{"func.objc_msgSendSuper2.arg.0", "void *,super"},
	{"func.objc_msgSendSuper2.arg.1", "char *,op"},
	{"func.objc_msgSendSuper2.arg.2", ",..."},
	{"func.objc_msgSendSuper2.args", "3"},
	{"func.objc_msgSendSuper2.ret", "void *"},
	{"func.objc_opt_self.arg.0", "void *"},
	{"func.objc_opt_self.args", "1"},
	{"func.objc_opt_self.ret", "void *"},
	{"func.objc_release.arg.0", "void *,instance"},
	{"func.objc_release.args", "1"},
	{"func.objc_release.ret", "void"},
	{"func.objc_retain.arg.0", "void *,obj"},
	{"func.objc_retain.args", "1"},
	{"func.objc_retain.ret", "void *"},
	{"func.objc_retainAutoreleasedReturnValue.arg.0", "void *,obj"},
	{"func.objc_retainAutoreleasedReturnValue.args", "1"},
	{"func.objc_retainAutoreleasedReturnValue.ret", "void *"},
	{"func.objc_storeStrong.arg.0", "void **,location"},
	{"func.objc_storeStrong.arg.1", "void *,obj"},
	{"func.objc_storeStrong.args", "2"},
	{"func.objc_storeStrong.ret", "void"},
	{"func.open.arg.0", "const char *,path"},
	{"func.open.arg.1", "int,oflag"},
	{"func.open.args", "2"},
	{"func.open.ret", "int"},
	{"func.openat.arg.0", "int,fd"},
	{"func.openat.arg.1", "const char *,path"},
	{"func.openat.arg.2", "int,oflag"},
	{"func.openat.args", "3"},
	{"func.openat.ret", "int"},
	{"func.pclose.arg.0", "FILE *,stream"},
	{"func.pclose.args", "1"},
	{"func.pclose.ret", "int"},
	{"func.perror.arg.0", "const char *,s"},
	{"func.perror.args", "1"},
	{"func.perror.ret", "void"},
	{"func.popen.arg.0", "const char *,filename"},
	{"func.popen.arg.1", "const char *,mode"},
	{"func.popen.args", "2"},
	{"func.popen.ret", "file*"},
	{"func.pow.arg.0", "arithmetic,x"},
	{"func.pow.arg.1", "arithmetic,y"},
	{"func.pow.args", "2"},
	{"func.pow.ret", "floating_point"},
	{"func.powf.arg.0", "float,x"},
	{"func.powf.arg.1", "float,y"},
	{"func.powf.args", "2"},
	{"func.powf.ret", "float"},
	{"func.powl.arg.0", "long double,x"},
	{"func.powl.arg.1", "long double,y"},
	{"func.powl.args", "2"},
	{"func.powl.ret", "long double"},
	{"func.printf.arg.0", "const char *,format"},
	{"func.printf.arg.1", ",..."},
	{"func.printf.args", "2"},
	{"func.printf.ret", "int"},
	{"func.ptrace.arg.0", "__ptrace_request,request"},
	{"func.ptrace.arg.1", "pid_t,pid"},
	{"func.ptrace.arg.2", "void*,addr"},
	{"func.ptrace.arg.3", "void*,data"},
	{"func.ptrace.args", "4"},
	{"func.ptrace.ret", "long"},
	{"func.putc.arg.0", "int,c"},
	{"func.putc.arg.1", "FILE *,stream"},
	{"func.putc.args", "2"},
	{"func.putc.ret", "int"},
	{"func.putchar.arg.0", "int,c"},
	{"func.putchar.args", "1"},
	{"func.putchar.ret", "int"},
	{"func.puts.arg.0", "const char *,s"},
	{"func.puts.args", "1"},
	{"func.puts.ret", "int"},
	{"func.pututxline.arg.0", "void *,utx"},
	{"func.pututxline.args", "1"},
	{"func.pututxline.ret", "void *"},
	{"func.putwc.arg.0", "wchar_t,c"},
	{"func.putwc.arg.1", "FILE *,stream"},
	{"func.putwc.args", "2"},
	{"func.putwc.ret", "wint_t"},
	{"func.putwchar.arg.0", "wchar_t,c"},
	{"func.putwchar.args", "1"},
	{"func.putwchar.ret", "wint_t"},
	{"func.qsort.arg.0", "void *,base"},
	{"func.qsort.arg.1", "size_t,nmemb"},
	{"func.qsort.arg.2", "size_t,size"},
	{"func.qsort.arg.3", "int(*compar)(const void *,const void *)"},
	{"func.qsort.args", "4"},
	{"func.quick_exit.arg.0", "int,status"},
	{"func.quick_exit.args", "1"},
	{"func.quick_exit.ret", "void"},
	{"func.raise.arg.0", "int,sig"},
	{"func.raise.args", "1"},
	{"func.raise.ret", "int"},
	{"func.rand.args", "0"},
	{"func.rand.ret", "int"},
	{"func.random.args", "0"},
	{"func.random.ret", "uint32_t"},
	{"func.read.arg.0", "int,fildes"},
	{"func.read.arg.1", "void *,buf"},
	{"func.read.arg.2", "size_t,nbyte"},
	{"func.read.args", "3"},
	{"func.read.ret", "ssize_t"},
	{"func.readlink.arg.0", "const char *,path"},
	{"func.readlink.arg.1", "char *,buf"},
	{"func.readlink.arg.2", "int,bufsize"},
	{"func.readlink.args", "3"},
	{"func.readlink.ret", "int"},
	{"func.realloc.arg.0", "void *,ptr"},
	{"func.realloc.arg.1", "size_t,size"},
	{"func.realloc.args", "2"},
	{"func.realloc.ret", "void *"},
	{"func.reallocf.arg.0", "void *,ptr"},
	{"func.reallocf.arg.1", "size_t,size"},
	{"func.reallocf.args", "2"},
	{"func.reallocf.ret", "void *"},
	{"func.recv.arg.0", "int,socket"},
	{"func.recv.arg.1", "void *,buffer"},
	{"func.recv.arg.2", "size_t,length"},
	{"func.recv.arg.3", "int,flags"},
	{"func.recv.args", "4"},
	{"func.recv.ret", "ssize_t"},
	{"func.remainder.arg.0", "arithmetic,x"},
	{"func.remainder.arg.1", "arithmetic,y"},
	{"func.remainder.args", "2"},
	{"func.remainder.ret", "floating_point"},
	{"func.remainderf.arg.0", "float,x"},
	{"func.remainderf.arg.1", "float,y"},
	{"func.remainderf.args", "2"},
	{"func.remainderf.ret", "float"},
	{"func.remainderl.arg.0", "long double,x"},
	{"func.remainderl.arg.1", "long double,y"},
	{"func.remainderl.args", "2"},
	{"func.remainderl.ret", "long double"},
	{"func.remove.arg.0", "const char *,filename"},
	{"func.remove.args", "1"},
	{"func.remove.ret", "int"},
	{"func.remquo.arg.0", "arithmetic,x"},
	{"func.remquo.arg.1", "arithmetic,y"},
	{"func.remquo.arg.2", "int *,pquo"},
	{"func.remquo.args", "3"},
	{"func.remquo.ret", "floating_point"},
	{"func.remquof.arg.0", "float,x"},
	{"func.remquof.arg.1", "float,y"},
	{"func.remquof.arg.2", "int *,pquo"},
	{"func.remquof.args", "3"},
	{"func.remquof.ret", "float"},
	{"func.remquol.arg.0", "long double,x"},
	{"func.remquol.arg.1", "long double,y"},
	{"func.remquol.arg.2", "int *,pquo"},
	{"func.remquol.args", "3"},
	{"func.remquol.ret", "long double"},
	{"func.rename.arg.0", "const char *,oldpath"},
	{"func.rename.arg.1", "const char *,newpath"},
	{"func.rename.args", "2"},
	{"func.rename.ret", "int"},
	{"func.rewind.arg.0", "FILE *,stream"},
	{"func.rewind.args", "1"},
	{"func.rewind.ret", "void"},
	{"func.rint.arg.0", "arithmetic,x"},
	{"func.rint.args", "1"},
	{"func.rint.ret", "floating_point"},
	{"func.rintf.arg.0", "float,x"},
	{"func.rintf.args", "1"},
	{"func.rintf.ret", "float"},
	{"func.rintl.arg.0", "long double,x"},
	{"func.rintl.args", "1"},
	{"func.rintl.ret", "long double"},
	{"func.round.arg.0", "arithmetic,x"},
	{"func.round.args", "1"},
	{"func.round.ret", "floating_point"},
	{"func.roundf.arg.0", "float,x"},
	{"func.roundf.args", "1"},
	{"func.roundf.ret", "float"},
	{"func.roundl.arg.0", "long double,x"},
	{"func.roundl.args", "1"},
	{"func.roundl.ret", "long double"},
	{"func.scalbln.arg.0", "arithmetic,x"},
	{"func.scalbln.arg.1", "long,ex"},
	{"func.scalbln.args", "2"},
	{"func.scalbln.ret", "floating_point"},
	{"func.scalblnf.arg.0", "float,x"},
	{"func.scalblnf.arg.1", "long,ex"},
	{"func.scalblnf.args", "2"},
	{"func.scalblnf.ret", "float"},
	{"func.scalblnl.arg.0", "long double,x"},
	{"func.scalblnl.arg.1", "long,ex"},
	{"func.scalblnl.args", "2"},
	{"func.scalblnl.ret", "long double"},
	{"func.scalbn.arg.0", "arithmetic,x"},
	{"func.scalbn.arg.1", "int,ex"},
	{"func.scalbn.args", "2"},
	{"func.scalbn.ret", "floating_point"},
	{"func.scalbnf.arg.0", "float,x"},
	{"func.scalbnf.arg.1", "int,ex"},
	{"func.scalbnf.args", "2"},
	{"func.scalbnf.ret", "float"},
	{"func.scalbnl.arg.0", "long double,x"},
	{"func.scalbnl.arg.1", "int,ex"},
	{"func.scalbnl.args", "2"},
	{"func.scalbnl.ret", "long double"},
	{"func.scanf.arg.0", "const char *,format"},
	{"func.scanf.arg.1", ",..."},
	{"func.scanf.args", "2"},
	{"func.scanf.ret", "int"},
	{"func.send.arg.0", "int,socket"},
	{"func.send.arg.1", "void *,buffer"},
	{"func.send.arg.2", "size_t,length"},
	{"func.send.arg.3", "int,flags"},
	{"func.send.args", "4"},
	{"func.send.ret", "ssize_t"},
	{"func.setbuf.arg.0", "FILE *,stream"},
	{"func.setbuf.arg.1", "char *,buf"},
	{"func.setbuf.args", "2"},
	{"func.setbuf.ret", "void"},
	{"func.setenv.arg.0", "const char *,name"},
	{"func.setenv.arg.1", "const char *,value"},
	{"func.setenv.arg.2", "int,overwrite"},
	{"func.setenv.args", "3"},
	{"func.setenv.ret", "int"},
	{"func.setgid.arg.0", "int,gid"},
	{"func.setgid.args", "1"},
	{"func.setgid.ret", "int"},
	{"func.setjmp.arg.0", "jmpbuf,env"},
	{"func.setjmp.args", "1"},
	{"func.setjmp.ret", "int"},
	{"func.setlocale.arg.0", "int,category"},
	{"func.setlocale.arg.1", "const char *,locale"},
	{"func.setlocale.args", "2"},
	{"func.setlocale.ret", "char *"},
	{"func.setstate.arg.0", "const char *,state"},
	{"func.setstate.args", "1"},
	{"func.setstate.ret", "const char *"},
	{"func.setuid.arg.0", "int,uid"},
	{"func.setuid.args", "1"},
	{"func.setuid.ret", "int"},
	{"func.setvbuf.arg.0", "FILE*,stream"},
	{"func.setvbuf.arg.1", "char *,buf"},
	{"func.setvbuf.arg.2", "int,mode"},
	{"func.setvbuf.arg.3", "size_t,size"},
	{"func.setvbuf.args", "4"},
	{"func.setvbuf.ret", "int"},
	{"func.signal.arg.0", "int,sig"},
	{"func.signal.arg.1", "void *,func"},
	{"func.signal.args", "2"},
	{"func.signal.ret", "void"},
	{"func.signbit.arg.0", "arithmetic,x"},
	{"func.signbit.args", "1"},
	{"func.signbit.ret", "bool"},
	{"func.sigprocmask.arg.0", "int,how"},
	{"func.sigprocmask.arg.1", "void *,set"},
	{"func.sigprocmask.arg.2", "void *,oldset"},
	{"func.sigprocmask.args", "3"},
	{"func.sigprocmask.ret", "pid_t"},
	{"func.sin.arg.0", "arithmetic,x"},
	{"func.sin.args", "1"},
	{"func.sin.ret", "floating_point"},
	{"func.sinf.arg.0", "float,x"},
	{"func.sinf.args", "1"},
	{"func.sinf.ret", "float"},
	{"func.sinh.arg.0", "arithmetic,x"},
	{"func.sinh.args", "1"},
	{"func.sinh.ret", "floating_point"},
	{"func.sinhf.arg.0", "float,x"},
	{"func.sinhf.args", "1"},
	{"func.sinhf.ret", "float"},
	{"func.sinhl.arg.0", "long double,x"},
	{"func.sinhl.args", "1"},
	{"func.sinhl.ret", "long double"},
	{"func.sinl.arg.0", "long double,x"},
	{"func.sinl.args", "1"},
	{"func.sinl.ret", "long double"},
	{"func.sleep.arg.0", "int,s"},
	{"func.sleep.args", "1"},
	{"func.sleep.ret", "int"},
	{"func.snprintf.arg.0", "char *,s"},
	{"func.snprintf.arg.1", "size_t,size"},
	{"func.snprintf.arg.2", "const char *,format"},
	{"func.snprintf.arg.3", ",..."},
	{"func.snprintf.args", "4"},
	{"func.snprintf.ret", "int"},
	{"func.snprintf_chk.arg.0", "char *,s"},
	{"func.snprintf_chk.arg.1", "size_t,maxlen"},
	{"func.snprintf_chk.arg.2", "int,flag"},
	{"func.snprintf_chk.arg.3", "size_t,slen"},
	{"func.snprintf_chk.arg.4", "const char *,format"},
	{"func.snprintf_chk.arg.5", ",..."},
	{"func.snprintf_chk.args", "6"},
	{"func.snprintf_chk.ret", "int"},
	{"func.socket.arg.0", "int,domain"},
	{"func.socket.arg.1", "int,type"},
	{"func.socket.arg.2", "int,protocol"},
	{"func.socket.args", "3"},
	{"func.socket.ret", "int"},
	{"func.sprintf.arg.0", "char *,s"},
	{"func.sprintf.arg.1", "const char *,format"},
	{"func.sprintf.arg.2", ",..."},
	{"func.sprintf.args", "3"},
	{"func.sprintf.ret", "int"},
	{"func.sprintf_chk.arg.0", "char *,s"},
	{"func.sprintf_chk.arg.1", "int,flag"},
	{"func.sprintf_chk.arg.2", "size_t,slen"},
	{"func.sprintf_chk.arg.3", "const char *,format"},
	{"func.sprintf_chk.arg.4", ",..."},
	{"func.sprintf_chk.args", "5"},
	{"func.sprintf_chk.ret", "int"},
	{"func.sqrt.arg.0", "arithmetic,x"},
	{"func.sqrt.args", "1"},
	{"func.sqrt.ret", "floating_point"},
	{"func.sqrtf.arg.0", "float,x"},
	{"func.sqrtf.args", "1"},
	{"func.sqrtf.ret", "float"},
	{"func.sqrtl.arg.0", "long double,x"},
	{"func.sqrtl.args", "1"},
	{"func.sqrtl.ret", "long double"},
	{"func.srand.arg.0", "int,seed"},
	{"func.srand.args", "1"},
	{"func.srand.ret", "void"},
	{"func.srandom.arg.0", "uint32_t,seed"},
	{"func.srandom.args", "1"},
	{"func.srandom.ret", "uint32_t"},
	{"func.srandomdev.args", "0"},
	{"func.srandomdev.ret", "void"},
	{"func.sscanf.arg.0", "const char *,s"},
	{"func.sscanf.arg.1", "const char *,format"},
	{"func.sscanf.arg.2", " ,..."},
	{"func.sscanf.args", "3"},
	{"func.sscanf.ret", "int"},
	{"func.stat.arg.0", "const char *,path"},
	{"func.stat.arg.1", "void *,buf"},
	{"func.stat.args", "2"},
	{"func.stat.ret", "int"},
	{"func.std::terminate__.args", "0"},
	{"func.std::terminate__.noreturn", "true"},
	{"func.std::terminate__.ret", "void"},
	{"func.stpcpy_chk.arg.0", "char *,dest"},
	{"func.stpcpy_chk.arg.1", "const char *,src"},
	{"func.stpcpy_chk.arg.2", "size_t,destlen"},
	{"func.stpcpy_chk.args", "3"},
	{"func.stpcpy_chk.ret", "char *"},
	{"func.stpncpy_chk.arg.0", "char *,dest"},
	{"func.stpncpy_chk.arg.1", "const char *,src"},
	{"func.stpncpy_chk.arg.2", "size_t,len"},
	{"func.stpncpy_chk.arg.3", "size_t,destlen"},
	{"func.stpncpy_chk.args", "4"},
	{"func.stpncpy_chk.ret", "char *"},
	{"func.strcasecmp.arg.0", "const char *,s1"},
	{"func.strcasecmp.arg.1", "const char *,s2"},
	{"func.strcasecmp.args", "2"},
	{"func.strcasecmp.ret", "int"},
	{"func.strcat.arg.0", "char *,s1"},
	{"func.strcat.arg.1", "const char *,s2"},
	{"func.strcat.args", "2"},
	{"func.strcat.ret", "char *"},
	{"func.strcat_chk.arg.0", "char *,dest"},
	{"func.strcat_chk.arg.1", "const char *,src"},
	{"func.strcat_chk.arg.2", "size_t,destlen"},
	{"func.strcat_chk.args", "3"},
	{"func.strcat_chk.ret", "char *"},
	{"func.strchr.arg.0", "const char *,s"},
	{"func.strchr.arg.1", "int,c"},
	{"func.strchr.args", "2"},
	{"func.strchr.ret", "char *"},
	{"func.strcmp.arg.0", "const char *,s1"},
	{"func.strcmp.arg.1", "const char *,s2"},
	{"func.strcmp.args", "2"},
	{"func.strcmp.ret", "int"},
	{"func.strcoll.arg.0", "const char *,s1"},
	{"func.strcoll.arg.1", "const char *,s2"},
	{"func.strcoll.args", "2"},
	{"func.strcoll.ret", "int"},
	{"func.strcpy.arg.0", "char *,dest"},
	{"func.strcpy.arg.1", "const char *,src"},
	{"func.strcpy.args", "2"},
	{"func.strcpy.ret", "char *"},
	{"func.strcpy_chk.arg.0", "char *,dest"},
	{"func.strcpy_chk.arg.1", "const char *,src"},
	{"func.strcpy_chk.arg.2", "size_t,destlen"},
	{"func.strcpy_chk.args", "3"},
	{"func.strcpy_chk.ret", "char *"},
	{"func.strcspn.arg.0", "const char *,s1"},
	{"func.strcspn.arg.1", "const char *,s2"},
	{"func.strcspn.args", "2"},
	{"func.strcspn.ret", "size_t"},
	{"func.strdup.arg.0", "const char *,src"},
	{"func.strdup.args", "1"},
	{"func.strdup.ret", "char *"},
	{"func.strerror.arg.0", "int,errnum"},
	{"func.strerror.args", "1"},
	{"func.strerror.ret", "char *"},
	{"func.strftime.arg.0", "char *,s"},
	{"func.strftime.arg.1", "size_t,maxsize"},
	{"func.strftime.arg.2", "const char *,format"},
	{"func.strftime.arg.3", "const tm *,timeptr"},
	{"func.strftime.args", "4"},
	{"func.strftime.ret", "size_t"},
	{"func.strlcat_chk.arg.0", "char *,dest"},
	{"func.strlcat_chk.arg.1", "const char *,src"},
	{"func.strlcat_chk.arg.2", "size_t,len"},
	{"func.strlcat_chk.arg.3", "size_t,destlen"},
	{"func.strlcat_chk.args", "4"},
	{"func.strlcat_chk.ret", "size_t"},
	{"func.strlcpy.arg.0", "char *,dest"},
	{"func.strlcpy.arg.1", "const char *,src"},
	{"func.strlcpy.arg.2", "size_t, n"},
	{"func.strlcpy.args", "3"},
	{"func.strlcpy.ret", "char *"},
	{"func.strlcpy_chk.arg.0", "char *,dest"},
	{"func.strlcpy_chk.arg.1", "const char *,src"},
	{"func.strlcpy_chk.arg.2", "size_t,len"},
	{"func.strlcpy_chk.arg.3", "size_t,destlen"},
	{"func.strlcpy_chk.args", "4"},
	{"func.strlcpy_chk.ret", "size_t"},
	{"func.strlen.arg.0", "const char *,s"},
	{"func.strlen.args", "1"},
	{"func.strlen.ret", "size_t"},
	{"func.strmode.arg.0", "int,mode"},
	{"func.strmode.arg.1", "char *,bp"},
	{"func.strmode.args", "2"},
	{"func.strmode.ret", "void"},
	{"func.strncasecmp.arg.0", "const char *,s1"},
	{"func.strncasecmp.arg.1", "const char *,s2"},
	{"func.strncasecmp.arg.2", "size_t,n"},
	{"func.strncasecmp.args", "3"},
	{"func.strncasecmp.ret", "int"},
	{"func.strncat.arg.0", "char *,s1"},
	{"func.strncat.arg.1", "const char *,s2"},
	{"func.strncat.arg.2", "size_t,n"},
	{"func.strncat.args", "3"},
	{"func.strncat.ret", "char *"},
	{"func.strncat_chk.arg.0", "char *,dest"},
	{"func.strncat_chk.arg.1", "const char *,src"},
	{"func.strncat_chk.arg.2", "size_t,len"},
	{"func.strncat_chk.arg.3", "size_t,destlen"},
	{"func.strncat_chk.args", "4"},
	{"func.strncat_chk.ret", "char *"},
	{"func.strncmp.arg.0", "const char *,s1"},
	{"func.strncmp.arg.1", "const char *,s2"},
	{"func.strncmp.arg.2", "size_t,n"},
	{"func.strncmp.args", "3"},
	{"func.strncmp.ret", "int"},
	{"func.strncpy.arg.0", "char *,dest"},
	{"func.strncpy.arg.1", "const char *,src"},
	{"func.strncpy.arg.2", "size_t, n"},
	{"func.strncpy.args", "3"},
	{"func.strncpy.ret", "char *"},
	{"func.strncpy_chk.arg.0", "char *,dest"},
	{"func.strncpy_chk.arg.1", "const char *,src"},
	{"func.strncpy_chk.arg.2", "size_t,len"},
	{"func.strncpy_chk.arg.3", "size_t,destlen"},
	{"func.strncpy_chk.args", "4"},
	{"func.strncpy_chk.ret", "char *"},
	{"func.strndup.arg.0", "const char *,src"},
	{"func.strndup.arg.1", "int,n"},
	{"func.strndup.args", "2"},
	{"func.strndup.ret", "char *"},
	{"func.strpbrk.arg.0", "const char *,s1"},
	{"func.strpbrk.arg.1", "const char *,s2"},
	{"func.strpbrk.args", "2"},
	{"func.strpbrk.ret", "char *"},
	{"func.strrchr.arg.0", "const char *,s"},
	{"func.strrchr.arg.1", "int,c"},
	{"func.strrchr.args", "2"},
	{"func.strrchr.ret", "char *"},
	{"func.strspn.arg.0", "const char *,s1"},
	{"func.strspn.arg.1", "const char *,s2"},
	{"func.strspn.args", "2"},
	{"func.strspn.ret", "size_t"},
	{"func.strstr.arg.0", "const char *,s1"},
	{"func.strstr.arg.1", "const char *,s2"},
	{"func.strstr.args", "2"},
	{"func.strstr.ret", "char *"},
	{"func.strtod.arg.0", "const char *,str"},
	{"func.strtod.arg.1", "char * *,endptr"},
	{"func.strtod.args", "2"},
	{"func.strtod.ret", "double"},
	{"func.strtof.arg.0", "const char *,str"},
	{"func.strtof.arg.1", "char * *,endptr"},
	{"func.strtof.args", "2"},
	{"func.strtof.ret", "float"},
	{"func.strtoimax.arg.0", "const char *,str"},
	{"func.strtoimax.arg.1", "char * *,endptr"},
	{"func.strtoimax.arg.2", "int,base"},
	{"func.strtoimax.args", "3"},
	{"func.strtoimax.ret", "intmax_t"},
	{"func.strtok.arg.0", "char *,s1"},
	{"func.strtok.arg.1", "const char *,s2"},
	{"func.strtok.args", "2"},
	{"func.strtok.ret", "char *"},
	{"func.strtol.arg.0", "const char *,str"},
	{"func.strtol.arg.1", "char * *,endptr"},
	{"func.strtol.arg.2", "int,base"},
	{"func.strtol.args", "3"},
	{"func.strtol.ret", "long"},
	{"func.strtold.arg.0", "const char *,str"},
	{"func.strtold.arg.1", "char * *,endptr"},
	{"func.strtold.args", "2"},
	{"func.strtold.ret", "long double"},
	{"func.strtoll.arg.0", "const char *,str"},
	{"func.strtoll.arg.1", "char * *,endptr"},
	{"func.strtoll.arg.2", "int,base"},
	{"func.strtoll.args", "3"},
	{"func.strtoll.ret", "long long"},
	{"func.strtonum.arg.0", "const char *,str"},
	{"func.strtonum.arg.1", "long long,minval"},
	{"func.strtonum.arg.2", "long long,maxval"},
	{"func.strtonum.arg.3", "const char **,errstr"},
	{"func.strtonum.args", "4"},
	{"func.strtonum.ret", "long long"},
	{"func.strtoul.arg.0", "const char *,str"},
	{"func.strtoul.arg.1", "char * *,endptr"},
	{"func.strtoul.arg.2", "int,base"},
	{"func.strtoul.args", "3"},
	{"func.strtoul.ret", "long"},
	{"func.strtoull.arg.0", "const char *,str"},
	{"func.strtoull.arg.1", "char * *,endptr"},
	{"func.strtoull.arg.2", "int,base"},
	{"func.strtoull.args", "3"},
	{"func.strtoull.ret", "long long"},
	{"func.strtoumax.arg.0", "const char *,str"},
	{"func.strtoumax.arg.1", "char * *,endptr"},
	{"func.strtoumax.arg.2", "int,base"},
	{"func.strtoumax.args", "3"},
	{"func.strtoumax.ret", "uintmax_t"},
	{"func.strxfrm.arg.0", "char *,s1"},
	{"func.strxfrm.arg.1", "const char *,s2"},
	{"func.strxfrm.arg.2", "size_t,n"},
	{"func.strxfrm.args", "3"},
	{"func.strxfrm.ret", "size_t"},
	{"func.swift_beginAccess.arg.0", "void *"},
	{"func.swift_beginAccess.arg.1", "void *"},
	{"func.swift_beginAccess.arg.2", "void *"},
	{"func.swift_beginAccess.arg.3", "void *"},
	{"func.swift_beginAccess.args", "4"},
	{"func.swift_beginAccess.ret", "void"},
	{"func.swift_bridgeObjectRelease.arg.0", "void *"},
	{"func.swift_bridgeObjectRelease.args", "1"},
	{"func.swift_bridgeObjectRelease.ret", "void"},
	{"func.swift_bridgeObjectRetain.arg.0", "void *"},
	{"func.swift_bridgeObjectRetain.args", "1"},
	{"func.swift_bridgeObjectRetain.ret", "void *"},
	{"func.swift_endAccess.arg.0", "void *"},
	{"func.swift_endAccess.args", "1"},
	{"func.swift_endAccess.ret", "void"},
	{"func.swift_getObjCClassFromMetadata.arg.0", "void *"},
	{"func.swift_getObjCClassFromMetadata.args", "1"},
	{"func.swift_getObjCClassFromMetadata.ret", "void *"},
	{"func.swift_initStackObject.arg.0", "void *"},
	{"func.swift_initStackObject.arg.1", "void *"},
	{"func.swift_initStackObject.args", "2"},
	{"func.swift_initStackObject.ret", "void *"},
	{"func.swift_release.arg.0", "void *"},
	{"func.swift_release.args", "1"},
	{"func.swift_release.ret", "void"},
	{"func.swift_unexpectedError.arg.0", "void *"},
	{"func.swift_unexpectedError.args", "1"},
	{"func.swift_unexpectedError.ret", "void"},
	{"func.swprintf.arg.0", "wchar_t *,s"},
	{"func.swprintf.arg.1", "size_t,n"},
	{"func.swprintf.arg.2", "const wchar_t *,format"},
	{"func.swprintf.arg.3", ",..."},
	{"func.swprintf.args", "4"},
	{"func.swprintf.ret", "int"},
	{"func.swscanf.arg.0", "const wchar_t *,s"},
	{"func.swscanf.arg.1", "const wchar_t *,format"},
	{"func.swscanf.args", "2"},
	{"func.swscanf.ret", "int"},
	{"func.symlink.arg.0", "const char *,path1"},
	{"func.symlink.arg.1", "const char *,path2"},
	{"func.symlink.args", "2"},
	{"func.symlink.ret", "int"},
	{"func.sysctl.arg.0", "const char *,name"},
	{"func.sysctl.arg.1", "int,namelen"},
	{"func.sysctl.arg.2", "void *,oldp"},
	{"func.sysctl.arg.3", "size_t *,oldlenp"},
	{"func.sysctl.arg.4", "void *,newp"},
	{"func.sysctl.arg.5", "size_t,newlen"},
	{"func.sysctl.args", "6"},
	{"func.sysctl.ret", "int"},
	{"func.sysctlbyname.arg.0", "const char *,name"},
	{"func.sysctlbyname.arg.1", "void *,oldp"},
	{"func.sysctlbyname.arg.2", "size_t *,oldlenp"},
	{"func.sysctlbyname.arg.3", "void *,newp"},
	{"func.sysctlbyname.arg.4", "size_t,newlen"},
	{"func.sysctlbyname.args", "5"},
	{"func.sysctlbyname.ret", "int"},
	{"func.sysctlnametomib.arg.0", "const char *,name"},
	{"func.sysctlnametomib.arg.1", "int *,mib"},
	{"func.sysctlnametomib.arg.2", "size_t *,sizep"},
	{"func.sysctlnametomib.args", "3"},
	{"func.sysctlnametomib.ret", "int"},
	{"func.syslog.arg.0", "int,priority"},
	{"func.syslog.arg.1", "const char *,format"},
	{"func.syslog.arg.2", ",..."},
	{"func.syslog.args", "3"},
	{"func.syslog.ret", "void"},
	{"func.system.arg.0", "const char *,string"},
	{"func.system.args", "1"},
	{"func.system.ret", "int"},
	{"func.tan.arg.0", "arithmetic,x"},
	{"func.tan.args", "1"},
	{"func.tan.ret", "floating_point"},
	{"func.tanf.arg.0", "float,x"},
	{"func.tanf.args", "1"},
	{"func.tanf.ret", "float"},
	{"func.tanh.arg.0", "arithmetic,x"},
	{"func.tanh.args", "1"},
	{"func.tanh.ret", "floating_point"},
	{"func.tanhf.arg.0", "float,x"},
	{"func.tanhf.args", "1"},
	{"func.tanhf.ret", "float"},
	{"func.tanhl.arg.0", "long double,x"},
	{"func.tanhl.args", "1"},
	{"func.tanhl.ret", "long double"},
	{"func.tanl.arg.0", "long double,x"},
	{"func.tanl.args", "1"},
	{"func.tanl.ret", "long double"},
	{"func.tcgetpgrp.arg.0", "int,fd"},
	{"func.tcgetpgrp.args", "1"},
	{"func.tcgetpgrp.ret", "pid_t"},
	{"func.textdomain.arg.0", "char *,domainname"},
	{"func.textdomain.args", "1"},
	{"func.textdomain.ret", "char *"},
	{"func.tgamma.arg.0", "arithmetic,x"},
	{"func.tgamma.args", "1"},
	{"func.tgamma.ret", "floating_point"},
	{"func.tgammaf.arg.0", "float,x"},
	{"func.tgammaf.args", "1"},
	{"func.tgammaf.ret", "float"},
	{"func.tgammal.arg.0", "long double,x"},
	{"func.tgammal.args", "1"},
	{"func.tgammal.ret", "long double"},
	{"func.tgetent.arg.0", "const char *,bp"},
	{"func.tgetent.arg.1", "const char *,name"},
	{"func.tgetent.args", "2"},
	{"func.tgetent.ret", "int"},
	{"func.tgetflag.arg.0", "const char *,id"},
	{"func.tgetflag.args", "1"},
	{"func.tgetflag.ret", "int"},
	{"func.tgetnum.arg.0", "char *,id"},
	{"func.tgetnum.args", "1"},
	{"func.tgetnum.ret", "int"},
	{"func.tgetstr.arg.0", "char *,id"},
	{"func.tgetstr.arg.1", "char **,area"},
	{"func.tgetstr.args", "2"},
	{"func.tgetstr.ret", "char*"},
	{"func.tgoto.arg.0", "const char *,cap"},
	{"func.tgoto.arg.1", "int,col"},
	{"func.tgoto.arg.2", "int,row"},
	{"func.tgoto.args", "3"},
	{"func.tgoto.ret", "char *"},
	{"func.time.arg.0", "time_t *,timer"},
	{"func.time.args", "1"},
	{"func.time.ret", "time_t"},
	{"func.tmpfile.args", "0"},
	{"func.tmpfile.ret", "file*"},
	{"func.tmpnam.arg.0", "char *,s"},
	{"func.tmpnam.args", "1"},
	{"func.tmpnam.ret", "char *"},
	{"func.tolower.arg.0", "int,c"},
	{"func.tolower.args", "1"},
	{"func.tolower.ret", "int"},
	{"func.toupper.arg.0", "int,c"},
	{"func.toupper.args", "1"},
	{"func.toupper.ret", "int"},
	{"func.towctrans.arg.0", "wint_t,wc"},
	{"func.towctrans.arg.1", "wctrans_t,desc"},
	{"func.towctrans.args", "2"},
	{"func.towctrans.ret", "wint_t"},
	{"func.towlower.arg.0", "wint_t,wc"},
	{"func.towlower.args", "1"},
	{"func.towlower.ret", "wint_t"},
	{"func.towupper.arg.0", "wint_t,wc"},
	{"func.towupper.args", "1"},
	{"func.towupper.ret", "wint_t"},
	{"func.trunc.arg.0", "arithmetic,x"},
	{"func.trunc.args", "1"},
	{"func.trunc.ret", "floating_point"},
	{"func.truncf.arg.0", "float,x"},
	{"func.truncf.args", "1"},
	{"func.truncf.ret", "float"},
	{"func.truncl.arg.0", "long double,x"},
	{"func.truncl.args", "1"},
	{"func.truncl.ret", "long double"},
	{"func.umask.arg.0", "int,m"},
	{"func.umask.args", "1"},
	{"func.umask.ret", "int"},
	{"func.ungetc.arg.0", "int,c"},
	{"func.ungetc.arg.1", "FILE *,stream"},
	{"func.ungetc.args", "2"},
	{"func.ungetc.ret", "int"},
	{"func.ungetwc.arg.0", "wint_t,c"},
	{"func.ungetwc.arg.1", "FILE *,stream"},
	{"func.ungetwc.args", "2"},
	{"func.ungetwc.ret", "wint_t"},
	{"func.unlink.arg.0", "const char *,path"},
	{"func.unlink.args", "1"},
	{"func.unlink.ret", "int"},
	{"func.user_from_uid.arg.0", "uid_t,uid"},
	{"func.user_from_uid.arg.1", "int,nouser"},
	{"func.user_from_uid.args", "2"},
	{"func.user_from_uid.include", "pwd.h"},
	{"func.user_from_uid.ret", "char *"},
	{"func.usleep.arg.0", "int,s"},
	{"func.usleep.args", "1"},
	{"func.usleep.ret", "int"},
	{"func.utime.arg.0", "const char *,filename"},
	{"func.utime.arg.1", "const void *,times"},
	{"func.utime.args", "2"},
	{"func.utime.ret", "int"},
	{"func.utimes.arg.0", "const char *,filename"},
	{"func.utimes.arg.1", "const void *,times"},
	{"func.utimes.args", "2"},
	{"func.utimes.ret", "int"},
	{"func.vasprintf.arg.0", "char **,ptr"},
	{"func.vasprintf.arg.1", "const char *,format"},
	{"func.vasprintf.arg.2", "va_list,ap"},
	{"func.vasprintf.args", "3"},
	{"func.vasprintf.ret", "int"},
	{"func.vdprintf.arg.0", "int,fd"},
	{"func.vdprintf.arg.1", "const char *,format"},
	{"func.vdprintf.arg.2", "va_list,ap"},
	{"func.vdprintf.args", "3"},
	{"func.vdprintf.ret", "int"},
	{"func.vfprintf.arg.0", "FILE *,stream"},
	{"func.vfprintf.arg.1", "const char *,format"},
	{"func.vfprintf.arg.2", "va_list,ap"},
	{"func.vfprintf.args", "3"},
	{"func.vfprintf.ret", "int"},
	{"func.vfscanf.arg.0", "FILE *,stream"},
	{"func.vfscanf.arg.1", "const char *,format"},
	{"func.vfscanf.arg.2", "va_list,ap"},
	{"func.vfscanf.args", "3"},
	{"func.vfscanf.ret", "int"},
	{"func.vfwprintf.arg.0", "FILE *,stream"},
	{"func.vfwprintf.arg.1", "const wchar_t *,format"},
	{"func.vfwprintf.arg.2", "va_list,arg"},
	{"func.vfwprintf.args", "3"},
	{"func.vfwprintf.ret", "int"},
	{"func.vfwscanf.arg.0", "FILE *,stream"},
	{"func.vfwscanf.arg.1", "const wchar_t *,format"},
	{"func.vfwscanf.arg.2", "va_list,arg"},
	{"func.vfwscanf.args", "3"},
	{"func.vfwscanf.ret", "int"},
	{"func.vprintf.arg.0", "const char *,format"},
	{"func.vprintf.arg.1", "va_list,ap"},
	{"func.vprintf.args", "2"},
	{"func.vprintf.ret", "int"},
	{"func.vscanf.arg.0", "const char *,format"},
	{"func.vscanf.arg.1", "va_list,ap"},
	{"func.vscanf.args", "2"},
	{"func.vscanf.ret", "int"},
	{"func.vsnprintf.arg.0", "char *,s"},
	{"func.vsnprintf.arg.1", "size_t,size"},
	{"func.vsnprintf.arg.2", "const char *,format"},
	{"func.vsnprintf.arg.3", "va_list,arg"},
	{"func.vsnprintf.args", "4"},
	{"func.vsnprintf.ret", "int"},
	{"func.vsnprintf_chk.arg.0", "char *,s"},
	{"func.vsnprintf_chk.arg.1", "size_t,maxlen"},
	{"func.vsnprintf_chk.arg.2", "int,flag"},
	{"func.vsnprintf_chk.arg.3", "size_t,slen"},
	{"func.vsnprintf_chk.arg.4", "const char *,format"},
	{"func.vsnprintf_chk.arg.5", "va_list,ap"},
	{"func.vsnprintf_chk.args", "6"},
	{"func.vsnprintf_chk.ret", "int"},
	{"func.vsprintf.arg.0", "char *,s"},
	{"func.vsprintf.arg.1", "const char *,format"},
	{"func.vsprintf.arg.2", "va_list,arg"},
	{"func.vsprintf.args", "3"},
	{"func.vsprintf.ret", "int"},
	{"func.vsprintf_chk.arg.0", "char *,s"},
	{"func.vsprintf_chk.arg.1", "int,flag"},
	{"func.vsprintf_chk.arg.2", "size_t,slen"},
	{"func.vsprintf_chk.arg.3", "const char *,format"},
	{"func.vsprintf_chk.arg.4", "va_list,ap"},
	{"func.vsprintf_chk.args", "5"},
	{"func.vsprintf_chk.ret", "int"},
	{"func.vsscanf.arg.0", "const char *,s"},
	{"func.vsscanf.arg.1", "const char *,format"},
	{"func.vsscanf.arg.2", "va_list,arg"},
	{"func.vsscanf.args", "3"},
	{"func.vsscanf.ret", "int"},
	{"func.vswprintf.arg.0", "wchar_t *,s"},
	{"func.vswprintf.arg.1", "size_t,n"},
	{"func.vswprintf.arg.2", "const wchar_t *,format"},
	{"func.vswprintf.arg.3", "va_list,arg"},
	{"func.vswprintf.args", "4"},
	{"func.vswprintf.ret", "int"},
	{"func.vswscanf.arg.0", "const wchar_t *,s"},
	{"func.vswscanf.arg.1", "const wchar_t *,format"},
	{"func.vswscanf.arg.2", "va_list,arg"},
	{"func.vswscanf.args", "3"},
	{"func.vswscanf.ret", "int"},
	{"func.vwprintf.arg.0", "const wchar_t *,format"},
	{"func.vwprintf.arg.1", "va_list,arg"},
	{"func.vwprintf.args", "2"},
	{"func.vwprintf.ret", "int"},
	{"func.vwscanf.arg.0", "const wchar_t *,format"},
	{"func.vwscanf.arg.1", "va_list,arg"},
	{"func.vwscanf.args", "2"},
	{"func.vwscanf.ret", "int"},
	{"func.warn.arg.0", "const char *,fmt"},
	{"func.warn.arg.1", ",..."},
	{"func.warn.args", "2"},
	{"func.warn.ret", "void"},
	{"func.warnc.arg.0", "int,eval"},
	{"func.warnc.arg.1", "int,code"},
	{"func.warnc.arg.2", "const char *,fmt"},
	{"func.warnc.args", "3"},
	{"func.warnc.ret", "void"},
	{"func.warnx.arg.0", "const char *,fmt"},
	{"func.warnx.arg.1", ",..."},
	{"func.warnx.args", "2"},
	{"func.warnx.ret", "void"},
	{"func.wcrtomb.arg.0", "char *,s"},
	{"func.wcrtomb.arg.1", "wchar_t,wc"},
	{"func.wcrtomb.arg.2", "mbstate_t *,ps"},
	{"func.wcrtomb.args", "3"},
	{"func.wcrtomb.ret", "size_t"},
	{"func.wcscat.arg.0", "wchar_t *,s1"},
	{"func.wcscat.arg.1", "const wchar_t *,s2"},
	{"func.wcscat.args", "2"},
	{"func.wcscat.ret", "wchar_t*"},
	{"func.wcschr.arg.0", "wchar_t *,s"},
	{"func.wcschr.arg.1", "wchar_t,c"},
	{"func.wcschr.args", "2"},
	{"func.wcschr.ret", "wchar_t*"},
	{"func.wcscmp.arg.0", "const wchar_t *,s1"},
	{"func.wcscmp.arg.1", "const wchar_t *,s2"},
	{"func.wcscmp.args", "2"},
	{"func.wcscmp.ret", "int"},
	{"func.wcscoll.arg.0", "const wchar_t *,s1"},
	{"func.wcscoll.arg.1", "const wchar_t *,s2"},
	{"func.wcscoll.args", "2"},
	{"func.wcscoll.ret", "int"},
	{"func.wcscpy.arg.0", "wchar_t *,s1"},
	{"func.wcscpy.arg.1", "const wchar_t *,s2"},
	{"func.wcscpy.args", "2"},
	{"func.wcscpy.ret", "wchar_t*"},
	{"func.wcscspn.arg.0", "const wchar_t *,s1"},
	{"func.wcscspn.arg.1", "const wchar_t *,s2"},
	{"func.wcscspn.args", "2"},
	{"func.wcscspn.ret", "size_t"},
	{"func.wcsftime.arg.0", "wchar_t *,s"},
	{"func.wcsftime.arg.1", "size_t,maxsize"},
	{"func.wcsftime.arg.2", "const wchar_t *,format"},
	{"func.wcsftime.arg.3", "const tm *,timeptr"},
	{"func.wcsftime.args", "4"},
	{"func.wcsftime.ret", "size_t"},
	{"func.wcslen.arg.0", "const wchar_t *,s"},
	{"func.wcslen.args", "1"},
	{"func.wcslen.ret", "size_t"},
	{"func.wcsncat.arg.0", "wchar_t *,s1"},
	{"func.wcsncat.arg.1", "const wchar_t *,s2"},
	{"func.wcsncat.arg.2", "size_t,n"},
	{"func.wcsncat.args", "3"},
	{"func.wcsncat.ret", "wchar_t*"},
	{"func.wcsncmp.arg.0", "const wchar_t *,s1"},
	{"func.wcsncmp.arg.1", "const wchar_t *,s2"},
	{"func.wcsncmp.arg.2", "size_t,n"},
	{"func.wcsncmp.args", "3"},
	{"func.wcsncmp.ret", "int"},
	{"func.wcsncpy.arg.0", "wchar_t *,s1"},
	{"func.wcsncpy.arg.1", "const wchar_t *,s2"},
	{"func.wcsncpy.arg.2", "size_t,n"},
	{"func.wcsncpy.args", "3"},
	{"func.wcsncpy.ret", "wchar_t*"},
	{"func.wcspbrk.arg.0", "wchar_t *,s1"},
	{"func.wcspbrk.arg.1", "const wchar_t *,s2"},
	{"func.wcspbrk.args", "2"},
	{"func.wcspbrk.ret", "wchar_t*"},
	{"func.wcsrchr.arg.0", "wchar_t *,s"},
	{"func.wcsrchr.arg.1", "wchar_t,c"},
	{"func.wcsrchr.args", "2"},
	{"func.wcsrchr.ret", "wchar_t*"},
	{"func.wcsrtombs.arg.0", "char *,dst"},
	{"func.wcsrtombs.arg.1", "const wchar_t* *,src"},
	{"func.wcsrtombs.arg.2", "size_t,len"},
	{"func.wcsrtombs.arg.3", "mbstate_t *,ps"},
	{"func.wcsrtombs.args", "4"},
	{"func.wcsrtombs.ret", "size_t"},
	{"func.wcsspn.arg.0", "const wchar_t *,s1"},
	{"func.wcsspn.arg.1", "const wchar_t *,s2"},
	{"func.wcsspn.args", "2"},
	{"func.wcsspn.ret", "size_t"},
	{"func.wcsstr.arg.0", "wchar_t *,s1"},
	{"func.wcsstr.arg.1", "const wchar_t *,s2"},
	{"func.wcsstr.args", "2"},
	{"func.wcsstr.ret", "wchar_t*"},
	{"func.wcstod.arg.0", "const wchar_t *,nptr"},
	{"func.wcstod.arg.1", "wchar_t* *,endptr"},
	{"func.wcstod.args", "2"},
	{"func.wcstod.ret", "double"},
	{"func.wcstof.arg.0", "const wchar_t *,nptr"},
	{"func.wcstof.arg.1", "wchar_t* *,endptr"},
	{"func.wcstof.args", "2"},
	{"func.wcstof.ret", "float"},
	{"func.wcstoimax.arg.0", "const,wchar_t*"},
	{"func.wcstoimax.arg.1", "wchar_t* *,endptr"},
	{"func.wcstoimax.arg.2", "int,base"},
	{"func.wcstoimax.args", "3"},
	{"func.wcstoimax.ret", "intmax_t"},
	{"func.wcstok.arg.0", "wchar_t *,s1"},
	{"func.wcstok.arg.1", "const wchar_t *,s2"},
	{"func.wcstok.arg.2", "wchar_t* *,ptr"},
	{"func.wcstok.args", "3"},
	{"func.wcstok.ret", "wchar_t*"},
	{"func.wcstol.arg.0", "const wchar_t *,nptr"},
	{"func.wcstol.arg.1", "wchar_t* *,endptr"},
	{"func.wcstol.arg.2", "int,base"},
	{"func.wcstol.args", "3"},
	{"func.wcstol.ret", "long"},
	{"func.wcstold.arg.0", "const wchar_t *,nptr"},
	{"func.wcstold.arg.1", "wchar_t* *,endptr"},
	{"func.wcstold.args", "2"},
	{"func.wcstold.ret", "long double"},
	{"func.wcstoll.arg.0", "const wchar_t *,nptr"},
	{"func.wcstoll.arg.1", "wchar_t* *,endptr"},
	{"func.wcstoll.arg.2", "int,base"},
	{"func.wcstoll.args", "3"},
	{"func.wcstoll.ret", "long long"},
	{"func.wcstombs.arg.0", "char *,s"},
	{"func.wcstombs.arg.1", "const wchar_t *,pwcs"},
	{"func.wcstombs.arg.2", "size_t,n"},
	{"func.wcstombs.args", "3"},
	{"func.wcstombs.ret", "size_t"},
	{"func.wcstoul.arg.0", "const wchar_t *,nptr"},
	{"func.wcstoul.arg.1", "wchar_t* *,endptr"},
	{"func.wcstoul.arg.2", "int,base"},
	{"func.wcstoul.args", "3"},
	{"func.wcstoul.ret", "long"},
	{"func.wcstoull.arg.0", "const wchar_t *,nptr"},
	{"func.wcstoull.arg.1", "wchar_t* *,endptr"},
	{"func.wcstoull.arg.2", "int,base"},
	{"func.wcstoull.args", "3"},
	{"func.wcstoull.ret", "long long"},
	{"func.wcstoumax.arg.0", "const,wchar_t*"},
	{"func.wcstoumax.arg.1", "wchar_t* *,endptr"},
	{"func.wcstoumax.arg.2", "int,base"},
	{"func.wcstoumax.args", "3"},
	{"func.wcstoumax.ret", "uintmax_t"},
	{"func.wcsxfrm.arg.0", "wchar_t *,s1"},
	{"func.wcsxfrm.arg.1", "const wchar_t *,s2"},
	{"func.wcsxfrm.arg.2", "size_t,n"},
	{"func.wcsxfrm.args", "3"},
	{"func.wcsxfrm.ret", "size_t"},
	{"func.wctob.arg.0", "wint_t,c"},
	{"func.wctob.args", "1"},
	{"func.wctob.ret", "int"},
	{"func.wctomb.arg.0", "char *,s"},
	{"func.wctomb.arg.1", "wchar_t,wchar"},
	{"func.wctomb.args", "2"},
	{"func.wctomb.ret", "int"},
	{"func.wctrans.arg.0", "const char *,property"},
	{"func.wctrans.args", "1"},
	{"func.wctrans.ret", "wctrans_t"},
	{"func.wctype.arg.0", "const char *,property"},
	{"func.wctype.args", "1"},
	{"func.wctype.ret", "wctype_t"},
	{"func.wmemchr.arg.0", "wchar_t *,s"},
	{"func.wmemchr.arg.1", "wchar_t,c"},
	{"func.wmemchr.arg.2", "size_t,n"},
	{"func.wmemchr.args", "3"},
	{"func.wmemchr.ret", "wchar_t*"},
	{"func.wmemcmp.arg.0", "wchar_t *,s1"},
	{"func.wmemcmp.arg.1", "const wchar_t *,s2"},
	{"func.wmemcmp.arg.2", "size_t,n"},
	{"func.wmemcmp.args", "3"},
	{"func.wmemcmp.ret", "int"},
	{"func.wmemcpy.arg.0", "wchar_t *,s1"},
	{"func.wmemcpy.arg.1", "const wchar_t *,s2"},
	{"func.wmemcpy.arg.2", "size_t,n"},
	{"func.wmemcpy.args", "3"},
	{"func.wmemcpy.ret", "wchar_t*"},
	{"func.wmemmove.arg.0", "wchar_t *,s1"},
	{"func.wmemmove.arg.1", "const wchar_t *,s2"},
	{"func.wmemmove.arg.2", "size_t,n"},
	{"func.wmemmove.args", "3"},
	{"func.wmemmove.ret", "wchar_t*"},
	{"func.wmemset.arg.0", "wchar_t *,s"},
	{"func.wmemset.arg.1", "wchar_t,c"},
	{"func.wmemset.arg.2", "size_t,n"},
	{"func.wmemset.args", "3"},
	{"func.wmemset.ret", "wchar_t*"},
	{"func.wprintf.arg.0", "const wchar_t *,format"},
	{"func.wprintf.arg.1", ",..."},
	{"func.wprintf.args", "2"},
	{"func.wprintf.ret", "int"},
	{"func.write.arg.0", "int,fd"},
	{"func.write.arg.1", "const char *,ptr"},
	{"func.write.arg.2", "size_t,nbytes"},
	{"func.write.args", "3"},
	{"func.write.ret", "ssize_t"},
	{"func.wscanf.arg.0", "const wchar_t *,format"},
	{"func.wscanf.arg.1", ",..."},
	{"func.wscanf.args", "2"},
	{"func.wscanf.ret", "int"},
	{"func.xmalloc.arg.0", "size_t,size"},
	{"func.xmalloc.args", "1"},
	{"func.xmalloc.ret", " void *"},
	{"fwide", "func"},
	{"fwprintf", "func"},
	{"fwrite", "func"},
	{"fwscanf", "func"},
	{"getbsize", "func"},
	{"getc", "func"},
	{"getchar", "func"},
	{"getenv", "func"},
	{"geteuid", "func"},
	{"getopt", "func"},
	{"getopt_long", "func"},
	{"getpid", "func"},
	{"getprogname", "func"},
	{"gets", "func"},
	{"gettext", "func"},
	{"getuid", "func"},
	{"getwc", "func"},
	{"getwchar", "func"},
	{"gmtime", "func"},
	{"group_from_gid", "func"},
	{"humanize_number", "func"},
	{"hypot", "func"},
	{"hypotf", "func"},
	{"hypotl", "func"},
	{"ilogb", "func"},
	{"ilogbf", "func"},
	{"ilogbl", "func"},
	{"imaxabs", "func"},
	{"imaxdiv", "func"},
	{"inet_aton", "func"},
	{"inet_ntoa", "func"},
	{"initstate", "func"},
	{"int", "type"},
	{"int16_t", "type"},
	{"int32_t", "type"},
	{"int64_t", "type"},
	{"int8_t", "type"},
	{"ioctl", "func"},
	{"isalnum", "func"},
	{"isalpha", "func"},
	{"isatty", "func"},
	{"isblank", "func"},
	{"iscntrl", "func"},
	{"isdigit", "func"},
	{"isfinite", "func"},
	{"isgraph", "func"},
	{"isgreater", "func"},
	{"isgreaterequal", "func"},
	{"isinf", "func"},
	{"isless", "func"},
	{"islessequal", "func"},
	{"islessgreater", "func"},
	{"islower", "func"},
	{"isnan", "func"},
	{"isnormal", "func"},
	{"isprint", "func"},
	{"ispunct", "func"},
	{"isspace", "func"},
	{"isunordered", "func"},
	{"isupper", "func"},
	{"iswalnum", "func"},
	{"iswalpha", "func"},
	{"iswblank", "func"},
	{"iswcntrl", "func"},
	{"iswctype", "func"},
	{"iswdigit", "func"},
	{"iswgraph", "func"},
	{"iswlower", "func"},
	{"iswprint", "func"},
	{"iswpunct", "func"},
	{"iswspace", "func"},
	{"iswupper", "func"},
	{"iswxdigit", "func"},
	{"isxdigit", "func"},
	{"kill", "func"},
	{"labs", "func"},
	{"ldexp", "func"},
	{"ldexpf", "func"},
	{"ldexpl", "func"},
	{"ldiv", "func"},
	{"lgamma", "func"},
	{"lgammaf", "func"},
	{"lgammal", "func"},
	{"listxattr", "func"},
	{"llabs", "func"},
	{"lldiv", "func"},
	{"llrint", "func"},
	{"llrintf", "func"},
	{"llrintl", "func"},
	{"llround", "func"},
	{"llroundf", "func"},
	{"llroundl", "func"},
	{"localeconv", "func"},
	{"localtime", "func"},
	{"log", "func"},
	{"log10", "func"},
	{"log10f", "func"},
	{"log10l", "func"},
	{"log1p", "func"},
	{"log1pf", "func"},
	{"log1pl", "func"},
	{"log2", "func"},
	{"log2f", "func"},
	{"log2l", "func"},
	{"logb", "func"},
	{"logbf", "func"},
	{"logbl", "func"},
	{"logf", "func"},
	{"logl", "func"},
	{"long", "type"},
	{"long long", "type"},
	{"longjmp", "func"},
	{"lrint", "func"},
	{"lrintf", "func"},
	{"lrintl", "func"},
	{"lround", "func"},
	{"lroundf", "func"},
	{"lroundl", "func"},
	{"lseek", "func"},
	{"lstat", "func"},
	{"main", "func"},
	{"malloc", "func"},
	{"maskrune", "func"},
	{"mblen", "func"},
	{"mbrlen", "func"},
	{"mbrtowc", "func"},
	{"mbsinit", "func"},
	{"mbsrtowcs", "func"},
	{"mbstowcs", "func"},
	{"mbtowc", "func"},
	{"memchr", "func"},
	{"memcmp", "func"},
	{"memcpy", "func"},
	{"memcpy_chk", "func"},
	{"memmem", "func"},
	{"memmove", "func"},
	{"memmove_chk", "func"},
	{"memset", "func"},
	{"memset_chk", "func"},
	{"mkstemp", "func"},
	{"mktemp", "func"},
	{"mktime", "func"},
	{"mmap", "func"},
	{"modf", "func"},
	{"modff", "func"},
	{"modfl", "func"},
	{"munmap", "func"},
	{"nan", "func"},
	{"nanf", "func"},
	{"nanl", "func"},
	{"nearbyint", "func"},
	{"nearbyintf", "func"},
	{"nearbyintl", "func"},
	{"nextafter", "func"},
	{"nextafterf", "func"},
	{"nextafterl", "func"},
	{"nexttoward", "func"},
	{"nexttowardf", "func"},
	{"nexttowardl", "func"},
	{"ngettext", "func"},
	{"nl_langinfo", "func"},
	{"nl_langinfo_l", "func"},
	{"objc_allocWithZone", "func"},
	{"objc_enumerationMutation", "func"},
	{"objc_exception_rethrow", "func"},
	{"objc_exception_throw", "func"},
	{"objc_msgSend", "func"},
	{"objc_msgSendSuper2", "func"},
	{"objc_opt_self", "func"},
	{"objc_release", "func"},
	{"objc_retain", "func"},
	{"objc_retainAutoreleasedReturnValue", "func"},
	{"objc_storeStrong", "func"},
	{"open", "func"},
	{"openat", "func"},
	{"pclose", "func"},
	{"perror", "func"},
	{"pid_t", "typedef"},
	{"popen", "func"},
	{"pow", "func"},
	{"powf", "func"},
	{"powl", "func"},
	{"printf", "func"},
	{"ptrace", "func"},
	{"putc", "func"},
	{"putchar", "func"},
	{"puts", "func"},
	{"pututxline", "func"},
	{"putwc", "func"},
	{"putwchar", "func"},
	{"qsort", "func"},
	{"quick_exit", "func"},
	{"raise", "func"},
	{"rand", "func"},
	{"random", "func"},
	{"read", "func"},
	{"readlink", "func"},
	{"realloc", "func"},
	{"reallocf", "func"},
	{"recv", "func"},
	{"remainder", "func"},
	{"remainderf", "func"},
	{"remainderl", "func"},
	{"remove", "func"},
	{"remquo", "func"},
	{"remquof", "func"},
	{"remquol", "func"},
	{"rename", "func"},
	{"rewind", "func"},
	{"rint", "func"},
	{"rintf", "func"},
	{"rintl", "func"},
	{"round", "func"},
	{"roundf", "func"},
	{"roundl", "func"},
	{"scalbln", "func"},
	{"scalblnf", "func"},
	{"scalblnl", "func"},
	{"scalbn", "func"},
	{"scalbnf", "func"},
	{"scalbnl", "func"},
	{"scanf", "func"},
	{"send", "func"},
	{"setbuf", "func"},
	{"setenv", "func"},
	{"setgid", "func"},
	{"setjmp", "func"},
	{"setlocale", "func"},
	{"setstate", "func"},
	{"setuid", "func"},
	{"setvbuf", "func"},
	{"short", "type"},
	{"signal", "func"},
	{"signbit", "func"},
	{"sigprocmask", "func"},
	{"sin", "func"},
	{"sinf", "func"},
	{"sinh", "func"},
	{"sinhf", "func"},
	{"sinhl", "func"},
	{"sinl", "func"},
	{"size_t", "typedef"},
	{"sleep", "func"},
	{"snprintf", "func"},
	{"snprintf_chk", "func"},
	{"socket", "func"},
	{"sprintf", "func"},
	{"sprintf_chk", "func"},
	{"sqrt", "func"},
	{"sqrtf", "func"},
	{"sqrtl", "func"},
	{"srand", "func"},
	{"srandom", "func"},
	{"srandomdev", "func"},
	{"sscanf", "func"},
	{"stat", "func"},
	{"std::terminate__", "func"},
	{"stpcpy_chk", "func"},
	{"stpncpy_chk", "func"},
	{"strcasecmp", "func"},
	{"strcat", "func"},
	{"strcat_chk", "func"},
	{"strchr", "func"},
	{"strcmp", "func"},
	{"strcoll", "func"},
	{"strcpy", "func"},
	{"strcpy_chk", "func"},
	{"strcspn", "func"},
	{"strdup", "func"},
	{"strerror", "func"},
	{"strftime", "func"},
	{"strlcat_chk", "func"},
	{"strlcpy", "func"},
	{"strlcpy_chk", "func"},
	{"strlen", "func"},
	{"strmode", "func"},
	{"strncasecmp", "func"},
	{"strncat", "func"},
	{"strncat_chk", "func"},
	{"strncmp", "func"},
	{"strncpy", "func"},
	{"strncpy_chk", "func"},
	{"strndup", "func"},
	{"strpbrk", "func"},
	{"strrchr", "func"},
	{"strspn", "func"},
	{"strstr", "func"},
	{"strtod", "func"},
	{"strtof", "func"},
	{"strtoimax", "func"},
	{"strtok", "func"},
	{"strtol", "func"},
	{"strtold", "func"},
	{"strtoll", "func"},
	{"strtonum", "func"},
	{"strtoul", "func"},
	{"strtoull", "func"},
	{"strtoumax", "func"},
	{"strxfrm", "func"},
	{"swift_beginAccess", "func"},
	{"swift_bridgeObjectRelease", "func"},
	{"swift_bridgeObjectRetain", "func"},
	{"swift_endAccess", "func"},
	{"swift_getObjCClassFromMetadata", "func"},
	{"swift_initStackObject", "func"},
	{"swift_release", "func"},
	{"swift_unexpectedError", "func"},
	{"swprintf", "func"},
	{"swscanf", "func"},
	{"symlink", "func"},
	{"sysctl", "func"},
	{"sysctlbyname", "func"},
	{"sysctlnametomib", "func"},
	{"syslog", "func"},
	{"system", "func"},
	{"tan", "func"},
	{"tanf", "func"},
	{"tanh", "func"},
	{"tanhf", "func"},
	{"tanhl", "func"},
	{"tanl", "func"},
	{"tcgetpgrp", "func"},
	{"textdomain", "func"},
	{"tgamma", "func"},
	{"tgammaf", "func"},
	{"tgammal", "func"},
	{"tgetent", "func"},
	{"tgetflag", "func"},
	{"tgetnum", "func"},
	{"tgetstr", "func"},
	{"tgoto", "func"},
	{"time", "func"},
	{"time_t", "typedef"},
	{"tmpfile", "func"},
	{"tmpnam", "func"},
	{"tolower", "func"},
	{"toupper", "func"},
	{"towctrans", "func"},
	{"towlower", "func"},
	{"towupper", "func"},
	{"trunc", "func"},
	{"truncf", "func"},
	{"truncl", "func"},
	{"type.FILE", "p"},
	{"type.FILE.size", "8"},
	{"type.char", "c"},
	{"type.char *", "z"},
	{"type.char **", "*z"},
	{"type.char.size", "8"},
	{"type.double", "F"},
	{"type.double.size", "64"},
	{"type.float", "f"},
	{"type.float.size", "32"},
	{"type.func", "p"},
	{"type.func.size", "8"},
	{"type.int", "d"},
	{"type.int.size", "32"},
	{"type.int16_t", "w"},
	{"type.int16_t.size", "16"},
	{"type.int32_t", "d"},
	{"type.int32_t.size", "32"},
	{"type.int64_t", "q"},
	{"type.int64_t.size", "64"},
	{"type.int8_t", "b"},
	{"type.int8_t.size", "8"},
	{"type.long", "x"},
	{"type.long long", "q"},
	{"type.long long.size", "64"},
	{"type.long.size", "64"},
	{"type.short", "w"},
	{"type.short.size", "16"},
	{"type.uint16_t", "w"},
	{"type.uint16_t.size", "16"},
	{"type.uint32_t", "d"},
	{"type.uint32_t.size", "32"},
	{"type.uint64_t", "q"},
	{"type.uint64_t.size", "64"},
	{"type.uint8_t", "b"},
	{"type.uint8_t.size", "8"},
	{"type.unsigned char", "b"},
	{"type.unsigned char.size", "8"},
	{"type.unsigned int", "i"},
	{"type.unsigned int.size", "32"},
	{"type.unsigned short", "w"},
	{"type.unsigned short.size", "16"},
	{"type.void *", "p"},
	{"typedef.pid_t", "int32_t"},
	{"typedef.size_t", "uint32_t"},
	{"typedef.time_t", "int64_t"},
	{"typedef.uid_t", "uint32_t"},
	{"uid_t", "typedef"},
	{"uint16_t", "type"},
	{"uint32_t", "type"},
	{"uint64_t", "type"},
	{"uint8_t", "type"},
	{"umask", "func"},
	{"ungetc", "func"},
	{"ungetwc", "func"},
	{"unlink", "func"},
	{"unsigned char", "type"},
	{"unsigned int", "type"},
	{"unsigned short", "type"},
	{"user_from_uid", "func"},
	{"usleep", "func"},
	{"utime", "func"},
	{"utimes", "func"},
	{"vasprintf", "func"},
	{"vdprintf", "func"},
	{"vfprintf", "func"},
	{"vfscanf", "func"},
	{"vfwprintf", "func"},
	{"vfwscanf", "func"},
	{"void *", "type"},
	{"vprintf", "func"},
	{"vscanf", "func"},
	{"vsnprintf", "func"},
	{"vsnprintf_chk", "func"},
	{"vsprintf", "func"},
	{"vsprintf_chk", "func"},
	{"vsscanf", "func"},
	{"vswprintf", "func"},
	{"vswscanf", "func"},
	{"vwprintf", "func"},
	{"vwscanf", "func"},
	{"warn", "func"},
	{"warnc", "func"},
	{"warnx", "func"},
	{"wcrtomb", "func"},
	{"wcscat", "func"},
	{"wcschr", "func"},
	{"wcscmp", "func"},
	{"wcscoll", "func"},
	{"wcscpy", "func"},
	{"wcscspn", "func"},
	{"wcsftime", "func"},
	{"wcslen", "func"},
	{"wcsncat", "func"},
	{"wcsncmp", "func"},
	{"wcsncpy", "func"},
	{"wcspbrk", "func"},
	{"wcsrchr", "func"},
	{"wcsrtombs", "func"},
	{"wcsspn", "func"},
	{"wcsstr", "func"},
	{"wcstod", "func"},
	{"wcstof", "func"},
	{"wcstoimax", "func"},
	{"wcstok", "func"},
	{"wcstol", "func"},
	{"wcstold", "func"},
	{"wcstoll", "func"},
	{"wcstombs", "func"},
	{"wcstoul", "func"},
	{"wcstoull", "func"},
	{"wcstoumax", "func"},
	{"wcsxfrm", "func"},
	{"wctob", "func"},
	{"wctomb", "func"},
	{"wctrans", "func"},
	{"wctype", "func"},
	{"wmemchr", "func"},
	{"wmemcmp", "func"},
	{"wmemcpy", "func"},
	{"wmemmove", "func"},
	{"wmemset", "func"},
	{"wprintf", "func"},
	{"write", "func"},
	{"wscanf", "func"},
	{"xmalloc", "func"},
  {NULL, NULL}
};
typedef int (*GperfForeachCallback)(void *user, const char *k, const char *v);
int gperf_types_foreach(GperfForeachCallback cb, void *user) {
  int i = 0; while (kvs[i].name) {
  cb (user, kvs[i].name, kvs[i].value);
  i++;}
  return 0;
}
const char *gperf_types_get(const char *s) {
  int i = 0; while (kvs[i].name) {
  if (!strcmp (s, kvs[i].name)) return kvs[i].value;
  i++;}
  return NULL;
}
#define sdb_hash_c_types(x,y) gperf_types_hash(x)
const unsigned int gperf_types_hash(const char *s) {
  int sum = strlen (s);
  while (*s) { sum += *s; s++; }
  return sum;
}
struct {const char *name;void *get;void *hash;void *foreach;} gperf_types = {
  .name = "types",
  .get = &gperf_types_get,
  .hash = &gperf_types_hash,
  .foreach = &gperf_types_foreach
};

#if MAIN
int main () {
	const char *s = ((char*(*)(char*))gperf_types.get)("foo");
	printf ("%s\n", s);
}
#endif