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);
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 * gets (char *S);
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 __sprintf_chk (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);
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);
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, ...);
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);
int *__errno_location (void);