# pylint:disable=line-too-long
import logging

from ...sim_type import SimTypeFunction, \
    SimTypeShort, SimTypeInt, SimTypeLong, SimTypeLongLong, SimTypeDouble, SimTypeFloat, \
    SimTypePointer, \
    SimTypeChar, \
    SimStruct, \
    SimTypeFixedSizeArray, \
    SimTypeBottom
from .. import SIM_PROCEDURES as P
from . import SimLibrary


_l = logging.getLogger(name=__name__)


libc = SimLibrary()
libc.set_library_names('libc.so.0', 'libc.so.1', 'libc.so.2', 'libc.so.3', 'libc.so.4', 'libc.so.5', 'libc.so.6', 'libc.so.7', 'libc.so')
libc.add_all_from_dict(P['libc'])
libc.add_all_from_dict(P['posix'])
libc.add_all_from_dict(P['glibc'])
libc.add_all_from_dict(P['uclibc']) # gotta do this since there's no distinguishing different libcs without analysis. there should be no naming conflicts in the functions.
libc.set_non_returning('exit_group', 'exit', 'abort', 'pthread_exit', '__assert_fail',
                       'longjmp', 'siglongjmp', '__longjmp_chk', '__siglongjmp_chk')


#
# parsed function prototypes
#

_libc_decls = \
    {
        # char * strerror (int ERRNUM);
        "strerror": SimTypeFunction([SimTypeInt(signed=True)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["errnum"]),
        # char * strerror_r (int ERRNUM, char *BUF, size_t N);
        "strerror_r": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeChar(), offset=0), arg_names=["errnum", "buf", "n"]),
        # void perror (const char *MESSAGE);
        "perror": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeBottom(label="void"), arg_names=["message"]),
        # void error (int STATUS, int ERRNUM, const char *FORMAT, ...);
        "error": SimTypeFunction([SimTypeInt(signed=True), SimTypeInt(signed=True), SimTypePointer(SimTypeChar(), offset=0)], SimTypeBottom(label="void"), arg_names=["status", "errnum", "format"], variadic=True),
        # void error_at_line (int STATUS, int ERRNUM, const char *FNAME, unsigned int LINENO, const char *FORMAT, ...);
        "error_at_line": SimTypeFunction([SimTypeInt(signed=True), SimTypeInt(signed=True), SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=False), SimTypePointer(SimTypeChar(), offset=0)], SimTypeBottom(label="void"), arg_names=["status", "errnum", "fname", "lineno", "format"], variadic=True),
        # void warn (const char *FORMAT, ...);
        "warn": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeBottom(label="void"), arg_names=["format"], variadic=True),
        # void vwarn (const char *FORMAT, va_list AP);
        "vwarn": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimStruct({}, name="va_list", pack=False, align=None)], SimTypeBottom(label="void"), arg_names=["format", "ap"]),
        # void warnx (const char *FORMAT, ...);
        "warnx": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeBottom(label="void"), arg_names=["format"], variadic=True),
        # void vwarnx (const char *FORMAT, va_list AP);
        "vwarnx": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimStruct({}, name="va_list", pack=False, align=None)], SimTypeBottom(label="void"), arg_names=["format", "ap"]),
        # void err (int STATUS, const char *FORMAT, ...);
        "err": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeChar(), offset=0)], SimTypeBottom(label="void"), arg_names=["status", "format"], variadic=True),
        # void verr (int STATUS, const char *FORMAT, va_list AP);
        "verr": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeChar(), offset=0), SimStruct({}, name="va_list", pack=False, align=None)], SimTypeBottom(label="void"), arg_names=["status", "format", "ap"]),
        # void errx (int STATUS, const char *FORMAT, ...);
        "errx": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeChar(), offset=0)], SimTypeBottom(label="void"), arg_names=["status", "format"], variadic=True),
        # void verrx (int STATUS, const char *FORMAT, va_list AP);
        "verrx": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeChar(), offset=0), SimStruct({}, name="va_list", pack=False, align=None)], SimTypeBottom(label="void"), arg_names=["status", "format", "ap"]),
        # void * malloc (size_t SIZE);
        "malloc": SimTypeFunction([SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeBottom(label="void"), offset=0), arg_names=["size"]),
        # void free (void *PTR);
        "free": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0)], SimTypeBottom(label="void"), arg_names=["ptr"]),
        # void * realloc (void *PTR, size_t NEWSIZE);
        "realloc": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeBottom(label="void"), offset=0), arg_names=["ptr", "newsize"]),
        # void * reallocarray (void *PTR, size_t NMEMB, size_t SIZE);
        "reallocarray": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeBottom(label="void"), offset=0), arg_names=["ptr", "nmemb", "size"]),
        # void * calloc (size_t COUNT, size_t ELTSIZE);
        "calloc": SimTypeFunction([SimTypeLong(signed=False, label="size_t"), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeBottom(label="void"), offset=0), arg_names=["count", "eltsize"]),
        # void * aligned_alloc (size_t ALIGNMENT, size_t SIZE);
        "aligned_alloc": SimTypeFunction([SimTypeLong(signed=False, label="size_t"), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeBottom(label="void"), offset=0), arg_names=["alignment", "size"]),
        # void * memalign (size_t BOUNDARY, size_t SIZE);
        "memalign": SimTypeFunction([SimTypeLong(signed=False, label="size_t"), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeBottom(label="void"), offset=0), arg_names=["boundary", "size"]),
        # int posix_memalign (void **MEMPTR, size_t ALIGNMENT, size_t SIZE);
        "posix_memalign": SimTypeFunction([SimTypePointer(SimTypePointer(SimTypeBottom(label="void"), offset=0), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["memptr", "alignment", "size"]),
        # void * valloc (size_t SIZE);
        "valloc": SimTypeFunction([SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeBottom(label="void"), offset=0), arg_names=["size"]),
        # int mallopt (int PARAM, int VALUE);
        "mallopt": SimTypeFunction([SimTypeInt(signed=True), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["param", "value"]),
        # int mcheck (void (*ABORTFN) (enum mcheck_status STATUS));
        "mcheck": None,
        # enum mcheck_status mprobe (void *POINTER);
        "mprobe": None,
        # struct mallinfo mallinfo (void);
        "mallinfo": SimTypeFunction([], SimStruct({}, name="mallinfo", pack=False, align=None)),
        # void mtrace (void);
        "mtrace": SimTypeFunction([], SimTypeBottom(label="void")),
        # void muntrace (void);
        "muntrace": SimTypeFunction([], SimTypeBottom(label="void")),
        # int obstack_init (struct obstack *OBSTACK_PTR);
        "obstack_init": SimTypeFunction([SimTypePointer(SimStruct({}, name="obstack", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["obstack_ptr"]),
        # void * obstack_alloc (struct obstack *OBSTACK_PTR, int SIZE);
        "obstack_alloc": SimTypeFunction([SimTypePointer(SimStruct({}, name="obstack", pack=False, align=None), offset=0), SimTypeInt(signed=True)], SimTypePointer(SimTypeBottom(label="void"), offset=0), arg_names=["obstack_ptr", "size"]),
        # void * obstack_copy (struct obstack *OBSTACK_PTR, void *ADDRESS, int SIZE);
        "obstack_copy": SimTypeFunction([SimTypePointer(SimStruct({}, name="obstack", pack=False, align=None), offset=0), SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeInt(signed=True)], SimTypePointer(SimTypeBottom(label="void"), offset=0), arg_names=["obstack_ptr", "address", "size"]),
        # void * obstack_copy0 (struct obstack *OBSTACK_PTR, void *ADDRESS, int SIZE);
        "obstack_copy0": SimTypeFunction([SimTypePointer(SimStruct({}, name="obstack", pack=False, align=None), offset=0), SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeInt(signed=True)], SimTypePointer(SimTypeBottom(label="void"), offset=0), arg_names=["obstack_ptr", "address", "size"]),
        # void obstack_free (struct obstack *OBSTACK_PTR, void *OBJECT);
        "obstack_free": SimTypeFunction([SimTypePointer(SimStruct({}, name="obstack", pack=False, align=None), offset=0), SimTypePointer(SimTypeBottom(label="void"), offset=0)], SimTypeBottom(label="void"), arg_names=["obstack_ptr", "object"]),
        # void obstack_blank (struct obstack *OBSTACK_PTR, int SIZE);
        "obstack_blank": SimTypeFunction([SimTypePointer(SimStruct({}, name="obstack", pack=False, align=None), offset=0), SimTypeInt(signed=True)], SimTypeBottom(label="void"), arg_names=["obstack_ptr", "size"]),
        # void obstack_grow (struct obstack *OBSTACK_PTR, void *DATA, int SIZE);
        "obstack_grow": SimTypeFunction([SimTypePointer(SimStruct({}, name="obstack", pack=False, align=None), offset=0), SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeInt(signed=True)], SimTypeBottom(label="void"), arg_names=["obstack_ptr", "data", "size"]),
        # void obstack_grow0 (struct obstack *OBSTACK_PTR, void *DATA, int SIZE);
        "obstack_grow0": SimTypeFunction([SimTypePointer(SimStruct({}, name="obstack", pack=False, align=None), offset=0), SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeInt(signed=True)], SimTypeBottom(label="void"), arg_names=["obstack_ptr", "data", "size"]),
        # void obstack_1grow (struct obstack *OBSTACK_PTR, char C);
        "obstack_1grow": SimTypeFunction([SimTypePointer(SimStruct({}, name="obstack", pack=False, align=None), offset=0), SimTypeChar()], SimTypeBottom(label="void"), arg_names=["obstack_ptr", "c"]),
        # void obstack_ptr_grow (struct obstack *OBSTACK_PTR, void *DATA);
        "obstack_ptr_grow": SimTypeFunction([SimTypePointer(SimStruct({}, name="obstack", pack=False, align=None), offset=0), SimTypePointer(SimTypeBottom(label="void"), offset=0)], SimTypeBottom(label="void"), arg_names=["obstack_ptr", "data"]),
        # void obstack_int_grow (struct obstack *OBSTACK_PTR, int DATA);
        "obstack_int_grow": SimTypeFunction([SimTypePointer(SimStruct({}, name="obstack", pack=False, align=None), offset=0), SimTypeInt(signed=True)], SimTypeBottom(label="void"), arg_names=["obstack_ptr", "data"]),
        # void * obstack_finish (struct obstack *OBSTACK_PTR);
        "obstack_finish": SimTypeFunction([SimTypePointer(SimStruct({}, name="obstack", pack=False, align=None), offset=0)], SimTypePointer(SimTypeBottom(label="void"), offset=0), arg_names=["obstack_ptr"]),
        # int obstack_object_size (struct obstack *OBSTACK_PTR);
        "obstack_object_size": SimTypeFunction([SimTypePointer(SimStruct({}, name="obstack", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["obstack_ptr"]),
        # int obstack_room (struct obstack *OBSTACK_PTR);
        "obstack_room": SimTypeFunction([SimTypePointer(SimStruct({}, name="obstack", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["obstack_ptr"]),
        # void obstack_1grow_fast (struct obstack *OBSTACK_PTR, char C);
        "obstack_1grow_fast": SimTypeFunction([SimTypePointer(SimStruct({}, name="obstack", pack=False, align=None), offset=0), SimTypeChar()], SimTypeBottom(label="void"), arg_names=["obstack_ptr", "c"]),
        # void obstack_ptr_grow_fast (struct obstack *OBSTACK_PTR, void *DATA);
        "obstack_ptr_grow_fast": SimTypeFunction([SimTypePointer(SimStruct({}, name="obstack", pack=False, align=None), offset=0), SimTypePointer(SimTypeBottom(label="void"), offset=0)], SimTypeBottom(label="void"), arg_names=["obstack_ptr", "data"]),
        # void obstack_int_grow_fast (struct obstack *OBSTACK_PTR, int DATA);
        "obstack_int_grow_fast": SimTypeFunction([SimTypePointer(SimStruct({}, name="obstack", pack=False, align=None), offset=0), SimTypeInt(signed=True)], SimTypeBottom(label="void"), arg_names=["obstack_ptr", "data"]),
        # void obstack_blank_fast (struct obstack *OBSTACK_PTR, int SIZE);
        "obstack_blank_fast": SimTypeFunction([SimTypePointer(SimStruct({}, name="obstack", pack=False, align=None), offset=0), SimTypeInt(signed=True)], SimTypeBottom(label="void"), arg_names=["obstack_ptr", "size"]),
        # void * obstack_base (struct obstack *OBSTACK_PTR);
        "obstack_base": SimTypeFunction([SimTypePointer(SimStruct({}, name="obstack", pack=False, align=None), offset=0)], SimTypePointer(SimTypeBottom(label="void"), offset=0), arg_names=["obstack_ptr"]),
        # void * alloca (size_t SIZE);
        "alloca": SimTypeFunction([SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeBottom(label="void"), offset=0), arg_names=["size"]),
        # int brk (void *ADDR);
        "brk": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0)], SimTypeInt(signed=True), arg_names=["addr"]),
        # void *sbrk (ptrdiff_t DELTA);
        "sbrk": SimTypeFunction([SimTypeLong(signed=True, label="ptrdiff_t")], SimTypePointer(SimTypeBottom(label="void"), offset=0), arg_names=["delta"]),
        # int mlock (const void *ADDR, size_t LEN);
        "mlock": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["addr", "len"]),
        # int munlock (const void *ADDR, size_t LEN);
        "munlock": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["addr", "len"]),
        # int mlockall (int FLAGS);
        "mlockall": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["flags"]),
        # int munlockall (void);
        "munlockall": SimTypeFunction([], SimTypeInt(signed=True)),
        # int islower (int C);
        "islower": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["c"]),
        # int isupper (int C);
        "isupper": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["c"]),
        # int isalpha (int C);
        "isalpha": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["c"]),
        # int isdigit (int C);
        "isdigit": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["c"]),
        # int isalnum (int C);
        "isalnum": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["c"]),
        # int isxdigit (int C);
        "isxdigit": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["c"]),
        # int ispunct (int C);
        "ispunct": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["c"]),
        # int isspace (int C);
        "isspace": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["c"]),
        # int isblank (int C);
        "isblank": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["c"]),
        # int isgraph (int C);
        "isgraph": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["c"]),
        # int isprint (int C);
        "isprint": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["c"]),
        # int iscntrl (int C);
        "iscntrl": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["c"]),
        # int isascii (int C);
        "isascii": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["c"]),
        # int tolower (int C);
        "tolower": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["c"]),
        # int toupper (int C);
        "toupper": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["c"]),
        # int toascii (int C);
        "toascii": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["c"]),
        # int _tolower (int C);
        "_tolower": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["c"]),
        # int _toupper (int C);
        "_toupper": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["c"]),
        # wctype_t wctype (const char *PROPERTY);
        "wctype": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeShort(signed=False, label="wctype_t"), arg_names=["property"]),
        # int iswctype (wint_t WC, wctype_t DESC);
        "iswctype": SimTypeFunction([SimTypeInt(signed=False, label="wint_t"), SimTypeShort(signed=False, label="wctype_t")], SimTypeInt(signed=True), arg_names=["wc", "desc"]),
        # int iswalnum (wint_t WC);
        "iswalnum": SimTypeFunction([SimTypeInt(signed=False, label="wint_t")], SimTypeInt(signed=True), arg_names=["wc"]),
        # int iswalpha (wint_t WC);
        "iswalpha": SimTypeFunction([SimTypeInt(signed=False, label="wint_t")], SimTypeInt(signed=True), arg_names=["wc"]),
        # int iswcntrl (wint_t WC);
        "iswcntrl": SimTypeFunction([SimTypeInt(signed=False, label="wint_t")], SimTypeInt(signed=True), arg_names=["wc"]),
        # int iswdigit (wint_t WC);
        "iswdigit": SimTypeFunction([SimTypeInt(signed=False, label="wint_t")], SimTypeInt(signed=True), arg_names=["wc"]),
        # int iswgraph (wint_t WC);
        "iswgraph": SimTypeFunction([SimTypeInt(signed=False, label="wint_t")], SimTypeInt(signed=True), arg_names=["wc"]),
        # int iswlower (wint_t WC);
        "iswlower": SimTypeFunction([SimTypeInt(signed=False, label="wint_t")], SimTypeInt(signed=True), arg_names=["wc"]),
        # int iswprint (wint_t WC);
        "iswprint": SimTypeFunction([SimTypeInt(signed=False, label="wint_t")], SimTypeInt(signed=True), arg_names=["wc"]),
        # int iswpunct (wint_t WC);
        "iswpunct": SimTypeFunction([SimTypeInt(signed=False, label="wint_t")], SimTypeInt(signed=True), arg_names=["wc"]),
        # int iswspace (wint_t WC);
        "iswspace": SimTypeFunction([SimTypeInt(signed=False, label="wint_t")], SimTypeInt(signed=True), arg_names=["wc"]),
        # int iswupper (wint_t WC);
        "iswupper": SimTypeFunction([SimTypeInt(signed=False, label="wint_t")], SimTypeInt(signed=True), arg_names=["wc"]),
        # int iswxdigit (wint_t WC);
        "iswxdigit": SimTypeFunction([SimTypeInt(signed=False, label="wint_t")], SimTypeInt(signed=True), arg_names=["wc"]),
        # int iswblank (wint_t WC);
        "iswblank": SimTypeFunction([SimTypeInt(signed=False, label="wint_t")], SimTypeInt(signed=True), arg_names=["wc"]),
        # wctrans_t wctrans (const char *PROPERTY);
        "wctrans": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeShort(signed=False, label="wctrans_t"), arg_names=["property"]),
        # wint_t towctrans (wint_t WC, wctrans_t DESC);
        "towctrans": SimTypeFunction([SimTypeInt(signed=False, label="wint_t"), SimTypeShort(signed=False, label="wctrans_t")], SimTypeInt(signed=False, label="wint_t"), arg_names=["wc", "desc"]),
        # wint_t towlower (wint_t WC);
        "towlower": SimTypeFunction([SimTypeInt(signed=False, label="wint_t")], SimTypeInt(signed=False, label="wint_t"), arg_names=["wc"]),
        # wint_t towupper (wint_t WC);
        "towupper": SimTypeFunction([SimTypeInt(signed=False, label="wint_t")], SimTypeInt(signed=False, label="wint_t"), arg_names=["wc"]),
        # size_t strlen (const char *S);
        "strlen": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeLong(signed=False, label="size_t"), arg_names=["s"]),
        # size_t wcslen (const wchar_t *WS);
        "wcslen": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0)], SimTypeLong(signed=False, label="size_t"), arg_names=["ws"]),
        # size_t strnlen (const char *S, size_t MAXLEN);
        "strnlen": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeLong(signed=False, label="size_t"), arg_names=["s", "maxlen"]),
        # size_t wcsnlen (const wchar_t *WS, size_t MAXLEN);
        "wcsnlen": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeLong(signed=False, label="size_t"), arg_names=["ws", "maxlen"]),
        # void * memcpy (void *restrict TO, const void *restrict FROM, size_t SIZE);
        "memcpy": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeBottom(label="void"), offset=0), arg_names=["to", "from", "size"]),
        # wchar_t * wmemcpy (wchar_t *restrict WTO, const wchar_t *restrict WFROM, size_t SIZE);
        "wmemcpy": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), arg_names=["wto", "wfrom", "size"]),
        # void * mempcpy (void *restrict TO, const void *restrict FROM, size_t SIZE);
        "mempcpy": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeBottom(label="void"), offset=0), arg_names=["to", "from", "size"]),
        # wchar_t * wmempcpy (wchar_t *restrict WTO, const wchar_t *restrict WFROM, size_t SIZE);
        "wmempcpy": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), arg_names=["wto", "wfrom", "size"]),
        # void * memmove (void *TO, const void *FROM, size_t SIZE);
        "memmove": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeBottom(label="void"), offset=0), arg_names=["to", "from", "size"]),
        # wchar_t * wmemmove (wchar_t *WTO, const wchar_t *WFROM, size_t SIZE);
        "wmemmove": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), arg_names=["wto", "wfrom", "size"]),
        # void * memccpy (void *restrict TO, const void *restrict FROM, int C, size_t SIZE);
        "memccpy": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeInt(signed=True), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeBottom(label="void"), offset=0), arg_names=["to", "from", "c", "size"]),
        # void * memset (void *BLOCK, int C, size_t SIZE);
        "memset": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeInt(signed=True), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeBottom(label="void"), offset=0), arg_names=["block", "c", "size"]),
        # wchar_t * wmemset (wchar_t *BLOCK, wchar_t WC, size_t SIZE);
        "wmemset": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypeShort(signed=False, label="wchar_t"), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), arg_names=["block", "wc", "size"]),
        # char * strcpy (char *restrict TO, const char *restrict FROM);
        "strcpy": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["to", "from"]),
        # wchar_t * wcscpy (wchar_t *restrict WTO, const wchar_t *restrict WFROM);
        "wcscpy": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0)], SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), arg_names=["wto", "wfrom"]),
        # char * strdup (const char *S);
        "strdup": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["s"]),
        # wchar_t * wcsdup (const wchar_t *WS);
        "wcsdup": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0)], SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), arg_names=["ws"]),
        # char * stpcpy (char *restrict TO, const char *restrict FROM);
        "stpcpy": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["to", "from"]),
        # wchar_t * wcpcpy (wchar_t *restrict WTO, const wchar_t *restrict WFROM);
        "wcpcpy": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0)], SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), arg_names=["wto", "wfrom"]),
        # void bcopy (const void *FROM, void *TO, size_t SIZE);
        "bcopy": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeBottom(label="void"), arg_names=["from", "to", "size"]),
        # void bzero (void *BLOCK, size_t SIZE);
        "bzero": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeBottom(label="void"), arg_names=["block", "size"]),
        # char * strcat (char *restrict TO, const char *restrict FROM);
        "strcat": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["to", "from"]),
        # wchar_t * wcscat (wchar_t *restrict WTO, const wchar_t *restrict WFROM);
        "wcscat": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0)], SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), arg_names=["wto", "wfrom"]),
        # char * strncpy (char *restrict TO, const char *restrict FROM, size_t SIZE);
        "strncpy": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeChar(), offset=0), arg_names=["to", "from", "size"]),
        # wchar_t * wcsncpy (wchar_t *restrict WTO, const wchar_t *restrict WFROM, size_t SIZE);
        "wcsncpy": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), arg_names=["wto", "wfrom", "size"]),
        # char * strndup (const char *S, size_t SIZE);
        "strndup": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeChar(), offset=0), arg_names=["s", "size"]),
        # char * stpncpy (char *restrict TO, const char *restrict FROM, size_t SIZE);
        "stpncpy": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeChar(), offset=0), arg_names=["to", "from", "size"]),
        # wchar_t * wcpncpy (wchar_t *restrict WTO, const wchar_t *restrict WFROM, size_t SIZE);
        "wcpncpy": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), arg_names=["wto", "wfrom", "size"]),
        # char * strncat (char *restrict TO, const char *restrict FROM, size_t SIZE);
        "strncat": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeChar(), offset=0), arg_names=["to", "from", "size"]),
        # wchar_t * wcsncat (wchar_t *restrict WTO, const wchar_t *restrict WFROM, size_t SIZE);
        "wcsncat": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), arg_names=["wto", "wfrom", "size"]),
        # int memcmp (const void *A1, const void *A2, size_t SIZE);
        "memcmp": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["a1", "a2", "size"]),
        # int wmemcmp (const wchar_t *A1, const wchar_t *A2, size_t SIZE);
        "wmemcmp": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["a1", "a2", "size"]),
        # int strcmp (const char *S1, const char *S2);
        "strcmp": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["s1", "s2"]),
        # int wcscmp (const wchar_t *WS1, const wchar_t *WS2);
        "wcscmp": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0)], SimTypeInt(signed=True), arg_names=["ws1", "ws2"]),
        # int strcasecmp (const char *S1, const char *S2);
        "strcasecmp": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["s1", "s2"]),
        # int wcscasecmp (const wchar_t *WS1, const wchar_t *WS2);
        "wcscasecmp": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0)], SimTypeInt(signed=True), arg_names=["ws1", "ws2"]),
        # int strncmp (const char *S1, const char *S2, size_t SIZE);
        "strncmp": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["s1", "s2", "size"]),
        # int wcsncmp (const wchar_t *WS1, const wchar_t *WS2, size_t SIZE);
        "wcsncmp": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["ws1", "ws2", "size"]),
        # int strncasecmp (const char *S1, const char *S2, size_t N);
        "strncasecmp": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["s1", "s2", "n"]),
        # int wcsncasecmp (const wchar_t *WS1, const wchar_t *S2, size_t N);
        "wcsncasecmp": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["ws1", "s2", "n"]),
        # int strverscmp (const char *S1, const char *S2);
        "strverscmp": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["s1", "s2"]),
        # int bcmp (const void *A1, const void *A2, size_t SIZE);
        "bcmp": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["a1", "a2", "size"]),
        # int strcoll (const char *S1, const char *S2);
        "strcoll": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["s1", "s2"]),
        # int wcscoll (const wchar_t *WS1, const wchar_t *WS2);
        "wcscoll": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0)], SimTypeInt(signed=True), arg_names=["ws1", "ws2"]),
        # size_t strxfrm (char *restrict TO, const char *restrict FROM, size_t SIZE);
        "strxfrm": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeLong(signed=False, label="size_t"), arg_names=["to", "from", "size"]),
        # size_t wcsxfrm (wchar_t *restrict WTO, const wchar_t *WFROM, size_t SIZE);
        "wcsxfrm": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeLong(signed=False, label="size_t"), arg_names=["wto", "wfrom", "size"]),
        # void * memchr (const void *BLOCK, int C, size_t SIZE);
        "memchr": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeInt(signed=True), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeBottom(label="void"), offset=0), arg_names=["block", "c", "size"]),
        # wchar_t * wmemchr (const wchar_t *BLOCK, wchar_t WC, size_t SIZE);
        "wmemchr": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypeShort(signed=False, label="wchar_t"), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), arg_names=["block", "wc", "size"]),
        # void * rawmemchr (const void *BLOCK, int C);
        "rawmemchr": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeInt(signed=True)], SimTypePointer(SimTypeBottom(label="void"), offset=0), arg_names=["block", "c"]),
        # void * memrchr (const void *BLOCK, int C, size_t SIZE);
        "memrchr": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeInt(signed=True), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeBottom(label="void"), offset=0), arg_names=["block", "c", "size"]),
        # char * strchr (const char *STRING, int C);
        "strchr": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=True)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["string", "c"]),
        # wchar_t * wcschr (const wchar_t *WSTRING, int WC);
        "wcschr": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypeInt(signed=True)], SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), arg_names=["wstring", "wc"]),
        # char * strchrnul (const char *STRING, int C);
        "strchrnul": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=True)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["string", "c"]),
        # wchar_t * wcschrnul (const wchar_t *WSTRING, wchar_t WC);
        "wcschrnul": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypeShort(signed=False, label="wchar_t")], SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), arg_names=["wstring", "wc"]),
        # char * strrchr (const char *STRING, int C);
        "strrchr": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=True)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["string", "c"]),
        # wchar_t * wcsrchr (const wchar_t *WSTRING, wchar_t C);
        "wcsrchr": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypeShort(signed=False, label="wchar_t")], SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), arg_names=["wstring", "c"]),
        # char * strstr (const char *HAYSTACK, const char *NEEDLE);
        "strstr": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["haystack", "needle"]),
        # wchar_t * wcsstr (const wchar_t *HAYSTACK, const wchar_t *NEEDLE);
        "wcsstr": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0)], SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), arg_names=["haystack", "needle"]),
        # wchar_t * wcswcs (const wchar_t *HAYSTACK, const wchar_t *NEEDLE);
        "wcswcs": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0)], SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), arg_names=["haystack", "needle"]),
        # char * strcasestr (const char *HAYSTACK, const char *NEEDLE);
        "strcasestr": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["haystack", "needle"]),
        # void * memmem (const void *HAYSTACK, size_t HAYSTACK_LEN, const void *NEEDLE, size_t NEEDLE_LEN);
        "memmem": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeBottom(label="void"), offset=0), arg_names=["haystack", "haystack_len", "needle", "needle_len"]),
        # size_t strspn (const char *STRING, const char *SKIPSET);
        "strspn": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypeLong(signed=False, label="size_t"), arg_names=["string", "skipset"]),
        # size_t wcsspn (const wchar_t *WSTRING, const wchar_t *SKIPSET);
        "wcsspn": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0)], SimTypeLong(signed=False, label="size_t"), arg_names=["wstring", "skipset"]),
        # size_t strcspn (const char *STRING, const char *STOPSET);
        "strcspn": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypeLong(signed=False, label="size_t"), arg_names=["string", "stopset"]),
        # size_t wcscspn (const wchar_t *WSTRING, const wchar_t *STOPSET);
        "wcscspn": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0)], SimTypeLong(signed=False, label="size_t"), arg_names=["wstring", "stopset"]),
        # char * strpbrk (const char *STRING, const char *STOPSET);
        "strpbrk": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["string", "stopset"]),
        # wchar_t * wcspbrk (const wchar_t *WSTRING, const wchar_t *STOPSET);
        "wcspbrk": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0)], SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), arg_names=["wstring", "stopset"]),
        # char * index (const char *STRING, int C);
        "index": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=True)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["string", "c"]),
        # char * rindex (const char *STRING, int C);
        "rindex": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=True)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["string", "c"]),
        # char * strtok (char *restrict NEWSTRING, const char *restrict DELIMITERS);
        "strtok": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["newstring", "delimiters"]),
        # wchar_t * wcstok (wchar_t *NEWSTRING, const wchar_t *DELIMITERS, wchar_t **SAVE_PTR);
        "wcstok": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), offset=0)], SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), arg_names=["newstring", "delimiters", "save_ptr"]),
        # char * strtok_r (char *NEWSTRING, const char *DELIMITERS, char **SAVE_PTR);
        "strtok_r": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["newstring", "delimiters", "save_ptr"]),
        # char * strsep (char **STRING_PTR, const char *DELIMITER);
        "strsep": SimTypeFunction([SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["string_ptr", "delimiter"]),
        # char * basename (const char *PATH);
        "basename": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["path"]),
        # char * dirname (char *PATH);
        "dirname": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["path"]),
        # void explicit_bzero (void *BLOCK, size_t LEN);
        "explicit_bzero": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeBottom(label="void"), arg_names=["block", "len"]),
        # char * strfry (char *STRING);
        "strfry": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["string"]),
        # void * memfrob (void *MEM, size_t LENGTH);
        "memfrob": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeBottom(label="void"), offset=0), arg_names=["mem", "length"]),
        # char * l64a (long int N);
        "l64a": SimTypeFunction([SimTypeLong(signed=True)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["n"]),
        # long int a64l (const char *STRING);
        "a64l": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeLong(signed=True), arg_names=["string"]),
        # error_t argz_create (char *const ARGV[], char **ARGZ, size_t *ARGZ_LEN);
        "argz_create": None,
        # error_t argz_create_sep (const char *STRING, int SEP, char **ARGZ, size_t *ARGZ_LEN);
        "argz_create_sep": None,
        # size_t argz_count (const char *ARGZ, size_t ARGZ_LEN);
        "argz_count": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeLong(signed=False, label="size_t"), arg_names=["argz", "argz_len"]),
        # void argz_extract (const char *ARGZ, size_t ARGZ_LEN, char **ARGV);
        "argz_extract": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0)], SimTypeBottom(label="void"), arg_names=["argz", "argz_len", "argv"]),
        # void argz_stringify (char *ARGZ, size_t LEN, int SEP);
        "argz_stringify": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypeInt(signed=True)], SimTypeBottom(label="void"), arg_names=["argz", "len", "sep"]),
        # error_t argz_add (char **ARGZ, size_t *ARGZ_LEN, const char *STR);
        "argz_add": None,
        # error_t argz_add_sep (char **ARGZ, size_t *ARGZ_LEN, const char *STR, int DELIM);
        "argz_add_sep": None,
        # error_t argz_append (char **ARGZ, size_t *ARGZ_LEN, const char *BUF, size_t BUF_LEN);
        "argz_append": None,
        # void argz_delete (char **ARGZ, size_t *ARGZ_LEN, char *ENTRY);
        "argz_delete": SimTypeFunction([SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0), SimTypePointer(SimTypeLong(signed=False, label="size_t"), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypeBottom(label="void"), arg_names=["argz", "argz_len", "entry"]),
        # error_t argz_insert (char **ARGZ, size_t *ARGZ_LEN, char *BEFORE, const char *ENTRY);
        "argz_insert": None,
        # char * argz_next (const char *ARGZ, size_t ARGZ_LEN, const char *ENTRY);
        "argz_next": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["argz", "argz_len", "entry"]),
        # error_t argz_replace (char **ARGZ, size_t *ARGZ_LEN, const char *STR, const char *WITH, unsigned *REPLACE_COUNT);
        "argz_replace": None,
        # char * envz_entry (const char *ENVZ, size_t ENVZ_LEN, const char *NAME);
        "envz_entry": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["envz", "envz_len", "name"]),
        # char * envz_get (const char *ENVZ, size_t ENVZ_LEN, const char *NAME);
        "envz_get": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["envz", "envz_len", "name"]),
        # error_t envz_add (char **ENVZ, size_t *ENVZ_LEN, const char *NAME, const char *VALUE);
        "envz_add": None,
        # error_t envz_merge (char **ENVZ, size_t *ENVZ_LEN, const char *ENVZ2, size_t ENVZ2_LEN, int OVERRIDE);
        "envz_merge": None,
        # void envz_strip (char **ENVZ, size_t *ENVZ_LEN);
        "envz_strip": SimTypeFunction([SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0), SimTypePointer(SimTypeLong(signed=False, label="size_t"), offset=0)], SimTypeBottom(label="void"), arg_names=["envz", "envz_len"]),
        # void envz_remove (char **ENVZ, size_t *ENVZ_LEN, const char *NAME);
        "envz_remove": SimTypeFunction([SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0), SimTypePointer(SimTypeLong(signed=False, label="size_t"), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypeBottom(label="void"), arg_names=["envz", "envz_len", "name"]),
        # int mbsinit (const mbstate_t *PS);
        "mbsinit": None,
        # wint_t btowc (int C);
        "btowc": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=False, label="wint_t"), arg_names=["c"]),
        # int wctob (wint_t C);
        "wctob": SimTypeFunction([SimTypeInt(signed=False, label="wint_t")], SimTypeInt(signed=True), arg_names=["c"]),
        # size_t mbrtowc (wchar_t *restrict PWC, const char *restrict S, size_t N, mbstate_t *restrict PS);
        "mbrtowc": None,
        # size_t mbrlen (const char *restrict S, size_t N, mbstate_t *PS);
        "mbrlen": None,
        # size_t wcrtomb (char *restrict S, wchar_t WC, mbstate_t *restrict PS);
        "wcrtomb": None,
        # size_t mbsrtowcs (wchar_t *restrict DST, const char **restrict SRC, size_t LEN, mbstate_t *restrict PS);
        "mbsrtowcs": None,
        # size_t wcsrtombs (char *restrict DST, const wchar_t **restrict SRC, size_t LEN, mbstate_t *restrict PS);
        "wcsrtombs": None,
        # size_t mbsnrtowcs (wchar_t *restrict DST, const char **restrict SRC, size_t NMC, size_t LEN, mbstate_t *restrict PS);
        "mbsnrtowcs": None,
        # size_t wcsnrtombs (char *restrict DST, const wchar_t **restrict SRC, size_t NWC, size_t LEN, mbstate_t *restrict PS);
        "wcsnrtombs": None,
        # int mbtowc (wchar_t *restrict RESULT, const char *restrict STRING, size_t SIZE);
        "mbtowc": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["result", "string", "size"]),
        # int wctomb (char *STRING, wchar_t WCHAR);
        "wctomb": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeShort(signed=False, label="wchar_t")], SimTypeInt(signed=True), arg_names=["string", "wchar"]),
        # int mblen (const char *STRING, size_t SIZE);
        "mblen": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["string", "size"]),
        # size_t mbstowcs (wchar_t *WSTRING, const char *STRING, size_t SIZE);
        "mbstowcs": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeLong(signed=False, label="size_t"), arg_names=["wstring", "string", "size"]),
        # size_t wcstombs (char *STRING, const wchar_t *WSTRING, size_t SIZE);
        "wcstombs": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeLong(signed=False, label="size_t"), arg_names=["string", "wstring", "size"]),
        # iconv_t iconv_open (const char *TOCODE, const char *FROMCODE);
        "iconv_open": None,
        # int iconv_close (iconv_t CD);
        "iconv_close": None,
        # size_t iconv (iconv_t CD, char **INBUF, size_t *INBYTESLEFT, char **OUTBUF, size_t *OUTBYTESLEFT);
        "iconv": None,
        # char * setlocale (int CATEGORY, const char *LOCALE);
        "setlocale": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["category", "locale"]),
        # struct lconv * localeconv (void);
        "localeconv": SimTypeFunction([], SimTypePointer(SimStruct({}, name="lconv", pack=False, align=None), offset=0)),
        # char * nl_langinfo (nl_item ITEM);
        "nl_langinfo": None,
        # ssize_t strfmon (char *S, size_t MAXSIZE, const char *FORMAT, ...);
        "strfmon": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypeChar(), offset=0)], SimTypeLong(signed=True, label="ssize_t"), arg_names=["s", "maxsize", "format"], variadic=True),
        # int rpmatch (const char *RESPONSE);
        "rpmatch": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["response"]),
        # nl_catd catopen (const char *CAT_NAME, int FLAG);
        "catopen": None,
        # char * catgets (nl_catd CATALOG_DESC, int SET, int MESSAGE, const char *STRING);
        "catgets": None,
        # int catclose (nl_catd CATALOG_DESC);
        "catclose": None,
        # char * gettext (const char *MSGID);
        "gettext": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["msgid"]),
        # char * dgettext (const char *DOMAINNAME, const char *MSGID);
        "dgettext": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["domainname", "msgid"]),
        # char * dcgettext (const char *DOMAINNAME, const char *MSGID, int CATEGORY);
        "dcgettext": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=True)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["domainname", "msgid", "category"]),
        # char * textdomain (const char *DOMAINNAME);
        "textdomain": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["domainname"]),
        # char * bindtextdomain (const char *DOMAINNAME, const char *DIRNAME);
        "bindtextdomain": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["domainname", "dirname"]),
        # char * ngettext (const char *MSGID1, const char *MSGID2, unsigned long int N);
        "ngettext": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["msgid1", "msgid2", "n"]),
        # char * dngettext (const char *DOMAIN, const char *MSGID1, const char *MSGID2, unsigned long int N);
        "dngettext": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["domain", "msgid1", "msgid2", "n"]),
        # char * dcngettext (const char *DOMAIN, const char *MSGID1, const char *MSGID2, unsigned long int N, int CATEGORY);
        "dcngettext": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False), SimTypeInt(signed=True)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["domain", "msgid1", "msgid2", "n", "category"]),
        # char * bind_textdomain_codeset (const char *DOMAINNAME, const char *CODESET);
        "bind_textdomain_codeset": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["domainname", "codeset"]),
        # void * lfind (const void *KEY, const void *BASE, size_t *NMEMB, size_t SIZE, comparison_fn_t COMPAR);
        "lfind": None,
        # void * lsearch (const void *KEY, void *BASE, size_t *NMEMB, size_t SIZE, comparison_fn_t COMPAR);
        "lsearch": None,
        # void * bsearch (const void *KEY, const void *ARRAY, size_t COUNT, size_t SIZE, comparison_fn_t COMPARE);
        "bsearch": None,
        # void qsort (void *ARRAY, size_t COUNT, size_t SIZE, comparison_fn_t COMPARE);
        "qsort": None,
        # int hcreate (size_t NEL);
        "hcreate": SimTypeFunction([SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["nel"]),
        # void hdestroy (void);
        "hdestroy": SimTypeFunction([], SimTypeBottom(label="void")),
        # ENTRY * hsearch (ENTRY ITEM, ACTION ACTION);
        "hsearch": None,
        # int hcreate_r (size_t NEL, struct hsearch_data *HTAB);
        "hcreate_r": SimTypeFunction([SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimStruct({}, name="hsearch_data", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["nel", "htab"]),
        # void hdestroy_r (struct hsearch_data *HTAB);
        "hdestroy_r": SimTypeFunction([SimTypePointer(SimStruct({}, name="hsearch_data", pack=False, align=None), offset=0)], SimTypeBottom(label="void"), arg_names=["htab"]),
        # int hsearch_r (ENTRY ITEM, ACTION ACTION, ENTRY **RETVAL, struct hsearch_data *HTAB);
        "hsearch_r": None,
        # void * tsearch (const void *KEY, void **ROOTP, comparison_fn_t COMPAR);
        "tsearch": None,
        # void * tfind (const void *KEY, void *const *ROOTP, comparison_fn_t COMPAR);
        "tfind": None,
        # void * tdelete (const void *KEY, void **ROOTP, comparison_fn_t COMPAR);
        "tdelete": None,
        # void tdestroy (void *VROOT, __free_fn_t FREEFCT);
        "tdestroy": None,
        # void twalk (const void *ROOT, __action_fn_t ACTION);
        "twalk": None,
        # int fnmatch (const char *PATTERN, const char *STRING, int FLAGS);
        "fnmatch": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["pattern", "string", "flags"]),
        # int glob (const char *PATTERN, int FLAGS, int (*ERRFUNC) (const char *FILENAME, int ERROR_CODE), glob_t *VECTOR_PTR);
        "glob": None,
        # int glob64 (const char *PATTERN, int FLAGS, int (*ERRFUNC) (const char *FILENAME, int ERROR_CODE), glob64_t *VECTOR_PTR);
        "glob64": None,
        # void globfree (glob_t *PGLOB);
        "globfree": None,
        # void globfree64 (glob64_t *PGLOB);
        "globfree64": None,
        # int regcomp (regex_t *restrict COMPILED, const char *restrict PATTERN, int CFLAGS);
        "regcomp": None,
        # int regexec (const regex_t *restrict COMPILED, const char *restrict STRING, size_t NMATCH, regmatch_t MATCHPTR[restrict], int EFLAGS);
        "regexec": None,
        # void regfree (regex_t *COMPILED);
        "regfree": None,
        # size_t regerror (int ERRCODE, const regex_t *restrict COMPILED, char *restrict BUFFER, size_t LENGTH);
        "regerror": None,
        # int wordexp (const char *WORDS, wordexp_t *WORD_VECTOR_PTR, int FLAGS);
        "wordexp": None,
        # void wordfree (wordexp_t *WORD_VECTOR_PTR);
        "wordfree": None,
        # FILE * fopen (const char *FILENAME, const char *OPENTYPE);
        "fopen": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), arg_names=["filename", "opentype"]),
        # FILE * fopen64 (const char *FILENAME, const char *OPENTYPE);
        "fopen64": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), arg_names=["filename", "opentype"]),
        # FILE * freopen (const char *FILENAME, const char *OPENTYPE, FILE *STREAM);
        "freopen": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), arg_names=["filename", "opentype", "stream"]),
        # FILE * freopen64 (const char *FILENAME, const char *OPENTYPE, FILE *STREAM);
        "freopen64": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), arg_names=["filename", "opentype", "stream"]),
        # int __freadable (FILE *STREAM);
        "__freadable": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["stream"]),
        # int __fwritable (FILE *STREAM);
        "__fwritable": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["stream"]),
        # int __freading (FILE *STREAM);
        "__freading": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["stream"]),
        # int __fwriting (FILE *STREAM);
        "__fwriting": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["stream"]),
        # int fclose (FILE *STREAM);
        "fclose": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["stream"]),
        # int fcloseall (void);
        "fcloseall": SimTypeFunction([], SimTypeInt(signed=True)),
        # void flockfile (FILE *STREAM);
        "flockfile": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeBottom(label="void"), arg_names=["stream"]),
        # int ftrylockfile (FILE *STREAM);
        "ftrylockfile": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["stream"]),
        # void funlockfile (FILE *STREAM);
        "funlockfile": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeBottom(label="void"), arg_names=["stream"]),
        # int __fsetlocking (FILE *STREAM, int TYPE);
        "__fsetlocking": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["stream", "type"]),
        # int fwide (FILE *STREAM, int MODE);
        "fwide": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["stream", "mode"]),
        # int fputc (int C, FILE *STREAM);
        "fputc": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["c", "stream"]),
        # wint_t fputwc (wchar_t WC, FILE *STREAM);
        "fputwc": SimTypeFunction([SimTypeShort(signed=False, label="wchar_t"), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=False, label="wint_t"), arg_names=["wc", "stream"]),
        # int fputc_unlocked (int C, FILE *STREAM);
        "fputc_unlocked": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["c", "stream"]),
        # wint_t fputwc_unlocked (wchar_t WC, FILE *STREAM);
        "fputwc_unlocked": SimTypeFunction([SimTypeShort(signed=False, label="wchar_t"), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=False, label="wint_t"), arg_names=["wc", "stream"]),
        # int putc (int C, FILE *STREAM);
        "putc": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["c", "stream"]),
        # wint_t putwc (wchar_t WC, FILE *STREAM);
        "putwc": SimTypeFunction([SimTypeShort(signed=False, label="wchar_t"), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=False, label="wint_t"), arg_names=["wc", "stream"]),
        # int putc_unlocked (int C, FILE *STREAM);
        "putc_unlocked": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["c", "stream"]),
        # wint_t putwc_unlocked (wchar_t WC, FILE *STREAM);
        "putwc_unlocked": SimTypeFunction([SimTypeShort(signed=False, label="wchar_t"), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=False, label="wint_t"), arg_names=["wc", "stream"]),
        # int putchar (int C);
        "putchar": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["c"]),
        # wint_t putwchar (wchar_t WC);
        "putwchar": SimTypeFunction([SimTypeShort(signed=False, label="wchar_t")], SimTypeInt(signed=False, label="wint_t"), arg_names=["wc"]),
        # int putchar_unlocked (int C);
        "putchar_unlocked": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["c"]),
        # wint_t putwchar_unlocked (wchar_t WC);
        "putwchar_unlocked": SimTypeFunction([SimTypeShort(signed=False, label="wchar_t")], SimTypeInt(signed=False, label="wint_t"), arg_names=["wc"]),
        # int fputs (const char *S, FILE *STREAM);
        "fputs": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["s", "stream"]),
        # int fputws (const wchar_t *WS, FILE *STREAM);
        "fputws": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["ws", "stream"]),
        # int fputs_unlocked (const char *S, FILE *STREAM);
        "fputs_unlocked": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["s", "stream"]),
        # int fputws_unlocked (const wchar_t *WS, FILE *STREAM);
        "fputws_unlocked": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["ws", "stream"]),
        # int puts (const char *S);
        "puts": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["s"]),
        # int putw (int W, FILE *STREAM);
        "putw": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["w", "stream"]),
        # int fgetc (FILE *STREAM);
        "fgetc": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["stream"]),
        # wint_t fgetwc (FILE *STREAM);
        "fgetwc": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=False, label="wint_t"), arg_names=["stream"]),
        # int fgetc_unlocked (FILE *STREAM);
        "fgetc_unlocked": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["stream"]),
        # wint_t fgetwc_unlocked (FILE *STREAM);
        "fgetwc_unlocked": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=False, label="wint_t"), arg_names=["stream"]),
        # int getc (FILE *STREAM);
        "getc": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["stream"]),
        # wint_t getwc (FILE *STREAM);
        "getwc": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=False, label="wint_t"), arg_names=["stream"]),
        # int getc_unlocked (FILE *STREAM);
        "getc_unlocked": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["stream"]),
        # wint_t getwc_unlocked (FILE *STREAM);
        "getwc_unlocked": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=False, label="wint_t"), arg_names=["stream"]),
        # int getchar (void);
        "getchar": SimTypeFunction([], SimTypeInt(signed=True)),
        # wint_t getwchar (void);
        "getwchar": SimTypeFunction([], SimTypeInt(signed=False, label="wint_t")),
        # int getchar_unlocked (void);
        "getchar_unlocked": SimTypeFunction([], SimTypeInt(signed=True)),
        # wint_t getwchar_unlocked (void);
        "getwchar_unlocked": SimTypeFunction([], SimTypeInt(signed=False, label="wint_t")),
        # int getw (FILE *STREAM);
        "getw": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["stream"]),
        # ssize_t getline (char **LINEPTR, size_t *N, FILE *STREAM);
        "getline": SimTypeFunction([SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0), SimTypePointer(SimTypeLong(signed=False, label="size_t"), offset=0), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeLong(signed=True, label="ssize_t"), arg_names=["lineptr", "n", "stream"]),
        # ssize_t getdelim (char **LINEPTR, size_t *N, int DELIMITER, FILE *STREAM);
        "getdelim": SimTypeFunction([SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0), SimTypePointer(SimTypeLong(signed=False, label="size_t"), offset=0), SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeLong(signed=True, label="ssize_t"), arg_names=["lineptr", "n", "delimiter", "stream"]),
        # char * fgets (char *S, int COUNT, FILE *STREAM);
        "fgets": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["s", "count", "stream"]),
        # wchar_t * fgetws (wchar_t *WS, int COUNT, FILE *STREAM);
        "fgetws": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), arg_names=["ws", "count", "stream"]),
        # char * fgets_unlocked (char *S, int COUNT, FILE *STREAM);
        "fgets_unlocked": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["s", "count", "stream"]),
        # wchar_t * fgetws_unlocked (wchar_t *WS, int COUNT, FILE *STREAM);
        "fgetws_unlocked": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), arg_names=["ws", "count", "stream"]),
        # int ungetc (int C, FILE *STREAM);
        "ungetc": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["c", "stream"]),
        # wint_t ungetwc (wint_t WC, FILE *STREAM);
        "ungetwc": SimTypeFunction([SimTypeInt(signed=False, label="wint_t"), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=False, label="wint_t"), arg_names=["wc", "stream"]),
        # size_t fread (void *DATA, size_t SIZE, size_t COUNT, FILE *STREAM);
        "fread": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeLong(signed=False, label="size_t"), arg_names=["data", "size", "count", "stream"]),
        # size_t fread_unlocked (void *DATA, size_t SIZE, size_t COUNT, FILE *STREAM);
        "fread_unlocked": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeLong(signed=False, label="size_t"), arg_names=["data", "size", "count", "stream"]),
        # size_t fwrite (const void *DATA, size_t SIZE, size_t COUNT, FILE *STREAM);
        "fwrite": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeLong(signed=False, label="size_t"), arg_names=["data", "size", "count", "stream"]),
        # size_t fwrite_unlocked (const void *DATA, size_t SIZE, size_t COUNT, FILE *STREAM);
        "fwrite_unlocked": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeLong(signed=False, label="size_t"), arg_names=["data", "size", "count", "stream"]),
        # int printf (const char *TEMPLATE, ...);
        "printf": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["template"], variadic=True),
        # int __printf_chk (int flag, const char *TEMPLATE, ...);
        "__printf_chk": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["flag", "template"], variadic=True),
        # int wprintf (const wchar_t *TEMPLATE, ...);
        "wprintf": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0)], SimTypeInt(signed=True), arg_names=["template"], variadic=True),
        # int fprintf (FILE *STREAM, const char *TEMPLATE, ...);
        "fprintf": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["stream", "template"], variadic=True),
        # int __fprintf_chk (int flag, FILE *STREAM, const char *TEMPLATE, ...);
        "__fprintf_chk": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["flag", "stream", "template"], variadic=True),
        # int fwprintf (FILE *STREAM, const wchar_t *TEMPLATE, ...);
        "fwprintf": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0)], SimTypeInt(signed=True), arg_names=["stream", "template"], variadic=True),
        # int sprintf (char *S, const char *TEMPLATE, ...);
        "sprintf": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["s", "template"], variadic=True),
        # int swprintf (wchar_t *WS, size_t SIZE, const wchar_t *TEMPLATE, ...);
        "swprintf": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0)], SimTypeInt(signed=True), arg_names=["ws", "size", "template"], variadic=True),
        # int snprintf (char *S, size_t SIZE, const char *TEMPLATE, ...);
        "snprintf": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["s", "size", "template"], variadic=True),
        # int asprintf (char **PTR, const char *TEMPLATE, ...);
        "asprintf": SimTypeFunction([SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["ptr", "template"], variadic=True),
        # int obstack_printf (struct obstack *OBSTACK, const char *TEMPLATE, ...);
        "obstack_printf": SimTypeFunction([SimTypePointer(SimStruct({}, name="obstack", pack=False, align=None), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["obstack", "template"], variadic=True),
        # int vprintf (const char *TEMPLATE, va_list AP);
        "vprintf": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimStruct({}, name="va_list", pack=False, align=None)], SimTypeInt(signed=True), arg_names=["template", "ap"]),
        # int vwprintf (const wchar_t *TEMPLATE, va_list AP);
        "vwprintf": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimStruct({}, name="va_list", pack=False, align=None)], SimTypeInt(signed=True), arg_names=["template", "ap"]),
        # int vfprintf (FILE *STREAM, const char *TEMPLATE, va_list AP);
        "vfprintf": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimStruct({}, name="va_list", pack=False, align=None)], SimTypeInt(signed=True), arg_names=["stream", "template", "ap"]),
        # int vfwprintf (FILE *STREAM, const wchar_t *TEMPLATE, va_list AP);
        "vfwprintf": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimStruct({}, name="va_list", pack=False, align=None)], SimTypeInt(signed=True), arg_names=["stream", "template", "ap"]),
        # int vsprintf (char *S, const char *TEMPLATE, va_list AP);
        "vsprintf": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimStruct({}, name="va_list", pack=False, align=None)], SimTypeInt(signed=True), arg_names=["s", "template", "ap"]),
        # int vswprintf (wchar_t *WS, size_t SIZE, const wchar_t *TEMPLATE, va_list AP);
        "vswprintf": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimStruct({}, name="va_list", pack=False, align=None)], SimTypeInt(signed=True), arg_names=["ws", "size", "template", "ap"]),
        # int vsnprintf (char *S, size_t SIZE, const char *TEMPLATE, va_list AP);
        "vsnprintf": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypeChar(), offset=0), SimStruct({}, name="va_list", pack=False, align=None)], SimTypeInt(signed=True), arg_names=["s", "size", "template", "ap"]),
        # int vasprintf (char **PTR, const char *TEMPLATE, va_list AP);
        "vasprintf": SimTypeFunction([SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimStruct({}, name="va_list", pack=False, align=None)], SimTypeInt(signed=True), arg_names=["ptr", "template", "ap"]),
        # int obstack_vprintf (struct obstack *OBSTACK, const char *TEMPLATE, va_list AP);
        "obstack_vprintf": SimTypeFunction([SimTypePointer(SimStruct({}, name="obstack", pack=False, align=None), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimStruct({}, name="va_list", pack=False, align=None)], SimTypeInt(signed=True), arg_names=["obstack", "template", "ap"]),
        # size_t parse_printf_format (const char *TEMPLATE, size_t N, int *ARGTYPES);
        "parse_printf_format": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypeInt(signed=True), offset=0)], SimTypeLong(signed=False, label="size_t"), arg_names=["template", "n", "argtypes"]),
        # int register_printf_function (int SPEC, printf_function HANDLER_FUNCTION, printf_arginfo_function ARGINFO_FUNCTION);
        "register_printf_function": None,
        # int printf_size (FILE *FP, const struct printf_info *INFO, const void *const *ARGS);
        "printf_size": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), SimTypePointer(SimStruct({}, name="printf_info", pack=False, align=None), offset=0), SimTypePointer(SimTypePointer(SimTypeBottom(label="void"), offset=0), offset=0)], SimTypeInt(signed=True), arg_names=["fp", "info", "args"]),
        # int printf_size_info (const struct printf_info *INFO, size_t N, int *ARGTYPES);
        "printf_size_info": SimTypeFunction([SimTypePointer(SimStruct({}, name="printf_info", pack=False, align=None), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypeInt(signed=True), offset=0)], SimTypeInt(signed=True), arg_names=["info", "n", "argtypes"]),
        # int __isoc99_scanf (const char *TEMPLATE, ...);
        "__isoc99_scanf": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["template"], variadic=True),
        # int scanf (const char *TEMPLATE, ...);
        "scanf": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["template"], variadic=True),
        # int wscanf (const wchar_t *TEMPLATE, ...);
        "wscanf": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0)], SimTypeInt(signed=True), arg_names=["template"], variadic=True),
        # int __isoc99_fscanf (FILE *STREAM, const char *TEMPLATE, ...);
        "__isoc99_fscanf": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["stream", "template"], variadic=True),
        # int fscanf (FILE *STREAM, const char *TEMPLATE, ...);
        "fscanf": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["stream", "template"], variadic=True),
        # int fwscanf (FILE *STREAM, const wchar_t *TEMPLATE, ...);
        "fwscanf": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0)], SimTypeInt(signed=True), arg_names=["stream", "template"], variadic=True),
        # int __isoc99_sscanf (const char *S, const char *TEMPLATE, ...);
        "__isoc99_sscanf": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["s", "template"], variadic=True),
        # int sscanf (const char *S, const char *TEMPLATE, ...);
        "sscanf": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["s", "template"], variadic=True),
        # int swscanf (const wchar_t *WS, const wchar_t *TEMPLATE, ...);
        "swscanf": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0)], SimTypeInt(signed=True), arg_names=["ws", "template"], variadic=True),
        # int vscanf (const char *TEMPLATE, va_list AP);
        "vscanf": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimStruct({}, name="va_list", pack=False, align=None)], SimTypeInt(signed=True), arg_names=["template", "ap"]),
        # int vwscanf (const wchar_t *TEMPLATE, va_list AP);
        "vwscanf": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimStruct({}, name="va_list", pack=False, align=None)], SimTypeInt(signed=True), arg_names=["template", "ap"]),
        # int vfscanf (FILE *STREAM, const char *TEMPLATE, va_list AP);
        "vfscanf": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimStruct({}, name="va_list", pack=False, align=None)], SimTypeInt(signed=True), arg_names=["stream", "template", "ap"]),
        # int vfwscanf (FILE *STREAM, const wchar_t *TEMPLATE, va_list AP);
        "vfwscanf": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimStruct({}, name="va_list", pack=False, align=None)], SimTypeInt(signed=True), arg_names=["stream", "template", "ap"]),
        # int vsscanf (const char *S, const char *TEMPLATE, va_list AP);
        "vsscanf": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimStruct({}, name="va_list", pack=False, align=None)], SimTypeInt(signed=True), arg_names=["s", "template", "ap"]),
        # int vswscanf (const wchar_t *S, const wchar_t *TEMPLATE, va_list AP);
        "vswscanf": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimStruct({}, name="va_list", pack=False, align=None)], SimTypeInt(signed=True), arg_names=["s", "template", "ap"]),
        # int feof (FILE *STREAM);
        "feof": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["stream"]),
        # int feof_unlocked (FILE *STREAM);
        "feof_unlocked": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["stream"]),
        # int ferror (FILE *STREAM);
        "ferror": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["stream"]),
        # int ferror_unlocked (FILE *STREAM);
        "ferror_unlocked": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["stream"]),
        # void clearerr (FILE *STREAM);
        "clearerr": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeBottom(label="void"), arg_names=["stream"]),
        # void clearerr_unlocked (FILE *STREAM);
        "clearerr_unlocked": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeBottom(label="void"), arg_names=["stream"]),
        # long int ftell (FILE *STREAM);
        "ftell": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeLong(signed=True), arg_names=["stream"]),
        # off_t ftello (FILE *STREAM);
        "ftello": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeLong(signed=False, label="off_t"), arg_names=["stream"]),
        # off64_t ftello64 (FILE *STREAM);
        "ftello64": None,
        # int fseek (FILE *STREAM, long int OFFSET, int WHENCE);
        "fseek": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), SimTypeLong(signed=True), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["stream", "offset", "whence"]),
        # int fseeko (FILE *STREAM, off_t OFFSET, int WHENCE);
        "fseeko": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), SimTypeLong(signed=False, label="off_t"), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["stream", "offset", "whence"]),
        # int fseeko64 (FILE *STREAM, off64_t OFFSET, int WHENCE);
        "fseeko64": None,
        # void rewind (FILE *STREAM);
        "rewind": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeBottom(label="void"), arg_names=["stream"]),
        # int fgetpos (FILE *STREAM, fpos_t *POSITION);
        "fgetpos": None,
        # int fgetpos64 (FILE *STREAM, fpos64_t *POSITION);
        "fgetpos64": None,
        # int fsetpos (FILE *STREAM, const fpos_t *POSITION);
        "fsetpos": None,
        # int fsetpos64 (FILE *STREAM, const fpos64_t *POSITION);
        "fsetpos64": None,
        # int fflush (FILE *STREAM);
        "fflush": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["stream"]),
        # int fflush_unlocked (FILE *STREAM);
        "fflush_unlocked": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["stream"]),
        # void _flushlbf (void);
        "_flushlbf": SimTypeFunction([], SimTypeBottom(label="void")),
        # void __fpurge (FILE *STREAM);
        "__fpurge": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeBottom(label="void"), arg_names=["stream"]),
        # int setvbuf (FILE *STREAM, char *BUF, int MODE, size_t SIZE);
        "setvbuf": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=True), SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["stream", "buf", "mode", "size"]),
        # void setbuf (FILE *STREAM, char *BUF);
        "setbuf": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypeBottom(label="void"), arg_names=["stream", "buf"]),
        # void setbuffer (FILE *STREAM, char *BUF, size_t SIZE);
        "setbuffer": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeBottom(label="void"), arg_names=["stream", "buf", "size"]),
        # void setlinebuf (FILE *STREAM);
        "setlinebuf": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeBottom(label="void"), arg_names=["stream"]),
        # int __flbf (FILE *STREAM);
        "__flbf": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["stream"]),
        # size_t __fbufsize (FILE *STREAM);
        "__fbufsize": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeLong(signed=False, label="size_t"), arg_names=["stream"]),
        # size_t __fpending (FILE *STREAM);
        "__fpending": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeLong(signed=False, label="size_t"), arg_names=["stream"]),
        # FILE * fmemopen (void *BUF, size_t SIZE, const char *OPENTYPE);
        "fmemopen": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), arg_names=["buf", "size", "opentype"]),
        # FILE * open_memstream (char **PTR, size_t *SIZELOC);
        "open_memstream": SimTypeFunction([SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0), SimTypePointer(SimTypeLong(signed=False, label="size_t"), offset=0)], SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), arg_names=["ptr", "sizeloc"]),
        # FILE * fopencookie (void *COOKIE, const char *OPENTYPE, cookie_io_functions_t IO-FUNCTIONS);
        "fopencookie": None,
        # int fmtmsg (long int CLASSIFICATION, const char *LABEL, int SEVERITY, const char *TEXT, const char *ACTION, const char *TAG);
        "fmtmsg": SimTypeFunction([SimTypeLong(signed=True), SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=True), SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["classification", "label", "severity", "text", "action", "tag"]),
        # int addseverity (int SEVERITY, const char *STRING);
        "addseverity": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["severity", "string"]),
        # int open (const char *FILENAME, int FLAGS, mode_t MODE);
        "open": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=True), SimTypeShort(signed=False, label="mode_t")], SimTypeInt(signed=True), arg_names=["filename", "flags", "mode"]),
        # int open64 (const char *FILENAME, int FLAGS, mode_t MODE);
        "open64": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=True), SimTypeShort(signed=False, label="mode_t")], SimTypeInt(signed=True), arg_names=["filename", "flags", "mode"]),
        # int close (int FILEDES);
        "close": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["filedes"]),
        # ssize_t read (int FILEDES, void *BUFFER, size_t SIZE);
        "read": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeLong(signed=True, label="ssize_t"), arg_names=["filedes", "buffer", "size"]),
        # ssize_t pread (int FILEDES, void *BUFFER, size_t SIZE, off_t OFFSET);
        "pread": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypeLong(signed=False, label="off_t")], SimTypeLong(signed=True, label="ssize_t"), arg_names=["filedes", "buffer", "size", "offset"]),
        # ssize_t pread64 (int FILEDES, void *BUFFER, size_t SIZE, off64_t OFFSET);
        "pread64": None,
        # ssize_t write (int FILEDES, const void *BUFFER, size_t SIZE);
        "write": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeLong(signed=True, label="ssize_t"), arg_names=["filedes", "buffer", "size"]),
        # ssize_t pwrite (int FILEDES, const void *BUFFER, size_t SIZE, off_t OFFSET);
        "pwrite": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypeLong(signed=False, label="off_t")], SimTypeLong(signed=True, label="ssize_t"), arg_names=["filedes", "buffer", "size", "offset"]),
        # ssize_t pwrite64 (int FILEDES, const void *BUFFER, size_t SIZE, off64_t OFFSET);
        "pwrite64": None,
        # ssize_t preadv (int FD, const struct iovec *IOV, int IOVCNT, off_t OFFSET);
        "preadv": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({"iov_base": SimTypePointer(SimTypeBottom(label="void"), offset=0), "iov_len": SimTypeLong(signed=False, label="size_t")}, name="iovec", pack=False, align=None), offset=0), SimTypeInt(signed=True), SimTypeLong(signed=False, label="off_t")], SimTypeLong(signed=True, label="ssize_t"), arg_names=["fd", "iov", "iovcnt", "offset"]),
        # ssize_t preadv64 (int FD, const struct iovec *IOV, int IOVCNT, off64_t OFFSET);
        "preadv64": None,
        # ssize_t pwritev (int FD, const struct iovec *IOV, int IOVCNT, off_t OFFSET);
        "pwritev": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({"iov_base": SimTypePointer(SimTypeBottom(label="void"), offset=0), "iov_len": SimTypeLong(signed=False, label="size_t")}, name="iovec", pack=False, align=None), offset=0), SimTypeInt(signed=True), SimTypeLong(signed=False, label="off_t")], SimTypeLong(signed=True, label="ssize_t"), arg_names=["fd", "iov", "iovcnt", "offset"]),
        # ssize_t pwritev64 (int FD, const struct iovec *IOV, int IOVCNT, off64_t OFFSET);
        "pwritev64": None,
        # ssize_t preadv2 (int FD, const struct iovec *IOV, int IOVCNT, off_t OFFSET, int FLAGS);
        "preadv2": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({"iov_base": SimTypePointer(SimTypeBottom(label="void"), offset=0), "iov_len": SimTypeLong(signed=False, label="size_t")}, name="iovec", pack=False, align=None), offset=0), SimTypeInt(signed=True), SimTypeLong(signed=False, label="off_t"), SimTypeInt(signed=True)], SimTypeLong(signed=True, label="ssize_t"), arg_names=["fd", "iov", "iovcnt", "offset", "flags"]),
        # ssize_t preadv64v2 (int FD, const struct iovec *IOV, int IOVCNT, off64_t OFFSET, int FLAGS);
        "preadv64v2": None,
        # ssize_t pwritev2 (int FD, const struct iovec *IOV, int IOVCNT, off_t OFFSET, int FLAGS);
        "pwritev2": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({"iov_base": SimTypePointer(SimTypeBottom(label="void"), offset=0), "iov_len": SimTypeLong(signed=False, label="size_t")}, name="iovec", pack=False, align=None), offset=0), SimTypeInt(signed=True), SimTypeLong(signed=False, label="off_t"), SimTypeInt(signed=True)], SimTypeLong(signed=True, label="ssize_t"), arg_names=["fd", "iov", "iovcnt", "offset", "flags"]),
        # ssize_t pwritev64v2 (int FD, const struct iovec *IOV, int IOVCNT, off64_t OFFSET, int FLAGS);
        "pwritev64v2": None,
        # off_t lseek (int FILEDES, off_t OFFSET, int WHENCE);
        "lseek": SimTypeFunction([SimTypeInt(signed=True), SimTypeLong(signed=False, label="off_t"), SimTypeInt(signed=True)], SimTypeLong(signed=False, label="off_t"), arg_names=["filedes", "offset", "whence"]),
        # off64_t lseek64 (int FILEDES, off64_t OFFSET, int WHENCE);
        "lseek64": None,
        # FILE * fdopen (int FILEDES, const char *OPENTYPE);
        "fdopen": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), arg_names=["filedes", "opentype"]),
        # int fileno (FILE *STREAM);
        "fileno": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["stream"]),
        # int fileno_unlocked (FILE *STREAM);
        "fileno_unlocked": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["stream"]),
        # ssize_t readv (int FILEDES, const struct iovec *VECTOR, int COUNT);
        "readv": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({"iov_base": SimTypePointer(SimTypeBottom(label="void"), offset=0), "iov_len": SimTypeLong(signed=False, label="size_t")}, name="iovec", pack=False, align=None), offset=0), SimTypeInt(signed=True)], SimTypeLong(signed=True, label="ssize_t"), arg_names=["filedes", "vector", "count"]),
        # ssize_t writev (int FILEDES, const struct iovec *VECTOR, int COUNT);
        "writev": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({"iov_base": SimTypePointer(SimTypeBottom(label="void"), offset=0), "iov_len": SimTypeLong(signed=False, label="size_t")}, name="iovec", pack=False, align=None), offset=0), SimTypeInt(signed=True)], SimTypeLong(signed=True, label="ssize_t"), arg_names=["filedes", "vector", "count"]),
        # void * mmap (void *ADDRESS, size_t LENGTH, int PROTECT, int FLAGS, int FILEDES, off_t OFFSET);
        "mmap": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypeInt(signed=True), SimTypeInt(signed=True), SimTypeInt(signed=True), SimTypeLong(signed=False, label="off_t")], SimTypePointer(SimTypeBottom(label="void"), offset=0), arg_names=["address", "length", "protect", "flags", "filedes", "offset"]),
        # void * mmap64 (void *ADDRESS, size_t LENGTH, int PROTECT, int FLAGS, int FILEDES, off64_t OFFSET);
        "mmap64": None,
        # int munmap (void *ADDR, size_t LENGTH);
        "munmap": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["addr", "length"]),
        # int msync (void *ADDRESS, size_t LENGTH, int FLAGS);
        "msync": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["address", "length", "flags"]),
        # void * mremap (void *ADDRESS, size_t LENGTH, size_t NEW_LENGTH, int FLAG);
        "mremap": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypeLong(signed=False, label="size_t"), SimTypeInt(signed=True)], SimTypePointer(SimTypeBottom(label="void"), offset=0), arg_names=["address", "length", "new_length", "flag"]),
        # int madvise (void *ADDR, size_t LENGTH, int ADVICE);
        "madvise": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["addr", "length", "advice"]),
        # int shm_open (const char *NAME, int OFLAG, mode_t MODE);
        "shm_open": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=True), SimTypeShort(signed=False, label="mode_t")], SimTypeInt(signed=True), arg_names=["name", "oflag", "mode"]),
        # int shm_unlink (const char *NAME);
        "shm_unlink": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["name"]),
        # int select (int NFDS, fd_set *READ_FDS, fd_set *WRITE_FDS, fd_set *EXCEPT_FDS, struct timeval *TIMEOUT);
        "select": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeBottom()), SimTypePointer(SimTypeBottom()), SimTypePointer(SimTypeBottom()), SimTypePointer(SimTypeBottom())], SimTypeInt(signed=True), arg_names=["nfds", "read_fds", "write_fds", "except_fds", "timeout"]),
        # void sync (void);
        "sync": SimTypeFunction([], SimTypeBottom(label="void")),
        # int fsync (int FILDES);
        "fsync": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["fildes"]),
        # int fdatasync (int FILDES);
        "fdatasync": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["fildes"]),
        # int aio_read (struct aiocb *AIOCBP);
        "aio_read": SimTypeFunction([SimTypePointer(SimStruct({}, name="aiocb", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["aiocbp"]),
        # int aio_read64 (struct aiocb64 *AIOCBP);
        "aio_read64": SimTypeFunction([SimTypePointer(SimStruct({}, name="aiocb64", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["aiocbp"]),
        # int aio_write (struct aiocb *AIOCBP);
        "aio_write": SimTypeFunction([SimTypePointer(SimStruct({}, name="aiocb", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["aiocbp"]),
        # int aio_write64 (struct aiocb64 *AIOCBP);
        "aio_write64": SimTypeFunction([SimTypePointer(SimStruct({}, name="aiocb64", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["aiocbp"]),
        # int lio_listio (int MODE, struct aiocb *const LIST[], int NENT, struct sigevent *SIG);
        "lio_listio": SimTypeFunction([SimTypeInt(signed=True), SimTypeFixedSizeArray(SimTypePointer(SimStruct({}, name="aiocb", pack=False, align=None), offset=0), 0), SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="sigevent", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["mode", "list", "nent", "sig"]),
        # int lio_listio64 (int MODE, struct aiocb64 *const LIST[], int NENT, struct sigevent *SIG);
        "lio_listio64": SimTypeFunction([SimTypeInt(signed=True), SimTypeFixedSizeArray(SimTypePointer(SimStruct({}, name="aiocb64", pack=False, align=None), offset=0), 0), SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="sigevent", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["mode", "list", "nent", "sig"]),
        # int aio_error (const struct aiocb *AIOCBP);
        "aio_error": SimTypeFunction([SimTypePointer(SimStruct({}, name="aiocb", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["aiocbp"]),
        # int aio_error64 (const struct aiocb64 *AIOCBP);
        "aio_error64": SimTypeFunction([SimTypePointer(SimStruct({}, name="aiocb64", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["aiocbp"]),
        # ssize_t aio_return (struct aiocb *AIOCBP);
        "aio_return": SimTypeFunction([SimTypePointer(SimStruct({}, name="aiocb", pack=False, align=None), offset=0)], SimTypeLong(signed=True, label="ssize_t"), arg_names=["aiocbp"]),
        # ssize_t aio_return64 (struct aiocb64 *AIOCBP);
        "aio_return64": SimTypeFunction([SimTypePointer(SimStruct({}, name="aiocb64", pack=False, align=None), offset=0)], SimTypeLong(signed=True, label="ssize_t"), arg_names=["aiocbp"]),
        # int aio_fsync (int OP, struct aiocb *AIOCBP);
        "aio_fsync": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="aiocb", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["op", "aiocbp"]),
        # int aio_fsync64 (int OP, struct aiocb64 *AIOCBP);
        "aio_fsync64": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="aiocb64", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["op", "aiocbp"]),
        # int aio_suspend (const struct aiocb *const LIST[], int NENT, const struct timespec *TIMEOUT);
        "aio_suspend": SimTypeFunction([SimTypeFixedSizeArray(SimTypePointer(SimStruct({}, name="aiocb", pack=False, align=None), offset=0), 0), SimTypeInt(signed=True), SimTypePointer(SimStruct({"tv_sec": SimTypeLong(signed=True, label="time_t"), "tv_nsec": SimTypeLong(signed=True)}, name="timespec", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["list", "nent", "timeout"]),
        # int aio_suspend64 (const struct aiocb64 *const LIST[], int NENT, const struct timespec *TIMEOUT);
        "aio_suspend64": SimTypeFunction([SimTypeFixedSizeArray(SimTypePointer(SimStruct({}, name="aiocb64", pack=False, align=None), offset=0), 0), SimTypeInt(signed=True), SimTypePointer(SimStruct({"tv_sec": SimTypeLong(signed=True, label="time_t"), "tv_nsec": SimTypeLong(signed=True)}, name="timespec", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["list", "nent", "timeout"]),
        # int aio_cancel (int FILDES, struct aiocb *AIOCBP);
        "aio_cancel": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="aiocb", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["fildes", "aiocbp"]),
        # int aio_cancel64 (int FILDES, struct aiocb64 *AIOCBP);
        "aio_cancel64": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="aiocb64", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["fildes", "aiocbp"]),
        # void aio_init (const struct aioinit *INIT);
        "aio_init": SimTypeFunction([SimTypePointer(SimStruct({}, name="aioinit", pack=False, align=None), offset=0)], SimTypeBottom(label="void"), arg_names=["init"]),
        # int fcntl (int FILEDES, int COMMAND, ...);
        "fcntl": SimTypeFunction([SimTypeInt(signed=True), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["filedes", "command"], variadic=True),
        # int dup (int OLD);
        "dup": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["old"]),
        # int dup2 (int OLD, int NEW);
        "dup2": SimTypeFunction([SimTypeInt(signed=True), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["old", "new"]),
        # int ioctl (int FILEDES, int COMMAND, ...);
        "ioctl": SimTypeFunction([SimTypeInt(signed=True), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["filedes", "command"], variadic=True),
        # char * getcwd (char *BUFFER, size_t SIZE);
        "getcwd": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeChar(), offset=0), arg_names=["buffer", "size"]),
        # char * get_current_dir_name (void);
        "get_current_dir_name": SimTypeFunction([], SimTypePointer(SimTypeChar(), offset=0)),
        # int chdir (const char *FILENAME);
        "chdir": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["filename"]),
        # int fchdir (int FILEDES);
        "fchdir": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["filedes"]),
        # int IFTODT (mode_t MODE);
        "IFTODT": SimTypeFunction([SimTypeShort(signed=False, label="mode_t")], SimTypeInt(signed=True), arg_names=["mode"]),
        # mode_t DTTOIF (int DTYPE);
        "DTTOIF": SimTypeFunction([SimTypeInt(signed=True)], SimTypeShort(signed=False, label="mode_t"), arg_names=["dtype"]),
        # DIR * opendir (const char *DIRNAME);
        "opendir": None,
        # DIR * fdopendir (int FD);
        "fdopendir": None,
        # int dirfd (DIR *DIRSTREAM);
        "dirfd": None,
        # struct dirent * readdir (DIR *DIRSTREAM);
        "readdir": None,
        # int readdir_r (DIR *DIRSTREAM, struct dirent *ENTRY, struct dirent **RESULT);
        "readdir_r": None,
        # struct dirent64 * readdir64 (DIR *DIRSTREAM);
        "readdir64": None,
        # int readdir64_r (DIR *DIRSTREAM, struct dirent64 *ENTRY, struct dirent64 **RESULT);
        "readdir64_r": None,
        # int closedir (DIR *DIRSTREAM);
        "closedir": None,
        # void rewinddir (DIR *DIRSTREAM);
        "rewinddir": None,
        # long int telldir (DIR *DIRSTREAM);
        "telldir": None,
        # void seekdir (DIR *DIRSTREAM, long int POS);
        "seekdir": None,
        # int scandir (const char *DIR, struct dirent ***NAMELIST, int (*SELECTOR);
        "scandir": None,
        # int alphasort (const struct dirent **A, const struct dirent **B);
        "alphasort": SimTypeFunction([SimTypePointer(SimTypePointer(SimStruct({}, name="dirent", pack=False, align=None), offset=0), offset=0), SimTypePointer(SimTypePointer(SimStruct({}, name="dirent", pack=False, align=None), offset=0), offset=0)], SimTypeInt(signed=True), arg_names=["a", "b"]),
        # int versionsort (const struct dirent **A, const struct dirent **B);
        "versionsort": SimTypeFunction([SimTypePointer(SimTypePointer(SimStruct({}, name="dirent", pack=False, align=None), offset=0), offset=0), SimTypePointer(SimTypePointer(SimStruct({}, name="dirent", pack=False, align=None), offset=0), offset=0)], SimTypeInt(signed=True), arg_names=["a", "b"]),
        # int scandir64 (const char *DIR, struct dirent64 ***NAMELIST, int (*SELECTOR);
        "scandir64": None,
        # int alphasort64 (const struct dirent64 **A, const struct dirent **B);
        "alphasort64": SimTypeFunction([SimTypePointer(SimTypePointer(SimStruct({}, name="dirent64", pack=False, align=None), offset=0), offset=0), SimTypePointer(SimTypePointer(SimStruct({}, name="dirent", pack=False, align=None), offset=0), offset=0)], SimTypeInt(signed=True), arg_names=["a", "b"]),
        # int versionsort64 (const struct dirent64 **A, const struct dirent64 **B);
        "versionsort64": SimTypeFunction([SimTypePointer(SimTypePointer(SimStruct({}, name="dirent64", pack=False, align=None), offset=0), offset=0), SimTypePointer(SimTypePointer(SimStruct({}, name="dirent64", pack=False, align=None), offset=0), offset=0)], SimTypeInt(signed=True), arg_names=["a", "b"]),
        # int ftw (const char *FILENAME, __ftw_func_t FUNC, int DESCRIPTORS);
        "ftw": None,
        # int ftw64 (const char *FILENAME, __ftw64_func_t FUNC, int DESCRIPTORS);
        "ftw64": None,
        # int nftw (const char *FILENAME, __nftw_func_t FUNC, int DESCRIPTORS, int FLAG);
        "nftw": None,
        # int nftw64 (const char *FILENAME, __nftw64_func_t FUNC, int DESCRIPTORS, int FLAG);
        "nftw64": None,
        # int link (const char *OLDNAME, const char *NEWNAME);
        "link": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["oldname", "newname"]),
        # int symlink (const char *OLDNAME, const char *NEWNAME);
        "symlink": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["oldname", "newname"]),
        # ssize_t readlink (const char *FILENAME, char *BUFFER, size_t SIZE);
        "readlink": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeLong(signed=True, label="ssize_t"), arg_names=["filename", "buffer", "size"]),
        # char * canonicalize_file_name (const char *NAME);
        "canonicalize_file_name": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["name"]),
        # char * realpath (const char *restrict NAME, char *restrict RESOLVED);
        "realpath": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["name", "resolved"]),
        # int unlink (const char *FILENAME);
        "unlink": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["filename"]),
        # int rmdir (const char *FILENAME);
        "rmdir": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["filename"]),
        # int remove (const char *FILENAME);
        "remove": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["filename"]),
        # int rename (const char *OLDNAME, const char *NEWNAME);
        "rename": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["oldname", "newname"]),
        # int mkdir (const char *FILENAME, mode_t MODE);
        "mkdir": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeShort(signed=False, label="mode_t")], SimTypeInt(signed=True), arg_names=["filename", "mode"]),
        # int stat (const char *FILENAME, struct stat *BUF);
        "stat": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimStruct({}, name="stat", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["filename", "buf"]),
        # int stat64 (const char *FILENAME, struct stat64 *BUF);
        "stat64": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimStruct({}, name="stat64", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["filename", "buf"]),
        # int fstat (int FILEDES, struct stat *BUF);
        "fstat": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="stat", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["filedes", "buf"]),
        # int fstat64 (int FILEDES, struct stat64 *BUF);
        "fstat64": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="stat64", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["filedes", "buf"]),
        # int lstat (const char *FILENAME, struct stat *BUF);
        "lstat": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimStruct({}, name="stat", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["filename", "buf"]),
        # int lstat64 (const char *FILENAME, struct stat64 *BUF);
        "lstat64": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimStruct({}, name="stat64", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["filename", "buf"]),
        # int chown (const char *FILENAME, uid_t OWNER, gid_t GROUP);
        "chown": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=False, label="uid_t"), SimTypeInt(signed=False, label="gid_t")], SimTypeInt(signed=True), arg_names=["filename", "owner", "group"]),
        # int fchown (int FILEDES, uid_t OWNER, gid_t GROUP);
        "fchown": SimTypeFunction([SimTypeInt(signed=True), SimTypeInt(signed=False, label="uid_t"), SimTypeInt(signed=False, label="gid_t")], SimTypeInt(signed=True), arg_names=["filedes", "owner", "group"]),
        # mode_t umask (mode_t MASK);
        "umask": SimTypeFunction([SimTypeShort(signed=False, label="mode_t")], SimTypeShort(signed=False, label="mode_t"), arg_names=["mask"]),
        # mode_t getumask (void);
        "getumask": SimTypeFunction([], SimTypeShort(signed=False, label="mode_t")),
        # int chmod (const char *FILENAME, mode_t MODE);
        "chmod": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeShort(signed=False, label="mode_t")], SimTypeInt(signed=True), arg_names=["filename", "mode"]),
        # int fchmod (int FILEDES, mode_t MODE);
        "fchmod": SimTypeFunction([SimTypeInt(signed=True), SimTypeShort(signed=False, label="mode_t")], SimTypeInt(signed=True), arg_names=["filedes", "mode"]),
        # int access (const char *FILENAME, int HOW);
        "access": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["filename", "how"]),
        # int utime (const char *FILENAME, const struct utimbuf *TIMES);
        "utime": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimStruct({}, name="utimbuf", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["filename", "times"]),
        # int utimes (const char *FILENAME, const struct timeval TVP[2]);
        "utimes": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeFixedSizeArray(SimStruct({"tv_sec": SimTypeLong(signed=True, label="time_t"), "tv_usec": SimTypeLong(signed=True)}, name="timeval", pack=False, align=None), 2)], SimTypeInt(signed=True), arg_names=["filename", "tvp"]),
        # int lutimes (const char *FILENAME, const struct timeval TVP[2]);
        "lutimes": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeFixedSizeArray(SimStruct({"tv_sec": SimTypeLong(signed=True, label="time_t"), "tv_usec": SimTypeLong(signed=True)}, name="timeval", pack=False, align=None), 2)], SimTypeInt(signed=True), arg_names=["filename", "tvp"]),
        # int futimes (int FD, const struct timeval TVP[2]);
        "futimes": SimTypeFunction([SimTypeInt(signed=True), SimTypeFixedSizeArray(SimStruct({"tv_sec": SimTypeLong(signed=True, label="time_t"), "tv_usec": SimTypeLong(signed=True)}, name="timeval", pack=False, align=None), 2)], SimTypeInt(signed=True), arg_names=["fd", "tvp"]),
        # int truncate (const char *FILENAME, off_t LENGTH);
        "truncate": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="off_t")], SimTypeInt(signed=True), arg_names=["filename", "length"]),
        # int truncate64 (const char *NAME, off64_t LENGTH);
        "truncate64": None,
        # int ftruncate (int FD, off_t LENGTH);
        "ftruncate": SimTypeFunction([SimTypeInt(signed=True), SimTypeLong(signed=False, label="off_t")], SimTypeInt(signed=True), arg_names=["fd", "length"]),
        # int ftruncate64 (int ID, off64_t LENGTH);
        "ftruncate64": None,
        # int posix_fallocate (int FD, off_t OFFSET, off_t LENGTH);
        "posix_fallocate": SimTypeFunction([SimTypeInt(signed=True), SimTypeLong(signed=False, label="off_t"), SimTypeLong(signed=False, label="off_t")], SimTypeInt(signed=True), arg_names=["fd", "offset", "length"]),
        # int posix_fallocate64 (int FD, off64_t OFFSET, off64_t LENGTH);
        "posix_fallocate64": None,
        # int mknod (const char *FILENAME, mode_t MODE, dev_t DEV);
        "mknod": None,
        # FILE * tmpfile (void);
        "tmpfile": SimTypeFunction([], SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)),
        # FILE * tmpfile64 (void);
        "tmpfile64": SimTypeFunction([], SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)),
        # char * tmpnam (char *RESULT);
        "tmpnam": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["result"]),
        # char * tmpnam_r (char *RESULT);
        "tmpnam_r": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["result"]),
        # char * tempnam (const char *DIR, const char *PREFIX);
        "tempnam": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["dir", "prefix"]),
        # char * mktemp (char *TEMPLATE);
        "mktemp": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["template"]),
        # int mkstemp (char *TEMPLATE);
        "mkstemp": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["template"]),
        # char * mkdtemp (char *TEMPLATE);
        "mkdtemp": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["template"]),
        # int pipe (int FILEDES[2]);
        "pipe": SimTypeFunction([SimTypeFixedSizeArray(SimTypeInt(signed=True), 2)], SimTypeInt(signed=True), arg_names=["filedes"]),
        # FILE * popen (const char *COMMAND, const char *MODE);
        "popen": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), arg_names=["command", "mode"]),
        # int pclose (FILE *STREAM);
        "pclose": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["stream"]),
        # int mkfifo (const char *FILENAME, mode_t MODE);
        "mkfifo": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeShort(signed=False, label="mode_t")], SimTypeInt(signed=True), arg_names=["filename", "mode"]),
        # int bind (int SOCKET, struct sockaddr *ADDR, socklen_t LENGTH);
        "bind": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="sockaddr", pack=False, align=None), offset=0), SimTypeInt(signed=True, label="socklen_t")], SimTypeInt(signed=True), arg_names=["socket", "addr", "length"]),
        # int getsockname (int SOCKET, struct sockaddr *ADDR, socklen_t *LENGTH_PTR);
        "getsockname": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="sockaddr", pack=False, align=None), offset=0), SimTypePointer(SimTypeInt(signed=True, label="socklen_t"), offset=0)], SimTypeInt(signed=True), arg_names=["socket", "addr", "length_ptr"]),
        # unsigned int if_nametoindex (const char *IFNAME);
        "if_nametoindex": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=False), arg_names=["ifname"]),
        # char * if_indextoname (unsigned int IFINDEX, char *IFNAME);
        "if_indextoname": SimTypeFunction([SimTypeInt(signed=False), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["ifindex", "ifname"]),
        # struct if_nameindex * if_nameindex (void);
        "if_nameindex": SimTypeFunction([], SimTypePointer(SimStruct({}, name="if_nameindex", pack=False, align=None), offset=0)),
        # void if_freenameindex (struct if_nameindex *PTR);
        "if_freenameindex": SimTypeFunction([SimTypePointer(SimStruct({}, name="if_nameindex", pack=False, align=None), offset=0)], SimTypeBottom(label="void"), arg_names=["ptr"]),
        # int inet_aton (const char *NAME, struct in_addr *ADDR);
        "inet_aton": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimStruct({}, name="in_addr", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["name", "addr"]),
        # uint32_t inet_addr (const char *NAME);
        "inet_addr": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=False, label="uint32_t"), arg_names=["name"]),
        # uint32_t inet_network (const char *NAME);
        "inet_network": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=False, label="uint32_t"), arg_names=["name"]),
        # char * inet_ntoa (struct in_addr ADDR);
        "inet_ntoa": SimTypeFunction([SimStruct({}, name="in_addr", pack=False, align=None)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["addr"]),
        # struct in_addr inet_makeaddr (uint32_t NET, uint32_t LOCAL);
        "inet_makeaddr": SimTypeFunction([SimTypeInt(signed=False, label="uint32_t"), SimTypeInt(signed=False, label="uint32_t")], SimStruct({}, name="in_addr", pack=False, align=None), arg_names=["net", "local"]),
        # uint32_t inet_lnaof (struct in_addr ADDR);
        "inet_lnaof": SimTypeFunction([SimStruct({}, name="in_addr", pack=False, align=None)], SimTypeInt(signed=False, label="uint32_t"), arg_names=["addr"]),
        # uint32_t inet_netof (struct in_addr ADDR);
        "inet_netof": SimTypeFunction([SimStruct({}, name="in_addr", pack=False, align=None)], SimTypeInt(signed=False, label="uint32_t"), arg_names=["addr"]),
        # int inet_pton (int AF, const char *CP, void *BUF);
        "inet_pton": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeBottom(label="void"), offset=0)], SimTypeInt(signed=True), arg_names=["af", "cp", "buf"]),
        # const char * inet_ntop (int AF, const void *CP, char *BUF, socklen_t LEN);
        "inet_ntop": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=True, label="socklen_t")], SimTypePointer(SimTypeChar(), offset=0), arg_names=["af", "cp", "buf", "len"]),
        # struct hostent * gethostbyname (const char *NAME);
        "gethostbyname": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimStruct({}, name="hostent", pack=False, align=None), offset=0), arg_names=["name"]),
        # struct hostent * gethostbyname2 (const char *NAME, int AF);
        "gethostbyname2": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=True)], SimTypePointer(SimStruct({}, name="hostent", pack=False, align=None), offset=0), arg_names=["name", "af"]),
        # struct hostent * gethostbyaddr (const void *ADDR, socklen_t LENGTH, int FORMAT);
        "gethostbyaddr": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeInt(signed=True, label="socklen_t"), SimTypeInt(signed=True)], SimTypePointer(SimStruct({}, name="hostent", pack=False, align=None), offset=0), arg_names=["addr", "length", "format"]),
        # int gethostbyname_r (const char *restrict NAME, struct hostent *restrict RESULT_BUF, char *restrict BUF, size_t BUFLEN, struct hostent **restrict RESULT, int * restrict H_ERRNOP);
        "gethostbyname_r": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimStruct({}, name="hostent", pack=False, align=None), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypePointer(SimStruct({}, name="hostent", pack=False, align=None), offset=0), offset=0), SimTypePointer(SimTypeInt(signed=True), offset=0)], SimTypeInt(signed=True), arg_names=["name", "result_buf", "buf", "buflen", "result", "h_errnop"]),
        # int gethostbyname2_r (const char *NAME, int AF, struct hostent *restrict RESULT_BUF, char *restrict BUF, size_t BUFLEN, struct hostent **restrict RESULT, int * restrict H_ERRNOP);
        "gethostbyname2_r": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="hostent", pack=False, align=None), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypePointer(SimStruct({}, name="hostent", pack=False, align=None), offset=0), offset=0), SimTypePointer(SimTypeInt(signed=True), offset=0)], SimTypeInt(signed=True), arg_names=["name", "af", "result_buf", "buf", "buflen", "result", "h_errnop"]),
        # int gethostbyaddr_r (const void *ADDR, socklen_t LENGTH, int FORMAT, struct hostent *restrict RESULT_BUF, char *restrict BUF, size_t BUFLEN, struct hostent ** restrict RESULT, int * restrict H_ERRNOP);
        "gethostbyaddr_r": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeInt(signed=True, label="socklen_t"), SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="hostent", pack=False, align=None), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypePointer(SimStruct({}, name="hostent", pack=False, align=None), offset=0), offset=0), SimTypePointer(SimTypeInt(signed=True), offset=0)], SimTypeInt(signed=True), arg_names=["addr", "length", "format", "result_buf", "buf", "buflen", "result", "h_errnop"]),
        # void sethostent (int STAYOPEN);
        "sethostent": SimTypeFunction([SimTypeInt(signed=True)], SimTypeBottom(label="void"), arg_names=["stayopen"]),
        # struct hostent * gethostent (void);
        "gethostent": SimTypeFunction([], SimTypePointer(SimStruct({}, name="hostent", pack=False, align=None), offset=0)),
        # void endhostent (void);
        "endhostent": SimTypeFunction([], SimTypeBottom(label="void")),
        # struct servent * getservbyname (const char *NAME, const char *PROTO);
        "getservbyname": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimStruct({}, name="servent", pack=False, align=None), offset=0), arg_names=["name", "proto"]),
        # struct servent * getservbyport (int PORT, const char *PROTO);
        "getservbyport": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimStruct({}, name="servent", pack=False, align=None), offset=0), arg_names=["port", "proto"]),
        # void setservent (int STAYOPEN);
        "setservent": SimTypeFunction([SimTypeInt(signed=True)], SimTypeBottom(label="void"), arg_names=["stayopen"]),
        # struct servent * getservent (void);
        "getservent": SimTypeFunction([], SimTypePointer(SimStruct({}, name="servent", pack=False, align=None), offset=0)),
        # void endservent (void);
        "endservent": SimTypeFunction([], SimTypeBottom(label="void")),
        # uint16_t htons (uint16_t HOSTSHORT);
        "htons": SimTypeFunction([SimTypeShort(signed=False, label="uint16_t")], SimTypeShort(signed=False, label="uint16_t"), arg_names=["hostshort"]),
        # uint16_t ntohs (uint16_t NETSHORT);
        "ntohs": SimTypeFunction([SimTypeShort(signed=False, label="uint16_t")], SimTypeShort(signed=False, label="uint16_t"), arg_names=["netshort"]),
        # uint32_t htonl (uint32_t HOSTLONG);
        "htonl": SimTypeFunction([SimTypeInt(signed=False, label="uint32_t")], SimTypeInt(signed=False, label="uint32_t"), arg_names=["hostlong"]),
        # uint32_t ntohl (uint32_t NETLONG);
        "ntohl": SimTypeFunction([SimTypeInt(signed=False, label="uint32_t")], SimTypeInt(signed=False, label="uint32_t"), arg_names=["netlong"]),
        # struct protoent * getprotobyname (const char *NAME);
        "getprotobyname": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimStruct({}, name="protoent", pack=False, align=None), offset=0), arg_names=["name"]),
        # struct protoent * getprotobynumber (int PROTOCOL);
        "getprotobynumber": SimTypeFunction([SimTypeInt(signed=True)], SimTypePointer(SimStruct({}, name="protoent", pack=False, align=None), offset=0), arg_names=["protocol"]),
        # void setprotoent (int STAYOPEN);
        "setprotoent": SimTypeFunction([SimTypeInt(signed=True)], SimTypeBottom(label="void"), arg_names=["stayopen"]),
        # struct protoent * getprotoent (void);
        "getprotoent": SimTypeFunction([], SimTypePointer(SimStruct({}, name="protoent", pack=False, align=None), offset=0)),
        # void endprotoent (void);
        "endprotoent": SimTypeFunction([], SimTypeBottom(label="void")),
        # int socket (int NAMESPACE, int STYLE, int PROTOCOL);
        "socket": SimTypeFunction([SimTypeInt(signed=True), SimTypeInt(signed=True), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["namespace", "style", "protocol"]),
        # int shutdown (int SOCKET, int HOW);
        "shutdown": SimTypeFunction([SimTypeInt(signed=True), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["socket", "how"]),
        # int socketpair (int NAMESPACE, int STYLE, int PROTOCOL, int FILEDES[2]);
        "socketpair": SimTypeFunction([SimTypeInt(signed=True), SimTypeInt(signed=True), SimTypeInt(signed=True), SimTypeFixedSizeArray(SimTypeInt(signed=True), 2)], SimTypeInt(signed=True), arg_names=["namespace", "style", "protocol", "filedes"]),
        # int connect (int SOCKET, struct sockaddr *ADDR, socklen_t LENGTH);
        "connect": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="sockaddr", pack=False, align=None), offset=0), SimTypeInt(signed=True, label="socklen_t")], SimTypeInt(signed=True), arg_names=["socket", "addr", "length"]),
        # int listen (int SOCKET, int N);
        "listen": SimTypeFunction([SimTypeInt(signed=True), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["socket", "n"]),
        # int accept (int SOCKET, struct sockaddr *ADDR, socklen_t *LENGTH_PTR);
        "accept": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="sockaddr", pack=False, align=None), offset=0), SimTypePointer(SimTypeInt(signed=True, label="socklen_t"), offset=0)], SimTypeInt(signed=True), arg_names=["socket", "addr", "length_ptr"]),
        # int getpeername (int SOCKET, struct sockaddr *ADDR, socklen_t *LENGTH_PTR);
        "getpeername": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="sockaddr", pack=False, align=None), offset=0), SimTypePointer(SimTypeInt(signed=True, label="socklen_t"), offset=0)], SimTypeInt(signed=True), arg_names=["socket", "addr", "length_ptr"]),
        # ssize_t send (int SOCKET, const void *BUFFER, size_t SIZE, int FLAGS);
        "send": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypeInt(signed=True)], SimTypeLong(signed=True, label="ssize_t"), arg_names=["socket", "buffer", "size", "flags"]),
        # ssize_t recv (int SOCKET, void *BUFFER, size_t SIZE, int FLAGS);
        "recv": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypeInt(signed=True)], SimTypeLong(signed=True, label="ssize_t"), arg_names=["socket", "buffer", "size", "flags"]),
        # ssize_t sendto (int SOCKET, const void *BUFFER, size_t SIZE, int FLAGS, struct sockaddr *ADDR, socklen_t LENGTH);
        "sendto": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="sockaddr", pack=False, align=None), offset=0), SimTypeInt(signed=True, label="socklen_t")], SimTypeLong(signed=True, label="ssize_t"), arg_names=["socket", "buffer", "size", "flags", "addr", "length"]),
        # ssize_t recvfrom (int SOCKET, void *BUFFER, size_t SIZE, int FLAGS, struct sockaddr *ADDR, socklen_t *LENGTH_PTR);
        "recvfrom": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="sockaddr", pack=False, align=None), offset=0), SimTypePointer(SimTypeInt(signed=True, label="socklen_t"), offset=0)], SimTypeLong(signed=True, label="ssize_t"), arg_names=["socket", "buffer", "size", "flags", "addr", "length_ptr"]),
        # int getsockopt (int SOCKET, int LEVEL, int OPTNAME, void *OPTVAL, socklen_t *OPTLEN_PTR);
        "getsockopt": SimTypeFunction([SimTypeInt(signed=True), SimTypeInt(signed=True), SimTypeInt(signed=True), SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypePointer(SimTypeInt(signed=True, label="socklen_t"), offset=0)], SimTypeInt(signed=True), arg_names=["socket", "level", "optname", "optval", "optlen_ptr"]),
        # int setsockopt (int SOCKET, int LEVEL, int OPTNAME, const void *OPTVAL, socklen_t OPTLEN);
        "setsockopt": SimTypeFunction([SimTypeInt(signed=True), SimTypeInt(signed=True), SimTypeInt(signed=True), SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeInt(signed=True, label="socklen_t")], SimTypeInt(signed=True), arg_names=["socket", "level", "optname", "optval", "optlen"]),
        # struct netent * getnetbyname (const char *NAME);
        "getnetbyname": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimStruct({}, name="netent", pack=False, align=None), offset=0), arg_names=["name"]),
        # struct netent * getnetbyaddr (uint32_t NET, int TYPE);
        "getnetbyaddr": SimTypeFunction([SimTypeInt(signed=False, label="uint32_t"), SimTypeInt(signed=True)], SimTypePointer(SimStruct({}, name="netent", pack=False, align=None), offset=0), arg_names=["net", "type"]),
        # void setnetent (int STAYOPEN);
        "setnetent": SimTypeFunction([SimTypeInt(signed=True)], SimTypeBottom(label="void"), arg_names=["stayopen"]),
        # struct netent * getnetent (void);
        "getnetent": SimTypeFunction([], SimTypePointer(SimStruct({}, name="netent", pack=False, align=None), offset=0)),
        # void endnetent (void);
        "endnetent": SimTypeFunction([], SimTypeBottom(label="void")),
        # int isatty (int FILEDES);
        "isatty": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["filedes"]),
        # char * ttyname (int FILEDES);
        "ttyname": SimTypeFunction([SimTypeInt(signed=True)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["filedes"]),
        # int ttyname_r (int FILEDES, char *BUF, size_t LEN);
        "ttyname_r": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["filedes", "buf", "len"]),
        # int tcgetattr (int FILEDES, struct termios *TERMIOS_P);
        "tcgetattr": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="termios", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["filedes", "termios_p"]),
        # int tcsetattr (int FILEDES, int WHEN, const struct termios *TERMIOS_P);
        "tcsetattr": SimTypeFunction([SimTypeInt(signed=True), SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="termios", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["filedes", "when", "termios_p"]),
        # speed_t cfgetospeed (const struct termios *TERMIOS_P);
        "cfgetospeed": SimTypeFunction([SimTypePointer(SimStruct({}, name="termios", pack=False, align=None), offset=0)], SimTypeInt(signed=False, label="speed_t"), arg_names=["termios_p"]),
        # speed_t cfgetispeed (const struct termios *TERMIOS_P);
        "cfgetispeed": SimTypeFunction([SimTypePointer(SimStruct({}, name="termios", pack=False, align=None), offset=0)], SimTypeInt(signed=False, label="speed_t"), arg_names=["termios_p"]),
        # int cfsetospeed (struct termios *TERMIOS_P, speed_t SPEED);
        "cfsetospeed": SimTypeFunction([SimTypePointer(SimStruct({}, name="termios", pack=False, align=None), offset=0), SimTypeInt(signed=False, label="speed_t")], SimTypeInt(signed=True), arg_names=["termios_p", "speed"]),
        # int cfsetispeed (struct termios *TERMIOS_P, speed_t SPEED);
        "cfsetispeed": SimTypeFunction([SimTypePointer(SimStruct({}, name="termios", pack=False, align=None), offset=0), SimTypeInt(signed=False, label="speed_t")], SimTypeInt(signed=True), arg_names=["termios_p", "speed"]),
        # int cfsetspeed (struct termios *TERMIOS_P, speed_t SPEED);
        "cfsetspeed": SimTypeFunction([SimTypePointer(SimStruct({}, name="termios", pack=False, align=None), offset=0), SimTypeInt(signed=False, label="speed_t")], SimTypeInt(signed=True), arg_names=["termios_p", "speed"]),
        # void cfmakeraw (struct termios *TERMIOS_P);
        "cfmakeraw": SimTypeFunction([SimTypePointer(SimStruct({}, name="termios", pack=False, align=None), offset=0)], SimTypeBottom(label="void"), arg_names=["termios_p"]),
        # int gtty (int FILEDES, struct sgttyb *ATTRIBUTES);
        "gtty": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="sgttyb", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["filedes", "attributes"]),
        # int stty (int FILEDES, const struct sgttyb *ATTRIBUTES);
        "stty": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="sgttyb", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["filedes", "attributes"]),
        # int tcsendbreak (int FILEDES, int DURATION);
        "tcsendbreak": SimTypeFunction([SimTypeInt(signed=True), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["filedes", "duration"]),
        # int tcdrain (int FILEDES);
        "tcdrain": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["filedes"]),
        # int tcflush (int FILEDES, int QUEUE);
        "tcflush": SimTypeFunction([SimTypeInt(signed=True), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["filedes", "queue"]),
        # int tcflow (int FILEDES, int ACTION);
        "tcflow": SimTypeFunction([SimTypeInt(signed=True), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["filedes", "action"]),
        # int getpt (void);
        "getpt": SimTypeFunction([], SimTypeInt(signed=True)),
        # int grantpt (int FILEDES);
        "grantpt": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["filedes"]),
        # int unlockpt (int FILEDES);
        "unlockpt": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["filedes"]),
        # char * ptsname (int FILEDES);
        "ptsname": SimTypeFunction([SimTypeInt(signed=True)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["filedes"]),
        # int ptsname_r (int FILEDES, char *BUF, size_t LEN);
        "ptsname_r": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["filedes", "buf", "len"]),
        # int openpty (int *AMASTER, int *ASLAVE, char *NAME, const struct termios *TERMP, const struct winsize *WINP);
        "openpty": SimTypeFunction([SimTypePointer(SimTypeInt(signed=True), offset=0), SimTypePointer(SimTypeInt(signed=True), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimStruct({}, name="termios", pack=False, align=None), offset=0), SimTypePointer(SimStruct({}, name="winsize", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["amaster", "aslave", "name", "termp", "winp"]),
        # int forkpty (int *AMASTER, char *NAME, const struct termios *TERMP, const struct winsize *WINP);
        "forkpty": SimTypeFunction([SimTypePointer(SimTypeInt(signed=True), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimStruct({}, name="termios", pack=False, align=None), offset=0), SimTypePointer(SimStruct({}, name="winsize", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["amaster", "name", "termp", "winp"]),
        # void openlog (const char *IDENT, int OPTION, int FACILITY);
        "openlog": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=True), SimTypeInt(signed=True)], SimTypeBottom(label="void"), arg_names=["ident", "option", "facility"]),
        # void syslog (int FACILITY_PRIORITY, const char *FORMAT, ...);
        "syslog": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeChar(), offset=0)], SimTypeBottom(label="void"), arg_names=["facility_priority", "format"], variadic=True),
        # void vsyslog (int FACILITY_PRIORITY, const char *FORMAT, va_list ARGLIST);
        "vsyslog": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeChar(), offset=0), SimStruct({}, name="va_list", pack=False, align=None)], SimTypeBottom(label="void"), arg_names=["facility_priority", "format", "arglist"]),
        # void closelog (void);
        "closelog": SimTypeFunction([], SimTypeBottom(label="void")),
        # int setlogmask (int MASK);
        "setlogmask": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["mask"]),
        # double sin (double X);
        "sin": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float sinf (float X);
        "sinf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double sinl (long double X);
        "sinl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN sinfN (_FloatN X);
        "sinfN": None,
        # _FloatNx sinfNx (_FloatNx X);
        "sinfNx": None,
        # double cos (double X);
        "cos": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float cosf (float X);
        "cosf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double cosl (long double X);
        "cosl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN cosfN (_FloatN X);
        "cosfN": None,
        # _FloatNx cosfNx (_FloatNx X);
        "cosfNx": None,
        # double tan (double X);
        "tan": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float tanf (float X);
        "tanf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double tanl (long double X);
        "tanl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN tanfN (_FloatN X);
        "tanfN": None,
        # _FloatNx tanfNx (_FloatNx X);
        "tanfNx": None,
        # void sincos (double X, double *SINX, double *COSX);
        "sincos": SimTypeFunction([SimTypeDouble(align_double=True), SimTypePointer(SimTypeDouble(align_double=True), offset=0), SimTypePointer(SimTypeDouble(align_double=True), offset=0)], SimTypeBottom(label="void"), arg_names=["x", "sinx", "cosx"]),
        # void sincosf (float X, float *SINX, float *COSX);
        "sincosf": SimTypeFunction([SimTypeFloat(size=32), SimTypePointer(SimTypeFloat(size=32), offset=0), SimTypePointer(SimTypeFloat(size=32), offset=0)], SimTypeBottom(label="void"), arg_names=["x", "sinx", "cosx"]),
        # void sincosl (long double X, long double *SINX, long double *COSX);
        "sincosl": SimTypeFunction([SimTypeDouble(align_double=True), SimTypePointer(SimTypeDouble(align_double=True), offset=0), SimTypePointer(SimTypeDouble(align_double=True), offset=0)], SimTypeBottom(label="void"), arg_names=["x", "sinx", "cosx"]),
        # _FloatN sincosfN (_FloatN X, _FloatN *SINX, _FloatN *COSX);
        "sincosfN": None,
        # _FloatNx sincosfNx (_FloatNx X, _FloatNx *SINX, _FloatNx *COSX);
        "sincosfNx": None,
        # complex double csin (complex double Z);
        "csin": None,
        # complex float csinf (complex float Z);
        "csinf": None,
        # complex long double csinl (complex long double Z);
        "csinl": None,
        # complex _FloatN csinfN (complex _FloatN Z);
        "csinfN": None,
        # complex _FloatNx csinfNx (complex _FloatNx Z);
        "csinfNx": None,
        # complex double ccos (complex double Z);
        "ccos": None,
        # complex float ccosf (complex float Z);
        "ccosf": None,
        # complex long double ccosl (complex long double Z);
        "ccosl": None,
        # complex _FloatN ccosfN (complex _FloatN Z);
        "ccosfN": None,
        # complex _FloatNx ccosfNx (complex _FloatNx Z);
        "ccosfNx": None,
        # complex double ctan (complex double Z);
        "ctan": None,
        # complex float ctanf (complex float Z);
        "ctanf": None,
        # complex long double ctanl (complex long double Z);
        "ctanl": None,
        # complex _FloatN ctanfN (complex _FloatN Z);
        "ctanfN": None,
        # complex _FloatNx ctanfNx (complex _FloatNx Z);
        "ctanfNx": None,
        # double asin (double X);
        "asin": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float asinf (float X);
        "asinf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double asinl (long double X);
        "asinl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN asinfN (_FloatN X);
        "asinfN": None,
        # _FloatNx asinfNx (_FloatNx X);
        "asinfNx": None,
        # double acos (double X);
        "acos": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float acosf (float X);
        "acosf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double acosl (long double X);
        "acosl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN acosfN (_FloatN X);
        "acosfN": None,
        # _FloatNx acosfNx (_FloatNx X);
        "acosfNx": None,
        # double atan (double X);
        "atan": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float atanf (float X);
        "atanf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double atanl (long double X);
        "atanl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN atanfN (_FloatN X);
        "atanfN": None,
        # _FloatNx atanfNx (_FloatNx X);
        "atanfNx": None,
        # double atan2 (double Y, double X);
        "atan2": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["y", "x"]),
        # float atan2f (float Y, float X);
        "atan2f": SimTypeFunction([SimTypeFloat(size=32), SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["y", "x"]),
        # long double atan2l (long double Y, long double X);
        "atan2l": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["y", "x"]),
        # _FloatN atan2fN (_FloatN Y, _FloatN X);
        "atan2fN": None,
        # _FloatNx atan2fNx (_FloatNx Y, _FloatNx X);
        "atan2fNx": None,
        # complex double casin (complex double Z);
        "casin": None,
        # complex float casinf (complex float Z);
        "casinf": None,
        # complex long double casinl (complex long double Z);
        "casinl": None,
        # complex _FloatN casinfN (complex _FloatN Z);
        "casinfN": None,
        # complex _FloatNx casinfNx (complex _FloatNx Z);
        "casinfNx": None,
        # complex double cacos (complex double Z);
        "cacos": None,
        # complex float cacosf (complex float Z);
        "cacosf": None,
        # complex long double cacosl (complex long double Z);
        "cacosl": None,
        # complex _FloatN cacosfN (complex _FloatN Z);
        "cacosfN": None,
        # complex _FloatNx cacosfNx (complex _FloatNx Z);
        "cacosfNx": None,
        # complex double catan (complex double Z);
        "catan": None,
        # complex float catanf (complex float Z);
        "catanf": None,
        # complex long double catanl (complex long double Z);
        "catanl": None,
        # complex _FloatN catanfN (complex _FloatN Z);
        "catanfN": None,
        # complex _FloatNx catanfNx (complex _FloatNx Z);
        "catanfNx": None,
        # double exp (double X);
        "exp": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float expf (float X);
        "expf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double expl (long double X);
        "expl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN expfN (_FloatN X);
        "expfN": None,
        # _FloatNx expfNx (_FloatNx X);
        "expfNx": None,
        # double exp2 (double X);
        "exp2": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float exp2f (float X);
        "exp2f": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double exp2l (long double X);
        "exp2l": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN exp2fN (_FloatN X);
        "exp2fN": None,
        # _FloatNx exp2fNx (_FloatNx X);
        "exp2fNx": None,
        # double exp10 (double X);
        "exp10": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float exp10f (float X);
        "exp10f": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double exp10l (long double X);
        "exp10l": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN exp10fN (_FloatN X);
        "exp10fN": None,
        # _FloatNx exp10fNx (_FloatNx X);
        "exp10fNx": None,
        # double pow10 (double X);
        "pow10": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float pow10f (float X);
        "pow10f": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double pow10l (long double X);
        "pow10l": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # double log (double X);
        "log": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float logf (float X);
        "logf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double logl (long double X);
        "logl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN logfN (_FloatN X);
        "logfN": None,
        # _FloatNx logfNx (_FloatNx X);
        "logfNx": None,
        # double log10 (double X);
        "log10": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float log10f (float X);
        "log10f": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double log10l (long double X);
        "log10l": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN log10fN (_FloatN X);
        "log10fN": None,
        # _FloatNx log10fNx (_FloatNx X);
        "log10fNx": None,
        # double log2 (double X);
        "log2": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float log2f (float X);
        "log2f": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double log2l (long double X);
        "log2l": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN log2fN (_FloatN X);
        "log2fN": None,
        # _FloatNx log2fNx (_FloatNx X);
        "log2fNx": None,
        # double logb (double X);
        "logb": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float logbf (float X);
        "logbf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double logbl (long double X);
        "logbl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN logbfN (_FloatN X);
        "logbfN": None,
        # _FloatNx logbfNx (_FloatNx X);
        "logbfNx": None,
        # int ilogb (double X);
        "ilogb": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeInt(signed=True), arg_names=["x"]),
        # int ilogbf (float X);
        "ilogbf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeInt(signed=True), arg_names=["x"]),
        # int ilogbl (long double X);
        "ilogbl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeInt(signed=True), arg_names=["x"]),
        # int ilogbfN (_FloatN X);
        "ilogbfN": None,
        # int ilogbfNx (_FloatNx X);
        "ilogbfNx": None,
        # long int llogb (double X);
        "llogb": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeLong(signed=True), arg_names=["x"]),
        # long int llogbf (float X);
        "llogbf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeLong(signed=True), arg_names=["x"]),
        # long int llogbl (long double X);
        "llogbl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeLong(signed=True), arg_names=["x"]),
        # long int llogbfN (_FloatN X);
        "llogbfN": None,
        # long int llogbfNx (_FloatNx X);
        "llogbfNx": None,
        # double pow (double BASE, double POWER);
        "pow": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["base", "power"]),
        # float powf (float BASE, float POWER);
        "powf": SimTypeFunction([SimTypeFloat(size=32), SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["base", "power"]),
        # long double powl (long double BASE, long double POWER);
        "powl": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["base", "power"]),
        # _FloatN powfN (_FloatN BASE, _FloatN POWER);
        "powfN": None,
        # _FloatNx powfNx (_FloatNx BASE, _FloatNx POWER);
        "powfNx": None,
        # double sqrt (double X);
        "sqrt": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float sqrtf (float X);
        "sqrtf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double sqrtl (long double X);
        "sqrtl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN sqrtfN (_FloatN X);
        "sqrtfN": None,
        # _FloatNx sqrtfNx (_FloatNx X);
        "sqrtfNx": None,
        # double cbrt (double X);
        "cbrt": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float cbrtf (float X);
        "cbrtf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double cbrtl (long double X);
        "cbrtl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN cbrtfN (_FloatN X);
        "cbrtfN": None,
        # _FloatNx cbrtfNx (_FloatNx X);
        "cbrtfNx": None,
        # double hypot (double X, double Y);
        "hypot": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x", "y"]),
        # float hypotf (float X, float Y);
        "hypotf": SimTypeFunction([SimTypeFloat(size=32), SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x", "y"]),
        # long double hypotl (long double X, long double Y);
        "hypotl": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x", "y"]),
        # _FloatN hypotfN (_FloatN X, _FloatN Y);
        "hypotfN": None,
        # _FloatNx hypotfNx (_FloatNx X, _FloatNx Y);
        "hypotfNx": None,
        # double expm1 (double X);
        "expm1": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float expm1f (float X);
        "expm1f": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double expm1l (long double X);
        "expm1l": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN expm1fN (_FloatN X);
        "expm1fN": None,
        # _FloatNx expm1fNx (_FloatNx X);
        "expm1fNx": None,
        # double log1p (double X);
        "log1p": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float log1pf (float X);
        "log1pf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double log1pl (long double X);
        "log1pl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN log1pfN (_FloatN X);
        "log1pfN": None,
        # _FloatNx log1pfNx (_FloatNx X);
        "log1pfNx": None,
        # complex double cexp (complex double Z);
        "cexp": None,
        # complex float cexpf (complex float Z);
        "cexpf": None,
        # complex long double cexpl (complex long double Z);
        "cexpl": None,
        # complex _FloatN cexpfN (complex _FloatN Z);
        "cexpfN": None,
        # complex _FloatNx cexpfNx (complex _FloatNx Z);
        "cexpfNx": None,
        # complex double clog (complex double Z);
        "clog": None,
        # complex float clogf (complex float Z);
        "clogf": None,
        # complex long double clogl (complex long double Z);
        "clogl": None,
        # complex _FloatN clogfN (complex _FloatN Z);
        "clogfN": None,
        # complex _FloatNx clogfNx (complex _FloatNx Z);
        "clogfNx": None,
        # complex double clog10 (complex double Z);
        "clog10": None,
        # complex float clog10f (complex float Z);
        "clog10f": None,
        # complex long double clog10l (complex long double Z);
        "clog10l": None,
        # complex _FloatN clog10fN (complex _FloatN Z);
        "clog10fN": None,
        # complex _FloatNx clog10fNx (complex _FloatNx Z);
        "clog10fNx": None,
        # complex double csqrt (complex double Z);
        "csqrt": None,
        # complex float csqrtf (complex float Z);
        "csqrtf": None,
        # complex long double csqrtl (complex long double Z);
        "csqrtl": None,
        # complex _FloatN csqrtfN (_FloatN Z);
        "csqrtfN": None,
        # complex _FloatNx csqrtfNx (complex _FloatNx Z);
        "csqrtfNx": None,
        # complex double cpow (complex double BASE, complex double POWER);
        "cpow": None,
        # complex float cpowf (complex float BASE, complex float POWER);
        "cpowf": None,
        # complex long double cpowl (complex long double BASE, complex long double POWER);
        "cpowl": None,
        # complex _FloatN cpowfN (complex _FloatN BASE, complex _FloatN POWER);
        "cpowfN": None,
        # complex _FloatNx cpowfNx (complex _FloatNx BASE, complex _FloatNx POWER);
        "cpowfNx": None,
        # double sinh (double X);
        "sinh": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float sinhf (float X);
        "sinhf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double sinhl (long double X);
        "sinhl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN sinhfN (_FloatN X);
        "sinhfN": None,
        # _FloatNx sinhfNx (_FloatNx X);
        "sinhfNx": None,
        # double cosh (double X);
        "cosh": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float coshf (float X);
        "coshf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double coshl (long double X);
        "coshl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN coshfN (_FloatN X);
        "coshfN": None,
        # _FloatNx coshfNx (_FloatNx X);
        "coshfNx": None,
        # double tanh (double X);
        "tanh": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float tanhf (float X);
        "tanhf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double tanhl (long double X);
        "tanhl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN tanhfN (_FloatN X);
        "tanhfN": None,
        # _FloatNx tanhfNx (_FloatNx X);
        "tanhfNx": None,
        # complex double csinh (complex double Z);
        "csinh": None,
        # complex float csinhf (complex float Z);
        "csinhf": None,
        # complex long double csinhl (complex long double Z);
        "csinhl": None,
        # complex _FloatN csinhfN (complex _FloatN Z);
        "csinhfN": None,
        # complex _FloatNx csinhfNx (complex _FloatNx Z);
        "csinhfNx": None,
        # complex double ccosh (complex double Z);
        "ccosh": None,
        # complex float ccoshf (complex float Z);
        "ccoshf": None,
        # complex long double ccoshl (complex long double Z);
        "ccoshl": None,
        # complex _FloatN ccoshfN (complex _FloatN Z);
        "ccoshfN": None,
        # complex _FloatNx ccoshfNx (complex _FloatNx Z);
        "ccoshfNx": None,
        # complex double ctanh (complex double Z);
        "ctanh": None,
        # complex float ctanhf (complex float Z);
        "ctanhf": None,
        # complex long double ctanhl (complex long double Z);
        "ctanhl": None,
        # complex _FloatN ctanhfN (complex _FloatN Z);
        "ctanhfN": None,
        # complex _FloatNx ctanhfNx (complex _FloatNx Z);
        "ctanhfNx": None,
        # double asinh (double X);
        "asinh": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float asinhf (float X);
        "asinhf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double asinhl (long double X);
        "asinhl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN asinhfN (_FloatN X);
        "asinhfN": None,
        # _FloatNx asinhfNx (_FloatNx X);
        "asinhfNx": None,
        # double acosh (double X);
        "acosh": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float acoshf (float X);
        "acoshf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double acoshl (long double X);
        "acoshl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN acoshfN (_FloatN X);
        "acoshfN": None,
        # _FloatNx acoshfNx (_FloatNx X);
        "acoshfNx": None,
        # double atanh (double X);
        "atanh": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float atanhf (float X);
        "atanhf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double atanhl (long double X);
        "atanhl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN atanhfN (_FloatN X);
        "atanhfN": None,
        # _FloatNx atanhfNx (_FloatNx X);
        "atanhfNx": None,
        # complex double casinh (complex double Z);
        "casinh": None,
        # complex float casinhf (complex float Z);
        "casinhf": None,
        # complex long double casinhl (complex long double Z);
        "casinhl": None,
        # complex _FloatN casinhfN (complex _FloatN Z);
        "casinhfN": None,
        # complex _FloatNx casinhfNx (complex _FloatNx Z);
        "casinhfNx": None,
        # complex double cacosh (complex double Z);
        "cacosh": None,
        # complex float cacoshf (complex float Z);
        "cacoshf": None,
        # complex long double cacoshl (complex long double Z);
        "cacoshl": None,
        # complex _FloatN cacoshfN (complex _FloatN Z);
        "cacoshfN": None,
        # complex _FloatNx cacoshfNx (complex _FloatNx Z);
        "cacoshfNx": None,
        # complex double catanh (complex double Z);
        "catanh": None,
        # complex float catanhf (complex float Z);
        "catanhf": None,
        # complex long double catanhl (complex long double Z);
        "catanhl": None,
        # complex _FloatN catanhfN (complex _FloatN Z);
        "catanhfN": None,
        # complex _FloatNx catanhfNx (complex _FloatNx Z);
        "catanhfNx": None,
        # double erf (double X);
        "erf": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float erff (float X);
        "erff": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double erfl (long double X);
        "erfl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN erffN (_FloatN X);
        "erffN": None,
        # _FloatNx erffNx (_FloatNx X);
        "erffNx": None,
        # double erfc (double X);
        "erfc": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float erfcf (float X);
        "erfcf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double erfcl (long double X);
        "erfcl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN erfcfN (_FloatN X);
        "erfcfN": None,
        # _FloatNx erfcfNx (_FloatNx X);
        "erfcfNx": None,
        # double lgamma (double X);
        "lgamma": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float lgammaf (float X);
        "lgammaf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double lgammal (long double X);
        "lgammal": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN lgammafN (_FloatN X);
        "lgammafN": None,
        # _FloatNx lgammafNx (_FloatNx X);
        "lgammafNx": None,
        # double lgamma_r (double X, int *SIGNP);
        "lgamma_r": SimTypeFunction([SimTypeDouble(align_double=True), SimTypePointer(SimTypeInt(signed=True), offset=0)], SimTypeDouble(align_double=True), arg_names=["x", "signp"]),
        # float lgammaf_r (float X, int *SIGNP);
        "lgammaf_r": SimTypeFunction([SimTypeFloat(size=32), SimTypePointer(SimTypeInt(signed=True), offset=0)], SimTypeFloat(size=32), arg_names=["x", "signp"]),
        # long double lgammal_r (long double X, int *SIGNP);
        "lgammal_r": SimTypeFunction([SimTypeDouble(align_double=True), SimTypePointer(SimTypeInt(signed=True), offset=0)], SimTypeDouble(align_double=True), arg_names=["x", "signp"]),
        # _FloatN lgammafN_r (_FloatN X, int *SIGNP);
        "lgammafN_r": None,
        # _FloatNx lgammafNx_r (_FloatNx X, int *SIGNP);
        "lgammafNx_r": None,
        # double gamma (double X);
        "gamma": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float gammaf (float X);
        "gammaf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double gammal (long double X);
        "gammal": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # double tgamma (double X);
        "tgamma": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float tgammaf (float X);
        "tgammaf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double tgammal (long double X);
        "tgammal": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN tgammafN (_FloatN X);
        "tgammafN": None,
        # _FloatNx tgammafNx (_FloatNx X);
        "tgammafNx": None,
        # double j0 (double X);
        "j0": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float j0f (float X);
        "j0f": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double j0l (long double X);
        "j0l": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN j0fN (_FloatN X);
        "j0fN": None,
        # _FloatNx j0fNx (_FloatNx X);
        "j0fNx": None,
        # double j1 (double X);
        "j1": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float j1f (float X);
        "j1f": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double j1l (long double X);
        "j1l": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN j1fN (_FloatN X);
        "j1fN": None,
        # _FloatNx j1fNx (_FloatNx X);
        "j1fNx": None,
        # double jn (int N, double X);
        "jn": SimTypeFunction([SimTypeInt(signed=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["n", "x"]),
        # float jnf (int N, float X);
        "jnf": SimTypeFunction([SimTypeInt(signed=True), SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["n", "x"]),
        # long double jnl (int N, long double X);
        "jnl": SimTypeFunction([SimTypeInt(signed=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["n", "x"]),
        # _FloatN jnfN (int N, _FloatN X);
        "jnfN": None,
        # _FloatNx jnfNx (int N, _FloatNx X);
        "jnfNx": None,
        # double y0 (double X);
        "y0": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float y0f (float X);
        "y0f": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double y0l (long double X);
        "y0l": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN y0fN (_FloatN X);
        "y0fN": None,
        # _FloatNx y0fNx (_FloatNx X);
        "y0fNx": None,
        # double y1 (double X);
        "y1": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float y1f (float X);
        "y1f": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double y1l (long double X);
        "y1l": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN y1fN (_FloatN X);
        "y1fN": None,
        # _FloatNx y1fNx (_FloatNx X);
        "y1fNx": None,
        # double yn (int N, double X);
        "yn": SimTypeFunction([SimTypeInt(signed=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["n", "x"]),
        # float ynf (int N, float X);
        "ynf": SimTypeFunction([SimTypeInt(signed=True), SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["n", "x"]),
        # long double ynl (int N, long double X);
        "ynl": SimTypeFunction([SimTypeInt(signed=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["n", "x"]),
        # _FloatN ynfN (int N, _FloatN X);
        "ynfN": None,
        # _FloatNx ynfNx (int N, _FloatNx X);
        "ynfNx": None,
        # int rand (void);
        "rand": SimTypeFunction([], SimTypeInt(signed=True)),
        # void srand (unsigned int SEED);
        "srand": SimTypeFunction([SimTypeInt(signed=False)], SimTypeBottom(label="void"), arg_names=["seed"]),
        # int rand_r (unsigned int *SEED);
        "rand_r": SimTypeFunction([SimTypePointer(SimTypeInt(signed=False), offset=0)], SimTypeInt(signed=True), arg_names=["seed"]),
        # long int random (void);
        "random": SimTypeFunction([], SimTypeLong(signed=True)),
        # void srandom (unsigned int SEED);
        "srandom": SimTypeFunction([SimTypeInt(signed=False)], SimTypeBottom(label="void"), arg_names=["seed"]),
        # char * initstate (unsigned int SEED, char *STATE, size_t SIZE);
        "initstate": SimTypeFunction([SimTypeInt(signed=False), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypePointer(SimTypeChar(), offset=0), arg_names=["seed", "state", "size"]),
        # char * setstate (char *STATE);
        "setstate": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["state"]),
        # int random_r (struct random_data *restrict BUF, int32_t *restrict RESULT);
        "random_r": SimTypeFunction([SimTypePointer(SimStruct({}, name="random_data", pack=False, align=None), offset=0), SimTypePointer(SimTypeInt(signed=True, label="int32_t"), offset=0)], SimTypeInt(signed=True), arg_names=["buf", "result"]),
        # int srandom_r (unsigned int SEED, struct random_data *BUF);
        "srandom_r": SimTypeFunction([SimTypeInt(signed=False), SimTypePointer(SimStruct({}, name="random_data", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["seed", "buf"]),
        # int initstate_r (unsigned int SEED, char *restrict STATEBUF, size_t STATELEN, struct random_data *restrict BUF);
        "initstate_r": SimTypeFunction([SimTypeInt(signed=False), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimStruct({}, name="random_data", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["seed", "statebuf", "statelen", "buf"]),
        # int setstate_r (char *restrict STATEBUF, struct random_data *restrict BUF);
        "setstate_r": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimStruct({}, name="random_data", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["statebuf", "buf"]),
        # double drand48 (void);
        "drand48": SimTypeFunction([], SimTypeDouble(align_double=True)),
        # double erand48 (unsigned short int XSUBI[3]);
        "erand48": SimTypeFunction([SimTypeFixedSizeArray(SimTypeShort(signed=False), 3)], SimTypeDouble(align_double=True), arg_names=["xsubi"]),
        # long int lrand48 (void);
        "lrand48": SimTypeFunction([], SimTypeLong(signed=True)),
        # long int nrand48 (unsigned short int XSUBI[3]);
        "nrand48": SimTypeFunction([SimTypeFixedSizeArray(SimTypeShort(signed=False), 3)], SimTypeLong(signed=True), arg_names=["xsubi"]),
        # long int mrand48 (void);
        "mrand48": SimTypeFunction([], SimTypeLong(signed=True)),
        # long int jrand48 (unsigned short int XSUBI[3]);
        "jrand48": SimTypeFunction([SimTypeFixedSizeArray(SimTypeShort(signed=False), 3)], SimTypeLong(signed=True), arg_names=["xsubi"]),
        # void srand48 (long int SEEDVAL);
        "srand48": SimTypeFunction([SimTypeLong(signed=True)], SimTypeBottom(label="void"), arg_names=["seedval"]),
        # unsigned short int * seed48 (unsigned short int SEED16V[3]);
        "seed48": SimTypeFunction([SimTypeFixedSizeArray(SimTypeShort(signed=False), 3)], SimTypePointer(SimTypeShort(signed=False), offset=0), arg_names=["seed16v"]),
        # void lcong48 (unsigned short int PARAM[7]);
        "lcong48": SimTypeFunction([SimTypeFixedSizeArray(SimTypeShort(signed=False), 7)], SimTypeBottom(label="void"), arg_names=["param"]),
        # int drand48_r (struct drand48_data *BUFFER, double *RESULT);
        "drand48_r": SimTypeFunction([SimTypePointer(SimStruct({}, name="drand48_data", pack=False, align=None), offset=0), SimTypePointer(SimTypeDouble(align_double=True), offset=0)], SimTypeInt(signed=True), arg_names=["buffer", "result"]),
        # int erand48_r (unsigned short int XSUBI[3], struct drand48_data *BUFFER, double *RESULT);
        "erand48_r": SimTypeFunction([SimTypeFixedSizeArray(SimTypeShort(signed=False), 3), SimTypePointer(SimStruct({}, name="drand48_data", pack=False, align=None), offset=0), SimTypePointer(SimTypeDouble(align_double=True), offset=0)], SimTypeInt(signed=True), arg_names=["xsubi", "buffer", "result"]),
        # int lrand48_r (struct drand48_data *BUFFER, long int *RESULT);
        "lrand48_r": SimTypeFunction([SimTypePointer(SimStruct({}, name="drand48_data", pack=False, align=None), offset=0), SimTypePointer(SimTypeLong(signed=True), offset=0)], SimTypeInt(signed=True), arg_names=["buffer", "result"]),
        # int nrand48_r (unsigned short int XSUBI[3], struct drand48_data *BUFFER, long int *RESULT);
        "nrand48_r": SimTypeFunction([SimTypeFixedSizeArray(SimTypeShort(signed=False), 3), SimTypePointer(SimStruct({}, name="drand48_data", pack=False, align=None), offset=0), SimTypePointer(SimTypeLong(signed=True), offset=0)], SimTypeInt(signed=True), arg_names=["xsubi", "buffer", "result"]),
        # int mrand48_r (struct drand48_data *BUFFER, long int *RESULT);
        "mrand48_r": SimTypeFunction([SimTypePointer(SimStruct({}, name="drand48_data", pack=False, align=None), offset=0), SimTypePointer(SimTypeLong(signed=True), offset=0)], SimTypeInt(signed=True), arg_names=["buffer", "result"]),
        # int jrand48_r (unsigned short int XSUBI[3], struct drand48_data *BUFFER, long int *RESULT);
        "jrand48_r": SimTypeFunction([SimTypeFixedSizeArray(SimTypeShort(signed=False), 3), SimTypePointer(SimStruct({}, name="drand48_data", pack=False, align=None), offset=0), SimTypePointer(SimTypeLong(signed=True), offset=0)], SimTypeInt(signed=True), arg_names=["xsubi", "buffer", "result"]),
        # int srand48_r (long int SEEDVAL, struct drand48_data *BUFFER);
        "srand48_r": SimTypeFunction([SimTypeLong(signed=True), SimTypePointer(SimStruct({}, name="drand48_data", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["seedval", "buffer"]),
        # int seed48_r (unsigned short int SEED16V[3], struct drand48_data *BUFFER);
        "seed48_r": SimTypeFunction([SimTypeFixedSizeArray(SimTypeShort(signed=False), 3), SimTypePointer(SimStruct({}, name="drand48_data", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["seed16v", "buffer"]),
        # int lcong48_r (unsigned short int PARAM[7], struct drand48_data *BUFFER);
        "lcong48_r": SimTypeFunction([SimTypeFixedSizeArray(SimTypeShort(signed=False), 7), SimTypePointer(SimStruct({}, name="drand48_data", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["param", "buffer"]),
        # div_t div (int NUMERATOR, int DENOMINATOR);
        "div": None,
        # ldiv_t ldiv (long int NUMERATOR, long int DENOMINATOR);
        "ldiv": None,
        # lldiv_t lldiv (long long int NUMERATOR, long long int DENOMINATOR);
        "lldiv": None,
        # imaxdiv_t imaxdiv (intmax_t NUMERATOR, intmax_t DENOMINATOR);
        "imaxdiv": None,
        # int isinf (double X);
        "isinf": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeInt(signed=True), arg_names=["x"]),
        # int isinff (float X);
        "isinff": SimTypeFunction([SimTypeFloat(size=32)], SimTypeInt(signed=True), arg_names=["x"]),
        # int isinfl (long double X);
        "isinfl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeInt(signed=True), arg_names=["x"]),
        # int isnan (double X);
        "isnan": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeInt(signed=True), arg_names=["x"]),
        # int isnanf (float X);
        "isnanf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeInt(signed=True), arg_names=["x"]),
        # int isnanl (long double X);
        "isnanl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeInt(signed=True), arg_names=["x"]),
        # int finite (double X);
        "finite": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeInt(signed=True), arg_names=["x"]),
        # int finitef (float X);
        "finitef": SimTypeFunction([SimTypeFloat(size=32)], SimTypeInt(signed=True), arg_names=["x"]),
        # int finitel (long double X);
        "finitel": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeInt(signed=True), arg_names=["x"]),
        # int feclearexcept (int EXCEPTS);
        "feclearexcept": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["excepts"]),
        # int feraiseexcept (int EXCEPTS);
        "feraiseexcept": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["excepts"]),
        # int fesetexcept (int EXCEPTS);
        "fesetexcept": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["excepts"]),
        # int fetestexcept (int EXCEPTS);
        "fetestexcept": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["excepts"]),
        # int fegetexceptflag (fexcept_t *FLAGP, int EXCEPTS);
        "fegetexceptflag": None,
        # int fesetexceptflag (const fexcept_t *FLAGP, int EXCEPTS);
        "fesetexceptflag": None,
        # int fetestexceptflag (const fexcept_t *FLAGP, int EXCEPTS);
        "fetestexceptflag": None,
        # int fegetround (void);
        "fegetround": SimTypeFunction([], SimTypeInt(signed=True)),
        # int fesetround (int ROUND);
        "fesetround": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["round"]),
        # int fegetenv (fenv_t *ENVP);
        "fegetenv": None,
        # int feholdexcept (fenv_t *ENVP);
        "feholdexcept": None,
        # int fesetenv (const fenv_t *ENVP);
        "fesetenv": None,
        # int feupdateenv (const fenv_t *ENVP);
        "feupdateenv": None,
        # int fegetmode (femode_t *MODEP);
        "fegetmode": None,
        # int fesetmode (const femode_t *MODEP);
        "fesetmode": None,
        # int feenableexcept (int EXCEPTS);
        "feenableexcept": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["excepts"]),
        # int fedisableexcept (int EXCEPTS);
        "fedisableexcept": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["excepts"]),
        # int fegetexcept (void);
        "fegetexcept": SimTypeFunction([], SimTypeInt(signed=True)),
        # int abs (int NUMBER);
        "abs": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["number"]),
        # long int labs (long int NUMBER);
        "labs": SimTypeFunction([SimTypeLong(signed=True)], SimTypeLong(signed=True), arg_names=["number"]),
        # long long int llabs (long long int NUMBER);
        "llabs": SimTypeFunction([SimTypeLongLong(signed=True)], SimTypeLongLong(signed=True), arg_names=["number"]),
        # intmax_t imaxabs (intmax_t NUMBER);
        "imaxabs": SimTypeFunction([SimTypeInt(signed=True, label="intmax_t")], SimTypeInt(signed=True, label="intmax_t"), arg_names=["number"]),
        # double fabs (double NUMBER);
        "fabs": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["number"]),
        # float fabsf (float NUMBER);
        "fabsf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["number"]),
        # long double fabsl (long double NUMBER);
        "fabsl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["number"]),
        # _FloatN fabsfN (_FloatN NUMBER);
        "fabsfN": None,
        # _FloatNx fabsfNx (_FloatNx NUMBER);
        "fabsfNx": None,
        # double cabs (complex double Z);
        "cabs": None,
        # float cabsf (complex float Z);
        "cabsf": None,
        # long double cabsl (complex long double Z);
        "cabsl": None,
        # _FloatN cabsfN (complex _FloatN Z);
        "cabsfN": None,
        # _FloatNx cabsfNx (complex _FloatNx Z);
        "cabsfNx": None,
        # double frexp (double VALUE, int *EXPONENT);
        "frexp": SimTypeFunction([SimTypeDouble(align_double=True), SimTypePointer(SimTypeInt(signed=True), offset=0)], SimTypeDouble(align_double=True), arg_names=["value", "exponent"]),
        # float frexpf (float VALUE, int *EXPONENT);
        "frexpf": SimTypeFunction([SimTypeFloat(size=32), SimTypePointer(SimTypeInt(signed=True), offset=0)], SimTypeFloat(size=32), arg_names=["value", "exponent"]),
        # long double frexpl (long double VALUE, int *EXPONENT);
        "frexpl": SimTypeFunction([SimTypeDouble(align_double=True), SimTypePointer(SimTypeInt(signed=True), offset=0)], SimTypeDouble(align_double=True), arg_names=["value", "exponent"]),
        # _FloatN frexpfN (_FloatN VALUE, int *EXPONENT);
        "frexpfN": None,
        # _FloatNx frexpfNx (_FloatNx VALUE, int *EXPONENT);
        "frexpfNx": None,
        # double ldexp (double VALUE, int EXPONENT);
        "ldexp": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeInt(signed=True)], SimTypeDouble(align_double=True), arg_names=["value", "exponent"]),
        # float ldexpf (float VALUE, int EXPONENT);
        "ldexpf": SimTypeFunction([SimTypeFloat(size=32), SimTypeInt(signed=True)], SimTypeFloat(size=32), arg_names=["value", "exponent"]),
        # long double ldexpl (long double VALUE, int EXPONENT);
        "ldexpl": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeInt(signed=True)], SimTypeDouble(align_double=True), arg_names=["value", "exponent"]),
        # _FloatN ldexpfN (_FloatN VALUE, int EXPONENT);
        "ldexpfN": None,
        # _FloatNx ldexpfNx (_FloatNx VALUE, int EXPONENT);
        "ldexpfNx": None,
        # double scalb (double VALUE, double EXPONENT);
        "scalb": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["value", "exponent"]),
        # float scalbf (float VALUE, float EXPONENT);
        "scalbf": SimTypeFunction([SimTypeFloat(size=32), SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["value", "exponent"]),
        # long double scalbl (long double VALUE, long double EXPONENT);
        "scalbl": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["value", "exponent"]),
        # double scalbn (double X, int N);
        "scalbn": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeInt(signed=True)], SimTypeDouble(align_double=True), arg_names=["x", "n"]),
        # float scalbnf (float X, int N);
        "scalbnf": SimTypeFunction([SimTypeFloat(size=32), SimTypeInt(signed=True)], SimTypeFloat(size=32), arg_names=["x", "n"]),
        # long double scalbnl (long double X, int N);
        "scalbnl": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeInt(signed=True)], SimTypeDouble(align_double=True), arg_names=["x", "n"]),
        # _FloatN scalbnfN (_FloatN X, int N);
        "scalbnfN": None,
        # _FloatNx scalbnfNx (_FloatNx X, int N);
        "scalbnfNx": None,
        # double scalbln (double X, long int N);
        "scalbln": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeLong(signed=True)], SimTypeDouble(align_double=True), arg_names=["x", "n"]),
        # float scalblnf (float X, long int N);
        "scalblnf": SimTypeFunction([SimTypeFloat(size=32), SimTypeLong(signed=True)], SimTypeFloat(size=32), arg_names=["x", "n"]),
        # long double scalblnl (long double X, long int N);
        "scalblnl": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeLong(signed=True)], SimTypeDouble(align_double=True), arg_names=["x", "n"]),
        # _FloatN scalblnfN (_FloatN X, long int N);
        "scalblnfN": None,
        # _FloatNx scalblnfNx (_FloatNx X, long int N);
        "scalblnfNx": None,
        # double significand (double X);
        "significand": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float significandf (float X);
        "significandf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double significandl (long double X);
        "significandl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # double ceil (double X);
        "ceil": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float ceilf (float X);
        "ceilf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double ceill (long double X);
        "ceill": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN ceilfN (_FloatN X);
        "ceilfN": None,
        # _FloatNx ceilfNx (_FloatNx X);
        "ceilfNx": None,
        # double floor (double X);
        "floor": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float floorf (float X);
        "floorf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double floorl (long double X);
        "floorl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN floorfN (_FloatN X);
        "floorfN": None,
        # _FloatNx floorfNx (_FloatNx X);
        "floorfNx": None,
        # double trunc (double X);
        "trunc": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float truncf (float X);
        "truncf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double truncl (long double X);
        "truncl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN truncfN (_FloatN X);
        "truncfN": None,
        # _FloatNx truncfNx (_FloatNx X);
        "truncfNx": None,
        # double rint (double X);
        "rint": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float rintf (float X);
        "rintf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double rintl (long double X);
        "rintl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN rintfN (_FloatN X);
        "rintfN": None,
        # _FloatNx rintfNx (_FloatNx X);
        "rintfNx": None,
        # double nearbyint (double X);
        "nearbyint": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float nearbyintf (float X);
        "nearbyintf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double nearbyintl (long double X);
        "nearbyintl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN nearbyintfN (_FloatN X);
        "nearbyintfN": None,
        # _FloatNx nearbyintfNx (_FloatNx X);
        "nearbyintfNx": None,
        # double round (double X);
        "round": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float roundf (float X);
        "roundf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double roundl (long double X);
        "roundl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN roundfN (_FloatN X);
        "roundfN": None,
        # _FloatNx roundfNx (_FloatNx X);
        "roundfNx": None,
        # double roundeven (double X);
        "roundeven": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float roundevenf (float X);
        "roundevenf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double roundevenl (long double X);
        "roundevenl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN roundevenfN (_FloatN X);
        "roundevenfN": None,
        # _FloatNx roundevenfNx (_FloatNx X);
        "roundevenfNx": None,
        # long int lrint (double X);
        "lrint": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeLong(signed=True), arg_names=["x"]),
        # long int lrintf (float X);
        "lrintf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeLong(signed=True), arg_names=["x"]),
        # long int lrintl (long double X);
        "lrintl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeLong(signed=True), arg_names=["x"]),
        # long int lrintfN (_FloatN X);
        "lrintfN": None,
        # long int lrintfNx (_FloatNx X);
        "lrintfNx": None,
        # long long int llrint (double X);
        "llrint": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeLongLong(signed=True), arg_names=["x"]),
        # long long int llrintf (float X);
        "llrintf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeLongLong(signed=True), arg_names=["x"]),
        # long long int llrintl (long double X);
        "llrintl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeLongLong(signed=True), arg_names=["x"]),
        # long long int llrintfN (_FloatN X);
        "llrintfN": None,
        # long long int llrintfNx (_FloatNx X);
        "llrintfNx": None,
        # long int lround (double X);
        "lround": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeLong(signed=True), arg_names=["x"]),
        # long int lroundf (float X);
        "lroundf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeLong(signed=True), arg_names=["x"]),
        # long int lroundl (long double X);
        "lroundl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeLong(signed=True), arg_names=["x"]),
        # long int lroundfN (_FloatN X);
        "lroundfN": None,
        # long int lroundfNx (_FloatNx X);
        "lroundfNx": None,
        # long long int llround (double X);
        "llround": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeLongLong(signed=True), arg_names=["x"]),
        # long long int llroundf (float X);
        "llroundf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeLongLong(signed=True), arg_names=["x"]),
        # long long int llroundl (long double X);
        "llroundl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeLongLong(signed=True), arg_names=["x"]),
        # long long int llroundfN (_FloatN X);
        "llroundfN": None,
        # long long int llroundfNx (_FloatNx X);
        "llroundfNx": None,
        # intmax_t fromfp (double X, int ROUND, unsigned int WIDTH);
        "fromfp": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeInt(signed=True), SimTypeInt(signed=False)], SimTypeInt(signed=True, label="intmax_t"), arg_names=["x", "round", "width"]),
        # intmax_t fromfpf (float X, int ROUND, unsigned int WIDTH);
        "fromfpf": SimTypeFunction([SimTypeFloat(size=32), SimTypeInt(signed=True), SimTypeInt(signed=False)], SimTypeInt(signed=True, label="intmax_t"), arg_names=["x", "round", "width"]),
        # intmax_t fromfpl (long double X, int ROUND, unsigned int WIDTH);
        "fromfpl": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeInt(signed=True), SimTypeInt(signed=False)], SimTypeInt(signed=True, label="intmax_t"), arg_names=["x", "round", "width"]),
        # intmax_t fromfpfN (_FloatN X, int ROUND, unsigned int WIDTH);
        "fromfpfN": None,
        # intmax_t fromfpfNx (_FloatNx X, int ROUND, unsigned int WIDTH);
        "fromfpfNx": None,
        # uintmax_t ufromfp (double X, int ROUND, unsigned int WIDTH);
        "ufromfp": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeInt(signed=True), SimTypeInt(signed=False)], SimTypeInt(signed=False, label="uintmax_t"), arg_names=["x", "round", "width"]),
        # uintmax_t ufromfpf (float X, int ROUND, unsigned int WIDTH);
        "ufromfpf": SimTypeFunction([SimTypeFloat(size=32), SimTypeInt(signed=True), SimTypeInt(signed=False)], SimTypeInt(signed=False, label="uintmax_t"), arg_names=["x", "round", "width"]),
        # uintmax_t ufromfpl (long double X, int ROUND, unsigned int WIDTH);
        "ufromfpl": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeInt(signed=True), SimTypeInt(signed=False)], SimTypeInt(signed=False, label="uintmax_t"), arg_names=["x", "round", "width"]),
        # uintmax_t ufromfpfN (_FloatN X, int ROUND, unsigned int WIDTH);
        "ufromfpfN": None,
        # uintmax_t ufromfpfNx (_FloatNx X, int ROUND, unsigned int WIDTH);
        "ufromfpfNx": None,
        # intmax_t fromfpx (double X, int ROUND, unsigned int WIDTH);
        "fromfpx": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeInt(signed=True), SimTypeInt(signed=False)], SimTypeInt(signed=True, label="intmax_t"), arg_names=["x", "round", "width"]),
        # intmax_t fromfpxf (float X, int ROUND, unsigned int WIDTH);
        "fromfpxf": SimTypeFunction([SimTypeFloat(size=32), SimTypeInt(signed=True), SimTypeInt(signed=False)], SimTypeInt(signed=True, label="intmax_t"), arg_names=["x", "round", "width"]),
        # intmax_t fromfpxl (long double X, int ROUND, unsigned int WIDTH);
        "fromfpxl": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeInt(signed=True), SimTypeInt(signed=False)], SimTypeInt(signed=True, label="intmax_t"), arg_names=["x", "round", "width"]),
        # intmax_t fromfpxfN (_FloatN X, int ROUND, unsigned int WIDTH);
        "fromfpxfN": None,
        # intmax_t fromfpxfNx (_FloatNx X, int ROUND, unsigned int WIDTH);
        "fromfpxfNx": None,
        # uintmax_t ufromfpx (double X, int ROUND, unsigned int WIDTH);
        "ufromfpx": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeInt(signed=True), SimTypeInt(signed=False)], SimTypeInt(signed=False, label="uintmax_t"), arg_names=["x", "round", "width"]),
        # uintmax_t ufromfpxf (float X, int ROUND, unsigned int WIDTH);
        "ufromfpxf": SimTypeFunction([SimTypeFloat(size=32), SimTypeInt(signed=True), SimTypeInt(signed=False)], SimTypeInt(signed=False, label="uintmax_t"), arg_names=["x", "round", "width"]),
        # uintmax_t ufromfpxl (long double X, int ROUND, unsigned int WIDTH);
        "ufromfpxl": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeInt(signed=True), SimTypeInt(signed=False)], SimTypeInt(signed=False, label="uintmax_t"), arg_names=["x", "round", "width"]),
        # uintmax_t ufromfpxfN (_FloatN X, int ROUND, unsigned int WIDTH);
        "ufromfpxfN": None,
        # uintmax_t ufromfpxfNx (_FloatNx X, int ROUND, unsigned int WIDTH);
        "ufromfpxfNx": None,
        # double modf (double VALUE, double *INTEGER-PART);
        "modf": None,
        # float modff (float VALUE, float *INTEGER-PART);
        "modff": None,
        # long double modfl (long double VALUE, long double *INTEGER-PART);
        "modfl": None,
        # _FloatN modffN (_FloatN VALUE, _FloatN *INTEGER-PART);
        "modffN": None,
        # _FloatNx modffNx (_FloatNx VALUE, _FloatNx *INTEGER-PART);
        "modffNx": None,
        # double fmod (double NUMERATOR, double DENOMINATOR);
        "fmod": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["numerator", "denominator"]),
        # float fmodf (float NUMERATOR, float DENOMINATOR);
        "fmodf": SimTypeFunction([SimTypeFloat(size=32), SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["numerator", "denominator"]),
        # long double fmodl (long double NUMERATOR, long double DENOMINATOR);
        "fmodl": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["numerator", "denominator"]),
        # _FloatN fmodfN (_FloatN NUMERATOR, _FloatN DENOMINATOR);
        "fmodfN": None,
        # _FloatNx fmodfNx (_FloatNx NUMERATOR, _FloatNx DENOMINATOR);
        "fmodfNx": None,
        # double remainder (double NUMERATOR, double DENOMINATOR);
        "remainder": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["numerator", "denominator"]),
        # float remainderf (float NUMERATOR, float DENOMINATOR);
        "remainderf": SimTypeFunction([SimTypeFloat(size=32), SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["numerator", "denominator"]),
        # long double remainderl (long double NUMERATOR, long double DENOMINATOR);
        "remainderl": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["numerator", "denominator"]),
        # _FloatN remainderfN (_FloatN NUMERATOR, _FloatN DENOMINATOR);
        "remainderfN": None,
        # _FloatNx remainderfNx (_FloatNx NUMERATOR, _FloatNx DENOMINATOR);
        "remainderfNx": None,
        # double drem (double NUMERATOR, double DENOMINATOR);
        "drem": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["numerator", "denominator"]),
        # float dremf (float NUMERATOR, float DENOMINATOR);
        "dremf": SimTypeFunction([SimTypeFloat(size=32), SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["numerator", "denominator"]),
        # long double dreml (long double NUMERATOR, long double DENOMINATOR);
        "dreml": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["numerator", "denominator"]),
        # double copysign (double X, double Y);
        "copysign": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x", "y"]),
        # float copysignf (float X, float Y);
        "copysignf": SimTypeFunction([SimTypeFloat(size=32), SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x", "y"]),
        # long double copysignl (long double X, long double Y);
        "copysignl": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x", "y"]),
        # _FloatN copysignfN (_FloatN X, _FloatN Y);
        "copysignfN": None,
        # _FloatNx copysignfNx (_FloatNx X, _FloatNx Y);
        "copysignfNx": None,
        # int signbit (_float-type_ X);
        "signbit": None,
        # double nextafter (double X, double Y);
        "nextafter": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x", "y"]),
        # float nextafterf (float X, float Y);
        "nextafterf": SimTypeFunction([SimTypeFloat(size=32), SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x", "y"]),
        # long double nextafterl (long double X, long double Y);
        "nextafterl": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x", "y"]),
        # _FloatN nextafterfN (_FloatN X, _FloatN Y);
        "nextafterfN": None,
        # _FloatNx nextafterfNx (_FloatNx X, _FloatNx Y);
        "nextafterfNx": None,
        # double nexttoward (double X, long double Y);
        "nexttoward": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x", "y"]),
        # float nexttowardf (float X, long double Y);
        "nexttowardf": SimTypeFunction([SimTypeFloat(size=32), SimTypeDouble(align_double=True)], SimTypeFloat(size=32), arg_names=["x", "y"]),
        # long double nexttowardl (long double X, long double Y);
        "nexttowardl": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x", "y"]),
        # double nextup (double X);
        "nextup": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float nextupf (float X);
        "nextupf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double nextupl (long double X);
        "nextupl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN nextupfN (_FloatN X);
        "nextupfN": None,
        # _FloatNx nextupfNx (_FloatNx X);
        "nextupfNx": None,
        # double nextdown (double X);
        "nextdown": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float nextdownf (float X);
        "nextdownf": SimTypeFunction([SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double nextdownl (long double X);
        "nextdownl": SimTypeFunction([SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN nextdownfN (_FloatN X);
        "nextdownfN": None,
        # _FloatNx nextdownfNx (_FloatNx X);
        "nextdownfNx": None,
        # double nan (const char *TAGP);
        "nan": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeDouble(align_double=True), arg_names=["tagp"]),
        # float nanf (const char *TAGP);
        "nanf": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeFloat(size=32), arg_names=["tagp"]),
        # long double nanl (const char *TAGP);
        "nanl": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeDouble(align_double=True), arg_names=["tagp"]),
        # _FloatN nanfN (const char *TAGP);
        "nanfN": None,
        # _FloatNx nanfNx (const char *TAGP);
        "nanfNx": None,
        # int canonicalize (double *CX, const double *X);
        "canonicalize": SimTypeFunction([SimTypePointer(SimTypeDouble(align_double=True), offset=0), SimTypePointer(SimTypeDouble(align_double=True), offset=0)], SimTypeInt(signed=True), arg_names=["cx", "x"]),
        # int canonicalizef (float *CX, const float *X);
        "canonicalizef": SimTypeFunction([SimTypePointer(SimTypeFloat(size=32), offset=0), SimTypePointer(SimTypeFloat(size=32), offset=0)], SimTypeInt(signed=True), arg_names=["cx", "x"]),
        # int canonicalizel (long double *CX, const long double *X);
        "canonicalizel": SimTypeFunction([SimTypePointer(SimTypeDouble(align_double=True), offset=0), SimTypePointer(SimTypeDouble(align_double=True), offset=0)], SimTypeInt(signed=True), arg_names=["cx", "x"]),
        # int canonicalizefN (_FloatN *CX, const _FloatN *X);
        "canonicalizefN": None,
        # int canonicalizefNx (_FloatNx *CX, const _FloatNx *X);
        "canonicalizefNx": None,
        # double getpayload (const double *X);
        "getpayload": SimTypeFunction([SimTypePointer(SimTypeDouble(align_double=True), offset=0)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # float getpayloadf (const float *X);
        "getpayloadf": SimTypeFunction([SimTypePointer(SimTypeFloat(size=32), offset=0)], SimTypeFloat(size=32), arg_names=["x"]),
        # long double getpayloadl (const long double *X);
        "getpayloadl": SimTypeFunction([SimTypePointer(SimTypeDouble(align_double=True), offset=0)], SimTypeDouble(align_double=True), arg_names=["x"]),
        # _FloatN getpayloadfN (const _FloatN *X);
        "getpayloadfN": None,
        # _FloatNx getpayloadfNx (const _FloatNx *X);
        "getpayloadfNx": None,
        # int setpayload (double *X, double PAYLOAD);
        "setpayload": SimTypeFunction([SimTypePointer(SimTypeDouble(align_double=True), offset=0), SimTypeDouble(align_double=True)], SimTypeInt(signed=True), arg_names=["x", "payload"]),
        # int setpayloadf (float *X, float PAYLOAD);
        "setpayloadf": SimTypeFunction([SimTypePointer(SimTypeFloat(size=32), offset=0), SimTypeFloat(size=32)], SimTypeInt(signed=True), arg_names=["x", "payload"]),
        # int setpayloadl (long double *X, long double PAYLOAD);
        "setpayloadl": SimTypeFunction([SimTypePointer(SimTypeDouble(align_double=True), offset=0), SimTypeDouble(align_double=True)], SimTypeInt(signed=True), arg_names=["x", "payload"]),
        # int setpayloadfN (_FloatN *X, _FloatN PAYLOAD);
        "setpayloadfN": None,
        # int setpayloadfNx (_FloatNx *X, _FloatNx PAYLOAD);
        "setpayloadfNx": None,
        # int setpayloadsig (double *X, double PAYLOAD);
        "setpayloadsig": SimTypeFunction([SimTypePointer(SimTypeDouble(align_double=True), offset=0), SimTypeDouble(align_double=True)], SimTypeInt(signed=True), arg_names=["x", "payload"]),
        # int setpayloadsigf (float *X, float PAYLOAD);
        "setpayloadsigf": SimTypeFunction([SimTypePointer(SimTypeFloat(size=32), offset=0), SimTypeFloat(size=32)], SimTypeInt(signed=True), arg_names=["x", "payload"]),
        # int setpayloadsigl (long double *X, long double PAYLOAD);
        "setpayloadsigl": SimTypeFunction([SimTypePointer(SimTypeDouble(align_double=True), offset=0), SimTypeDouble(align_double=True)], SimTypeInt(signed=True), arg_names=["x", "payload"]),
        # int setpayloadsigfN (_FloatN *X, _FloatN PAYLOAD);
        "setpayloadsigfN": None,
        # int setpayloadsigfNx (_FloatNx *X, _FloatNx PAYLOAD);
        "setpayloadsigfNx": None,
        # int totalorder (double X, double Y);
        "totalorder": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeInt(signed=True), arg_names=["x", "y"]),
        # int totalorderf (float X, float Y);
        "totalorderf": SimTypeFunction([SimTypeFloat(size=32), SimTypeFloat(size=32)], SimTypeInt(signed=True), arg_names=["x", "y"]),
        # int totalorderl (long double X, long double Y);
        "totalorderl": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeInt(signed=True), arg_names=["x", "y"]),
        # int totalorderfN (_FloatN X, _FloatN Y);
        "totalorderfN": None,
        # int totalorderfNx (_FloatNx X, _FloatNx Y);
        "totalorderfNx": None,
        # int totalordermag (double X, double Y);
        "totalordermag": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeInt(signed=True), arg_names=["x", "y"]),
        # int totalordermagf (float X, float Y);
        "totalordermagf": SimTypeFunction([SimTypeFloat(size=32), SimTypeFloat(size=32)], SimTypeInt(signed=True), arg_names=["x", "y"]),
        # int totalordermagl (long double X, long double Y);
        "totalordermagl": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeInt(signed=True), arg_names=["x", "y"]),
        # int totalordermagfN (_FloatN X, _FloatN Y);
        "totalordermagfN": None,
        # int totalordermagfNx (_FloatNx X, _FloatNx Y);
        "totalordermagfNx": None,
        # double fmin (double X, double Y);
        "fmin": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x", "y"]),
        # float fminf (float X, float Y);
        "fminf": SimTypeFunction([SimTypeFloat(size=32), SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x", "y"]),
        # long double fminl (long double X, long double Y);
        "fminl": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x", "y"]),
        # _FloatN fminfN (_FloatN X, _FloatN Y);
        "fminfN": None,
        # _FloatNx fminfNx (_FloatNx X, _FloatNx Y);
        "fminfNx": None,
        # double fmax (double X, double Y);
        "fmax": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x", "y"]),
        # float fmaxf (float X, float Y);
        "fmaxf": SimTypeFunction([SimTypeFloat(size=32), SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x", "y"]),
        # long double fmaxl (long double X, long double Y);
        "fmaxl": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x", "y"]),
        # _FloatN fmaxfN (_FloatN X, _FloatN Y);
        "fmaxfN": None,
        # _FloatNx fmaxfNx (_FloatNx X, _FloatNx Y);
        "fmaxfNx": None,
        # double fminmag (double X, double Y);
        "fminmag": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x", "y"]),
        # float fminmagf (float X, float Y);
        "fminmagf": SimTypeFunction([SimTypeFloat(size=32), SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x", "y"]),
        # long double fminmagl (long double X, long double Y);
        "fminmagl": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x", "y"]),
        # _FloatN fminmagfN (_FloatN X, _FloatN Y);
        "fminmagfN": None,
        # _FloatNx fminmagfNx (_FloatNx X, _FloatNx Y);
        "fminmagfNx": None,
        # double fmaxmag (double X, double Y);
        "fmaxmag": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x", "y"]),
        # float fmaxmagf (float X, float Y);
        "fmaxmagf": SimTypeFunction([SimTypeFloat(size=32), SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x", "y"]),
        # long double fmaxmagl (long double X, long double Y);
        "fmaxmagl": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x", "y"]),
        # _FloatN fmaxmagfN (_FloatN X, _FloatN Y);
        "fmaxmagfN": None,
        # _FloatNx fmaxmagfNx (_FloatNx X, _FloatNx Y);
        "fmaxmagfNx": None,
        # double fdim (double X, double Y);
        "fdim": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x", "y"]),
        # float fdimf (float X, float Y);
        "fdimf": SimTypeFunction([SimTypeFloat(size=32), SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x", "y"]),
        # long double fdiml (long double X, long double Y);
        "fdiml": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x", "y"]),
        # _FloatN fdimfN (_FloatN X, _FloatN Y);
        "fdimfN": None,
        # _FloatNx fdimfNx (_FloatNx X, _FloatNx Y);
        "fdimfNx": None,
        # double fma (double X, double Y, double Z);
        "fma": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x", "y", "z"]),
        # float fmaf (float X, float Y, float Z);
        "fmaf": SimTypeFunction([SimTypeFloat(size=32), SimTypeFloat(size=32), SimTypeFloat(size=32)], SimTypeFloat(size=32), arg_names=["x", "y", "z"]),
        # long double fmal (long double X, long double Y, long double Z);
        "fmal": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeDouble(align_double=True), SimTypeDouble(align_double=True)], SimTypeDouble(align_double=True), arg_names=["x", "y", "z"]),
        # _FloatN fmafN (_FloatN X, _FloatN Y, _FloatN Z);
        "fmafN": None,
        # _FloatNx fmafNx (_FloatNx X, _FloatNx Y, _FloatNx Z);
        "fmafNx": None,
        # double creal (complex double Z);
        "creal": None,
        # float crealf (complex float Z);
        "crealf": None,
        # long double creall (complex long double Z);
        "creall": None,
        # _FloatN crealfN (complex _FloatN Z);
        "crealfN": None,
        # _FloatNx crealfNx (complex _FloatNx Z);
        "crealfNx": None,
        # double cimag (complex double Z);
        "cimag": None,
        # float cimagf (complex float Z);
        "cimagf": None,
        # long double cimagl (complex long double Z);
        "cimagl": None,
        # _FloatN cimagfN (complex _FloatN Z);
        "cimagfN": None,
        # _FloatNx cimagfNx (complex _FloatNx Z);
        "cimagfNx": None,
        # complex double conj (complex double Z);
        "conj": None,
        # complex float conjf (complex float Z);
        "conjf": None,
        # complex long double conjl (complex long double Z);
        "conjl": None,
        # complex _FloatN conjfN (complex _FloatN Z);
        "conjfN": None,
        # complex _FloatNx conjfNx (complex _FloatNx Z);
        "conjfNx": None,
        # double carg (complex double Z);
        "carg": None,
        # float cargf (complex float Z);
        "cargf": None,
        # long double cargl (complex long double Z);
        "cargl": None,
        # _FloatN cargfN (complex _FloatN Z);
        "cargfN": None,
        # _FloatNx cargfNx (complex _FloatNx Z);
        "cargfNx": None,
        # complex double cproj (complex double Z);
        "cproj": None,
        # complex float cprojf (complex float Z);
        "cprojf": None,
        # complex long double cprojl (complex long double Z);
        "cprojl": None,
        # complex _FloatN cprojfN (complex _FloatN Z);
        "cprojfN": None,
        # complex _FloatNx cprojfNx (complex _FloatNx Z);
        "cprojfNx": None,
        # long int strtol (const char *restrict STRING, char **restrict TAILPTR, int BASE);
        "strtol": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0), SimTypeInt(signed=True)], SimTypeLong(signed=True), arg_names=["string", "tailptr", "base"]),
        # long int wcstol (const wchar_t *restrict STRING, wchar_t **restrict TAILPTR, int BASE);
        "wcstol": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), offset=0), SimTypeInt(signed=True)], SimTypeLong(signed=True), arg_names=["string", "tailptr", "base"]),
        # unsigned long int strtoul (const char *retrict STRING, char **restrict TAILPTR, int BASE);
        "strtoul": None,
        # unsigned long int wcstoul (const wchar_t *restrict STRING, wchar_t **restrict TAILPTR, int BASE);
        "wcstoul": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), offset=0), SimTypeInt(signed=True)], SimTypeLong(signed=False), arg_names=["string", "tailptr", "base"]),
        # long long int strtoll (const char *restrict STRING, char **restrict TAILPTR, int BASE);
        "strtoll": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0), SimTypeInt(signed=True)], SimTypeLongLong(signed=True), arg_names=["string", "tailptr", "base"]),
        # long long int wcstoll (const wchar_t *restrict STRING, wchar_t **restrict TAILPTR, int BASE);
        "wcstoll": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), offset=0), SimTypeInt(signed=True)], SimTypeLongLong(signed=True), arg_names=["string", "tailptr", "base"]),
        # long long int strtoq (const char *restrict STRING, char **restrict TAILPTR, int BASE);
        "strtoq": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0), SimTypeInt(signed=True)], SimTypeLongLong(signed=True), arg_names=["string", "tailptr", "base"]),
        # long long int wcstoq (const wchar_t *restrict STRING, wchar_t **restrict TAILPTR, int BASE);
        "wcstoq": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), offset=0), SimTypeInt(signed=True)], SimTypeLongLong(signed=True), arg_names=["string", "tailptr", "base"]),
        # unsigned long long int strtoull (const char *restrict STRING, char **restrict TAILPTR, int BASE);
        "strtoull": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0), SimTypeInt(signed=True)], SimTypeLongLong(signed=False), arg_names=["string", "tailptr", "base"]),
        # unsigned long long int wcstoull (const wchar_t *restrict STRING, wchar_t **restrict TAILPTR, int BASE);
        "wcstoull": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), offset=0), SimTypeInt(signed=True)], SimTypeLongLong(signed=False), arg_names=["string", "tailptr", "base"]),
        # unsigned long long int strtouq (const char *restrict STRING, char **restrict TAILPTR, int BASE);
        "strtouq": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0), SimTypeInt(signed=True)], SimTypeLongLong(signed=False), arg_names=["string", "tailptr", "base"]),
        # unsigned long long int wcstouq (const wchar_t *restrict STRING, wchar_t **restrict TAILPTR, int BASE);
        "wcstouq": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), offset=0), SimTypeInt(signed=True)], SimTypeLongLong(signed=False), arg_names=["string", "tailptr", "base"]),
        # intmax_t strtoimax (const char *restrict STRING, char **restrict TAILPTR, int BASE);
        "strtoimax": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0), SimTypeInt(signed=True)], SimTypeInt(signed=True, label="intmax_t"), arg_names=["string", "tailptr", "base"]),
        # intmax_t wcstoimax (const wchar_t *restrict STRING, wchar_t **restrict TAILPTR, int BASE);
        "wcstoimax": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), offset=0), SimTypeInt(signed=True)], SimTypeInt(signed=True, label="intmax_t"), arg_names=["string", "tailptr", "base"]),
        # uintmax_t strtoumax (const char *restrict STRING, char **restrict TAILPTR, int BASE);
        "strtoumax": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0), SimTypeInt(signed=True)], SimTypeInt(signed=False, label="uintmax_t"), arg_names=["string", "tailptr", "base"]),
        # uintmax_t wcstoumax (const wchar_t *restrict STRING, wchar_t **restrict TAILPTR, int BASE);
        "wcstoumax": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), offset=0), SimTypeInt(signed=True)], SimTypeInt(signed=False, label="uintmax_t"), arg_names=["string", "tailptr", "base"]),
        # long int atol (const char *STRING);
        "atol": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeLong(signed=True), arg_names=["string"]),
        # int atoi (const char *STRING);
        "atoi": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["string"]),
        # long long int atoll (const char *STRING);
        "atoll": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeLongLong(signed=True), arg_names=["string"]),
        # double strtod (const char *restrict STRING, char **restrict TAILPTR);
        "strtod": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0)], SimTypeDouble(align_double=True), arg_names=["string", "tailptr"]),
        # float strtof (const char *STRING, char **TAILPTR);
        "strtof": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0)], SimTypeFloat(size=32), arg_names=["string", "tailptr"]),
        # long double strtold (const char *STRING, char **TAILPTR);
        "strtold": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0)], SimTypeDouble(align_double=True), arg_names=["string", "tailptr"]),
        # _FloatN strtofN (const char *STRING, char **TAILPTR);
        "strtofN": None,
        # _FloatNx strtofNx (const char *STRING, char **TAILPTR);
        "strtofNx": None,
        # double wcstod (const wchar_t *restrict STRING, wchar_t **restrict TAILPTR);
        "wcstod": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), offset=0)], SimTypeDouble(align_double=True), arg_names=["string", "tailptr"]),
        # float wcstof (const wchar_t *STRING, wchar_t **TAILPTR);
        "wcstof": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), offset=0)], SimTypeFloat(size=32), arg_names=["string", "tailptr"]),
        # long double wcstold (const wchar_t *STRING, wchar_t **TAILPTR);
        "wcstold": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), offset=0)], SimTypeDouble(align_double=True), arg_names=["string", "tailptr"]),
        # _FloatN wcstofN (const wchar_t *STRING, wchar_t **TAILPTR);
        "wcstofN": None,
        # _FloatNx wcstofNx (const wchar_t *STRING, wchar_t **TAILPTR);
        "wcstofNx": None,
        # double atof (const char *STRING);
        "atof": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeDouble(align_double=True), arg_names=["string"]),
        # int strfromd (char *restrict STRING, size_t SIZE, const char *restrict FORMAT, double VALUE);
        "strfromd": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypeChar(), offset=0), SimTypeDouble(align_double=True)], SimTypeInt(signed=True), arg_names=["string", "size", "format", "value"]),
        # int strfromf (char *restrict STRING, size_t SIZE, const char *restrict FORMAT, float VALUE);
        "strfromf": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypeChar(), offset=0), SimTypeFloat(size=32)], SimTypeInt(signed=True), arg_names=["string", "size", "format", "value"]),
        # int strfroml (char *restrict STRING, size_t SIZE, const char *restrict FORMAT, long double VALUE);
        "strfroml": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypeChar(), offset=0), SimTypeDouble(align_double=True)], SimTypeInt(signed=True), arg_names=["string", "size", "format", "value"]),
        # int strfromfN (char *restrict STRING, size_t SIZE, const char *restrict FORMAT, _FloatN VALUE);
        "strfromfN": None,
        # int strfromfNx (char *restrict STRING, size_t SIZE, const char *restrict FORMAT, _FloatNx VALUE);
        "strfromfNx": None,
        # char * ecvt (double VALUE, int NDIGIT, int *DECPT, int *NEG);
        "ecvt": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeInt(signed=True), SimTypePointer(SimTypeInt(signed=True), offset=0), SimTypePointer(SimTypeInt(signed=True), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["value", "ndigit", "decpt", "neg"]),
        # char * fcvt (double VALUE, int NDIGIT, int *DECPT, int *NEG);
        "fcvt": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeInt(signed=True), SimTypePointer(SimTypeInt(signed=True), offset=0), SimTypePointer(SimTypeInt(signed=True), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["value", "ndigit", "decpt", "neg"]),
        # char * gcvt (double VALUE, int NDIGIT, char *BUF);
        "gcvt": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeInt(signed=True), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["value", "ndigit", "buf"]),
        # char * qecvt (long double VALUE, int NDIGIT, int *DECPT, int *NEG);
        "qecvt": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeInt(signed=True), SimTypePointer(SimTypeInt(signed=True), offset=0), SimTypePointer(SimTypeInt(signed=True), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["value", "ndigit", "decpt", "neg"]),
        # char * qfcvt (long double VALUE, int NDIGIT, int *DECPT, int *NEG);
        "qfcvt": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeInt(signed=True), SimTypePointer(SimTypeInt(signed=True), offset=0), SimTypePointer(SimTypeInt(signed=True), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["value", "ndigit", "decpt", "neg"]),
        # char * qgcvt (long double VALUE, int NDIGIT, char *BUF);
        "qgcvt": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeInt(signed=True), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["value", "ndigit", "buf"]),
        # int ecvt_r (double VALUE, int NDIGIT, int *DECPT, int *NEG, char *BUF, size_t LEN);
        "ecvt_r": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeInt(signed=True), SimTypePointer(SimTypeInt(signed=True), offset=0), SimTypePointer(SimTypeInt(signed=True), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["value", "ndigit", "decpt", "neg", "buf", "len"]),
        # int fcvt_r (double VALUE, int NDIGIT, int *DECPT, int *NEG, char *BUF, size_t LEN);
        "fcvt_r": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeInt(signed=True), SimTypePointer(SimTypeInt(signed=True), offset=0), SimTypePointer(SimTypeInt(signed=True), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["value", "ndigit", "decpt", "neg", "buf", "len"]),
        # int qecvt_r (long double VALUE, int NDIGIT, int *DECPT, int *NEG, char *BUF, size_t LEN);
        "qecvt_r": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeInt(signed=True), SimTypePointer(SimTypeInt(signed=True), offset=0), SimTypePointer(SimTypeInt(signed=True), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["value", "ndigit", "decpt", "neg", "buf", "len"]),
        # int qfcvt_r (long double VALUE, int NDIGIT, int *DECPT, int *NEG, char *BUF, size_t LEN);
        "qfcvt_r": SimTypeFunction([SimTypeDouble(align_double=True), SimTypeInt(signed=True), SimTypePointer(SimTypeInt(signed=True), offset=0), SimTypePointer(SimTypeInt(signed=True), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["value", "ndigit", "decpt", "neg", "buf", "len"]),
        # double difftime (time_t TIME1, time_t TIME0);
        "difftime": SimTypeFunction([SimTypeLong(signed=True, label="time_t"), SimTypeLong(signed=True, label="time_t")], SimTypeDouble(align_double=True), arg_names=["time1", "time0"]),
        # clock_t clock (void);
        "clock": SimTypeFunction([], SimTypeLong(signed=True, label="clock_t")),
        # clock_t times (struct tms *BUFFER);
        "times": SimTypeFunction([SimTypePointer(SimStruct({}, name="tms", pack=False, align=None), offset=0)], SimTypeLong(signed=True, label="clock_t"), arg_names=["buffer"]),
        # time_t time (time_t *RESULT);
        "time": SimTypeFunction([SimTypePointer(SimTypeLong(signed=True, label="time_t"), offset=0)], SimTypeLong(signed=True, label="time_t"), arg_names=["result"]),
        # int stime (const time_t *NEWTIME);
        "stime": SimTypeFunction([SimTypePointer(SimTypeLong(signed=True, label="time_t"), offset=0)], SimTypeInt(signed=True), arg_names=["newtime"]),
        # int gettimeofday (struct timeval *TP, struct timezone *TZP);
        "gettimeofday": SimTypeFunction([SimTypePointer(SimStruct({"tv_sec": SimTypeLong(signed=True, label="time_t"), "tv_usec": SimTypeLong(signed=True)}, name="timeval", pack=False, align=None), offset=0), SimTypePointer(SimStruct({}, name="timezone", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["tp", "tzp"]),
        # int settimeofday (const struct timeval *TP, const struct timezone *TZP);
        "settimeofday": SimTypeFunction([SimTypePointer(SimStruct({"tv_sec": SimTypeLong(signed=True, label="time_t"), "tv_usec": SimTypeLong(signed=True)}, name="timeval", pack=False, align=None), offset=0), SimTypePointer(SimStruct({}, name="timezone", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["tp", "tzp"]),
        # int adjtime (const struct timeval *DELTA, struct timeval *OLDDELTA);
        "adjtime": SimTypeFunction([SimTypePointer(SimStruct({"tv_sec": SimTypeLong(signed=True, label="time_t"), "tv_usec": SimTypeLong(signed=True)}, name="timeval", pack=False, align=None), offset=0), SimTypePointer(SimStruct({"tv_sec": SimTypeLong(signed=True, label="time_t"), "tv_usec": SimTypeLong(signed=True)}, name="timeval", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["delta", "olddelta"]),
        # int adjtimex (struct timex *TIMEX);
        "adjtimex": SimTypeFunction([SimTypePointer(SimStruct({}, name="timex", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["timex"]),
        # struct tm * localtime (const time_t *TIME);
        "localtime": SimTypeFunction([SimTypePointer(SimTypeLong(signed=True, label="time_t"), offset=0)], SimTypePointer(SimStruct({}, name="tm", pack=False, align=None), offset=0), arg_names=["time"]),
        # struct tm * localtime_r (const time_t *TIME, struct tm *RESULTP);
        "localtime_r": SimTypeFunction([SimTypePointer(SimTypeLong(signed=True, label="time_t"), offset=0), SimTypePointer(SimStruct({}, name="tm", pack=False, align=None), offset=0)], SimTypePointer(SimStruct({}, name="tm", pack=False, align=None), offset=0), arg_names=["time", "resultp"]),
        # struct tm * gmtime (const time_t *TIME);
        "gmtime": SimTypeFunction([SimTypePointer(SimTypeLong(signed=True, label="time_t"), offset=0)], SimTypePointer(SimStruct({}, name="tm", pack=False, align=None), offset=0), arg_names=["time"]),
        # struct tm * gmtime_r (const time_t *TIME, struct tm *RESULTP);
        "gmtime_r": SimTypeFunction([SimTypePointer(SimTypeLong(signed=True, label="time_t"), offset=0), SimTypePointer(SimStruct({}, name="tm", pack=False, align=None), offset=0)], SimTypePointer(SimStruct({}, name="tm", pack=False, align=None), offset=0), arg_names=["time", "resultp"]),
        # time_t mktime (struct tm *BROKENTIME);
        "mktime": SimTypeFunction([SimTypePointer(SimStruct({}, name="tm", pack=False, align=None), offset=0)], SimTypeLong(signed=True, label="time_t"), arg_names=["brokentime"]),
        # time_t timelocal (struct tm *BROKENTIME);
        "timelocal": SimTypeFunction([SimTypePointer(SimStruct({}, name="tm", pack=False, align=None), offset=0)], SimTypeLong(signed=True, label="time_t"), arg_names=["brokentime"]),
        # time_t timegm (struct tm *BROKENTIME);
        "timegm": SimTypeFunction([SimTypePointer(SimStruct({}, name="tm", pack=False, align=None), offset=0)], SimTypeLong(signed=True, label="time_t"), arg_names=["brokentime"]),
        # int ntp_gettime (struct ntptimeval *TPTR);
        "ntp_gettime": SimTypeFunction([SimTypePointer(SimStruct({}, name="ntptimeval", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["tptr"]),
        # int ntp_adjtime (struct timex *TPTR);
        "ntp_adjtime": SimTypeFunction([SimTypePointer(SimStruct({}, name="timex", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["tptr"]),
        # char * asctime (const struct tm *BROKENTIME);
        "asctime": SimTypeFunction([SimTypePointer(SimStruct({}, name="tm", pack=False, align=None), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["brokentime"]),
        # char * asctime_r (const struct tm *BROKENTIME, char *BUFFER);
        "asctime_r": SimTypeFunction([SimTypePointer(SimStruct({}, name="tm", pack=False, align=None), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["brokentime", "buffer"]),
        # char * ctime (const time_t *TIME);
        "ctime": SimTypeFunction([SimTypePointer(SimTypeLong(signed=True, label="time_t"), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["time"]),
        # char * ctime_r (const time_t *TIME, char *BUFFER);
        "ctime_r": SimTypeFunction([SimTypePointer(SimTypeLong(signed=True, label="time_t"), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["time", "buffer"]),
        # size_t strftime (char *S, size_t SIZE, const char *TEMPLATE, const struct tm *BROKENTIME);
        "strftime": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimStruct({}, name="tm", pack=False, align=None), offset=0)], SimTypeLong(signed=False, label="size_t"), arg_names=["s", "size", "template", "brokentime"]),
        # size_t wcsftime (wchar_t *S, size_t SIZE, const wchar_t *TEMPLATE, const struct tm *BROKENTIME);
        "wcsftime": SimTypeFunction([SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypeShort(signed=False, label="wchar_t"), offset=0), SimTypePointer(SimStruct({}, name="tm", pack=False, align=None), offset=0)], SimTypeLong(signed=False, label="size_t"), arg_names=["s", "size", "template", "brokentime"]),
        # char * strptime (const char *S, const char *FMT, struct tm *TP);
        "strptime": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimStruct({}, name="tm", pack=False, align=None), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["s", "fmt", "tp"]),
        # struct tm * getdate (const char *STRING);
        "getdate": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimStruct({}, name="tm", pack=False, align=None), offset=0), arg_names=["string"]),
        # int getdate_r (const char *STRING, struct tm *TP);
        "getdate_r": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimStruct({}, name="tm", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["string", "tp"]),
        # void tzset (void);
        "tzset": SimTypeFunction([], SimTypeBottom(label="void")),
        # int setitimer (int WHICH, const struct itimerval *NEW, struct itimerval *OLD);
        "setitimer": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="itimerval", pack=False, align=None), offset=0), SimTypePointer(SimStruct({}, name="itimerval", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["which", "new", "old"]),
        # int getitimer (int WHICH, struct itimerval *OLD);
        "getitimer": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="itimerval", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["which", "old"]),
        # unsigned int alarm (unsigned int SECONDS);
        "alarm": SimTypeFunction([SimTypeInt(signed=False)], SimTypeInt(signed=False), arg_names=["seconds"]),
        # unsigned int sleep (unsigned int SECONDS);
        "sleep": SimTypeFunction([SimTypeInt(signed=False)], SimTypeInt(signed=False), arg_names=["seconds"]),
        # int nanosleep (const struct timespec *REQUESTED_TIME, struct timespec *REMAINING);
        "nanosleep": SimTypeFunction([SimTypePointer(SimStruct({"tv_sec": SimTypeLong(signed=True, label="time_t"), "tv_nsec": SimTypeLong(signed=True)}, name="timespec", pack=False, align=None), offset=0), SimTypePointer(SimStruct({"tv_sec": SimTypeLong(signed=True, label="time_t"), "tv_nsec": SimTypeLong(signed=True)}, name="timespec", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["requested_time", "remaining"]),
        # int getrusage (int PROCESSES, struct rusage *RUSAGE);
        "getrusage": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="rusage", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["processes", "rusage"]),
        # int vtimes (struct vtimes *CURRENT, struct vtimes *CHILD);
        "vtimes": SimTypeFunction([SimTypePointer(SimStruct({}, name="vtimes", pack=False, align=None), offset=0), SimTypePointer(SimStruct({}, name="vtimes", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["current", "child"]),
        # int getrlimit (int RESOURCE, struct rlimit *RLP);
        "getrlimit": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="rlimit", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["resource", "rlp"]),
        # int getrlimit64 (int RESOURCE, struct rlimit64 *RLP);
        "getrlimit64": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="rlimit64", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["resource", "rlp"]),
        # int setrlimit (int RESOURCE, const struct rlimit *RLP);
        "setrlimit": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="rlimit", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["resource", "rlp"]),
        # int setrlimit64 (int RESOURCE, const struct rlimit64 *RLP);
        "setrlimit64": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="rlimit64", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["resource", "rlp"]),
        # long int ulimit (int CMD, ...);
        "ulimit": SimTypeFunction([SimTypeInt(signed=True)], SimTypeLong(signed=True), arg_names=["cmd"], variadic=True),
        # int vlimit (int RESOURCE, int LIMIT);
        "vlimit": SimTypeFunction([SimTypeInt(signed=True), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["resource", "limit"]),
        # int sched_setscheduler (pid_t PID, int POLICY, const struct sched_param *PARAM);
        "sched_setscheduler": SimTypeFunction([SimTypeInt(signed=True, label="pid_t"), SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="sched_param", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["pid", "policy", "param"]),
        # int sched_getscheduler (pid_t PID);
        "sched_getscheduler": SimTypeFunction([SimTypeInt(signed=True, label="pid_t")], SimTypeInt(signed=True), arg_names=["pid"]),
        # int sched_setparam (pid_t PID, const struct sched_param *PARAM);
        "sched_setparam": SimTypeFunction([SimTypeInt(signed=True, label="pid_t"), SimTypePointer(SimStruct({}, name="sched_param", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["pid", "param"]),
        # int sched_getparam (pid_t PID, struct sched_param *PARAM);
        "sched_getparam": SimTypeFunction([SimTypeInt(signed=True, label="pid_t"), SimTypePointer(SimStruct({}, name="sched_param", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["pid", "param"]),
        # int sched_get_priority_min (int POLICY);
        "sched_get_priority_min": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["policy"]),
        # int sched_get_priority_max (int POLICY);
        "sched_get_priority_max": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["policy"]),
        # int sched_rr_get_interval (pid_t PID, struct timespec *INTERVAL);
        "sched_rr_get_interval": SimTypeFunction([SimTypeInt(signed=True, label="pid_t"), SimTypePointer(SimStruct({"tv_sec": SimTypeLong(signed=True, label="time_t"), "tv_nsec": SimTypeLong(signed=True)}, name="timespec", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["pid", "interval"]),
        # int sched_yield (void);
        "sched_yield": SimTypeFunction([], SimTypeInt(signed=True)),
        # int getpriority (int CLASS, int ID);
        "getpriority": SimTypeFunction([SimTypeInt(signed=True), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["class", "id"]),
        # int setpriority (int CLASS, int ID, int NICEVAL);
        "setpriority": SimTypeFunction([SimTypeInt(signed=True), SimTypeInt(signed=True), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["class", "id", "niceval"]),
        # int nice (int INCREMENT);
        "nice": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["increment"]),
        # int sched_getaffinity (pid_t PID, size_t CPUSETSIZE, cpu_set_t *CPUSET);
        "sched_getaffinity": None,
        # int sched_setaffinity (pid_t PID, size_t CPUSETSIZE, const cpu_set_t *CPUSET);
        "sched_setaffinity": None,
        # int getpagesize (void);
        "getpagesize": SimTypeFunction([], SimTypeInt(signed=True)),
        # long int get_phys_pages (void);
        "get_phys_pages": SimTypeFunction([], SimTypeLong(signed=True)),
        # long int get_avphys_pages (void);
        "get_avphys_pages": SimTypeFunction([], SimTypeLong(signed=True)),
        # int get_nprocs_conf (void);
        "get_nprocs_conf": SimTypeFunction([], SimTypeInt(signed=True)),
        # int get_nprocs (void);
        "get_nprocs": SimTypeFunction([], SimTypeInt(signed=True)),
        # int getloadavg (double LOADAVG[], int NELEM);
        "getloadavg": SimTypeFunction([SimTypeFixedSizeArray(SimTypeDouble(align_double=True), 0), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["loadavg", "nelem"]),
        # void longjmp (jmp_buf STATE, int VALUE);
        "longjmp": None,
        # int sigsetjmp (sigjmp_buf STATE, int SAVESIGS);
        "sigsetjmp": None,
        # void siglongjmp (sigjmp_buf STATE, int VALUE);
        "siglongjmp": None,
        # int getcontext (ucontext_t *UCP);
        "getcontext": None,
        # void makecontext (ucontext_t *UCP, void (*FUNC);
        "makecontext": None,
        # int setcontext (const ucontext_t *UCP);
        "setcontext": None,
        # int swapcontext (ucontext_t *restrict OUCP, const ucontext_t *restrict UCP);
        "swapcontext": None,
        # char * strsignal (int SIGNUM);
        "strsignal": SimTypeFunction([SimTypeInt(signed=True)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["signum"]),
        # void psignal (int SIGNUM, const char *MESSAGE);
        "psignal": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeChar(), offset=0)], SimTypeBottom(label="void"), arg_names=["signum", "message"]),
        # sighandler_t signal (int SIGNUM, sighandler_t ACTION);
        "signal": None,
        # sighandler_t sysv_signal (int SIGNUM, sighandler_t ACTION);
        "sysv_signal": None,
        # sighandler_t ssignal (int SIGNUM, sighandler_t ACTION);
        "ssignal": None,
        # int sigaction (int SIGNUM, const struct sigaction *restrict ACTION, struct sigaction *restrict OLD-ACTION);
        "sigaction": None,
        # int raise (int SIGNUM);
        "raise": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["signum"]),
        # int gsignal (int SIGNUM);
        "gsignal": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["signum"]),
        # int kill (pid_t PID, int SIGNUM);
        "kill": SimTypeFunction([SimTypeInt(signed=True, label="pid_t"), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["pid", "signum"]),
        # int killpg (int PGID, int SIGNUM);
        "killpg": SimTypeFunction([SimTypeInt(signed=True), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["pgid", "signum"]),
        # int sigemptyset (sigset_t *SET);
        "sigemptyset": SimTypeFunction([SimTypePointer(SimTypeInt(signed=True, label="sigset_t"), offset=0)], SimTypeInt(signed=True), arg_names=["set"]),
        # int sigfillset (sigset_t *SET);
        "sigfillset": SimTypeFunction([SimTypePointer(SimTypeInt(signed=True, label="sigset_t"), offset=0)], SimTypeInt(signed=True), arg_names=["set"]),
        # int sigaddset (sigset_t *SET, int SIGNUM);
        "sigaddset": SimTypeFunction([SimTypePointer(SimTypeInt(signed=True, label="sigset_t"), offset=0), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["set", "signum"]),
        # int sigdelset (sigset_t *SET, int SIGNUM);
        "sigdelset": SimTypeFunction([SimTypePointer(SimTypeInt(signed=True, label="sigset_t"), offset=0), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["set", "signum"]),
        # int sigismember (const sigset_t *SET, int SIGNUM);
        "sigismember": SimTypeFunction([SimTypePointer(SimTypeInt(signed=True, label="sigset_t"), offset=0), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["set", "signum"]),
        # int sigprocmask (int HOW, const sigset_t *restrict SET, sigset_t *restrict OLDSET);
        "sigprocmask": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeInt(signed=True, label="sigset_t"), offset=0), SimTypePointer(SimTypeInt(signed=True, label="sigset_t"), offset=0)], SimTypeInt(signed=True), arg_names=["how", "set", "oldset"]),
        # int sigpending (sigset_t *SET);
        "sigpending": SimTypeFunction([SimTypePointer(SimTypeInt(signed=True, label="sigset_t"), offset=0)], SimTypeInt(signed=True), arg_names=["set"]),
        # int pause (void);
        "pause": SimTypeFunction([], SimTypeInt(signed=True)),
        # int sigsuspend (const sigset_t *SET);
        "sigsuspend": SimTypeFunction([SimTypePointer(SimTypeInt(signed=True, label="sigset_t"), offset=0)], SimTypeInt(signed=True), arg_names=["set"]),
        # int sigaltstack (const stack_t *restrict STACK, stack_t *restrict OLDSTACK);
        "sigaltstack": None,
        # int sigstack (struct sigstack *STACK, struct sigstack *OLDSTACK);
        "sigstack": SimTypeFunction([SimTypePointer(SimStruct({}, name="sigstack", pack=False, align=None), offset=0), SimTypePointer(SimStruct({}, name="sigstack", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["stack", "oldstack"]),
        # int siginterrupt (int SIGNUM, int FAILFLAG);
        "siginterrupt": SimTypeFunction([SimTypeInt(signed=True), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["signum", "failflag"]),
        # int sigblock (int MASK);
        "sigblock": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["mask"]),
        # int sigsetmask (int MASK);
        "sigsetmask": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["mask"]),
        # int sigpause (int MASK);
        "sigpause": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["mask"]),
        # int getopt (int ARGC, char *const *ARGV, const char *OPTIONS);
        "getopt": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["argc", "argv", "options"]),
        # int getopt_long (int ARGC, char *const *ARGV, const char *SHORTOPTS, const struct option *LONGOPTS, int *INDEXPTR);
        "getopt_long": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimStruct({}, name="option", pack=False, align=None), offset=0), SimTypePointer(SimTypeInt(signed=True), offset=0)], SimTypeInt(signed=True), arg_names=["argc", "argv", "shortopts", "longopts", "indexptr"]),
        # int getopt_long_only (int ARGC, char *const *ARGV, const char *SHORTOPTS, const struct option *LONGOPTS, int *INDEXPTR);
        "getopt_long_only": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimStruct({}, name="option", pack=False, align=None), offset=0), SimTypePointer(SimTypeInt(signed=True), offset=0)], SimTypeInt(signed=True), arg_names=["argc", "argv", "shortopts", "longopts", "indexptr"]),
        # error_t argp_parse (const struct argp *ARGP, int ARGC, char **ARGV, unsigned FLAGS, int *ARG_INDEX, void *INPUT);
        "argp_parse": None,
        # void argp_usage (const struct argp_state *STATE);
        "argp_usage": SimTypeFunction([SimTypePointer(SimStruct({}, name="argp_state", pack=False, align=None), offset=0)], SimTypeBottom(label="void"), arg_names=["state"]),
        # void argp_error (const struct argp_state *STATE, const char *FMT, ...);
        "argp_error": SimTypeFunction([SimTypePointer(SimStruct({}, name="argp_state", pack=False, align=None), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypeBottom(label="void"), arg_names=["state", "fmt"], variadic=True),
        # void argp_failure (const struct argp_state *STATE, int STATUS, int ERRNUM, const char *FMT, ...);
        "argp_failure": SimTypeFunction([SimTypePointer(SimStruct({}, name="argp_state", pack=False, align=None), offset=0), SimTypeInt(signed=True), SimTypeInt(signed=True), SimTypePointer(SimTypeChar(), offset=0)], SimTypeBottom(label="void"), arg_names=["state", "status", "errnum", "fmt"], variadic=True),
        # void argp_state_help (const struct argp_state *STATE, FILE *STREAM, unsigned FLAGS);
        "argp_state_help": None,
        # void argp_help (const struct argp *ARGP, FILE *STREAM, unsigned FLAGS, char *NAME);
        "argp_help": None,
        # int getsubopt (char **OPTIONP, char *const *TOKENS, char **VALUEP);
        "getsubopt": SimTypeFunction([SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0), SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0), SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0)], SimTypeInt(signed=True), arg_names=["optionp", "tokens", "valuep"]),
        # char * getenv (const char *NAME);
        "getenv": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["name"]),
        # char * secure_getenv (const char *NAME);
        "secure_getenv": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["name"]),
        # int putenv (char *STRING);
        "putenv": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["string"]),
        # int setenv (const char *NAME, const char *VALUE, int REPLACE);
        "setenv": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["name", "value", "replace"]),
        # int unsetenv (const char *NAME);
        "unsetenv": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["name"]),
        # int clearenv (void);
        "clearenv": SimTypeFunction([], SimTypeInt(signed=True)),
        # unsigned long int getauxval (unsigned long int TYPE);
        "getauxval": SimTypeFunction([SimTypeLong(signed=False)], SimTypeLong(signed=False), arg_names=["type"]),
        # long int syscall (long int SYSNO, ...);
        "syscall": SimTypeFunction([SimTypeLong(signed=True)], SimTypeLong(signed=True), arg_names=["sysno"], variadic=True),
        # void exit (int STATUS);
        "exit": SimTypeFunction([SimTypeInt(signed=True)], SimTypeBottom(label="void"), arg_names=["status"]),
        # int atexit (void (*FUNCTION));
        "atexit": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0)], SimTypeInt(signed=True), arg_names=["function"]),
        # int on_exit (void (*FUNCTION));
        "on_exit": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0)], SimTypeInt(signed=True), arg_names=["function"]),
        # void abort (void);
        "abort": SimTypeFunction([], SimTypeBottom(label="void")),
        # void _exit (int STATUS);
        "_exit": SimTypeFunction([SimTypeInt(signed=True)], SimTypeBottom(label="void"), arg_names=["status"]),
        # void _Exit (int STATUS);
        "_Exit": SimTypeFunction([SimTypeInt(signed=True)], SimTypeBottom(label="void"), arg_names=["status"]),
        # int system (const char *COMMAND);
        "system": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["command"]),
        # pid_t getpid (void);
        "getpid": SimTypeFunction([], SimTypeInt(signed=True, label="pid_t")),
        # pid_t getppid (void);
        "getppid": SimTypeFunction([], SimTypeInt(signed=True, label="pid_t")),
        # pid_t fork (void);
        "fork": SimTypeFunction([], SimTypeInt(signed=True, label="pid_t")),
        # pid_t vfork (void);
        "vfork": SimTypeFunction([], SimTypeInt(signed=True, label="pid_t")),
        # int execv (const char *FILENAME, char *const ARGV[]);
        "execv": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeFixedSizeArray(SimTypePointer(SimTypeChar(), offset=0), 0)], SimTypeInt(signed=True), arg_names=["filename", "argv"]),
        # int execl (const char *FILENAME, const char *ARG0, ...);
        "execl": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["filename", "arg0"], variadic=True),
        # int execve (const char *FILENAME, char *const ARGV[], char *const ENV[]);
        "execve": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeFixedSizeArray(SimTypePointer(SimTypeChar(), offset=0), 0), SimTypeFixedSizeArray(SimTypePointer(SimTypeChar(), offset=0), 0)], SimTypeInt(signed=True), arg_names=["filename", "argv", "env"]),
        # int execle (const char *FILENAME, const char *ARG0, ..., char *const ENV[]);
        "execle": None,
        # int execvp (const char *FILENAME, char *const ARGV[]);
        "execvp": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeFixedSizeArray(SimTypePointer(SimTypeChar(), offset=0), 0)], SimTypeInt(signed=True), arg_names=["filename", "argv"]),
        # int execvpe (const char *FILENAME, char *const ARGV[], char *const ENV[]);,
        "execvpe": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeFixedSizeArray(SimTypePointer(SimTypeChar(), offset=0), 0), SimTypeFixedSizeArray(SimTypePointer(SimTypeChar(), offset=0), 0)], SimTypeInt(signed=True), arg_names=["filename", "argv", "env"]),
        # int execlp (const char *FILENAME, const char *ARG0, ...);
        "execlp": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["filename", "arg0"], variadic=True),
        # pid_t waitpid (pid_t PID, int *STATUS_PTR, int OPTIONS);
        "waitpid": SimTypeFunction([SimTypeInt(signed=True, label="pid_t"), SimTypePointer(SimTypeInt(signed=True), offset=0), SimTypeInt(signed=True)], SimTypeInt(signed=True, label="pid_t"), arg_names=["pid", "status_ptr", "options"]),
        # pid_t wait (int *STATUS_PTR);
        "wait": SimTypeFunction([SimTypePointer(SimTypeInt(signed=True), offset=0)], SimTypeInt(signed=True, label="pid_t"), arg_names=["status_ptr"]),
        # pid_t wait4 (pid_t PID, int *STATUS_PTR, int OPTIONS, struct rusage *USAGE);
        "wait4": SimTypeFunction([SimTypeInt(signed=True, label="pid_t"), SimTypePointer(SimTypeInt(signed=True), offset=0), SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="rusage", pack=False, align=None), offset=0)], SimTypeInt(signed=True, label="pid_t"), arg_names=["pid", "status_ptr", "options", "usage"]),
        # pid_t wait3 (int *STATUS_PTR, int OPTIONS, struct rusage *USAGE);
        "wait3": SimTypeFunction([SimTypePointer(SimTypeInt(signed=True), offset=0), SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="rusage", pack=False, align=None), offset=0)], SimTypeInt(signed=True, label="pid_t"), arg_names=["status_ptr", "options", "usage"]),
        # int semctl (int SEMID, int SEMNUM, int CMD);
        "semctl": SimTypeFunction([SimTypeInt(signed=True), SimTypeInt(signed=True), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["semid", "semnum", "cmd"]),
        # int semget (key_t KEY, int NSEMS, int SEMFLG);
        "semget": None,
        # int semop (int SEMID, struct sembuf *SOPS, size_t NSOPS);
        "semop": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="sembuf", pack=False, align=None), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["semid", "sops", "nsops"]),
        # int semtimedop (int SEMID, struct sembuf *SOPS, size_t NSOPS, const struct timespec *TIMEOUT);
        "semtimedop": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="sembuf", pack=False, align=None), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimStruct({"tv_sec": SimTypeLong(signed=True, label="time_t"), "tv_nsec": SimTypeLong(signed=True)}, name="timespec", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["semid", "sops", "nsops", "timeout"]),
        # int sem_init (sem_t *SEM, int PSHARED, unsigned int VALUE);
        "sem_init": SimTypeFunction([SimTypePointer(SimTypeInt(signed=False, label="sem_t"), offset=0), SimTypeInt(signed=True), SimTypeInt(signed=False)], SimTypeInt(signed=True), arg_names=["sem", "pshared", "value"]),
        # int sem_destroy (sem_t *SEM);
        "sem_destroy": SimTypeFunction([SimTypePointer(SimTypeInt(signed=False, label="sem_t"), offset=0)], SimTypeInt(signed=True), arg_names=["sem"]),
        # sem_t *sem_open (const char *NAME, int OFLAG, ...);
        "sem_open": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=True)], SimTypePointer(SimTypeInt(signed=False, label="sem_t"), offset=0), arg_names=["name", "oflag"], variadic=True),
        # int sem_close (sem_t *SEM);
        "sem_close": SimTypeFunction([SimTypePointer(SimTypeInt(signed=False, label="sem_t"), offset=0)], SimTypeInt(signed=True), arg_names=["sem"]),
        # int sem_unlink (const char *NAME);
        "sem_unlink": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["name"]),
        # int sem_wait (sem_t *SEM);
        "sem_wait": SimTypeFunction([SimTypePointer(SimTypeInt(signed=False, label="sem_t"), offset=0)], SimTypeInt(signed=True), arg_names=["sem"]),
        # int sem_timedwait (sem_t *SEM, const struct timespec *ABSTIME);
        "sem_timedwait": SimTypeFunction([SimTypePointer(SimTypeInt(signed=False, label="sem_t"), offset=0), SimTypePointer(SimStruct({"tv_sec": SimTypeLong(signed=True, label="time_t"), "tv_nsec": SimTypeLong(signed=True)}, name="timespec", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["sem", "abstime"]),
        # int sem_trywait (sem_t *SEM);
        "sem_trywait": SimTypeFunction([SimTypePointer(SimTypeInt(signed=False, label="sem_t"), offset=0)], SimTypeInt(signed=True), arg_names=["sem"]),
        # int sem_post (sem_t *SEM);
        "sem_post": SimTypeFunction([SimTypePointer(SimTypeInt(signed=False, label="sem_t"), offset=0)], SimTypeInt(signed=True), arg_names=["sem"]),
        # int sem_getvalue (sem_t *SEM, int *SVAL);
        "sem_getvalue": SimTypeFunction([SimTypePointer(SimTypeInt(signed=False, label="sem_t"), offset=0), SimTypePointer(SimTypeInt(signed=True), offset=0)], SimTypeInt(signed=True), arg_names=["sem", "sval"]),
        # char * ctermid (char *STRING);
        "ctermid": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["string"]),
        # pid_t setsid (void);
        "setsid": SimTypeFunction([], SimTypeInt(signed=True, label="pid_t")),
        # pid_t getsid (pid_t PID);
        "getsid": SimTypeFunction([SimTypeInt(signed=True, label="pid_t")], SimTypeInt(signed=True, label="pid_t"), arg_names=["pid"]),
        # pid_t getpgrp (void);
        "getpgrp": SimTypeFunction([], SimTypeInt(signed=True, label="pid_t")),
        # int getpgid (pid_t PID);
        "getpgid": SimTypeFunction([SimTypeInt(signed=True, label="pid_t")], SimTypeInt(signed=True), arg_names=["pid"]),
        # int setpgid (pid_t PID, pid_t PGID);
        "setpgid": SimTypeFunction([SimTypeInt(signed=True, label="pid_t"), SimTypeInt(signed=True, label="pid_t")], SimTypeInt(signed=True), arg_names=["pid", "pgid"]),
        # int setpgrp (pid_t PID, pid_t PGID);
        "setpgrp": SimTypeFunction([SimTypeInt(signed=True, label="pid_t"), SimTypeInt(signed=True, label="pid_t")], SimTypeInt(signed=True), arg_names=["pid", "pgid"]),
        # pid_t tcgetpgrp (int FILEDES);
        "tcgetpgrp": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True, label="pid_t"), arg_names=["filedes"]),
        # int tcsetpgrp (int FILEDES, pid_t PGID);
        "tcsetpgrp": SimTypeFunction([SimTypeInt(signed=True), SimTypeInt(signed=True, label="pid_t")], SimTypeInt(signed=True), arg_names=["filedes", "pgid"]),
        # pid_t tcgetsid (int FILDES);
        "tcgetsid": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True, label="pid_t"), arg_names=["fildes"]),
        # uid_t getuid (void);
        "getuid": SimTypeFunction([], SimTypeInt(signed=False, label="uid_t")),
        # gid_t getgid (void);
        "getgid": SimTypeFunction([], SimTypeInt(signed=False, label="gid_t")),
        # uid_t geteuid (void);
        "geteuid": SimTypeFunction([], SimTypeInt(signed=False, label="uid_t")),
        # gid_t getegid (void);
        "getegid": SimTypeFunction([], SimTypeInt(signed=False, label="gid_t")),
        # int getgroups (int COUNT, gid_t *GROUPS);
        "getgroups": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeInt(signed=False, label="gid_t"), offset=0)], SimTypeInt(signed=True), arg_names=["count", "groups"]),
        # int seteuid (uid_t NEWEUID);
        "seteuid": SimTypeFunction([SimTypeInt(signed=False, label="uid_t")], SimTypeInt(signed=True), arg_names=["neweuid"]),
        # int setuid (uid_t NEWUID);
        "setuid": SimTypeFunction([SimTypeInt(signed=False, label="uid_t")], SimTypeInt(signed=True), arg_names=["newuid"]),
        # int setreuid (uid_t RUID, uid_t EUID);
        "setreuid": SimTypeFunction([SimTypeInt(signed=False, label="uid_t"), SimTypeInt(signed=False, label="uid_t")], SimTypeInt(signed=True), arg_names=["ruid", "euid"]),
        # int setegid (gid_t NEWGID);
        "setegid": SimTypeFunction([SimTypeInt(signed=False, label="gid_t")], SimTypeInt(signed=True), arg_names=["newgid"]),
        # int setgid (gid_t NEWGID);
        "setgid": SimTypeFunction([SimTypeInt(signed=False, label="gid_t")], SimTypeInt(signed=True), arg_names=["newgid"]),
        # int setregid (gid_t RGID, gid_t EGID);
        "setregid": SimTypeFunction([SimTypeInt(signed=False, label="gid_t"), SimTypeInt(signed=False, label="gid_t")], SimTypeInt(signed=True), arg_names=["rgid", "egid"]),
        # int setgroups (size_t COUNT, const gid_t *GROUPS);
        "setgroups": SimTypeFunction([SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypeInt(signed=False, label="gid_t"), offset=0)], SimTypeInt(signed=True), arg_names=["count", "groups"]),
        # int initgroups (const char *USER, gid_t GROUP);
        "initgroups": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=False, label="gid_t")], SimTypeInt(signed=True), arg_names=["user", "group"]),
        # int getgrouplist (const char *USER, gid_t GROUP, gid_t *GROUPS, int *NGROUPS);
        "getgrouplist": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=False, label="gid_t"), SimTypePointer(SimTypeInt(signed=False, label="gid_t"), offset=0), SimTypePointer(SimTypeInt(signed=True), offset=0)], SimTypeInt(signed=True), arg_names=["user", "group", "groups", "ngroups"]),
        # char * getlogin (void);
        "getlogin": SimTypeFunction([], SimTypePointer(SimTypeChar(), offset=0)),
        # char * cuserid (char *STRING);
        "cuserid": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["string"]),
        # void setutent (void);
        "setutent": SimTypeFunction([], SimTypeBottom(label="void")),
        # struct utmp * getutent (void);
        "getutent": SimTypeFunction([], SimTypePointer(SimStruct({}, name="utmp", pack=False, align=None), offset=0)),
        # void endutent (void);
        "endutent": SimTypeFunction([], SimTypeBottom(label="void")),
        # struct utmp * getutid (const struct utmp *ID);
        "getutid": SimTypeFunction([SimTypePointer(SimStruct({}, name="utmp", pack=False, align=None), offset=0)], SimTypePointer(SimStruct({}, name="utmp", pack=False, align=None), offset=0), arg_names=["id"]),
        # struct utmp * getutline (const struct utmp *LINE);
        "getutline": SimTypeFunction([SimTypePointer(SimStruct({}, name="utmp", pack=False, align=None), offset=0)], SimTypePointer(SimStruct({}, name="utmp", pack=False, align=None), offset=0), arg_names=["line"]),
        # struct utmp * pututline (const struct utmp *UTMP);
        "pututline": SimTypeFunction([SimTypePointer(SimStruct({}, name="utmp", pack=False, align=None), offset=0)], SimTypePointer(SimStruct({}, name="utmp", pack=False, align=None), offset=0), arg_names=["utmp"]),
        # int getutent_r (struct utmp *BUFFER, struct utmp **RESULT);
        "getutent_r": SimTypeFunction([SimTypePointer(SimStruct({}, name="utmp", pack=False, align=None), offset=0), SimTypePointer(SimTypePointer(SimStruct({}, name="utmp", pack=False, align=None), offset=0), offset=0)], SimTypeInt(signed=True), arg_names=["buffer", "result"]),
        # int getutid_r (const struct utmp *ID, struct utmp *BUFFER, struct utmp **RESULT);
        "getutid_r": SimTypeFunction([SimTypePointer(SimStruct({}, name="utmp", pack=False, align=None), offset=0), SimTypePointer(SimStruct({}, name="utmp", pack=False, align=None), offset=0), SimTypePointer(SimTypePointer(SimStruct({}, name="utmp", pack=False, align=None), offset=0), offset=0)], SimTypeInt(signed=True), arg_names=["id", "buffer", "result"]),
        # int getutline_r (const struct utmp *LINE, struct utmp *BUFFER, struct utmp **RESULT);
        "getutline_r": SimTypeFunction([SimTypePointer(SimStruct({}, name="utmp", pack=False, align=None), offset=0), SimTypePointer(SimStruct({}, name="utmp", pack=False, align=None), offset=0), SimTypePointer(SimTypePointer(SimStruct({}, name="utmp", pack=False, align=None), offset=0), offset=0)], SimTypeInt(signed=True), arg_names=["line", "buffer", "result"]),
        # int utmpname (const char *FILE);
        "utmpname": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["file"]),
        # void updwtmp (const char *WTMP_FILE, const struct utmp *UTMP);
        "updwtmp": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimStruct({}, name="utmp", pack=False, align=None), offset=0)], SimTypeBottom(label="void"), arg_names=["wtmp_file", "utmp"]),
        # void setutxent (void);
        "setutxent": SimTypeFunction([], SimTypeBottom(label="void")),
        # struct utmpx * getutxent (void);
        "getutxent": SimTypeFunction([], SimTypePointer(SimStruct({}, name="utmpx", pack=False, align=None), offset=0)),
        # void endutxent (void);
        "endutxent": SimTypeFunction([], SimTypeBottom(label="void")),
        # struct utmpx * getutxid (const struct utmpx *ID);
        "getutxid": SimTypeFunction([SimTypePointer(SimStruct({}, name="utmpx", pack=False, align=None), offset=0)], SimTypePointer(SimStruct({}, name="utmpx", pack=False, align=None), offset=0), arg_names=["id"]),
        # struct utmpx * getutxline (const struct utmpx *LINE);
        "getutxline": SimTypeFunction([SimTypePointer(SimStruct({}, name="utmpx", pack=False, align=None), offset=0)], SimTypePointer(SimStruct({}, name="utmpx", pack=False, align=None), offset=0), arg_names=["line"]),
        # struct utmpx * pututxline (const struct utmpx *UTMP);
        "pututxline": SimTypeFunction([SimTypePointer(SimStruct({}, name="utmpx", pack=False, align=None), offset=0)], SimTypePointer(SimStruct({}, name="utmpx", pack=False, align=None), offset=0), arg_names=["utmp"]),
        # int utmpxname (const char *FILE);
        "utmpxname": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["file"]),
        # int getutmp (const struct utmpx *UTMPX, struct utmp *UTMP);
        "getutmp": SimTypeFunction([SimTypePointer(SimStruct({}, name="utmpx", pack=False, align=None), offset=0), SimTypePointer(SimStruct({}, name="utmp", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["utmpx", "utmp"]),
        # int getutmpx (const struct utmp *UTMP, struct utmpx *UTMPX);
        "getutmpx": SimTypeFunction([SimTypePointer(SimStruct({}, name="utmp", pack=False, align=None), offset=0), SimTypePointer(SimStruct({}, name="utmpx", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["utmp", "utmpx"]),
        # int login_tty (int FILEDES);
        "login_tty": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["filedes"]),
        # void login (const struct utmp *ENTRY);
        "login": SimTypeFunction([SimTypePointer(SimStruct({}, name="utmp", pack=False, align=None), offset=0)], SimTypeBottom(label="void"), arg_names=["entry"]),
        # int logout (const char *UT_LINE);
        "logout": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["ut_line"]),
        # void logwtmp (const char *UT_LINE, const char *UT_NAME, const char *UT_HOST);
        "logwtmp": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypeBottom(label="void"), arg_names=["ut_line", "ut_name", "ut_host"]),
        # struct passwd * getpwuid (uid_t UID);
        "getpwuid": SimTypeFunction([SimTypeInt(signed=False, label="uid_t")], SimTypePointer(SimStruct({}, name="passwd", pack=False, align=None), offset=0), arg_names=["uid"]),
        # int getpwuid_r (uid_t UID, struct passwd *RESULT_BUF, char *BUFFER, size_t BUFLEN, struct passwd **RESULT);
        "getpwuid_r": SimTypeFunction([SimTypeInt(signed=False, label="uid_t"), SimTypePointer(SimStruct({}, name="passwd", pack=False, align=None), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypePointer(SimStruct({}, name="passwd", pack=False, align=None), offset=0), offset=0)], SimTypeInt(signed=True), arg_names=["uid", "result_buf", "buffer", "buflen", "result"]),
        # struct passwd * getpwnam (const char *NAME);
        "getpwnam": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimStruct({}, name="passwd", pack=False, align=None), offset=0), arg_names=["name"]),
        # int getpwnam_r (const char *NAME, struct passwd *RESULT_BUF, char *BUFFER, size_t BUFLEN, struct passwd **RESULT);
        "getpwnam_r": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimStruct({}, name="passwd", pack=False, align=None), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypePointer(SimStruct({}, name="passwd", pack=False, align=None), offset=0), offset=0)], SimTypeInt(signed=True), arg_names=["name", "result_buf", "buffer", "buflen", "result"]),
        # struct passwd * fgetpwent (FILE *STREAM);
        "fgetpwent": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypePointer(SimStruct({}, name="passwd", pack=False, align=None), offset=0), arg_names=["stream"]),
        # int fgetpwent_r (FILE *STREAM, struct passwd *RESULT_BUF, char *BUFFER, size_t BUFLEN, struct passwd **RESULT);
        "fgetpwent_r": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), SimTypePointer(SimStruct({}, name="passwd", pack=False, align=None), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypePointer(SimStruct({}, name="passwd", pack=False, align=None), offset=0), offset=0)], SimTypeInt(signed=True), arg_names=["stream", "result_buf", "buffer", "buflen", "result"]),
        # void setpwent (void);
        "setpwent": SimTypeFunction([], SimTypeBottom(label="void")),
        # struct passwd * getpwent (void);
        "getpwent": SimTypeFunction([], SimTypePointer(SimStruct({}, name="passwd", pack=False, align=None), offset=0)),
        # int getpwent_r (struct passwd *RESULT_BUF, char *BUFFER, size_t BUFLEN, struct passwd **RESULT);
        "getpwent_r": SimTypeFunction([SimTypePointer(SimStruct({}, name="passwd", pack=False, align=None), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypePointer(SimStruct({}, name="passwd", pack=False, align=None), offset=0), offset=0)], SimTypeInt(signed=True), arg_names=["result_buf", "buffer", "buflen", "result"]),
        # void endpwent (void);
        "endpwent": SimTypeFunction([], SimTypeBottom(label="void")),
        # int putpwent (const struct passwd *P, FILE *STREAM);
        "putpwent": SimTypeFunction([SimTypePointer(SimStruct({}, name="passwd", pack=False, align=None), offset=0), SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["p", "stream"]),
        # struct group * getgrgid (gid_t GID);
        "getgrgid": SimTypeFunction([SimTypeInt(signed=False, label="gid_t")], SimTypePointer(SimStruct({}, name="group", pack=False, align=None), offset=0), arg_names=["gid"]),
        # int getgrgid_r (gid_t GID, struct group *RESULT_BUF, char *BUFFER, size_t BUFLEN, struct group **RESULT);
        "getgrgid_r": SimTypeFunction([SimTypeInt(signed=False, label="gid_t"), SimTypePointer(SimStruct({}, name="group", pack=False, align=None), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypePointer(SimStruct({}, name="group", pack=False, align=None), offset=0), offset=0)], SimTypeInt(signed=True), arg_names=["gid", "result_buf", "buffer", "buflen", "result"]),
        # struct group * getgrnam (const char *NAME);
        "getgrnam": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimStruct({}, name="group", pack=False, align=None), offset=0), arg_names=["name"]),
        # int getgrnam_r (const char *NAME, struct group *RESULT_BUF, char *BUFFER, size_t BUFLEN, struct group **RESULT);
        "getgrnam_r": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimStruct({}, name="group", pack=False, align=None), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypePointer(SimStruct({}, name="group", pack=False, align=None), offset=0), offset=0)], SimTypeInt(signed=True), arg_names=["name", "result_buf", "buffer", "buflen", "result"]),
        # struct group * fgetgrent (FILE *STREAM);
        "fgetgrent": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypePointer(SimStruct({}, name="group", pack=False, align=None), offset=0), arg_names=["stream"]),
        # int fgetgrent_r (FILE *STREAM, struct group *RESULT_BUF, char *BUFFER, size_t BUFLEN, struct group **RESULT);
        "fgetgrent_r": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), SimTypePointer(SimStruct({}, name="group", pack=False, align=None), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypePointer(SimStruct({}, name="group", pack=False, align=None), offset=0), offset=0)], SimTypeInt(signed=True), arg_names=["stream", "result_buf", "buffer", "buflen", "result"]),
        # void setgrent (void);
        "setgrent": SimTypeFunction([], SimTypeBottom(label="void")),
        # struct group * getgrent (void);
        "getgrent": SimTypeFunction([], SimTypePointer(SimStruct({}, name="group", pack=False, align=None), offset=0)),
        # int getgrent_r (struct group *RESULT_BUF, char *BUFFER, size_t BUFLEN, struct group **RESULT);
        "getgrent_r": SimTypeFunction([SimTypePointer(SimStruct({}, name="group", pack=False, align=None), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypePointer(SimTypePointer(SimStruct({}, name="group", pack=False, align=None), offset=0), offset=0)], SimTypeInt(signed=True), arg_names=["result_buf", "buffer", "buflen", "result"]),
        # void endgrent (void);
        "endgrent": SimTypeFunction([], SimTypeBottom(label="void")),
        # int setnetgrent (const char *NETGROUP);
        "setnetgrent": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["netgroup"]),
        # int getnetgrent (char **HOSTP, char **USERP, char **DOMAINP);
        "getnetgrent": SimTypeFunction([SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0), SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0), SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0)], SimTypeInt(signed=True), arg_names=["hostp", "userp", "domainp"]),
        # int getnetgrent_r (char **HOSTP, char **USERP, char **DOMAINP, char *BUFFER, size_t BUFLEN);
        "getnetgrent_r": SimTypeFunction([SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0), SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0), SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["hostp", "userp", "domainp", "buffer", "buflen"]),
        # void endnetgrent (void);
        "endnetgrent": SimTypeFunction([], SimTypeBottom(label="void")),
        # int innetgr (const char *NETGROUP, const char *HOST, const char *USER, const char *DOMAIN);
        "innetgr": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["netgroup", "host", "user", "domain"]),
        # int gethostname (char *NAME, size_t SIZE);
        "gethostname": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["name", "size"]),
        # int sethostname (const char *NAME, size_t LENGTH);
        "sethostname": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["name", "length"]),
        # int getdomainnname (char *NAME, size_t LENGTH);
        "getdomainnname": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["name", "length"]),
        # int setdomainname (const char *NAME, size_t LENGTH);
        "setdomainname": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["name", "length"]),
        # long int gethostid (void);
        "gethostid": SimTypeFunction([], SimTypeLong(signed=True)),
        # int sethostid (long int ID);
        "sethostid": SimTypeFunction([SimTypeLong(signed=True)], SimTypeInt(signed=True), arg_names=["id"]),
        # int uname (struct utsname *INFO);
        "uname": SimTypeFunction([SimTypePointer(SimStruct({}, name="utsname", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["info"]),
        # int setfsent (void);
        "setfsent": SimTypeFunction([], SimTypeInt(signed=True)),
        # void endfsent (void);
        "endfsent": SimTypeFunction([], SimTypeBottom(label="void")),
        # struct fstab * getfsent (void);
        "getfsent": SimTypeFunction([], SimTypePointer(SimStruct({}, name="fstab", pack=False, align=None), offset=0)),
        # struct fstab * getfsspec (const char *NAME);
        "getfsspec": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimStruct({}, name="fstab", pack=False, align=None), offset=0), arg_names=["name"]),
        # struct fstab * getfsfile (const char *NAME);
        "getfsfile": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimStruct({}, name="fstab", pack=False, align=None), offset=0), arg_names=["name"]),
        # FILE * setmntent (const char *FILE, const char *MODE);
        "setmntent": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), arg_names=["file", "mode"]),
        # int endmntent (FILE *STREAM);
        "endmntent": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["stream"]),
        # struct mntent * getmntent (FILE *STREAM);
        "getmntent": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0)], SimTypePointer(SimStruct({}, name="mntent", pack=False, align=None), offset=0), arg_names=["stream"]),
        # struct mntent * getmntent_r (FILE *STREAM, struct mntent *RESULT, char *BUFFER, int BUFSIZE);
        "getmntent_r": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), SimTypePointer(SimStruct({}, name="mntent", pack=False, align=None), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=True)], SimTypePointer(SimStruct({}, name="mntent", pack=False, align=None), offset=0), arg_names=["stream", "result", "buffer", "bufsize"]),
        # int addmntent (FILE *STREAM, const struct mntent *MNT);
        "addmntent": SimTypeFunction([SimTypePointer(SimStruct({}, name="FILE_t", pack=False, align=None), offset=0), SimTypePointer(SimStruct({}, name="mntent", pack=False, align=None), offset=0)], SimTypeInt(signed=True), arg_names=["stream", "mnt"]),
        # char * hasmntopt (const struct mntent *MNT, const char *OPT);
        "hasmntopt": SimTypeFunction([SimTypePointer(SimStruct({}, name="mntent", pack=False, align=None), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["mnt", "opt"]),
        # int mount (const char *SPECIAL_FILE, const char *DIR, const char *FSTYPE, unsigned long int OPTIONS, const void *DATA);
        "mount": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False), SimTypePointer(SimTypeBottom(label="void"), offset=0)], SimTypeInt(signed=True), arg_names=["special_file", "dir", "fstype", "options", "data"]),
        # int umount2 (const char *FILE, int FLAGS);
        "umount2": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["file", "flags"]),
        # int umount (const char *FILE);
        "umount": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["file"]),
        # int sysctl (int *NAMES, int NLEN, void *OLDVAL, size_t *OLDLENP, void *NEWVAL, size_t NEWLEN);
        "sysctl": SimTypeFunction([SimTypePointer(SimTypeInt(signed=True), offset=0), SimTypeInt(signed=True), SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypePointer(SimTypeLong(signed=False, label="size_t"), offset=0), SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["names", "nlen", "oldval", "oldlenp", "newval", "newlen"]),
        # long int sysconf (int PARAMETER);
        "sysconf": SimTypeFunction([SimTypeInt(signed=True)], SimTypeLong(signed=True), arg_names=["parameter"]),
        # long int pathconf (const char *FILENAME, int PARAMETER);
        "pathconf": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=True)], SimTypeLong(signed=True), arg_names=["filename", "parameter"]),
        # long int fpathconf (int FILEDES, int PARAMETER);
        "fpathconf": SimTypeFunction([SimTypeInt(signed=True), SimTypeInt(signed=True)], SimTypeLong(signed=True), arg_names=["filedes", "parameter"]),
        # size_t confstr (int PARAMETER, char *BUF, size_t LEN);
        "confstr": SimTypeFunction([SimTypeInt(signed=True), SimTypePointer(SimTypeChar(), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeLong(signed=False, label="size_t"), arg_names=["parameter", "buf", "len"]),
        # char * getpass (const char *PROMPT);
        "getpass": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["prompt"]),
        # char * crypt (const char *KEY, const char *SALT);
        "crypt": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["key", "salt"]),
        # char * crypt_r (const char *KEY, const char *SALT, struct crypt_data * DATA);
        "crypt_r": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimStruct({}, name="crypt_data", pack=False, align=None), offset=0)], SimTypePointer(SimTypeChar(), offset=0), arg_names=["key", "salt", "data"]),
        # void setkey (const char *KEY);
        "setkey": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeBottom(label="void"), arg_names=["key"]),
        # void encrypt (char *BLOCK, int EDFLAG);
        "encrypt": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=True)], SimTypeBottom(label="void"), arg_names=["block", "edflag"]),
        # void setkey_r (const char *KEY, struct crypt_data * DATA);
        "setkey_r": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimStruct({}, name="crypt_data", pack=False, align=None), offset=0)], SimTypeBottom(label="void"), arg_names=["key", "data"]),
        # void encrypt_r (char *BLOCK, int EDFLAG, struct crypt_data * DATA);
        "encrypt_r": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=True), SimTypePointer(SimStruct({}, name="crypt_data", pack=False, align=None), offset=0)], SimTypeBottom(label="void"), arg_names=["block", "edflag", "data"]),
        # int ecb_crypt (char *KEY, char *BLOCKS, unsigned int LEN, unsigned int MODE);
        "ecb_crypt": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=False), SimTypeInt(signed=False)], SimTypeInt(signed=True), arg_names=["key", "blocks", "len", "mode"]),
        # int DES_FAILED (int ERR);
        "DES_FAILED": SimTypeFunction([SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["err"]),
        # int cbc_crypt (char *KEY, char *BLOCKS, unsigned int LEN, unsigned int MODE, char *IVEC);
        "cbc_crypt": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0), SimTypePointer(SimTypeChar(), offset=0), SimTypeInt(signed=False), SimTypeInt(signed=False), SimTypePointer(SimTypeChar(), offset=0)], SimTypeInt(signed=True), arg_names=["key", "blocks", "len", "mode", "ivec"]),
        # void des_setparity (char *KEY);
        "des_setparity": SimTypeFunction([SimTypePointer(SimTypeChar(), offset=0)], SimTypeBottom(label="void"), arg_names=["key"]),
        # int getentropy (void *BUFFER, size_t LENGTH);
        "getentropy": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t")], SimTypeInt(signed=True), arg_names=["buffer", "length"]),
        # ssize_t getrandom (void *BUFFER, size_t LENGTH, unsigned int FLAGS);
        "getrandom": SimTypeFunction([SimTypePointer(SimTypeBottom(label="void"), offset=0), SimTypeLong(signed=False, label="size_t"), SimTypeInt(signed=False)], SimTypeLong(signed=True, label="ssize_t"), arg_names=["buffer", "length", "flags"]),
        # int backtrace (void **BUFFER, int SIZE);
        "backtrace": SimTypeFunction([SimTypePointer(SimTypePointer(SimTypeBottom(label="void"), offset=0), offset=0), SimTypeInt(signed=True)], SimTypeInt(signed=True), arg_names=["buffer", "size"]),
        # char ** backtrace_symbols (void *const *BUFFER, int SIZE);
        "backtrace_symbols": SimTypeFunction([SimTypePointer(SimTypePointer(SimTypeBottom(label="void"), offset=0), offset=0), SimTypeInt(signed=True)], SimTypePointer(SimTypePointer(SimTypeChar(), offset=0), offset=0), arg_names=["buffer", "size"]),
        # void backtrace_symbols_fd (void *const *BUFFER, int SIZE, int FD);
        "backtrace_symbols_fd": SimTypeFunction([SimTypePointer(SimTypePointer(SimTypeBottom(label="void"), offset=0), offset=0), SimTypeInt(signed=True), SimTypeInt(signed=True)], SimTypeBottom(label="void"), arg_names=["buffer", "size", "fd"]),
        # int pthread_key_create (pthread_key_t *KEY, void (*DESTRUCTOR);
        "pthread_key_create": None,
        # int pthread_key_delete (pthread_key_t KEY);
        "pthread_key_delete": SimTypeFunction([SimTypeInt(signed=False, label="pthread_key_t")], SimTypeInt(signed=True), arg_names=["key"]),
        # void *pthread_getspecific (pthread_key_t KEY);
        "pthread_getspecific": SimTypeFunction([SimTypeInt(signed=False, label="pthread_key_t")], SimTypePointer(SimTypeBottom(label="void"), offset=0), arg_names=["key"]),
        # int pthread_setspecific (pthread_key_t KEY, const void *VALUE);
        "pthread_setspecific": SimTypeFunction([SimTypeInt(signed=False, label="pthread_key_t"), SimTypePointer(SimTypeBottom(label="void"), offset=0)], SimTypeInt(signed=True), arg_names=["key", "value"]),
        # int pthread_getattr_default_np (pthread_attr_t *ATTR);
        "pthread_getattr_default_np": None,
        # int pthread_setattr_default_np (pthread_attr_t *ATTR);
        "pthread_setattr_default_np": None,
        # uint64_t __ppc_get_timebase (void);
        "__ppc_get_timebase": SimTypeFunction([], SimTypeLongLong(signed=False, label="uint64_t")),
        # uint64_t __ppc_get_timebase_freq (void);
        "__ppc_get_timebase_freq": SimTypeFunction([], SimTypeLongLong(signed=False, label="uint64_t")),
        # void __ppc_yield (void);
        "__ppc_yield": SimTypeFunction([], SimTypeBottom(label="void")),
        # void __ppc_mdoio (void);
        "__ppc_mdoio": SimTypeFunction([], SimTypeBottom(label="void")),
        # void __ppc_mdoom (void);
        "__ppc_mdoom": SimTypeFunction([], SimTypeBottom(label="void")),
        # void __ppc_set_ppr_med (void);
        "__ppc_set_ppr_med": SimTypeFunction([], SimTypeBottom(label="void")),
        # void __ppc_set_ppr_low (void);
        "__ppc_set_ppr_low": SimTypeFunction([], SimTypeBottom(label="void")),
        # void __ppc_set_ppr_med_low (void);
        "__ppc_set_ppr_med_low": SimTypeFunction([], SimTypeBottom(label="void")),
        # void __ppc_set_ppr_very_low (void);
        "__ppc_set_ppr_very_low": SimTypeFunction([], SimTypeBottom(label="void")),
        # void __ppc_set_ppr_med_high (void);
        "__ppc_set_ppr_med_high": SimTypeFunction([], SimTypeBottom(label="void")),
        # void __stack_chk_fail (void);
        "__stack_chk_fail": SimTypeFunction([], SimTypeBottom(label="void")),
    }


proto_count = 0
unsupported_count = 0

for name, proto in _libc_decls.items():
    if proto is not None:
        libc.set_prototype(name, proto)
        proto_count += 1
    else:
        unsupported_count += 1

_l.debug("Libc provides %d function prototypes, and has %d unsupported function prototypes.",
         proto_count, unsupported_count)

libc.add_alias('abort', '__assert_fail', '__stack_chk_fail')
libc.add_alias('memcpy', 'memmove', 'bcopy')
libc.add_alias('getc', '_IO_getc')
libc.add_alias('putc', '_IO_putc')


#
# function prototypes in strings
#

_libc_c_decls = \
    [
        "char * strerror (int ERRNUM);",
        "char * strerror_r (int ERRNUM, char *BUF, size_t N);",
        "void perror (const char *MESSAGE);",
        "void error (int STATUS, int ERRNUM, const char *FORMAT, ...);",
        "void error_at_line (int STATUS, int ERRNUM, const char *FNAME, unsigned int LINENO, const char *FORMAT, ...);",
        "void warn (const char *FORMAT, ...);",
        "void vwarn (const char *FORMAT, va_list AP);",
        "void warnx (const char *FORMAT, ...);",
        "void vwarnx (const char *FORMAT, va_list AP);",
        "void err (int STATUS, const char *FORMAT, ...);",
        "void verr (int STATUS, const char *FORMAT, va_list AP);",
        "void errx (int STATUS, const char *FORMAT, ...);",
        "void verrx (int STATUS, const char *FORMAT, va_list AP);",
        "void * malloc (size_t SIZE);",
        "void free (void *PTR);",
        "void * realloc (void *PTR, size_t NEWSIZE);",
        "void * reallocarray (void *PTR, size_t NMEMB, size_t SIZE);",
        "void * calloc (size_t COUNT, size_t ELTSIZE);",
        "void * aligned_alloc (size_t ALIGNMENT, size_t SIZE);",
        "void * memalign (size_t BOUNDARY, size_t SIZE);",
        "int posix_memalign (void **MEMPTR, size_t ALIGNMENT, size_t SIZE);",
        "void * valloc (size_t SIZE);",
        "int mallopt (int PARAM, int VALUE);",
        "int mcheck (void (*ABORTFN) (enum mcheck_status STATUS));",
        "enum mcheck_status mprobe (void *POINTER);",
        "struct mallinfo mallinfo (void);",
        "void mtrace (void);",
        "void muntrace (void);",
        "int obstack_init (struct obstack *OBSTACK_PTR);",
        "void * obstack_alloc (struct obstack *OBSTACK_PTR, int SIZE);",
        "void * obstack_copy (struct obstack *OBSTACK_PTR, void *ADDRESS, int SIZE);",
        "void * obstack_copy0 (struct obstack *OBSTACK_PTR, void *ADDRESS, int SIZE);",
        "void obstack_free (struct obstack *OBSTACK_PTR, void *OBJECT);",
        "void obstack_blank (struct obstack *OBSTACK_PTR, int SIZE);",
        "void obstack_grow (struct obstack *OBSTACK_PTR, void *DATA, int SIZE);",
        "void obstack_grow0 (struct obstack *OBSTACK_PTR, void *DATA, int SIZE);",
        "void obstack_1grow (struct obstack *OBSTACK_PTR, char C);",
        "void obstack_ptr_grow (struct obstack *OBSTACK_PTR, void *DATA);",
        "void obstack_int_grow (struct obstack *OBSTACK_PTR, int DATA);",
        "void * obstack_finish (struct obstack *OBSTACK_PTR);",
        "int obstack_object_size (struct obstack *OBSTACK_PTR);",
        "int obstack_room (struct obstack *OBSTACK_PTR);",
        "void obstack_1grow_fast (struct obstack *OBSTACK_PTR, char C);",
        "void obstack_ptr_grow_fast (struct obstack *OBSTACK_PTR, void *DATA);",
        "void obstack_int_grow_fast (struct obstack *OBSTACK_PTR, int DATA);",
        "void obstack_blank_fast (struct obstack *OBSTACK_PTR, int SIZE);",
        "void * obstack_base (struct obstack *OBSTACK_PTR);",
        "void * alloca (size_t SIZE);",
        "int brk (void *ADDR);",
        "void *sbrk (ptrdiff_t DELTA);",
        "int mlock (const void *ADDR, size_t LEN);",
        "int munlock (const void *ADDR, size_t LEN);",
        "int mlockall (int FLAGS);",
        "int munlockall (void);",
        "int islower (int C);",
        "int isupper (int C);",
        "int isalpha (int C);",
        "int isdigit (int C);",
        "int isalnum (int C);",
        "int isxdigit (int C);",
        "int ispunct (int C);",
        "int isspace (int C);",
        "int isblank (int C);",
        "int isgraph (int C);",
        "int isprint (int C);",
        "int iscntrl (int C);",
        "int isascii (int C);",
        "int tolower (int C);",
        "int toupper (int C);",
        "int toascii (int C);",
        "int _tolower (int C);",
        "int _toupper (int C);",
        "wctype_t wctype (const char *PROPERTY);",
        "int iswctype (wint_t WC, wctype_t DESC);",
        "int iswalnum (wint_t WC);",
        "int iswalpha (wint_t WC);",
        "int iswcntrl (wint_t WC);",
        "int iswdigit (wint_t WC);",
        "int iswgraph (wint_t WC);",
        "int iswlower (wint_t WC);",
        "int iswprint (wint_t WC);",
        "int iswpunct (wint_t WC);",
        "int iswspace (wint_t WC);",
        "int iswupper (wint_t WC);",
        "int iswxdigit (wint_t WC);",
        "int iswblank (wint_t WC);",
        "wctrans_t wctrans (const char *PROPERTY);",
        "wint_t towctrans (wint_t WC, wctrans_t DESC);",
        "wint_t towlower (wint_t WC);",
        "wint_t towupper (wint_t WC);",
        "size_t strlen (const char *S);",
        "size_t wcslen (const wchar_t *WS);",
        "size_t strnlen (const char *S, size_t MAXLEN);",
        "size_t wcsnlen (const wchar_t *WS, size_t MAXLEN);",
        "void * memcpy (void *restrict TO, const void *restrict FROM, size_t SIZE);",
        "wchar_t * wmemcpy (wchar_t *restrict WTO, const wchar_t *restrict WFROM, size_t SIZE);",
        "void * mempcpy (void *restrict TO, const void *restrict FROM, size_t SIZE);",
        "wchar_t * wmempcpy (wchar_t *restrict WTO, const wchar_t *restrict WFROM, size_t SIZE);",
        "void * memmove (void *TO, const void *FROM, size_t SIZE);",
        "wchar_t * wmemmove (wchar_t *WTO, const wchar_t *WFROM, size_t SIZE);",
        "void * memccpy (void *restrict TO, const void *restrict FROM, int C, size_t SIZE);",
        "void * memset (void *BLOCK, int C, size_t SIZE);",
        "wchar_t * wmemset (wchar_t *BLOCK, wchar_t WC, size_t SIZE);",
        "char * strcpy (char *restrict TO, const char *restrict FROM);",
        "wchar_t * wcscpy (wchar_t *restrict WTO, const wchar_t *restrict WFROM);",
        "char * strdup (const char *S);",
        "wchar_t * wcsdup (const wchar_t *WS);",
        "char * stpcpy (char *restrict TO, const char *restrict FROM);",
        "wchar_t * wcpcpy (wchar_t *restrict WTO, const wchar_t *restrict WFROM);",
        "void bcopy (const void *FROM, void *TO, size_t SIZE);",
        "void bzero (void *BLOCK, size_t SIZE);",
        "char * strcat (char *restrict TO, const char *restrict FROM);",
        "wchar_t * wcscat (wchar_t *restrict WTO, const wchar_t *restrict WFROM);",
        "char * strncpy (char *restrict TO, const char *restrict FROM, size_t SIZE);",
        "wchar_t * wcsncpy (wchar_t *restrict WTO, const wchar_t *restrict WFROM, size_t SIZE);",
        "char * strndup (const char *S, size_t SIZE);",
        "char * stpncpy (char *restrict TO, const char *restrict FROM, size_t SIZE);",
        "wchar_t * wcpncpy (wchar_t *restrict WTO, const wchar_t *restrict WFROM, size_t SIZE);",
        "char * strncat (char *restrict TO, const char *restrict FROM, size_t SIZE);",
        "wchar_t * wcsncat (wchar_t *restrict WTO, const wchar_t *restrict WFROM, size_t SIZE);",
        "int memcmp (const void *A1, const void *A2, size_t SIZE);",
        "int wmemcmp (const wchar_t *A1, const wchar_t *A2, size_t SIZE);",
        "int strcmp (const char *S1, const char *S2);",
        "int wcscmp (const wchar_t *WS1, const wchar_t *WS2);",
        "int strcasecmp (const char *S1, const char *S2);",
        "int wcscasecmp (const wchar_t *WS1, const wchar_t *WS2);",
        "int strncmp (const char *S1, const char *S2, size_t SIZE);",
        "int wcsncmp (const wchar_t *WS1, const wchar_t *WS2, size_t SIZE);",
        "int strncasecmp (const char *S1, const char *S2, size_t N);",
        "int wcsncasecmp (const wchar_t *WS1, const wchar_t *S2, size_t N);",
        "int strverscmp (const char *S1, const char *S2);",
        "int bcmp (const void *A1, const void *A2, size_t SIZE);",
        "int strcoll (const char *S1, const char *S2);",
        "int wcscoll (const wchar_t *WS1, const wchar_t *WS2);",
        "size_t strxfrm (char *restrict TO, const char *restrict FROM, size_t SIZE);",
        "size_t wcsxfrm (wchar_t *restrict WTO, const wchar_t *WFROM, size_t SIZE);",
        "void * memchr (const void *BLOCK, int C, size_t SIZE);",
        "wchar_t * wmemchr (const wchar_t *BLOCK, wchar_t WC, size_t SIZE);",
        "void * rawmemchr (const void *BLOCK, int C);",
        "void * memrchr (const void *BLOCK, int C, size_t SIZE);",
        "char * strchr (const char *STRING, int C);",
        "wchar_t * wcschr (const wchar_t *WSTRING, int WC);",
        "char * strchrnul (const char *STRING, int C);",
        "wchar_t * wcschrnul (const wchar_t *WSTRING, wchar_t WC);",
        "char * strrchr (const char *STRING, int C);",
        "wchar_t * wcsrchr (const wchar_t *WSTRING, wchar_t C);",
        "char * strstr (const char *HAYSTACK, const char *NEEDLE);",
        "wchar_t * wcsstr (const wchar_t *HAYSTACK, const wchar_t *NEEDLE);",
        "wchar_t * wcswcs (const wchar_t *HAYSTACK, const wchar_t *NEEDLE);",
        "char * strcasestr (const char *HAYSTACK, const char *NEEDLE);",
        "void * memmem (const void *HAYSTACK, size_t HAYSTACK_LEN, const void *NEEDLE, size_t NEEDLE_LEN);",
        "size_t strspn (const char *STRING, const char *SKIPSET);",
        "size_t wcsspn (const wchar_t *WSTRING, const wchar_t *SKIPSET);",
        "size_t strcspn (const char *STRING, const char *STOPSET);",
        "size_t wcscspn (const wchar_t *WSTRING, const wchar_t *STOPSET);",
        "char * strpbrk (const char *STRING, const char *STOPSET);",
        "wchar_t * wcspbrk (const wchar_t *WSTRING, const wchar_t *STOPSET);",
        "char * index (const char *STRING, int C);",
        "char * rindex (const char *STRING, int C);",
        "char * strtok (char *restrict NEWSTRING, const char *restrict DELIMITERS);",
        "wchar_t * wcstok (wchar_t *NEWSTRING, const wchar_t *DELIMITERS, wchar_t **SAVE_PTR);",
        "char * strtok_r (char *NEWSTRING, const char *DELIMITERS, char **SAVE_PTR);",
        "char * strsep (char **STRING_PTR, const char *DELIMITER);",
        "char * basename (const char *PATH);",
        "char * dirname (char *PATH);",
        "void explicit_bzero (void *BLOCK, size_t LEN);",
        "char * strfry (char *STRING);",
        "void * memfrob (void *MEM, size_t LENGTH);",
        "char * l64a (long int N);",
        "long int a64l (const char *STRING);",
        "error_t argz_create (char *const ARGV[], char **ARGZ, size_t *ARGZ_LEN);",
        "error_t argz_create_sep (const char *STRING, int SEP, char **ARGZ, size_t *ARGZ_LEN);",
        "size_t argz_count (const char *ARGZ, size_t ARGZ_LEN);",
        "void argz_extract (const char *ARGZ, size_t ARGZ_LEN, char **ARGV);",
        "void argz_stringify (char *ARGZ, size_t LEN, int SEP);",
        "error_t argz_add (char **ARGZ, size_t *ARGZ_LEN, const char *STR);",
        "error_t argz_add_sep (char **ARGZ, size_t *ARGZ_LEN, const char *STR, int DELIM);",
        "error_t argz_append (char **ARGZ, size_t *ARGZ_LEN, const char *BUF, size_t BUF_LEN);",
        "void argz_delete (char **ARGZ, size_t *ARGZ_LEN, char *ENTRY);",
        "error_t argz_insert (char **ARGZ, size_t *ARGZ_LEN, char *BEFORE, const char *ENTRY);",
        "char * argz_next (const char *ARGZ, size_t ARGZ_LEN, const char *ENTRY);",
        "error_t argz_replace (char **ARGZ, size_t *ARGZ_LEN, const char *STR, const char *WITH, unsigned *REPLACE_COUNT);",
        "char * envz_entry (const char *ENVZ, size_t ENVZ_LEN, const char *NAME);",
        "char * envz_get (const char *ENVZ, size_t ENVZ_LEN, const char *NAME);",
        "error_t envz_add (char **ENVZ, size_t *ENVZ_LEN, const char *NAME, const char *VALUE);",
        "error_t envz_merge (char **ENVZ, size_t *ENVZ_LEN, const char *ENVZ2, size_t ENVZ2_LEN, int OVERRIDE);",
        "void envz_strip (char **ENVZ, size_t *ENVZ_LEN);",
        "void envz_remove (char **ENVZ, size_t *ENVZ_LEN, const char *NAME);",
        "int mbsinit (const mbstate_t *PS);",
        "wint_t btowc (int C);",
        "int wctob (wint_t C);",
        "size_t mbrtowc (wchar_t *restrict PWC, const char *restrict S, size_t N, mbstate_t *restrict PS);",
        "size_t mbrlen (const char *restrict S, size_t N, mbstate_t *PS);",
        "size_t wcrtomb (char *restrict S, wchar_t WC, mbstate_t *restrict PS);",
        "size_t mbsrtowcs (wchar_t *restrict DST, const char **restrict SRC, size_t LEN, mbstate_t *restrict PS);",
        "size_t wcsrtombs (char *restrict DST, const wchar_t **restrict SRC, size_t LEN, mbstate_t *restrict PS);",
        "size_t mbsnrtowcs (wchar_t *restrict DST, const char **restrict SRC, size_t NMC, size_t LEN, mbstate_t *restrict PS);",
        "size_t wcsnrtombs (char *restrict DST, const wchar_t **restrict SRC, size_t NWC, size_t LEN, mbstate_t *restrict PS);",
        "int mbtowc (wchar_t *restrict RESULT, const char *restrict STRING, size_t SIZE);",
        "int wctomb (char *STRING, wchar_t WCHAR);",
        "int mblen (const char *STRING, size_t SIZE);",
        "size_t mbstowcs (wchar_t *WSTRING, const char *STRING, size_t SIZE);",
        "size_t wcstombs (char *STRING, const wchar_t *WSTRING, size_t SIZE);",
        "iconv_t iconv_open (const char *TOCODE, const char *FROMCODE);",
        "int iconv_close (iconv_t CD);",
        "size_t iconv (iconv_t CD, char **INBUF, size_t *INBYTESLEFT, char **OUTBUF, size_t *OUTBYTESLEFT);",
        "char * setlocale (int CATEGORY, const char *LOCALE);",
        "struct lconv * localeconv (void);",
        "char * nl_langinfo (nl_item ITEM);",
        "ssize_t strfmon (char *S, size_t MAXSIZE, const char *FORMAT, ...);",
        "int rpmatch (const char *RESPONSE);",
        "nl_catd catopen (const char *CAT_NAME, int FLAG);",
        "char * catgets (nl_catd CATALOG_DESC, int SET, int MESSAGE, const char *STRING);",
        "int catclose (nl_catd CATALOG_DESC);",
        "char * gettext (const char *MSGID);",
        "char * dgettext (const char *DOMAINNAME, const char *MSGID);",
        "char * dcgettext (const char *DOMAINNAME, const char *MSGID, int CATEGORY);",
        "char * textdomain (const char *DOMAINNAME);",
        "char * bindtextdomain (const char *DOMAINNAME, const char *DIRNAME);",
        "char * ngettext (const char *MSGID1, const char *MSGID2, unsigned long int N);",
        "char * dngettext (const char *DOMAIN, const char *MSGID1, const char *MSGID2, unsigned long int N);",
        "char * dcngettext (const char *DOMAIN, const char *MSGID1, const char *MSGID2, unsigned long int N, int CATEGORY);",
        "char * bind_textdomain_codeset (const char *DOMAINNAME, const char *CODESET);",
        "void * lfind (const void *KEY, const void *BASE, size_t *NMEMB, size_t SIZE, comparison_fn_t COMPAR);",
        "void * lsearch (const void *KEY, void *BASE, size_t *NMEMB, size_t SIZE, comparison_fn_t COMPAR);",
        "void * bsearch (const void *KEY, const void *ARRAY, size_t COUNT, size_t SIZE, comparison_fn_t COMPARE);",
        "void qsort (void *ARRAY, size_t COUNT, size_t SIZE, comparison_fn_t COMPARE);",
        "int hcreate (size_t NEL);",
        "void hdestroy (void);",
        "ENTRY * hsearch (ENTRY ITEM, ACTION ACTION);",
        "int hcreate_r (size_t NEL, struct hsearch_data *HTAB);",
        "void hdestroy_r (struct hsearch_data *HTAB);",
        "int hsearch_r (ENTRY ITEM, ACTION ACTION, ENTRY **RETVAL, struct hsearch_data *HTAB);",
        "void * tsearch (const void *KEY, void **ROOTP, comparison_fn_t COMPAR);",
        "void * tfind (const void *KEY, void *const *ROOTP, comparison_fn_t COMPAR);",
        "void * tdelete (const void *KEY, void **ROOTP, comparison_fn_t COMPAR);",
        "void tdestroy (void *VROOT, __free_fn_t FREEFCT);",
        "void twalk (const void *ROOT, __action_fn_t ACTION);",
        "int fnmatch (const char *PATTERN, const char *STRING, int FLAGS);",
        "int glob (const char *PATTERN, int FLAGS, int (*ERRFUNC) (const char *FILENAME, int ERROR_CODE), glob_t *VECTOR_PTR);",
        "int glob64 (const char *PATTERN, int FLAGS, int (*ERRFUNC) (const char *FILENAME, int ERROR_CODE), glob64_t *VECTOR_PTR);",
        "void globfree (glob_t *PGLOB);",
        "void globfree64 (glob64_t *PGLOB);",
        "int regcomp (regex_t *restrict COMPILED, const char *restrict PATTERN, int CFLAGS);",
        "int regexec (const regex_t *restrict COMPILED, const char *restrict STRING, size_t NMATCH, regmatch_t MATCHPTR[restrict], int EFLAGS);",
        "void regfree (regex_t *COMPILED);",
        "size_t regerror (int ERRCODE, const regex_t *restrict COMPILED, char *restrict BUFFER, size_t LENGTH);",
        "int wordexp (const char *WORDS, wordexp_t *WORD_VECTOR_PTR, int FLAGS);",
        "void wordfree (wordexp_t *WORD_VECTOR_PTR);",

        # TODO: Support FILE*

        "FILE * fopen (const char *FILENAME, const char *OPENTYPE);",
        "FILE * fopen64 (const char *FILENAME, const char *OPENTYPE);",
        "FILE * freopen (const char *FILENAME, const char *OPENTYPE, FILE *STREAM);",
        "FILE * freopen64 (const char *FILENAME, const char *OPENTYPE, FILE *STREAM);",
        "int __freadable (FILE *STREAM);",
        "int __fwritable (FILE *STREAM);",
        "int __freading (FILE *STREAM);",
        "int __fwriting (FILE *STREAM);",
        "int fclose (FILE *STREAM);",
        "int fcloseall (void);",
        "void flockfile (FILE *STREAM);",
        "int ftrylockfile (FILE *STREAM);",
        "void funlockfile (FILE *STREAM);",
        "int __fsetlocking (FILE *STREAM, int TYPE);",
        "int fwide (FILE *STREAM, int MODE);",
        "int fputc (int C, FILE *STREAM);",
        "wint_t fputwc (wchar_t WC, FILE *STREAM);",
        "int fputc_unlocked (int C, FILE *STREAM);",
        "wint_t fputwc_unlocked (wchar_t WC, FILE *STREAM);",
        "int putc (int C, FILE *STREAM);",
        "wint_t putwc (wchar_t WC, FILE *STREAM);",
        "int putc_unlocked (int C, FILE *STREAM);",
        "wint_t putwc_unlocked (wchar_t WC, FILE *STREAM);",
        "int putchar (int C);",
        "wint_t putwchar (wchar_t WC);",
        "int putchar_unlocked (int C);",
        "wint_t putwchar_unlocked (wchar_t WC);",
        "int fputs (const char *S, FILE *STREAM);",
        "int fputws (const wchar_t *WS, FILE *STREAM);",
        "int fputs_unlocked (const char *S, FILE *STREAM);",
        "int fputws_unlocked (const wchar_t *WS, FILE *STREAM);",
        "int puts (const char *S);",
        "int putw (int W, FILE *STREAM);",
        "int fgetc (FILE *STREAM);",
        "wint_t fgetwc (FILE *STREAM);",
        "int fgetc_unlocked (FILE *STREAM);",
        "wint_t fgetwc_unlocked (FILE *STREAM);",
        "int getc (FILE *STREAM);",
        "wint_t getwc (FILE *STREAM);",
        "int getc_unlocked (FILE *STREAM);",
        "wint_t getwc_unlocked (FILE *STREAM);",
        "int getchar (void);",
        "wint_t getwchar (void);",
        "int getchar_unlocked (void);",
        "wint_t getwchar_unlocked (void);",
        "int getw (FILE *STREAM);",
        "ssize_t getline (char **LINEPTR, size_t *N, FILE *STREAM);",
        "ssize_t getdelim (char **LINEPTR, size_t *N, int DELIMITER, FILE *STREAM);",
        "char * fgets (char *S, int COUNT, FILE *STREAM);",
        "wchar_t * fgetws (wchar_t *WS, int COUNT, FILE *STREAM);",
        "char * fgets_unlocked (char *S, int COUNT, FILE *STREAM);",
        "wchar_t * fgetws_unlocked (wchar_t *WS, int COUNT, FILE *STREAM);",
        "int ungetc (int C, FILE *STREAM);",
        "wint_t ungetwc (wint_t WC, FILE *STREAM);",
        "size_t fread (void *DATA, size_t SIZE, size_t COUNT, FILE *STREAM);",
        "size_t fread_unlocked (void *DATA, size_t SIZE, size_t COUNT, FILE *STREAM);",
        "size_t fwrite (const void *DATA, size_t SIZE, size_t COUNT, FILE *STREAM);",
        "size_t fwrite_unlocked (const void *DATA, size_t SIZE, size_t COUNT, FILE *STREAM);",


        "int printf (const char *TEMPLATE, ...);",
        "int __printf_chk (int flag, const char *TEMPLATE, ...);",
        "int wprintf (const wchar_t *TEMPLATE, ...);",
        "int fprintf (FILE *STREAM, const char *TEMPLATE, ...);",
        "int __fprintf_chk (int flag, FILE *STREAM, const char *TEMPLATE, ...);",
        "int fwprintf (FILE *STREAM, const wchar_t *TEMPLATE, ...);",
        "int sprintf (char *S, const char *TEMPLATE, ...);",
        "int swprintf (wchar_t *WS, size_t SIZE, const wchar_t *TEMPLATE, ...);",
        "int snprintf (char *S, size_t SIZE, const char *TEMPLATE, ...);",
        "int asprintf (char **PTR, const char *TEMPLATE, ...);",
        "int obstack_printf (struct obstack *OBSTACK, const char *TEMPLATE, ...);",
        "int vprintf (const char *TEMPLATE, va_list AP);",
        "int vwprintf (const wchar_t *TEMPLATE, va_list AP);",
        "int vfprintf (FILE *STREAM, const char *TEMPLATE, va_list AP);",
        "int vfwprintf (FILE *STREAM, const wchar_t *TEMPLATE, va_list AP);",
        "int vsprintf (char *S, const char *TEMPLATE, va_list AP);",
        "int vswprintf (wchar_t *WS, size_t SIZE, const wchar_t *TEMPLATE, va_list AP);",
        "int vsnprintf (char *S, size_t SIZE, const char *TEMPLATE, va_list AP);",
        "int vasprintf (char **PTR, const char *TEMPLATE, va_list AP);",
        "int obstack_vprintf (struct obstack *OBSTACK, const char *TEMPLATE, va_list AP);",
        "size_t parse_printf_format (const char *TEMPLATE, size_t N, int *ARGTYPES);",
        "int register_printf_function (int SPEC, printf_function HANDLER_FUNCTION, printf_arginfo_function ARGINFO_FUNCTION);",
        "int printf_size (FILE *FP, const struct printf_info *INFO, const void *const *ARGS);",
        "int printf_size_info (const struct printf_info *INFO, size_t N, int *ARGTYPES);",
        "int __isoc99_scanf (const char *TEMPLATE, ...);",
        "int scanf (const char *TEMPLATE, ...);",
        "int wscanf (const wchar_t *TEMPLATE, ...);",
        "int __isoc99_fscanf (FILE *STREAM, const char *TEMPLATE, ...);",
        "int fscanf (FILE *STREAM, const char *TEMPLATE, ...);",
        "int fwscanf (FILE *STREAM, const wchar_t *TEMPLATE, ...);",
        "int __isoc99_sscanf (const char *S, const char *TEMPLATE, ...);",
        "int sscanf (const char *S, const char *TEMPLATE, ...);",
        "int swscanf (const wchar_t *WS, const wchar_t *TEMPLATE, ...);",
        "int vscanf (const char *TEMPLATE, va_list AP);",
        "int vwscanf (const wchar_t *TEMPLATE, va_list AP);",
        "int vfscanf (FILE *STREAM, const char *TEMPLATE, va_list AP);",
        "int vfwscanf (FILE *STREAM, const wchar_t *TEMPLATE, va_list AP);",
        "int vsscanf (const char *S, const char *TEMPLATE, va_list AP);",
        "int vswscanf (const wchar_t *S, const wchar_t *TEMPLATE, va_list AP);",
        "int feof (FILE *STREAM);",
        "int feof_unlocked (FILE *STREAM);",
        "int ferror (FILE *STREAM);",
        "int ferror_unlocked (FILE *STREAM);",
        "void clearerr (FILE *STREAM);",
        "void clearerr_unlocked (FILE *STREAM);",
        "long int ftell (FILE *STREAM);",
        "off_t ftello (FILE *STREAM);",
        "off64_t ftello64 (FILE *STREAM);",
        "int fseek (FILE *STREAM, long int OFFSET, int WHENCE);",
        "int fseeko (FILE *STREAM, off_t OFFSET, int WHENCE);",
        "int fseeko64 (FILE *STREAM, off64_t OFFSET, int WHENCE);",
        "void rewind (FILE *STREAM);",
        "int fgetpos (FILE *STREAM, fpos_t *POSITION);",
        "int fgetpos64 (FILE *STREAM, fpos64_t *POSITION);",
        "int fsetpos (FILE *STREAM, const fpos_t *POSITION);",
        "int fsetpos64 (FILE *STREAM, const fpos64_t *POSITION);",
        "int fflush (FILE *STREAM);",
        "int fflush_unlocked (FILE *STREAM);",
        "void _flushlbf (void);",
        "void __fpurge (FILE *STREAM);",
        "int setvbuf (FILE *STREAM, char *BUF, int MODE, size_t SIZE);",
        "void setbuf (FILE *STREAM, char *BUF);",
        "void setbuffer (FILE *STREAM, char *BUF, size_t SIZE);",
        "void setlinebuf (FILE *STREAM);",
        "int __flbf (FILE *STREAM);",
        "size_t __fbufsize (FILE *STREAM);",
        "size_t __fpending (FILE *STREAM);",
        "FILE * fmemopen (void *BUF, size_t SIZE, const char *OPENTYPE);",
        "FILE * open_memstream (char **PTR, size_t *SIZELOC);",
        "FILE * fopencookie (void *COOKIE, const char *OPENTYPE, cookie_io_functions_t IO-FUNCTIONS);",
        "int fmtmsg (long int CLASSIFICATION, const char *LABEL, int SEVERITY, const char *TEXT, const char *ACTION, const char *TAG);",
        "int addseverity (int SEVERITY, const char *STRING);",
        "int open (const char *FILENAME, int FLAGS, mode_t MODE);",
        "int open64 (const char *FILENAME, int FLAGS, mode_t MODE);",
        "int close (int FILEDES);",
        "ssize_t read (int FILEDES, void *BUFFER, size_t SIZE);",
        "ssize_t pread (int FILEDES, void *BUFFER, size_t SIZE, off_t OFFSET);",
        "ssize_t pread64 (int FILEDES, void *BUFFER, size_t SIZE, off64_t OFFSET);",
        "ssize_t write (int FILEDES, const void *BUFFER, size_t SIZE);",
        "ssize_t pwrite (int FILEDES, const void *BUFFER, size_t SIZE, off_t OFFSET);",
        "ssize_t pwrite64 (int FILEDES, const void *BUFFER, size_t SIZE, off64_t OFFSET);",
        "ssize_t preadv (int FD, const struct iovec *IOV, int IOVCNT, off_t OFFSET);",
        "ssize_t preadv64 (int FD, const struct iovec *IOV, int IOVCNT, off64_t OFFSET);",
        "ssize_t pwritev (int FD, const struct iovec *IOV, int IOVCNT, off_t OFFSET);",
        "ssize_t pwritev64 (int FD, const struct iovec *IOV, int IOVCNT, off64_t OFFSET);",
        "ssize_t preadv2 (int FD, const struct iovec *IOV, int IOVCNT, off_t OFFSET, int FLAGS);",
        "ssize_t preadv64v2 (int FD, const struct iovec *IOV, int IOVCNT, off64_t OFFSET, int FLAGS);",
        "ssize_t pwritev2 (int FD, const struct iovec *IOV, int IOVCNT, off_t OFFSET, int FLAGS);",
        "ssize_t pwritev64v2 (int FD, const struct iovec *IOV, int IOVCNT, off64_t OFFSET, int FLAGS);",
        "off_t lseek (int FILEDES, off_t OFFSET, int WHENCE);",
        "off64_t lseek64 (int FILEDES, off64_t OFFSET, int WHENCE);",
        "FILE * fdopen (int FILEDES, const char *OPENTYPE);",
        "int fileno (FILE *STREAM);",
        "int fileno_unlocked (FILE *STREAM);",
        "ssize_t readv (int FILEDES, const struct iovec *VECTOR, int COUNT);",
        "ssize_t writev (int FILEDES, const struct iovec *VECTOR, int COUNT);",
        "void * mmap (void *ADDRESS, size_t LENGTH, int PROTECT, int FLAGS, int FILEDES, off_t OFFSET);",
        "void * mmap64 (void *ADDRESS, size_t LENGTH, int PROTECT, int FLAGS, int FILEDES, off64_t OFFSET);",
        "int munmap (void *ADDR, size_t LENGTH);",
        "int msync (void *ADDRESS, size_t LENGTH, int FLAGS);",
        "void * mremap (void *ADDRESS, size_t LENGTH, size_t NEW_LENGTH, int FLAG);",
        "int madvise (void *ADDR, size_t LENGTH, int ADVICE);",
        "int shm_open (const char *NAME, int OFLAG, mode_t MODE);",
        "int shm_unlink (const char *NAME);",
        "int select (int NFDS, fd_set *READ_FDS, fd_set *WRITE_FDS, fd_set *EXCEPT_FDS, struct timeval *TIMEOUT);",
        "void sync (void);",
        "int fsync (int FILDES);",
        "int fdatasync (int FILDES);",
        "int aio_read (struct aiocb *AIOCBP);",
        "int aio_read64 (struct aiocb64 *AIOCBP);",
        "int aio_write (struct aiocb *AIOCBP);",
        "int aio_write64 (struct aiocb64 *AIOCBP);",
        "int lio_listio (int MODE, struct aiocb *const LIST[], int NENT, struct sigevent *SIG);",
        "int lio_listio64 (int MODE, struct aiocb64 *const LIST[], int NENT, struct sigevent *SIG);",
        "int aio_error (const struct aiocb *AIOCBP);",
        "int aio_error64 (const struct aiocb64 *AIOCBP);",
        "ssize_t aio_return (struct aiocb *AIOCBP);",
        "ssize_t aio_return64 (struct aiocb64 *AIOCBP);",
        "int aio_fsync (int OP, struct aiocb *AIOCBP);",
        "int aio_fsync64 (int OP, struct aiocb64 *AIOCBP);",
        "int aio_suspend (const struct aiocb *const LIST[], int NENT, const struct timespec *TIMEOUT);",
        "int aio_suspend64 (const struct aiocb64 *const LIST[], int NENT, const struct timespec *TIMEOUT);",
        "int aio_cancel (int FILDES, struct aiocb *AIOCBP);",
        "int aio_cancel64 (int FILDES, struct aiocb64 *AIOCBP);",
        "void aio_init (const struct aioinit *INIT);",
        "int fcntl (int FILEDES, int COMMAND, ...);",
        "int dup (int OLD);",
        "int dup2 (int OLD, int NEW);",
        "int ioctl (int FILEDES, int COMMAND, ...);",
        "char * getcwd (char *BUFFER, size_t SIZE);",
        "char * get_current_dir_name (void);",
        "int chdir (const char *FILENAME);",
        "int fchdir (int FILEDES);",
        "int IFTODT (mode_t MODE);",
        "mode_t DTTOIF (int DTYPE);",

        # TODO: Support DIR*

        "DIR * opendir (const char *DIRNAME);",
        "DIR * fdopendir (int FD);",
        "int dirfd (DIR *DIRSTREAM);",
        "struct dirent * readdir (DIR *DIRSTREAM);",
        "int readdir_r (DIR *DIRSTREAM, struct dirent *ENTRY, struct dirent **RESULT);",
        "struct dirent64 * readdir64 (DIR *DIRSTREAM);",
        "int readdir64_r (DIR *DIRSTREAM, struct dirent64 *ENTRY, struct dirent64 **RESULT);",
        "int closedir (DIR *DIRSTREAM);",
        "void rewinddir (DIR *DIRSTREAM);",
        "long int telldir (DIR *DIRSTREAM);",
        "void seekdir (DIR *DIRSTREAM, long int POS);",
        "int scandir (const char *DIR, struct dirent ***NAMELIST, int (*SELECTOR);",
        "int alphasort (const struct dirent **A, const struct dirent **B);",
        "int versionsort (const struct dirent **A, const struct dirent **B);",
        "int scandir64 (const char *DIR, struct dirent64 ***NAMELIST, int (*SELECTOR);",
        "int alphasort64 (const struct dirent64 **A, const struct dirent **B);",
        "int versionsort64 (const struct dirent64 **A, const struct dirent64 **B);",
        "int ftw (const char *FILENAME, __ftw_func_t FUNC, int DESCRIPTORS);",
        "int ftw64 (const char *FILENAME, __ftw64_func_t FUNC, int DESCRIPTORS);",
        "int nftw (const char *FILENAME, __nftw_func_t FUNC, int DESCRIPTORS, int FLAG);",
        "int nftw64 (const char *FILENAME, __nftw64_func_t FUNC, int DESCRIPTORS, int FLAG);",
        "int link (const char *OLDNAME, const char *NEWNAME);",
        "int symlink (const char *OLDNAME, const char *NEWNAME);",
        "ssize_t readlink (const char *FILENAME, char *BUFFER, size_t SIZE);",
        "char * canonicalize_file_name (const char *NAME);",
        "char * realpath (const char *restrict NAME, char *restrict RESOLVED);",
        "int unlink (const char *FILENAME);",
        "int rmdir (const char *FILENAME);",
        "int remove (const char *FILENAME);",
        "int rename (const char *OLDNAME, const char *NEWNAME);",
        "int mkdir (const char *FILENAME, mode_t MODE);",
        "int stat (const char *FILENAME, struct stat *BUF);",
        "int stat64 (const char *FILENAME, struct stat64 *BUF);",
        "int fstat (int FILEDES, struct stat *BUF);",
        "int fstat64 (int FILEDES, struct stat64 *BUF);",
        "int lstat (const char *FILENAME, struct stat *BUF);",
        "int lstat64 (const char *FILENAME, struct stat64 *BUF);",
        "int chown (const char *FILENAME, uid_t OWNER, gid_t GROUP);",
        "int fchown (int FILEDES, uid_t OWNER, gid_t GROUP);",
        "mode_t umask (mode_t MASK);",
        "mode_t getumask (void);",
        "int chmod (const char *FILENAME, mode_t MODE);",
        "int fchmod (int FILEDES, mode_t MODE);",
        "int access (const char *FILENAME, int HOW);",
        "int utime (const char *FILENAME, const struct utimbuf *TIMES);",
        "int utimes (const char *FILENAME, const struct timeval TVP[2]);",
        "int lutimes (const char *FILENAME, const struct timeval TVP[2]);",
        "int futimes (int FD, const struct timeval TVP[2]);",
        "int truncate (const char *FILENAME, off_t LENGTH);",
        "int truncate64 (const char *NAME, off64_t LENGTH);",
        "int ftruncate (int FD, off_t LENGTH);",
        "int ftruncate64 (int ID, off64_t LENGTH);",
        "int posix_fallocate (int FD, off_t OFFSET, off_t LENGTH);",
        "int posix_fallocate64 (int FD, off64_t OFFSET, off64_t LENGTH);",
        "int mknod (const char *FILENAME, mode_t MODE, dev_t DEV);",
        "FILE * tmpfile (void);",
        "FILE * tmpfile64 (void);",
        "char * tmpnam (char *RESULT);",
        "char * tmpnam_r (char *RESULT);",
        "char * tempnam (const char *DIR, const char *PREFIX);",
        "char * mktemp (char *TEMPLATE);",
        "int mkstemp (char *TEMPLATE);",
        "char * mkdtemp (char *TEMPLATE);",
        "int pipe (int FILEDES[2]);",
        "FILE * popen (const char *COMMAND, const char *MODE);",
        "int pclose (FILE *STREAM);",
        "int mkfifo (const char *FILENAME, mode_t MODE);",
        "int bind (int SOCKET, struct sockaddr *ADDR, socklen_t LENGTH);",
        "int getsockname (int SOCKET, struct sockaddr *ADDR, socklen_t *LENGTH_PTR);",
        "unsigned int if_nametoindex (const char *IFNAME);",
        "char * if_indextoname (unsigned int IFINDEX, char *IFNAME);",
        "struct if_nameindex * if_nameindex (void);",
        "void if_freenameindex (struct if_nameindex *PTR);",
        "int inet_aton (const char *NAME, struct in_addr *ADDR);",
        "uint32_t inet_addr (const char *NAME);",
        "uint32_t inet_network (const char *NAME);",
        "char * inet_ntoa (struct in_addr ADDR);",
        "struct in_addr inet_makeaddr (uint32_t NET, uint32_t LOCAL);",
        "uint32_t inet_lnaof (struct in_addr ADDR);",
        "uint32_t inet_netof (struct in_addr ADDR);",
        "int inet_pton (int AF, const char *CP, void *BUF);",
        "const char * inet_ntop (int AF, const void *CP, char *BUF, socklen_t LEN);",
        "struct hostent * gethostbyname (const char *NAME);",
        "struct hostent * gethostbyname2 (const char *NAME, int AF);",
        "struct hostent * gethostbyaddr (const void *ADDR, socklen_t LENGTH, int FORMAT);",
        "int gethostbyname_r (const char *restrict NAME, struct hostent *restrict RESULT_BUF, char *restrict BUF, size_t BUFLEN, struct hostent **restrict RESULT, int * restrict H_ERRNOP);",
        "int gethostbyname2_r (const char *NAME, int AF, struct hostent *restrict RESULT_BUF, char *restrict BUF, size_t BUFLEN, struct hostent **restrict RESULT, int * restrict H_ERRNOP);",
        "int gethostbyaddr_r (const void *ADDR, socklen_t LENGTH, int FORMAT, struct hostent *restrict RESULT_BUF, char *restrict BUF, size_t BUFLEN, struct hostent ** restrict RESULT, int * restrict H_ERRNOP);",
        "void sethostent (int STAYOPEN);",
        "struct hostent * gethostent (void);",
        "void endhostent (void);",
        "struct servent * getservbyname (const char *NAME, const char *PROTO);",
        "struct servent * getservbyport (int PORT, const char *PROTO);",
        "void setservent (int STAYOPEN);",
        "struct servent * getservent (void);",
        "void endservent (void);",
        "uint16_t htons (uint16_t HOSTSHORT);",
        "uint16_t ntohs (uint16_t NETSHORT);",
        "uint32_t htonl (uint32_t HOSTLONG);",
        "uint32_t ntohl (uint32_t NETLONG);",
        "struct protoent * getprotobyname (const char *NAME);",
        "struct protoent * getprotobynumber (int PROTOCOL);",
        "void setprotoent (int STAYOPEN);",
        "struct protoent * getprotoent (void);",
        "void endprotoent (void);",
        "int socket (int NAMESPACE, int STYLE, int PROTOCOL);",
        "int shutdown (int SOCKET, int HOW);",
        "int socketpair (int NAMESPACE, int STYLE, int PROTOCOL, int FILEDES[2]);",
        "int connect (int SOCKET, struct sockaddr *ADDR, socklen_t LENGTH);",
        "int listen (int SOCKET, int N);",
        "int accept (int SOCKET, struct sockaddr *ADDR, socklen_t *LENGTH_PTR);",
        "int getpeername (int SOCKET, struct sockaddr *ADDR, socklen_t *LENGTH_PTR);",
        "ssize_t send (int SOCKET, const void *BUFFER, size_t SIZE, int FLAGS);",
        "ssize_t recv (int SOCKET, void *BUFFER, size_t SIZE, int FLAGS);",
        "ssize_t sendto (int SOCKET, const void *BUFFER, size_t SIZE, int FLAGS, struct sockaddr *ADDR, socklen_t LENGTH);",
        "ssize_t recvfrom (int SOCKET, void *BUFFER, size_t SIZE, int FLAGS, struct sockaddr *ADDR, socklen_t *LENGTH_PTR);",
        "int getsockopt (int SOCKET, int LEVEL, int OPTNAME, void *OPTVAL, socklen_t *OPTLEN_PTR);",
        "int setsockopt (int SOCKET, int LEVEL, int OPTNAME, const void *OPTVAL, socklen_t OPTLEN);",
        "struct netent * getnetbyname (const char *NAME);",
        "struct netent * getnetbyaddr (uint32_t NET, int TYPE);",
        "void setnetent (int STAYOPEN);",
        "struct netent * getnetent (void);",
        "void endnetent (void);",
        "int isatty (int FILEDES);",
        "char * ttyname (int FILEDES);",
        "int ttyname_r (int FILEDES, char *BUF, size_t LEN);",
        "int tcgetattr (int FILEDES, struct termios *TERMIOS_P);",
        "int tcsetattr (int FILEDES, int WHEN, const struct termios *TERMIOS_P);",
        "speed_t cfgetospeed (const struct termios *TERMIOS_P);",
        "speed_t cfgetispeed (const struct termios *TERMIOS_P);",
        "int cfsetospeed (struct termios *TERMIOS_P, speed_t SPEED);",
        "int cfsetispeed (struct termios *TERMIOS_P, speed_t SPEED);",
        "int cfsetspeed (struct termios *TERMIOS_P, speed_t SPEED);",
        "void cfmakeraw (struct termios *TERMIOS_P);",
        "int gtty (int FILEDES, struct sgttyb *ATTRIBUTES);",
        "int stty (int FILEDES, const struct sgttyb *ATTRIBUTES);",
        "int tcsendbreak (int FILEDES, int DURATION);",
        "int tcdrain (int FILEDES);",
        "int tcflush (int FILEDES, int QUEUE);",
        "int tcflow (int FILEDES, int ACTION);",
        "int getpt (void);",
        "int grantpt (int FILEDES);",
        "int unlockpt (int FILEDES);",
        "char * ptsname (int FILEDES);",
        "int ptsname_r (int FILEDES, char *BUF, size_t LEN);",
        "int openpty (int *AMASTER, int *ASLAVE, char *NAME, const struct termios *TERMP, const struct winsize *WINP);",
        "int forkpty (int *AMASTER, char *NAME, const struct termios *TERMP, const struct winsize *WINP);",
        "void openlog (const char *IDENT, int OPTION, int FACILITY);",
        "void syslog (int FACILITY_PRIORITY, const char *FORMAT, ...);",
        "void vsyslog (int FACILITY_PRIORITY, const char *FORMAT, va_list ARGLIST);",
        "void closelog (void);",
        "int setlogmask (int MASK);",
        "double sin (double X);",
        "float sinf (float X);",

        # TODO: Support long double

        "long double sinl (long double X);",
        "_FloatN sinfN (_FloatN X);",
        "_FloatNx sinfNx (_FloatNx X);",
        "double cos (double X);",
        "float cosf (float X);",
        "long double cosl (long double X);",
        "_FloatN cosfN (_FloatN X);",
        "_FloatNx cosfNx (_FloatNx X);",
        "double tan (double X);",
        "float tanf (float X);",
        "long double tanl (long double X);",
        "_FloatN tanfN (_FloatN X);",
        "_FloatNx tanfNx (_FloatNx X);",
        "void sincos (double X, double *SINX, double *COSX);",
        "void sincosf (float X, float *SINX, float *COSX);",
        "void sincosl (long double X, long double *SINX, long double *COSX);",
        "_FloatN sincosfN (_FloatN X, _FloatN *SINX, _FloatN *COSX);",
        "_FloatNx sincosfNx (_FloatNx X, _FloatNx *SINX, _FloatNx *COSX);",
        "complex double csin (complex double Z);",
        "complex float csinf (complex float Z);",
        "complex long double csinl (complex long double Z);",
        "complex _FloatN csinfN (complex _FloatN Z);",
        "complex _FloatNx csinfNx (complex _FloatNx Z);",
        "complex double ccos (complex double Z);",
        "complex float ccosf (complex float Z);",
        "complex long double ccosl (complex long double Z);",
        "complex _FloatN ccosfN (complex _FloatN Z);",
        "complex _FloatNx ccosfNx (complex _FloatNx Z);",
        "complex double ctan (complex double Z);",
        "complex float ctanf (complex float Z);",
        "complex long double ctanl (complex long double Z);",
        "complex _FloatN ctanfN (complex _FloatN Z);",
        "complex _FloatNx ctanfNx (complex _FloatNx Z);",
        "double asin (double X);",
        "float asinf (float X);",
        "long double asinl (long double X);",
        "_FloatN asinfN (_FloatN X);",
        "_FloatNx asinfNx (_FloatNx X);",
        "double acos (double X);",
        "float acosf (float X);",
        "long double acosl (long double X);",
        "_FloatN acosfN (_FloatN X);",
        "_FloatNx acosfNx (_FloatNx X);",
        "double atan (double X);",
        "float atanf (float X);",
        "long double atanl (long double X);",
        "_FloatN atanfN (_FloatN X);",
        "_FloatNx atanfNx (_FloatNx X);",
        "double atan2 (double Y, double X);",
        "float atan2f (float Y, float X);",
        "long double atan2l (long double Y, long double X);",
        "_FloatN atan2fN (_FloatN Y, _FloatN X);",
        "_FloatNx atan2fNx (_FloatNx Y, _FloatNx X);",
        "complex double casin (complex double Z);",
        "complex float casinf (complex float Z);",
        "complex long double casinl (complex long double Z);",
        "complex _FloatN casinfN (complex _FloatN Z);",
        "complex _FloatNx casinfNx (complex _FloatNx Z);",
        "complex double cacos (complex double Z);",
        "complex float cacosf (complex float Z);",
        "complex long double cacosl (complex long double Z);",
        "complex _FloatN cacosfN (complex _FloatN Z);",
        "complex _FloatNx cacosfNx (complex _FloatNx Z);",
        "complex double catan (complex double Z);",
        "complex float catanf (complex float Z);",
        "complex long double catanl (complex long double Z);",
        "complex _FloatN catanfN (complex _FloatN Z);",
        "complex _FloatNx catanfNx (complex _FloatNx Z);",
        "double exp (double X);",
        "float expf (float X);",
        "long double expl (long double X);",
        "_FloatN expfN (_FloatN X);",
        "_FloatNx expfNx (_FloatNx X);",
        "double exp2 (double X);",
        "float exp2f (float X);",
        "long double exp2l (long double X);",
        "_FloatN exp2fN (_FloatN X);",
        "_FloatNx exp2fNx (_FloatNx X);",
        "double exp10 (double X);",
        "float exp10f (float X);",
        "long double exp10l (long double X);",
        "_FloatN exp10fN (_FloatN X);",
        "_FloatNx exp10fNx (_FloatNx X);",
        "double pow10 (double X);",
        "float pow10f (float X);",
        "long double pow10l (long double X);",
        "double log (double X);",
        "float logf (float X);",
        "long double logl (long double X);",
        "_FloatN logfN (_FloatN X);",
        "_FloatNx logfNx (_FloatNx X);",
        "double log10 (double X);",
        "float log10f (float X);",
        "long double log10l (long double X);",
        "_FloatN log10fN (_FloatN X);",
        "_FloatNx log10fNx (_FloatNx X);",
        "double log2 (double X);",
        "float log2f (float X);",
        "long double log2l (long double X);",
        "_FloatN log2fN (_FloatN X);",
        "_FloatNx log2fNx (_FloatNx X);",
        "double logb (double X);",
        "float logbf (float X);",
        "long double logbl (long double X);",
        "_FloatN logbfN (_FloatN X);",
        "_FloatNx logbfNx (_FloatNx X);",
        "int ilogb (double X);",
        "int ilogbf (float X);",
        "int ilogbl (long double X);",
        "int ilogbfN (_FloatN X);",
        "int ilogbfNx (_FloatNx X);",
        "long int llogb (double X);",
        "long int llogbf (float X);",
        "long int llogbl (long double X);",
        "long int llogbfN (_FloatN X);",
        "long int llogbfNx (_FloatNx X);",
        "double pow (double BASE, double POWER);",
        "float powf (float BASE, float POWER);",
        "long double powl (long double BASE, long double POWER);",
        "_FloatN powfN (_FloatN BASE, _FloatN POWER);",
        "_FloatNx powfNx (_FloatNx BASE, _FloatNx POWER);",
        "double sqrt (double X);",
        "float sqrtf (float X);",
        "long double sqrtl (long double X);",
        "_FloatN sqrtfN (_FloatN X);",
        "_FloatNx sqrtfNx (_FloatNx X);",
        "double cbrt (double X);",
        "float cbrtf (float X);",
        "long double cbrtl (long double X);",
        "_FloatN cbrtfN (_FloatN X);",
        "_FloatNx cbrtfNx (_FloatNx X);",
        "double hypot (double X, double Y);",
        "float hypotf (float X, float Y);",
        "long double hypotl (long double X, long double Y);",
        "_FloatN hypotfN (_FloatN X, _FloatN Y);",
        "_FloatNx hypotfNx (_FloatNx X, _FloatNx Y);",
        "double expm1 (double X);",
        "float expm1f (float X);",
        "long double expm1l (long double X);",
        "_FloatN expm1fN (_FloatN X);",
        "_FloatNx expm1fNx (_FloatNx X);",
        "double log1p (double X);",
        "float log1pf (float X);",
        "long double log1pl (long double X);",
        "_FloatN log1pfN (_FloatN X);",
        "_FloatNx log1pfNx (_FloatNx X);",
        "complex double cexp (complex double Z);",
        "complex float cexpf (complex float Z);",
        "complex long double cexpl (complex long double Z);",
        "complex _FloatN cexpfN (complex _FloatN Z);",
        "complex _FloatNx cexpfNx (complex _FloatNx Z);",
        "complex double clog (complex double Z);",
        "complex float clogf (complex float Z);",
        "complex long double clogl (complex long double Z);",
        "complex _FloatN clogfN (complex _FloatN Z);",
        "complex _FloatNx clogfNx (complex _FloatNx Z);",
        "complex double clog10 (complex double Z);",
        "complex float clog10f (complex float Z);",
        "complex long double clog10l (complex long double Z);",
        "complex _FloatN clog10fN (complex _FloatN Z);",
        "complex _FloatNx clog10fNx (complex _FloatNx Z);",
        "complex double csqrt (complex double Z);",
        "complex float csqrtf (complex float Z);",
        "complex long double csqrtl (complex long double Z);",
        "complex _FloatN csqrtfN (_FloatN Z);",
        "complex _FloatNx csqrtfNx (complex _FloatNx Z);",
        "complex double cpow (complex double BASE, complex double POWER);",
        "complex float cpowf (complex float BASE, complex float POWER);",
        "complex long double cpowl (complex long double BASE, complex long double POWER);",
        "complex _FloatN cpowfN (complex _FloatN BASE, complex _FloatN POWER);",
        "complex _FloatNx cpowfNx (complex _FloatNx BASE, complex _FloatNx POWER);",
        "double sinh (double X);",
        "float sinhf (float X);",
        "long double sinhl (long double X);",
        "_FloatN sinhfN (_FloatN X);",
        "_FloatNx sinhfNx (_FloatNx X);",
        "double cosh (double X);",
        "float coshf (float X);",
        "long double coshl (long double X);",
        "_FloatN coshfN (_FloatN X);",
        "_FloatNx coshfNx (_FloatNx X);",
        "double tanh (double X);",
        "float tanhf (float X);",
        "long double tanhl (long double X);",
        "_FloatN tanhfN (_FloatN X);",
        "_FloatNx tanhfNx (_FloatNx X);",
        "complex double csinh (complex double Z);",
        "complex float csinhf (complex float Z);",
        "complex long double csinhl (complex long double Z);",
        "complex _FloatN csinhfN (complex _FloatN Z);",
        "complex _FloatNx csinhfNx (complex _FloatNx Z);",
        "complex double ccosh (complex double Z);",
        "complex float ccoshf (complex float Z);",
        "complex long double ccoshl (complex long double Z);",
        "complex _FloatN ccoshfN (complex _FloatN Z);",
        "complex _FloatNx ccoshfNx (complex _FloatNx Z);",
        "complex double ctanh (complex double Z);",
        "complex float ctanhf (complex float Z);",
        "complex long double ctanhl (complex long double Z);",
        "complex _FloatN ctanhfN (complex _FloatN Z);",
        "complex _FloatNx ctanhfNx (complex _FloatNx Z);",
        "double asinh (double X);",
        "float asinhf (float X);",
        "long double asinhl (long double X);",
        "_FloatN asinhfN (_FloatN X);",
        "_FloatNx asinhfNx (_FloatNx X);",
        "double acosh (double X);",
        "float acoshf (float X);",
        "long double acoshl (long double X);",
        "_FloatN acoshfN (_FloatN X);",
        "_FloatNx acoshfNx (_FloatNx X);",
        "double atanh (double X);",
        "float atanhf (float X);",
        "long double atanhl (long double X);",
        "_FloatN atanhfN (_FloatN X);",
        "_FloatNx atanhfNx (_FloatNx X);",
        "complex double casinh (complex double Z);",
        "complex float casinhf (complex float Z);",
        "complex long double casinhl (complex long double Z);",
        "complex _FloatN casinhfN (complex _FloatN Z);",
        "complex _FloatNx casinhfNx (complex _FloatNx Z);",
        "complex double cacosh (complex double Z);",
        "complex float cacoshf (complex float Z);",
        "complex long double cacoshl (complex long double Z);",
        "complex _FloatN cacoshfN (complex _FloatN Z);",
        "complex _FloatNx cacoshfNx (complex _FloatNx Z);",
        "complex double catanh (complex double Z);",
        "complex float catanhf (complex float Z);",
        "complex long double catanhl (complex long double Z);",
        "complex _FloatN catanhfN (complex _FloatN Z);",
        "complex _FloatNx catanhfNx (complex _FloatNx Z);",
        "double erf (double X);",
        "float erff (float X);",
        "long double erfl (long double X);",
        "_FloatN erffN (_FloatN X);",
        "_FloatNx erffNx (_FloatNx X);",
        "double erfc (double X);",
        "float erfcf (float X);",
        "long double erfcl (long double X);",
        "_FloatN erfcfN (_FloatN X);",
        "_FloatNx erfcfNx (_FloatNx X);",
        "double lgamma (double X);",
        "float lgammaf (float X);",
        "long double lgammal (long double X);",
        "_FloatN lgammafN (_FloatN X);",
        "_FloatNx lgammafNx (_FloatNx X);",
        "double lgamma_r (double X, int *SIGNP);",
        "float lgammaf_r (float X, int *SIGNP);",
        "long double lgammal_r (long double X, int *SIGNP);",
        "_FloatN lgammafN_r (_FloatN X, int *SIGNP);",
        "_FloatNx lgammafNx_r (_FloatNx X, int *SIGNP);",
        "double gamma (double X);",
        "float gammaf (float X);",
        "long double gammal (long double X);",
        "double tgamma (double X);",
        "float tgammaf (float X);",
        "long double tgammal (long double X);",
        "_FloatN tgammafN (_FloatN X);",
        "_FloatNx tgammafNx (_FloatNx X);",
        "double j0 (double X);",
        "float j0f (float X);",
        "long double j0l (long double X);",
        "_FloatN j0fN (_FloatN X);",
        "_FloatNx j0fNx (_FloatNx X);",
        "double j1 (double X);",
        "float j1f (float X);",
        "long double j1l (long double X);",
        "_FloatN j1fN (_FloatN X);",
        "_FloatNx j1fNx (_FloatNx X);",
        "double jn (int N, double X);",
        "float jnf (int N, float X);",
        "long double jnl (int N, long double X);",
        "_FloatN jnfN (int N, _FloatN X);",
        "_FloatNx jnfNx (int N, _FloatNx X);",
        "double y0 (double X);",
        "float y0f (float X);",
        "long double y0l (long double X);",
        "_FloatN y0fN (_FloatN X);",
        "_FloatNx y0fNx (_FloatNx X);",
        "double y1 (double X);",
        "float y1f (float X);",
        "long double y1l (long double X);",
        "_FloatN y1fN (_FloatN X);",
        "_FloatNx y1fNx (_FloatNx X);",
        "double yn (int N, double X);",
        "float ynf (int N, float X);",
        "long double ynl (int N, long double X);",
        "_FloatN ynfN (int N, _FloatN X);",
        "_FloatNx ynfNx (int N, _FloatNx X);",
        "int rand (void);",
        "void srand (unsigned int SEED);",
        "int rand_r (unsigned int *SEED);",
        "long int random (void);",
        "void srandom (unsigned int SEED);",
        "char * initstate (unsigned int SEED, char *STATE, size_t SIZE);",
        "char * setstate (char *STATE);",
        "int random_r (struct random_data *restrict BUF, int32_t *restrict RESULT);",
        "int srandom_r (unsigned int SEED, struct random_data *BUF);",
        "int initstate_r (unsigned int SEED, char *restrict STATEBUF, size_t STATELEN, struct random_data *restrict BUF);",
        "int setstate_r (char *restrict STATEBUF, struct random_data *restrict BUF);",
        "double drand48 (void);",
        "double erand48 (unsigned short int XSUBI[3]);",
        "long int lrand48 (void);",
        "long int nrand48 (unsigned short int XSUBI[3]);",
        "long int mrand48 (void);",
        "long int jrand48 (unsigned short int XSUBI[3]);",
        "void srand48 (long int SEEDVAL);",
        "unsigned short int * seed48 (unsigned short int SEED16V[3]);",
        "void lcong48 (unsigned short int PARAM[7]);",
        "int drand48_r (struct drand48_data *BUFFER, double *RESULT);",
        "int erand48_r (unsigned short int XSUBI[3], struct drand48_data *BUFFER, double *RESULT);",
        "int lrand48_r (struct drand48_data *BUFFER, long int *RESULT);",
        "int nrand48_r (unsigned short int XSUBI[3], struct drand48_data *BUFFER, long int *RESULT);",
        "int mrand48_r (struct drand48_data *BUFFER, long int *RESULT);",
        "int jrand48_r (unsigned short int XSUBI[3], struct drand48_data *BUFFER, long int *RESULT);",
        "int srand48_r (long int SEEDVAL, struct drand48_data *BUFFER);",
        "int seed48_r (unsigned short int SEED16V[3], struct drand48_data *BUFFER);",
        "int lcong48_r (unsigned short int PARAM[7], struct drand48_data *BUFFER);",
        "div_t div (int NUMERATOR, int DENOMINATOR);",
        "ldiv_t ldiv (long int NUMERATOR, long int DENOMINATOR);",
        "lldiv_t lldiv (long long int NUMERATOR, long long int DENOMINATOR);",
        "imaxdiv_t imaxdiv (intmax_t NUMERATOR, intmax_t DENOMINATOR);",
        "int isinf (double X);",
        "int isinff (float X);",
        "int isinfl (long double X);",
        "int isnan (double X);",
        "int isnanf (float X);",
        "int isnanl (long double X);",
        "int finite (double X);",
        "int finitef (float X);",
        "int finitel (long double X);",
        "int feclearexcept (int EXCEPTS);",
        "int feraiseexcept (int EXCEPTS);",
        "int fesetexcept (int EXCEPTS);",
        "int fetestexcept (int EXCEPTS);",
        "int fegetexceptflag (fexcept_t *FLAGP, int EXCEPTS);",
        "int fesetexceptflag (const fexcept_t *FLAGP, int EXCEPTS);",
        "int fetestexceptflag (const fexcept_t *FLAGP, int EXCEPTS);",
        "int fegetround (void);",
        "int fesetround (int ROUND);",
        "int fegetenv (fenv_t *ENVP);",
        "int feholdexcept (fenv_t *ENVP);",
        "int fesetenv (const fenv_t *ENVP);",
        "int feupdateenv (const fenv_t *ENVP);",
        "int fegetmode (femode_t *MODEP);",
        "int fesetmode (const femode_t *MODEP);",
        "int feenableexcept (int EXCEPTS);",
        "int fedisableexcept (int EXCEPTS);",
        "int fegetexcept (void);",
        "int abs (int NUMBER);",
        "long int labs (long int NUMBER);",
        "long long int llabs (long long int NUMBER);",
        "intmax_t imaxabs (intmax_t NUMBER);",
        "double fabs (double NUMBER);",
        "float fabsf (float NUMBER);",
        "long double fabsl (long double NUMBER);",
        "_FloatN fabsfN (_FloatN NUMBER);",
        "_FloatNx fabsfNx (_FloatNx NUMBER);",
        "double cabs (complex double Z);",
        "float cabsf (complex float Z);",
        "long double cabsl (complex long double Z);",
        "_FloatN cabsfN (complex _FloatN Z);",
        "_FloatNx cabsfNx (complex _FloatNx Z);",
        "double frexp (double VALUE, int *EXPONENT);",
        "float frexpf (float VALUE, int *EXPONENT);",
        "long double frexpl (long double VALUE, int *EXPONENT);",
        "_FloatN frexpfN (_FloatN VALUE, int *EXPONENT);",
        "_FloatNx frexpfNx (_FloatNx VALUE, int *EXPONENT);",
        "double ldexp (double VALUE, int EXPONENT);",
        "float ldexpf (float VALUE, int EXPONENT);",
        "long double ldexpl (long double VALUE, int EXPONENT);",
        "_FloatN ldexpfN (_FloatN VALUE, int EXPONENT);",
        "_FloatNx ldexpfNx (_FloatNx VALUE, int EXPONENT);",
        "double scalb (double VALUE, double EXPONENT);",
        "float scalbf (float VALUE, float EXPONENT);",
        "long double scalbl (long double VALUE, long double EXPONENT);",
        "double scalbn (double X, int N);",
        "float scalbnf (float X, int N);",
        "long double scalbnl (long double X, int N);",
        "_FloatN scalbnfN (_FloatN X, int N);",
        "_FloatNx scalbnfNx (_FloatNx X, int N);",
        "double scalbln (double X, long int N);",
        "float scalblnf (float X, long int N);",
        "long double scalblnl (long double X, long int N);",
        "_FloatN scalblnfN (_FloatN X, long int N);",
        "_FloatNx scalblnfNx (_FloatNx X, long int N);",
        "double significand (double X);",
        "float significandf (float X);",
        "long double significandl (long double X);",
        "double ceil (double X);",
        "float ceilf (float X);",
        "long double ceill (long double X);",
        "_FloatN ceilfN (_FloatN X);",
        "_FloatNx ceilfNx (_FloatNx X);",
        "double floor (double X);",
        "float floorf (float X);",
        "long double floorl (long double X);",
        "_FloatN floorfN (_FloatN X);",
        "_FloatNx floorfNx (_FloatNx X);",
        "double trunc (double X);",
        "float truncf (float X);",
        "long double truncl (long double X);",
        "_FloatN truncfN (_FloatN X);",
        "_FloatNx truncfNx (_FloatNx X);",
        "double rint (double X);",
        "float rintf (float X);",
        "long double rintl (long double X);",
        "_FloatN rintfN (_FloatN X);",
        "_FloatNx rintfNx (_FloatNx X);",
        "double nearbyint (double X);",
        "float nearbyintf (float X);",
        "long double nearbyintl (long double X);",
        "_FloatN nearbyintfN (_FloatN X);",
        "_FloatNx nearbyintfNx (_FloatNx X);",
        "double round (double X);",
        "float roundf (float X);",
        "long double roundl (long double X);",
        "_FloatN roundfN (_FloatN X);",
        "_FloatNx roundfNx (_FloatNx X);",
        "double roundeven (double X);",
        "float roundevenf (float X);",
        "long double roundevenl (long double X);",
        "_FloatN roundevenfN (_FloatN X);",
        "_FloatNx roundevenfNx (_FloatNx X);",
        "long int lrint (double X);",
        "long int lrintf (float X);",
        "long int lrintl (long double X);",
        "long int lrintfN (_FloatN X);",
        "long int lrintfNx (_FloatNx X);",
        "long long int llrint (double X);",
        "long long int llrintf (float X);",
        "long long int llrintl (long double X);",
        "long long int llrintfN (_FloatN X);",
        "long long int llrintfNx (_FloatNx X);",
        "long int lround (double X);",
        "long int lroundf (float X);",
        "long int lroundl (long double X);",
        "long int lroundfN (_FloatN X);",
        "long int lroundfNx (_FloatNx X);",
        "long long int llround (double X);",
        "long long int llroundf (float X);",
        "long long int llroundl (long double X);",
        "long long int llroundfN (_FloatN X);",
        "long long int llroundfNx (_FloatNx X);",
        "intmax_t fromfp (double X, int ROUND, unsigned int WIDTH);",
        "intmax_t fromfpf (float X, int ROUND, unsigned int WIDTH);",
        "intmax_t fromfpl (long double X, int ROUND, unsigned int WIDTH);",
        "intmax_t fromfpfN (_FloatN X, int ROUND, unsigned int WIDTH);",
        "intmax_t fromfpfNx (_FloatNx X, int ROUND, unsigned int WIDTH);",
        "uintmax_t ufromfp (double X, int ROUND, unsigned int WIDTH);",
        "uintmax_t ufromfpf (float X, int ROUND, unsigned int WIDTH);",
        "uintmax_t ufromfpl (long double X, int ROUND, unsigned int WIDTH);",
        "uintmax_t ufromfpfN (_FloatN X, int ROUND, unsigned int WIDTH);",
        "uintmax_t ufromfpfNx (_FloatNx X, int ROUND, unsigned int WIDTH);",
        "intmax_t fromfpx (double X, int ROUND, unsigned int WIDTH);",
        "intmax_t fromfpxf (float X, int ROUND, unsigned int WIDTH);",
        "intmax_t fromfpxl (long double X, int ROUND, unsigned int WIDTH);",
        "intmax_t fromfpxfN (_FloatN X, int ROUND, unsigned int WIDTH);",
        "intmax_t fromfpxfNx (_FloatNx X, int ROUND, unsigned int WIDTH);",
        "uintmax_t ufromfpx (double X, int ROUND, unsigned int WIDTH);",
        "uintmax_t ufromfpxf (float X, int ROUND, unsigned int WIDTH);",
        "uintmax_t ufromfpxl (long double X, int ROUND, unsigned int WIDTH);",
        "uintmax_t ufromfpxfN (_FloatN X, int ROUND, unsigned int WIDTH);",
        "uintmax_t ufromfpxfNx (_FloatNx X, int ROUND, unsigned int WIDTH);",
        "double modf (double VALUE, double *INTEGER-PART);",
        "float modff (float VALUE, float *INTEGER-PART);",
        "long double modfl (long double VALUE, long double *INTEGER-PART);",
        "_FloatN modffN (_FloatN VALUE, _FloatN *INTEGER-PART);",
        "_FloatNx modffNx (_FloatNx VALUE, _FloatNx *INTEGER-PART);",
        "double fmod (double NUMERATOR, double DENOMINATOR);",
        "float fmodf (float NUMERATOR, float DENOMINATOR);",
        "long double fmodl (long double NUMERATOR, long double DENOMINATOR);",
        "_FloatN fmodfN (_FloatN NUMERATOR, _FloatN DENOMINATOR);",
        "_FloatNx fmodfNx (_FloatNx NUMERATOR, _FloatNx DENOMINATOR);",
        "double remainder (double NUMERATOR, double DENOMINATOR);",
        "float remainderf (float NUMERATOR, float DENOMINATOR);",
        "long double remainderl (long double NUMERATOR, long double DENOMINATOR);",
        "_FloatN remainderfN (_FloatN NUMERATOR, _FloatN DENOMINATOR);",
        "_FloatNx remainderfNx (_FloatNx NUMERATOR, _FloatNx DENOMINATOR);",
        "double drem (double NUMERATOR, double DENOMINATOR);",
        "float dremf (float NUMERATOR, float DENOMINATOR);",
        "long double dreml (long double NUMERATOR, long double DENOMINATOR);",
        "double copysign (double X, double Y);",
        "float copysignf (float X, float Y);",
        "long double copysignl (long double X, long double Y);",
        "_FloatN copysignfN (_FloatN X, _FloatN Y);",
        "_FloatNx copysignfNx (_FloatNx X, _FloatNx Y);",
        "int signbit (_float-type_ X);",
        "double nextafter (double X, double Y);",
        "float nextafterf (float X, float Y);",
        "long double nextafterl (long double X, long double Y);",
        "_FloatN nextafterfN (_FloatN X, _FloatN Y);",
        "_FloatNx nextafterfNx (_FloatNx X, _FloatNx Y);",
        "double nexttoward (double X, long double Y);",
        "float nexttowardf (float X, long double Y);",
        "long double nexttowardl (long double X, long double Y);",
        "double nextup (double X);",
        "float nextupf (float X);",
        "long double nextupl (long double X);",
        "_FloatN nextupfN (_FloatN X);",
        "_FloatNx nextupfNx (_FloatNx X);",
        "double nextdown (double X);",
        "float nextdownf (float X);",
        "long double nextdownl (long double X);",
        "_FloatN nextdownfN (_FloatN X);",
        "_FloatNx nextdownfNx (_FloatNx X);",
        "double nan (const char *TAGP);",
        "float nanf (const char *TAGP);",
        "long double nanl (const char *TAGP);",
        "_FloatN nanfN (const char *TAGP);",
        "_FloatNx nanfNx (const char *TAGP);",
        "int canonicalize (double *CX, const double *X);",
        "int canonicalizef (float *CX, const float *X);",
        "int canonicalizel (long double *CX, const long double *X);",
        "int canonicalizefN (_FloatN *CX, const _FloatN *X);",
        "int canonicalizefNx (_FloatNx *CX, const _FloatNx *X);",
        "double getpayload (const double *X);",
        "float getpayloadf (const float *X);",
        "long double getpayloadl (const long double *X);",
        "_FloatN getpayloadfN (const _FloatN *X);",
        "_FloatNx getpayloadfNx (const _FloatNx *X);",
        "int setpayload (double *X, double PAYLOAD);",
        "int setpayloadf (float *X, float PAYLOAD);",
        "int setpayloadl (long double *X, long double PAYLOAD);",
        "int setpayloadfN (_FloatN *X, _FloatN PAYLOAD);",
        "int setpayloadfNx (_FloatNx *X, _FloatNx PAYLOAD);",
        "int setpayloadsig (double *X, double PAYLOAD);",
        "int setpayloadsigf (float *X, float PAYLOAD);",
        "int setpayloadsigl (long double *X, long double PAYLOAD);",
        "int setpayloadsigfN (_FloatN *X, _FloatN PAYLOAD);",
        "int setpayloadsigfNx (_FloatNx *X, _FloatNx PAYLOAD);",
        "int totalorder (double X, double Y);",
        "int totalorderf (float X, float Y);",
        "int totalorderl (long double X, long double Y);",
        "int totalorderfN (_FloatN X, _FloatN Y);",
        "int totalorderfNx (_FloatNx X, _FloatNx Y);",
        "int totalordermag (double X, double Y);",
        "int totalordermagf (float X, float Y);",
        "int totalordermagl (long double X, long double Y);",
        "int totalordermagfN (_FloatN X, _FloatN Y);",
        "int totalordermagfNx (_FloatNx X, _FloatNx Y);",
        "double fmin (double X, double Y);",
        "float fminf (float X, float Y);",
        "long double fminl (long double X, long double Y);",
        "_FloatN fminfN (_FloatN X, _FloatN Y);",
        "_FloatNx fminfNx (_FloatNx X, _FloatNx Y);",
        "double fmax (double X, double Y);",
        "float fmaxf (float X, float Y);",
        "long double fmaxl (long double X, long double Y);",
        "_FloatN fmaxfN (_FloatN X, _FloatN Y);",
        "_FloatNx fmaxfNx (_FloatNx X, _FloatNx Y);",
        "double fminmag (double X, double Y);",
        "float fminmagf (float X, float Y);",
        "long double fminmagl (long double X, long double Y);",
        "_FloatN fminmagfN (_FloatN X, _FloatN Y);",
        "_FloatNx fminmagfNx (_FloatNx X, _FloatNx Y);",
        "double fmaxmag (double X, double Y);",
        "float fmaxmagf (float X, float Y);",
        "long double fmaxmagl (long double X, long double Y);",
        "_FloatN fmaxmagfN (_FloatN X, _FloatN Y);",
        "_FloatNx fmaxmagfNx (_FloatNx X, _FloatNx Y);",
        "double fdim (double X, double Y);",
        "float fdimf (float X, float Y);",
        "long double fdiml (long double X, long double Y);",
        "_FloatN fdimfN (_FloatN X, _FloatN Y);",
        "_FloatNx fdimfNx (_FloatNx X, _FloatNx Y);",
        "double fma (double X, double Y, double Z);",
        "float fmaf (float X, float Y, float Z);",
        "long double fmal (long double X, long double Y, long double Z);",
        "_FloatN fmafN (_FloatN X, _FloatN Y, _FloatN Z);",
        "_FloatNx fmafNx (_FloatNx X, _FloatNx Y, _FloatNx Z);",
        "double creal (complex double Z);",
        "float crealf (complex float Z);",
        "long double creall (complex long double Z);",
        "_FloatN crealfN (complex _FloatN Z);",
        "_FloatNx crealfNx (complex _FloatNx Z);",
        "double cimag (complex double Z);",
        "float cimagf (complex float Z);",
        "long double cimagl (complex long double Z);",
        "_FloatN cimagfN (complex _FloatN Z);",
        "_FloatNx cimagfNx (complex _FloatNx Z);",
        "complex double conj (complex double Z);",
        "complex float conjf (complex float Z);",
        "complex long double conjl (complex long double Z);",
        "complex _FloatN conjfN (complex _FloatN Z);",
        "complex _FloatNx conjfNx (complex _FloatNx Z);",
        "double carg (complex double Z);",
        "float cargf (complex float Z);",
        "long double cargl (complex long double Z);",
        "_FloatN cargfN (complex _FloatN Z);",
        "_FloatNx cargfNx (complex _FloatNx Z);",
        "complex double cproj (complex double Z);",
        "complex float cprojf (complex float Z);",
        "complex long double cprojl (complex long double Z);",
        "complex _FloatN cprojfN (complex _FloatN Z);",
        "complex _FloatNx cprojfNx (complex _FloatNx Z);",
        "long int strtol (const char *restrict STRING, char **restrict TAILPTR, int BASE);",
        "long int wcstol (const wchar_t *restrict STRING, wchar_t **restrict TAILPTR, int BASE);",
        "unsigned long int strtoul (const char *retrict STRING, char **restrict TAILPTR, int BASE);",
        "unsigned long int wcstoul (const wchar_t *restrict STRING, wchar_t **restrict TAILPTR, int BASE);",
        "long long int strtoll (const char *restrict STRING, char **restrict TAILPTR, int BASE);",
        "long long int wcstoll (const wchar_t *restrict STRING, wchar_t **restrict TAILPTR, int BASE);",
        "long long int strtoq (const char *restrict STRING, char **restrict TAILPTR, int BASE);",
        "long long int wcstoq (const wchar_t *restrict STRING, wchar_t **restrict TAILPTR, int BASE);",
        "unsigned long long int strtoull (const char *restrict STRING, char **restrict TAILPTR, int BASE);",
        "unsigned long long int wcstoull (const wchar_t *restrict STRING, wchar_t **restrict TAILPTR, int BASE);",
        "unsigned long long int strtouq (const char *restrict STRING, char **restrict TAILPTR, int BASE);",
        "unsigned long long int wcstouq (const wchar_t *restrict STRING, wchar_t **restrict TAILPTR, int BASE);",
        "intmax_t strtoimax (const char *restrict STRING, char **restrict TAILPTR, int BASE);",
        "intmax_t wcstoimax (const wchar_t *restrict STRING, wchar_t **restrict TAILPTR, int BASE);",
        "uintmax_t strtoumax (const char *restrict STRING, char **restrict TAILPTR, int BASE);",
        "uintmax_t wcstoumax (const wchar_t *restrict STRING, wchar_t **restrict TAILPTR, int BASE);",
        "long int atol (const char *STRING);",
        "int atoi (const char *STRING);",
        "long long int atoll (const char *STRING);",
        "double strtod (const char *restrict STRING, char **restrict TAILPTR);",
        "float strtof (const char *STRING, char **TAILPTR);",
        "long double strtold (const char *STRING, char **TAILPTR);",
        "_FloatN strtofN (const char *STRING, char **TAILPTR);",
        "_FloatNx strtofNx (const char *STRING, char **TAILPTR);",
        "double wcstod (const wchar_t *restrict STRING, wchar_t **restrict TAILPTR);",
        "float wcstof (const wchar_t *STRING, wchar_t **TAILPTR);",
        "long double wcstold (const wchar_t *STRING, wchar_t **TAILPTR);",
        "_FloatN wcstofN (const wchar_t *STRING, wchar_t **TAILPTR);",
        "_FloatNx wcstofNx (const wchar_t *STRING, wchar_t **TAILPTR);",
        "double atof (const char *STRING);",
        "int strfromd (char *restrict STRING, size_t SIZE, const char *restrict FORMAT, double VALUE);",
        "int strfromf (char *restrict STRING, size_t SIZE, const char *restrict FORMAT, float VALUE);",
        "int strfroml (char *restrict STRING, size_t SIZE, const char *restrict FORMAT, long double VALUE);",
        "int strfromfN (char *restrict STRING, size_t SIZE, const char *restrict FORMAT, _FloatN VALUE);",
        "int strfromfNx (char *restrict STRING, size_t SIZE, const char *restrict FORMAT, _FloatNx VALUE);",
        "char * ecvt (double VALUE, int NDIGIT, int *DECPT, int *NEG);",
        "char * fcvt (double VALUE, int NDIGIT, int *DECPT, int *NEG);",
        "char * gcvt (double VALUE, int NDIGIT, char *BUF);",
        "char * qecvt (long double VALUE, int NDIGIT, int *DECPT, int *NEG);",
        "char * qfcvt (long double VALUE, int NDIGIT, int *DECPT, int *NEG);",
        "char * qgcvt (long double VALUE, int NDIGIT, char *BUF);",
        "int ecvt_r (double VALUE, int NDIGIT, int *DECPT, int *NEG, char *BUF, size_t LEN);",
        "int fcvt_r (double VALUE, int NDIGIT, int *DECPT, int *NEG, char *BUF, size_t LEN);",
        "int qecvt_r (long double VALUE, int NDIGIT, int *DECPT, int *NEG, char *BUF, size_t LEN);",
        "int qfcvt_r (long double VALUE, int NDIGIT, int *DECPT, int *NEG, char *BUF, size_t LEN);",
        "double difftime (time_t TIME1, time_t TIME0);",
        "clock_t clock (void);",
        "clock_t times (struct tms *BUFFER);",
        "time_t time (time_t *RESULT);",
        "int stime (const time_t *NEWTIME);",
        "int gettimeofday (struct timeval *TP, struct timezone *TZP);",
        "int settimeofday (const struct timeval *TP, const struct timezone *TZP);",
        "int adjtime (const struct timeval *DELTA, struct timeval *OLDDELTA);",
        "int adjtimex (struct timex *TIMEX);",
        "struct tm * localtime (const time_t *TIME);",
        "struct tm * localtime_r (const time_t *TIME, struct tm *RESULTP);",
        "struct tm * gmtime (const time_t *TIME);",
        "struct tm * gmtime_r (const time_t *TIME, struct tm *RESULTP);",
        "time_t mktime (struct tm *BROKENTIME);",
        "time_t timelocal (struct tm *BROKENTIME);",
        "time_t timegm (struct tm *BROKENTIME);",
        "int ntp_gettime (struct ntptimeval *TPTR);",
        "int ntp_adjtime (struct timex *TPTR);",
        "char * asctime (const struct tm *BROKENTIME);",
        "char * asctime_r (const struct tm *BROKENTIME, char *BUFFER);",
        "char * ctime (const time_t *TIME);",
        "char * ctime_r (const time_t *TIME, char *BUFFER);",
        "size_t strftime (char *S, size_t SIZE, const char *TEMPLATE, const struct tm *BROKENTIME);",
        "size_t wcsftime (wchar_t *S, size_t SIZE, const wchar_t *TEMPLATE, const struct tm *BROKENTIME);",
        "char * strptime (const char *S, const char *FMT, struct tm *TP);",
        "struct tm * getdate (const char *STRING);",
        "int getdate_r (const char *STRING, struct tm *TP);",
        "void tzset (void);",
        "int setitimer (int WHICH, const struct itimerval *NEW, struct itimerval *OLD);",
        "int getitimer (int WHICH, struct itimerval *OLD);",
        "unsigned int alarm (unsigned int SECONDS);",
        "unsigned int sleep (unsigned int SECONDS);",
        "int nanosleep (const struct timespec *REQUESTED_TIME, struct timespec *REMAINING);",
        "int getrusage (int PROCESSES, struct rusage *RUSAGE);",
        "int vtimes (struct vtimes *CURRENT, struct vtimes *CHILD);",
        "int getrlimit (int RESOURCE, struct rlimit *RLP);",
        "int getrlimit64 (int RESOURCE, struct rlimit64 *RLP);",
        "int setrlimit (int RESOURCE, const struct rlimit *RLP);",
        "int setrlimit64 (int RESOURCE, const struct rlimit64 *RLP);",
        "long int ulimit (int CMD, ...);",
        "int vlimit (int RESOURCE, int LIMIT);",
        "int sched_setscheduler (pid_t PID, int POLICY, const struct sched_param *PARAM);",
        "int sched_getscheduler (pid_t PID);",
        "int sched_setparam (pid_t PID, const struct sched_param *PARAM);",
        "int sched_getparam (pid_t PID, struct sched_param *PARAM);",
        "int sched_get_priority_min (int POLICY);",
        "int sched_get_priority_max (int POLICY);",
        "int sched_rr_get_interval (pid_t PID, struct timespec *INTERVAL);",
        "int sched_yield (void);",
        "int getpriority (int CLASS, int ID);",
        "int setpriority (int CLASS, int ID, int NICEVAL);",
        "int nice (int INCREMENT);",
        "int sched_getaffinity (pid_t PID, size_t CPUSETSIZE, cpu_set_t *CPUSET);",
        "int sched_setaffinity (pid_t PID, size_t CPUSETSIZE, const cpu_set_t *CPUSET);",
        "int getpagesize (void);",
        "long int get_phys_pages (void);",
        "long int get_avphys_pages (void);",
        "int get_nprocs_conf (void);",
        "int get_nprocs (void);",
        "int getloadavg (double LOADAVG[], int NELEM);",
        "void longjmp (jmp_buf STATE, int VALUE);",
        "int sigsetjmp (sigjmp_buf STATE, int SAVESIGS);",
        "void siglongjmp (sigjmp_buf STATE, int VALUE);",
        "int getcontext (ucontext_t *UCP);",
        "void makecontext (ucontext_t *UCP, void (*FUNC);",
        "int setcontext (const ucontext_t *UCP);",
        "int swapcontext (ucontext_t *restrict OUCP, const ucontext_t *restrict UCP);",
        "char * strsignal (int SIGNUM);",
        "void psignal (int SIGNUM, const char *MESSAGE);",
        "sighandler_t signal (int SIGNUM, sighandler_t ACTION);",
        "sighandler_t sysv_signal (int SIGNUM, sighandler_t ACTION);",
        "sighandler_t ssignal (int SIGNUM, sighandler_t ACTION);",
        "int sigaction (int SIGNUM, const struct sigaction *restrict ACTION, struct sigaction *restrict OLD-ACTION);",
        "int raise (int SIGNUM);",
        "int gsignal (int SIGNUM);",
        "int kill (pid_t PID, int SIGNUM);",
        "int killpg (int PGID, int SIGNUM);",
        "int sigemptyset (sigset_t *SET);",
        "int sigfillset (sigset_t *SET);",
        "int sigaddset (sigset_t *SET, int SIGNUM);",
        "int sigdelset (sigset_t *SET, int SIGNUM);",
        "int sigismember (const sigset_t *SET, int SIGNUM);",
        "int sigprocmask (int HOW, const sigset_t *restrict SET, sigset_t *restrict OLDSET);",
        "int sigpending (sigset_t *SET);",
        "int pause (void);",
        "int sigsuspend (const sigset_t *SET);",
        "int sigaltstack (const stack_t *restrict STACK, stack_t *restrict OLDSTACK);",
        "int sigstack (struct sigstack *STACK, struct sigstack *OLDSTACK);",
        "int siginterrupt (int SIGNUM, int FAILFLAG);",
        "int sigblock (int MASK);",
        "int sigsetmask (int MASK);",
        "int sigpause (int MASK);",
        "int getopt (int ARGC, char *const *ARGV, const char *OPTIONS);",
        "int getopt_long (int ARGC, char *const *ARGV, const char *SHORTOPTS, const struct option *LONGOPTS, int *INDEXPTR);",
        "int getopt_long_only (int ARGC, char *const *ARGV, const char *SHORTOPTS, const struct option *LONGOPTS, int *INDEXPTR);",
        "error_t argp_parse (const struct argp *ARGP, int ARGC, char **ARGV, unsigned FLAGS, int *ARG_INDEX, void *INPUT);",
        "void argp_usage (const struct argp_state *STATE);",
        "void argp_error (const struct argp_state *STATE, const char *FMT, ...);",
        "void argp_failure (const struct argp_state *STATE, int STATUS, int ERRNUM, const char *FMT, ...);",
        "void argp_state_help (const struct argp_state *STATE, FILE *STREAM, unsigned FLAGS);",
        "void argp_help (const struct argp *ARGP, FILE *STREAM, unsigned FLAGS, char *NAME);",
        "int getsubopt (char **OPTIONP, char *const *TOKENS, char **VALUEP);",
        "char * getenv (const char *NAME);",
        "char * secure_getenv (const char *NAME);",
        "int putenv (char *STRING);",
        "int setenv (const char *NAME, const char *VALUE, int REPLACE);",
        "int unsetenv (const char *NAME);",
        "int clearenv (void);",
        "unsigned long int getauxval (unsigned long int TYPE);",
        "long int syscall (long int SYSNO, ...);",
        "void exit (int STATUS);",
        "int atexit (void (*FUNCTION));",
        "int on_exit (void (*FUNCTION));",
        "void abort (void);",
        "void _exit (int STATUS);",
        "void _Exit (int STATUS);",
        "int system (const char *COMMAND);",
        "pid_t getpid (void);",
        "pid_t getppid (void);",
        "pid_t fork (void);",
        "pid_t vfork (void);",
        "int execv (const char *FILENAME, char *const ARGV[]);",
        "int execl (const char *FILENAME, const char *ARG0, ...);",
        "int execve (const char *FILENAME, char *const ARGV[], char *const ENV[]);",
        "int execle (const char *FILENAME, const char *ARG0, ..., char *const ENV[]);",
        "int execvp (const char *FILENAME, char *const ARGV[]);",
        "int execvpe (const char *FILENAME, char *const ARGV[], char *const ENV[]);",
        "int execlp (const char *FILENAME, const char *ARG0, ...);",
        "pid_t waitpid (pid_t PID, int *STATUS_PTR, int OPTIONS);",
        "pid_t wait (int *STATUS_PTR);",
        "pid_t wait4 (pid_t PID, int *STATUS_PTR, int OPTIONS, struct rusage *USAGE);",
        "pid_t wait3 (int *STATUS_PTR, int OPTIONS, struct rusage *USAGE);",
        "int semctl (int SEMID, int SEMNUM, int CMD);",
        "int semget (key_t KEY, int NSEMS, int SEMFLG);",
        "int semop (int SEMID, struct sembuf *SOPS, size_t NSOPS);",
        "int semtimedop (int SEMID, struct sembuf *SOPS, size_t NSOPS, const struct timespec *TIMEOUT);",
        "int sem_init (sem_t *SEM, int PSHARED, unsigned int VALUE);",
        "int sem_destroy (sem_t *SEM);",
        "sem_t *sem_open (const char *NAME, int OFLAG, ...);",
        "int sem_close (sem_t *SEM);",
        "int sem_unlink (const char *NAME);",
        "int sem_wait (sem_t *SEM);",
        "int sem_timedwait (sem_t *SEM, const struct timespec *ABSTIME);",
        "int sem_trywait (sem_t *SEM);",
        "int sem_post (sem_t *SEM);",
        "int sem_getvalue (sem_t *SEM, int *SVAL);",
        "char * ctermid (char *STRING);",
        "pid_t setsid (void);",
        "pid_t getsid (pid_t PID);",
        "pid_t getpgrp (void);",
        "int getpgid (pid_t PID);",
        "int setpgid (pid_t PID, pid_t PGID);",
        "int setpgrp (pid_t PID, pid_t PGID);",
        "pid_t tcgetpgrp (int FILEDES);",
        "int tcsetpgrp (int FILEDES, pid_t PGID);",
        "pid_t tcgetsid (int FILDES);",
        "uid_t getuid (void);",
        "gid_t getgid (void);",
        "uid_t geteuid (void);",
        "gid_t getegid (void);",
        "int getgroups (int COUNT, gid_t *GROUPS);",
        "int seteuid (uid_t NEWEUID);",
        "int setuid (uid_t NEWUID);",
        "int setreuid (uid_t RUID, uid_t EUID);",
        "int setegid (gid_t NEWGID);",
        "int setgid (gid_t NEWGID);",
        "int setregid (gid_t RGID, gid_t EGID);",
        "int setgroups (size_t COUNT, const gid_t *GROUPS);",
        "int initgroups (const char *USER, gid_t GROUP);",
        "int getgrouplist (const char *USER, gid_t GROUP, gid_t *GROUPS, int *NGROUPS);",
        "char * getlogin (void);",
        "char * cuserid (char *STRING);",
        "void setutent (void);",
        "struct utmp * getutent (void);",
        "void endutent (void);",
        "struct utmp * getutid (const struct utmp *ID);",
        "struct utmp * getutline (const struct utmp *LINE);",
        "struct utmp * pututline (const struct utmp *UTMP);",
        "int getutent_r (struct utmp *BUFFER, struct utmp **RESULT);",
        "int getutid_r (const struct utmp *ID, struct utmp *BUFFER, struct utmp **RESULT);",
        "int getutline_r (const struct utmp *LINE, struct utmp *BUFFER, struct utmp **RESULT);",
        "int utmpname (const char *FILE);",
        "void updwtmp (const char *WTMP_FILE, const struct utmp *UTMP);",
        "void setutxent (void);",
        "struct utmpx * getutxent (void);",
        "void endutxent (void);",
        "struct utmpx * getutxid (const struct utmpx *ID);",
        "struct utmpx * getutxline (const struct utmpx *LINE);",
        "struct utmpx * pututxline (const struct utmpx *UTMP);",
        "int utmpxname (const char *FILE);",
        "int getutmp (const struct utmpx *UTMPX, struct utmp *UTMP);",
        "int getutmpx (const struct utmp *UTMP, struct utmpx *UTMPX);",
        "int login_tty (int FILEDES);",
        "void login (const struct utmp *ENTRY);",
        "int logout (const char *UT_LINE);",
        "void logwtmp (const char *UT_LINE, const char *UT_NAME, const char *UT_HOST);",
        "struct passwd * getpwuid (uid_t UID);",
        "int getpwuid_r (uid_t UID, struct passwd *RESULT_BUF, char *BUFFER, size_t BUFLEN, struct passwd **RESULT);",
        "struct passwd * getpwnam (const char *NAME);",
        "int getpwnam_r (const char *NAME, struct passwd *RESULT_BUF, char *BUFFER, size_t BUFLEN, struct passwd **RESULT);",
        "struct passwd * fgetpwent (FILE *STREAM);",
        "int fgetpwent_r (FILE *STREAM, struct passwd *RESULT_BUF, char *BUFFER, size_t BUFLEN, struct passwd **RESULT);",
        "void setpwent (void);",
        "struct passwd * getpwent (void);",
        "int getpwent_r (struct passwd *RESULT_BUF, char *BUFFER, size_t BUFLEN, struct passwd **RESULT);",
        "void endpwent (void);",
        "int putpwent (const struct passwd *P, FILE *STREAM);",
        "struct group * getgrgid (gid_t GID);",
        "int getgrgid_r (gid_t GID, struct group *RESULT_BUF, char *BUFFER, size_t BUFLEN, struct group **RESULT);",
        "struct group * getgrnam (const char *NAME);",
        "int getgrnam_r (const char *NAME, struct group *RESULT_BUF, char *BUFFER, size_t BUFLEN, struct group **RESULT);",
        "struct group * fgetgrent (FILE *STREAM);",
        "int fgetgrent_r (FILE *STREAM, struct group *RESULT_BUF, char *BUFFER, size_t BUFLEN, struct group **RESULT);",
        "void setgrent (void);",
        "struct group * getgrent (void);",
        "int getgrent_r (struct group *RESULT_BUF, char *BUFFER, size_t BUFLEN, struct group **RESULT);",
        "void endgrent (void);",
        "int setnetgrent (const char *NETGROUP);",
        "int getnetgrent (char **HOSTP, char **USERP, char **DOMAINP);",
        "int getnetgrent_r (char **HOSTP, char **USERP, char **DOMAINP, char *BUFFER, size_t BUFLEN);",
        "void endnetgrent (void);",
        "int innetgr (const char *NETGROUP, const char *HOST, const char *USER, const char *DOMAIN);",
        "int gethostname (char *NAME, size_t SIZE);",
        "int sethostname (const char *NAME, size_t LENGTH);",
        "int getdomainnname (char *NAME, size_t LENGTH);",
        "int setdomainname (const char *NAME, size_t LENGTH);",
        "long int gethostid (void);",
        "int sethostid (long int ID);",
        "int uname (struct utsname *INFO);",
        "int setfsent (void);",
        "void endfsent (void);",
        "struct fstab * getfsent (void);",
        "struct fstab * getfsspec (const char *NAME);",
        "struct fstab * getfsfile (const char *NAME);",
        "FILE * setmntent (const char *FILE, const char *MODE);",
        "int endmntent (FILE *STREAM);",
        "struct mntent * getmntent (FILE *STREAM);",
        "struct mntent * getmntent_r (FILE *STREAM, struct mntent *RESULT, char *BUFFER, int BUFSIZE);",
        "int addmntent (FILE *STREAM, const struct mntent *MNT);",
        "char * hasmntopt (const struct mntent *MNT, const char *OPT);",
        "int mount (const char *SPECIAL_FILE, const char *DIR, const char *FSTYPE, unsigned long int OPTIONS, const void *DATA);",
        "int umount2 (const char *FILE, int FLAGS);",
        "int umount (const char *FILE);",
        "int sysctl (int *NAMES, int NLEN, void *OLDVAL, size_t *OLDLENP, void *NEWVAL, size_t NEWLEN);",
        "long int sysconf (int PARAMETER);",
        "long int pathconf (const char *FILENAME, int PARAMETER);",
        "long int fpathconf (int FILEDES, int PARAMETER);",
        "size_t confstr (int PARAMETER, char *BUF, size_t LEN);",
        "char * getpass (const char *PROMPT);",
        "char * crypt (const char *KEY, const char *SALT);",
        "char * crypt_r (const char *KEY, const char *SALT, struct crypt_data * DATA);",
        "void setkey (const char *KEY);",
        "void encrypt (char *BLOCK, int EDFLAG);",
        "void setkey_r (const char *KEY, struct crypt_data * DATA);",
        "void encrypt_r (char *BLOCK, int EDFLAG, struct crypt_data * DATA);",
        "int ecb_crypt (char *KEY, char *BLOCKS, unsigned int LEN, unsigned int MODE);",
        "int DES_FAILED (int ERR);",
        "int cbc_crypt (char *KEY, char *BLOCKS, unsigned int LEN, unsigned int MODE, char *IVEC);",
        "void des_setparity (char *KEY);",
        "int getentropy (void *BUFFER, size_t LENGTH);",
        "ssize_t getrandom (void *BUFFER, size_t LENGTH, unsigned int FLAGS);",
        "int backtrace (void **BUFFER, int SIZE);",
        "char ** backtrace_symbols (void *const *BUFFER, int SIZE);",
        "void backtrace_symbols_fd (void *const *BUFFER, int SIZE, int FD);",
        "int pthread_key_create (pthread_key_t *KEY, void (*DESTRUCTOR);",
        "int pthread_key_delete (pthread_key_t KEY);",
        "void *pthread_getspecific (pthread_key_t KEY);",
        "int pthread_setspecific (pthread_key_t KEY, const void *VALUE);",
        "int pthread_getattr_default_np (pthread_attr_t *ATTR);",
        "int pthread_setattr_default_np (pthread_attr_t *ATTR);",
        "uint64_t __ppc_get_timebase (void);",
        "uint64_t __ppc_get_timebase_freq (void);",
        "void __ppc_yield (void);",
        "void __ppc_mdoio (void);",
        "void __ppc_mdoom (void);",
        "void __ppc_set_ppr_med (void);",
        "void __ppc_set_ppr_low (void);",
        "void __ppc_set_ppr_med_low (void);",
        "void __ppc_set_ppr_very_low (void);",
        "void __ppc_set_ppr_med_high (void);",
        "void __stack_chk_fail (void);",
    ]
