FD_CLR	sys/select.h		pselect, select - synchronous I/O multiplexing	void FD_CLR(int fd, fd_set *fdset);
FD_ISSET	sys/select.h		pselect, select - synchronous I/O multiplexing	int FD_ISSET(int fd, fd_set *fdset);
FD_SET	sys/select.h		pselect, select - synchronous I/O multiplexing	void FD_SET(int fd, fd_set *fdset);
FD_ZERO	sys/select.h		pselect, select - synchronous I/O multiplexing	void FD_ZERO(fd_set *fdset);
_Exit	stdlib.h		_Exit, _exit - terminate a process	void _Exit(int status);
_exit	unistd.h		_Exit, _exit - terminate a process	void _exit(int status);
_longjmp	setjmp.h	OB XSI	_longjmp, _setjmp - non-local goto	void _longjmp(jmp_buf env, int val);
_setjmp	setjmp.h	OB XSI	_longjmp, _setjmp - non-local goto	int _setjmp(jmp_buf env);
_tolower	ctype.h	OB XSI	_tolower - transliterate uppercase characters to lowercase	int _tolower(int c);
_toupper	ctype.h	OB XSI	_toupper - transliterate lowercase characters to uppercase	int _toupper(int c);
a64l	stdlib.h	XSI	a64l, l64a - convert between a 32-bit integer and a radix-64 ASCII string	long a64l(const char *s);
abort	stdlib.h		abort - generate an abnormal process abort	void abort(void);
abs	stdlib.h		abs - return an integer absolute value	int abs(int i);
accept	sys/socket.h		accept - accept a new connection on a socket	int accept(int socket, struct sockaddr *restrict address, socklen_t *restrict address_len);
access	unistd.h		access, faccessat - determine accessibility of a file relative to directory file descriptor	int access(const char *path, int amode);
acos	math.h		acos, acosf, acosl - arc cosine functions	double acos(double x);
acosf	math.h		acos, acosf, acosl - arc cosine functions	float acosf(float x);
acosh	math.h		acosh, acoshf, acoshl - inverse hyperbolic cosine functions	double acosh(double x);
acoshf	math.h		acosh, acoshf, acoshl - inverse hyperbolic cosine functions	float acoshf(float x);
acoshl	math.h		acosh, acoshf, acoshl - inverse hyperbolic cosine functions	long double acoshl(long double x);
acosl	math.h		acos, acosf, acosl - arc cosine functions	long double acosl(long double x);
aio_cancel	aio.h		aio_cancel - cancel an asynchronous I/O request	int aio_cancel(int fildes, struct aiocb *aiocbp);
aio_error	aio.h		aio_error - retrieve errors status for an asynchronous I/O operation	int aio_error(const struct aiocb *aiocbp);
aio_fsync	aio.h		aio_fsync - asynchronous file synchronization	int aio_fsync(int op, struct aiocb *aiocbp);
aio_read	aio.h		aio_read - asynchronous read from a file	int aio_read(struct aiocb *aiocbp);
aio_return	aio.h		aio_return - retrieve return status of an asynchronous I/O operation	ssize_t aio_return(struct aiocb *aiocbp);
aio_suspend	aio.h		aio_suspend - wait for an asynchronous I/O request	int aio_suspend(const struct aiocb *const list[], int nent, const struct timespec *timeout);
aio_write	aio.h		aio_write - asynchronous write to a file	int aio_write(struct aiocb *aiocbp);
alarm	unistd.h		alarm - schedule an alarm signal	unsigned alarm(unsigned seconds);
alphasort	dirent.h		alphasort, scandir - scan a directory	int alphasort(const struct dirent **d1, const struct dirent **d2);
asctime	time.h	OB	asctime, asctime_r - convert date and time to a string	char *asctime(const struct tm *timeptr);
asctime_r	time.h	OB CX	asctime, asctime_r - convert date and time to a string	char *asctime_r(const struct tm *restrict tm, char *restrict buf);
asin	math.h		asin, asinf, asinl - arc sine function	double asin(double x);
asinf	math.h		asin, asinf, asinl - arc sine function	float asinf(float x);
asinh	math.h		asinh, asinhf, asinhl - inverse hyperbolic sine functions	double asinh(double x);
asinhf	math.h		asinh, asinhf, asinhl - inverse hyperbolic sine functions	float asinhf(float x);
asinhl	math.h		asinh, asinhf, asinhl - inverse hyperbolic sine functions	long double asinhl(long double x);
asinl	math.h		asin, asinf, asinl - arc sine function	long double asinl(long double x);
assert	assert.h		assert - insert program diagnostics	void assert(scalar expression);
atan	math.h		atan, atanf, atanl - arc tangent function	double atan(double x);
atan2	math.h		atan2, atan2f, atan2l - arc tangent functions	double atan2(double y, double x);
atan2f	math.h		atan2, atan2f, atan2l - arc tangent functions	float atan2f(float y, float x);
atan2l	math.h		atan2, atan2f, atan2l - arc tangent functions	long double atan2l(long double y, long double x);
atanf	math.h		atan, atanf, atanl - arc tangent function	float atanf(float x);
atanh	math.h		atanh, atanhf, atanhl - inverse hyperbolic tangent functions	double atanh(double x);
atanhf	math.h		atanh, atanhf, atanhl - inverse hyperbolic tangent functions	float atanhf(float x);
atanhl	math.h		atanh, atanhf, atanhl - inverse hyperbolic tangent functions	long double atanhl(long double x);
atanl	math.h		atan, atanf, atanl - arc tangent function	long double atanl(long double x);
atexit	stdlib.h		atexit - register a function to run at process termination	int atexit(void (*func)(void));
atof	stdlib.h		atof - convert a string to a double-precision number	double atof(const char *str);
atoi	stdlib.h		atoi - convert a string to an integer	int atoi(const char *str);
atol	stdlib.h		atol, atoll - convert a string to a long integer	long atol(const char *str);
atoll	stdlib.h		atol, atoll - convert a string to a long integer	long long atoll(const char *nptr);
basename	libgen.h	XSI	basename - return the last component of a pathname	char *basename(char *path);
bind	sys/socket.h		bind - bind a name to a socket	int bind(int socket, const struct sockaddr *address, socklen_t address_len);
bsearch	stdlib.h		bsearch - binary search a sorted table	void *bsearch(const void *key, const void *base, size_t nel, size_t width, int (*compar)(const void *, const void *));
btowc	stdio.h wchar.h		btowc - single byte to wide character conversion	wint_t btowc(int c);
cabs	complex.h		cabs, cabsf, cabsl - return a complex absolute value	double cabs(double complex z);
cabsf	complex.h		cabs, cabsf, cabsl - return a complex absolute value	float cabsf(float complex z);
cabsl	complex.h		cabs, cabsf, cabsl - return a complex absolute value	long double cabsl(long double complex z);
cacos	complex.h		cacos, cacosf, cacosl - complex arc cosine functions	double complex cacos(double complex z);
cacosf	complex.h		cacos, cacosf, cacosl - complex arc cosine functions	float complex cacosf(float complex z);
cacosh	complex.h		cacosh, cacoshf, cacoshl - complex arc hyperbolic cosine functions	double complex cacosh(double complex z);
cacoshf	complex.h		cacosh, cacoshf, cacoshl - complex arc hyperbolic cosine functions	float complex cacoshf(float complex z);
cacoshl	complex.h		cacosh, cacoshf, cacoshl - complex arc hyperbolic cosine functions	long double complex cacoshl(long double complex z);
cacosl	complex.h		cacos, cacosf, cacosl - complex arc cosine functions	long double complex cacosl(long double complex z);
calloc	stdlib.h		calloc - a memory allocator	void *calloc(size_t nelem, size_t elsize);
carg	complex.h		carg, cargf, cargl - complex argument functions	double carg(double complex z);
cargf	complex.h		carg, cargf, cargl - complex argument functions	float cargf(float complex z);
cargl	complex.h		carg, cargf, cargl - complex argument functions	long double cargl(long double complex z);
casin	complex.h		casin, casinf, casinl - complex arc sine functions	double complex casin(double complex z);
casinf	complex.h		casin, casinf, casinl - complex arc sine functions	float complex casinf(float complex z);
casinh	complex.h		casinh, casinhf, casinhl - complex arc hyperbolic sine functions	double complex casinh(double complex z);
casinhf	complex.h		casinh, casinhf, casinhl - complex arc hyperbolic sine functions	float complex casinhf(float complex z);
casinhl	complex.h		casinh, casinhf, casinhl - complex arc hyperbolic sine functions	long double complex casinhl(long double complex z);
casinl	complex.h		casin, casinf, casinl - complex arc sine functions	long double complex casinl(long double complex z);
catan	complex.h		catan, catanf, catanl - complex arc tangent functions	double complex catan(double complex z);
catanf	complex.h		catan, catanf, catanl - complex arc tangent functions	float complex catanf(float complex z);
catanh	complex.h		catanh, catanhf, catanhl - complex arc hyperbolic tangent functions	double complex catanh(double complex z);
catanhf	complex.h		catanh, catanhf, catanhl - complex arc hyperbolic tangent functions	float complex catanhf(float complex z);
catanhl	complex.h		catanh, catanhf, catanhl - complex arc hyperbolic tangent functions	long double complex catanhl(long double complex z);
catanl	complex.h		catan, catanf, catanl - complex arc tangent functions	long double complex catanl(long double complex z);
catclose	nl_types.h		catclose - close a message catalog descriptor	int catclose(nl_catd catd);
catgets	nl_types.h		catgets - read a program message	char *catgets(nl_catd catd, int set_id, int msg_id, const char *s);
catopen	nl_types.h		catopen - open a message catalog	nl_catd catopen(const char *name, int oflag);
cbrt	math.h		cbrt, cbrtf, cbrtl - cube root functions	double cbrt(double x);
cbrtf	math.h		cbrt, cbrtf, cbrtl - cube root functions	float cbrtf(float x);
cbrtl	math.h		cbrt, cbrtf, cbrtl - cube root functions	long double cbrtl(long double x);
ccos	complex.h		ccos, ccosf, ccosl - complex cosine functions	double complex ccos(double complex z);
ccosf	complex.h		ccos, ccosf, ccosl - complex cosine functions	float complex ccosf(float complex z);
ccosh	complex.h		ccosh, ccoshf, ccoshl - complex hyperbolic cosine functions	double complex ccosh(double complex z);
ccoshf	complex.h		ccosh, ccoshf, ccoshl - complex hyperbolic cosine functions	float complex ccoshf(float complex z);
ccoshl	complex.h		ccosh, ccoshf, ccoshl - complex hyperbolic cosine functions	long double complex ccoshl(long double complex z);
ccosl	complex.h		ccos, ccosf, ccosl - complex cosine functions	long double complex ccosl(long double complex z);
ceil	math.h		ceil, ceilf, ceill - ceiling value function	double ceil(double x);
ceilf	math.h		ceil, ceilf, ceill - ceiling value function	float ceilf(float x);
ceill	math.h		ceil, ceilf, ceill - ceiling value function	long double ceill(long double x);
cexp	complex.h		cexp, cexpf, cexpl - complex exponential functions	double complex cexp(double complex z);
cexpf	complex.h		cexp, cexpf, cexpl - complex exponential functions	float complex cexpf(float complex z);
cexpl	complex.h		cexp, cexpf, cexpl - complex exponential functions	long double complex cexpl(long double complex z);
cfgetispeed	termios.h		cfgetispeed - get input baud rate	speed_t cfgetispeed(const struct termios *termios_p);
cfgetospeed	termios.h		cfgetospeed - get output baud rate	speed_t cfgetospeed(const struct termios *termios_p);
cfsetispeed	termios.h		cfsetispeed - set input baud rate	int cfsetispeed(struct termios *termios_p, speed_t speed);
cfsetospeed	termios.h		cfsetospeed - set output baud rate	int cfsetospeed(struct termios *termios_p, speed_t speed);
chdir	unistd.h		chdir - change working directory	int chdir(const char *path);
chmod	sys/stat.h		chmod, fchmodat - change mode of a file relative to directory file descriptor	int chmod(const char *path, mode_t mode);
chown	unistd.h		chown, fchownat - change owner and group of a file relative to directory file descriptor	int chown(const char *path, uid_t owner, gid_t group);
cimag	complex.h		cimag, cimagf, cimagl - complex imaginary functions	double cimag(double complex z);
cimagf	complex.h		cimag, cimagf, cimagl - complex imaginary functions	float cimagf(float complex z);
cimagl	complex.h		cimag, cimagf, cimagl - complex imaginary functions	long double cimagl(long double complex z);
clearerr	stdio.h		clearerr - clear indicators on a stream	void clearerr(FILE *stream);
clock	time.h		clock - report CPU time used	clock_t clock(void);
clock_getcpuclockid	time.h	CPT	clock_getcpuclockid - access a process CPU-time clock (<b>ADVANCED REALTIME</b>)	int clock_getcpuclockid(pid_t pid, clockid_t *clock_id);
clock_getres	time.h	CX	clock_getres, clock_gettime, clock_settime - clock and timer functions	int clock_getres(clockid_t clock_id, struct timespec *res);
clock_gettime	time.h	CX	clock_getres, clock_gettime, clock_settime - clock and timer functions	int clock_gettime(clockid_t clock_id, struct timespec *tp);
clock_nanosleep	time.h	CX	clock_nanosleep - high resolution sleep with specifiable clock	int clock_nanosleep(clockid_t clock_id, int flags, const struct timespec *rqtp, struct timespec *rmtp);
clock_settime	time.h	CX	clock_getres, clock_gettime, clock_settime - clock and timer functions	int clock_settime(clockid_t clock_id, const struct timespec *tp);
clog	complex.h		clog, clogf, clogl - complex natural logarithm functions	double complex clog(double complex z);
clogf	complex.h		clog, clogf, clogl - complex natural logarithm functions	float complex clogf(float complex z);
clogl	complex.h		clog, clogf, clogl - complex natural logarithm functions	long double complex clogl(long double complex z);
close	unistd.h		close - close a file descriptor	int close(int fildes);
closedir	dirent.h		closedir - close a directory stream	int closedir(DIR *dirp);
closelog	syslog.h	XSI	closelog, openlog, setlogmask, syslog - control system log	void closelog(void);
confstr	unistd.h		confstr - get configurable variables	size_t confstr(int name, char *buf, size_t len);
conj	complex.h		conj, conjf, conjl - complex conjugate functions	double complex conj(double complex z);
conjf	complex.h		conj, conjf, conjl - complex conjugate functions	float complex conjf(float complex z);
conjl	complex.h		conj, conjf, conjl - complex conjugate functions	long double complex conjl(long double complex z);
connect	sys/socket.h		connect - connect a socket	int connect(int socket, const struct sockaddr *address, socklen_t address_len);
copysign	math.h		copysign, copysignf, copysignl - number manipulation function	double copysign(double x, double y);
copysignf	math.h		copysign, copysignf, copysignl - number manipulation function	float copysignf(float x, float y);
copysignl	math.h		copysign, copysignf, copysignl - number manipulation function	long double copysignl(long double x, long double y);
cos	math.h		cos, cosf, cosl - cosine function	double cos(double x);
cosf	math.h		cos, cosf, cosl - cosine function	float cosf(float x);
cosh	math.h		cosh, coshf, coshl - hyperbolic cosine functions	double cosh(double x);
coshf	math.h		cosh, coshf, coshl - hyperbolic cosine functions	float coshf(float x);
coshl	math.h		cosh, coshf, coshl - hyperbolic cosine functions	long double coshl(long double x);
cosl	math.h		cos, cosf, cosl - cosine function	long double cosl(long double x);
cpow	complex.h		cpow, cpowf, cpowl - complex power functions	double complex cpow(double complex x, double complex y);
cpowf	complex.h		cpow, cpowf, cpowl - complex power functions	float complex cpowf(float complex x, float complex y);
cpowl	complex.h		cpow, cpowf, cpowl - complex power functions	long double complex cpowl(long double complex x, long double complex y);
cproj	complex.h		cproj, cprojf, cprojl - complex projection functions	double complex cproj(double complex z);
cprojf	complex.h		cproj, cprojf, cprojl - complex projection functions	float complex cprojf(float complex z);
cprojl	complex.h		cproj, cprojf, cprojl - complex projection functions	long double complex cprojl(long double complex z);
creal	complex.h		creal, crealf, creall - complex real functions	double creal(double complex z);
crealf	complex.h		creal, crealf, creall - complex real functions	float crealf(float complex z);
creall	complex.h		creal, crealf, creall - complex real functions	long double creall(long double complex z);
creat	sys/stat.h fcntl.h	OH	creat - create a new file or rewrite an existing one	int creat(const char *path, mode_t mode);
crypt	unistd.h	XSI	crypt - string encoding function (<b>CRYPT</b>)	char *crypt(const char *key, const char *salt);
csin	complex.h		csin, csinf, csinl - complex sine functions	double complex csin(double complex z);
csinf	complex.h		csin, csinf, csinl - complex sine functions	float complex csinf(float complex z);
csinh	complex.h		csinh, csinhf, csinhl - complex hyperbolic sine functions	double complex csinh(double complex z);
csinhf	complex.h		csinh, csinhf, csinhl - complex hyperbolic sine functions	float complex csinhf(float complex z);
csinhl	complex.h		csinh, csinhf, csinhl - complex hyperbolic sine functions	long double complex csinhl(long double complex z);
csinl	complex.h		csin, csinf, csinl - complex sine functions	long double complex csinl(long double complex z);
csqrt	complex.h		csqrt, csqrtf, csqrtl - complex square root functions	double complex csqrt(double complex z);
csqrtf	complex.h		csqrt, csqrtf, csqrtl - complex square root functions	float complex csqrtf(float complex z);
csqrtl	complex.h		csqrt, csqrtf, csqrtl - complex square root functions	long double complex csqrtl(long double complex z);
ctan	complex.h		ctan, ctanf, ctanl - complex tangent functions	double complex ctan(double complex z);
ctanf	complex.h		ctan, ctanf, ctanl - complex tangent functions	float complex ctanf(float complex z);
ctanh	complex.h		ctanh, ctanhf, ctanhl - complex hyperbolic tangent functions	double complex ctanh(double complex z);
ctanhf	complex.h		ctanh, ctanhf, ctanhl - complex hyperbolic tangent functions	float complex ctanhf(float complex z);
ctanhl	complex.h		ctanh, ctanhf, ctanhl - complex hyperbolic tangent functions	long double complex ctanhl(long double complex z);
ctanl	complex.h		ctan, ctanf, ctanl - complex tangent functions	long double complex ctanl(long double complex z);
ctermid	stdio.h	CX	ctermid - generate a pathname for the controlling terminal	char *ctermid(char *s);
ctime	time.h	OB	ctime, ctime_r - convert a time value to a date and time string	char *ctime(const time_t *clock);
ctime_r	time.h	OB CX	ctime, ctime_r - convert a time value to a date and time string	char *ctime_r(const time_t *clock, char *buf);
daylight	time.h	XSI	daylight, timezone, tzname, tzset - set timezone conversion information	
dbm_clearerr	ndbm.h	XSI	dbm_clearerr, dbm_close, dbm_delete, dbm_error, dbm_fetch, dbm_firstkey, dbm_nextkey, dbm_open, dbm_store - database functions	int dbm_clearerr(DBM *db);
dbm_close	ndbm.h	XSI	dbm_clearerr, dbm_close, dbm_delete, dbm_error, dbm_fetch, dbm_firstkey, dbm_nextkey, dbm_open, dbm_store - database functions	void dbm_close(DBM *db);
dbm_delete	ndbm.h	XSI	dbm_clearerr, dbm_close, dbm_delete, dbm_error, dbm_fetch, dbm_firstkey, dbm_nextkey, dbm_open, dbm_store - database functions	int dbm_delete(DBM *db, datum key);
dbm_error	ndbm.h	XSI	dbm_clearerr, dbm_close, dbm_delete, dbm_error, dbm_fetch, dbm_firstkey, dbm_nextkey, dbm_open, dbm_store - database functions	int dbm_error(DBM *db);
dbm_fetch	ndbm.h	XSI	dbm_clearerr, dbm_close, dbm_delete, dbm_error, dbm_fetch, dbm_firstkey, dbm_nextkey, dbm_open, dbm_store - database functions	datum dbm_fetch(DBM *db, datum key);
dbm_firstkey	ndbm.h	XSI	dbm_clearerr, dbm_close, dbm_delete, dbm_error, dbm_fetch, dbm_firstkey, dbm_nextkey, dbm_open, dbm_store - database functions	datum dbm_firstkey(DBM *db);
dbm_nextkey	ndbm.h	XSI	dbm_clearerr, dbm_close, dbm_delete, dbm_error, dbm_fetch, dbm_firstkey, dbm_nextkey, dbm_open, dbm_store - database functions	datum dbm_nextkey(DBM *db);
dbm_open	ndbm.h	XSI	dbm_clearerr, dbm_close, dbm_delete, dbm_error, dbm_fetch, dbm_firstkey, dbm_nextkey, dbm_open, dbm_store - database functions	DBM *dbm_open(const char *file, int open_flags, mode_t file_mode);
dbm_store	ndbm.h	XSI	dbm_clearerr, dbm_close, dbm_delete, dbm_error, dbm_fetch, dbm_firstkey, dbm_nextkey, dbm_open, dbm_store - database functions	int dbm_store(DBM *db, datum key, datum content, int store_mode);
difftime	time.h		difftime - compute the difference between two calendar time values	double difftime(time_t time1, time_t time0);
dirfd	dirent.h		dirfd - extract the file descriptor used by a DIR stream	int dirfd(DIR *dirp);
dirname	libgen.h	XSI	dirname - report the parent directory name of a file pathname	char *dirname(char *path);
div	stdlib.h		div - compute the quotient and remainder of an integer division	div_t div(int numer, int denom);
dlclose	dlfcn.h		dlclose - close a dlopen object	int dlclose(void *handle);
dlerror	dlfcn.h		dlerror - get diagnostic information	char *dlerror(void);
dlopen	dlfcn.h		dlopen - gain access to an executable object file	void *dlopen(const char *file, int mode);
dlsym	dlfcn.h		dlsym - obtain the address of a symbol from a dlopen object	void *dlsym(void *restrict handle, const char *restrict name);
dprintf	stdio.h	CX	dprintf, fprintf, printf, snprintf, sprintf - print formatted output	int dprintf(int fildes, const char *restrict format, ...);
drand48	stdlib.h	XSI	drand48, erand48, jrand48, lcong48, lrand48, mrand48, nrand48, seed48, srand48 - generate uniformly distributed pseudo-random numbers	double drand48(void);
dup	unistd.h		dup, dup2 - duplicate an open file descriptor	int dup(int fildes);
dup2	unistd.h		dup, dup2 - duplicate an open file descriptor	int dup2(int fildes, int fildes2);
duplocale	locale.h	CX	duplocale - duplicate a locale object	locale_t duplocale(locale_t locobj);
encrypt	unistd.h	XSI	encrypt - encoding function (<b>CRYPT</b>)	void encrypt(char block[64], int edflag);
endgrent	grp.h	XSI	endgrent, getgrent, setgrent - group database entry functions	void endgrent(void);
endhostent	netdb.h		endhostent, gethostent, sethostent - network host database functions	void endhostent(void);
endnetent	netdb.h		endnetent, getnetbyaddr, getnetbyname, getnetent, setnetent - network database functions	void endnetent(void);
endprotoent	netdb.h		endprotoent, getprotobyname, getprotobynumber, getprotoent, setprotoent - network protocol database functions	void endprotoent(void);
endpwent	pwd.h	XSI	endpwent, getpwent, setpwent - user database functions	void endpwent(void);
endservent	netdb.h		endservent, getservbyname, getservbyport, getservent, setservent - network services database functions	void endservent(void);
endutxent	utmpx.h	XSI	endutxent, getutxent, getutxid, getutxline, pututxline, setutxent - user accounting database functions	void endutxent(void);
environ	unistd.h		environ, execl, execle, execlp, execv, execve, execvp, fexecve - execute a file	
erand48	stdlib.h	XSI	drand48, erand48, jrand48, lcong48, lrand48, mrand48, nrand48, seed48, srand48 - generate uniformly distributed pseudo-random numbers	double erand48(unsigned short xsubi[3]);
erf	math.h		erf, erff, erfl - error functions	double erf(double x);
erfc	math.h		erfc, erfcf, erfcl - complementary error functions	double erfc(double x);
erfcf	math.h		erfc, erfcf, erfcl - complementary error functions	float erfcf(float x);
erfcl	math.h		erfc, erfcf, erfcl - complementary error functions	long double erfcl(long double x);
erff	math.h		erf, erff, erfl - error functions	float erff(float x);
erfl	math.h		erf, erff, erfl - error functions	long double erfl(long double x);
errno	errno.h		errno - error return value	
execl	unistd.h		environ, execl, execle, execlp, execv, execve, execvp, fexecve - execute a file	int execl(const char *path, const char *arg0, ... /*, (char *)0 */);
execle	unistd.h		environ, execl, execle, execlp, execv, execve, execvp, fexecve - execute a file	int execle(const char *path, const char *arg0, ... /*, (char *)0, char *const envp[]*/);
execlp	unistd.h		environ, execl, execle, execlp, execv, execve, execvp, fexecve - execute a file	int execlp(const char *file, const char *arg0, ... /*, (char *)0 */);
execv	unistd.h		environ, execl, execle, execlp, execv, execve, execvp, fexecve - execute a file	int execv(const char *path, char *const argv[]);
execve	unistd.h		environ, execl, execle, execlp, execv, execve, execvp, fexecve - execute a file	int execve(const char *path, char *const argv[], char *const envp[]);
execvp	unistd.h		environ, execl, execle, execlp, execv, execve, execvp, fexecve - execute a file	int execvp(const char *file, char *const argv[]);
exit	stdlib.h		exit - terminate a process	void exit(int status);
exp	math.h		exp, expf, expl - exponential function	double exp(double x);
exp2	math.h		exp2, exp2f, exp2l - exponential base 2 functions	double exp2(double x);
exp2f	math.h		exp2, exp2f, exp2l - exponential base 2 functions	float exp2f(float x);
exp2l	math.h		exp2, exp2f, exp2l - exponential base 2 functions	long double exp2l(long double x);
expf	math.h		exp, expf, expl - exponential function	float expf(float x);
expl	math.h		exp, expf, expl - exponential function	long double expl(long double x);
expm1	math.h		expm1, expm1f, expm1l - compute exponential functions	double expm1(double x);
expm1f	math.h		expm1, expm1f, expm1l - compute exponential functions	float expm1f(float x);
expm1l	math.h		expm1, expm1f, expm1l - compute exponential functions	long double expm1l(long double x);
fabs	math.h		fabs, fabsf, fabsl - absolute value function	double fabs(double x);
fabsf	math.h		fabs, fabsf, fabsl - absolute value function	float fabsf(float x);
fabsl	math.h		fabs, fabsf, fabsl - absolute value function	long double fabsl(long double x);
faccessat	unistd.h		access, faccessat - determine accessibility of a file relative to directory file descriptor	int faccessat(int fd, const char *path, int amode, int flag);
fchdir	unistd.h		fchdir - change working directory	int fchdir(int fildes);
fchmod	sys/stat.h		fchmod - change mode of a file	int fchmod(int fildes, mode_t mode);
fchmodat	sys/stat.h		chmod, fchmodat - change mode of a file relative to directory file descriptor	int fchmodat(int fd, const char *path, mode_t mode, int flag);
fchown	unistd.h		fchown - change owner and group of a file	int fchown(int fildes, uid_t owner, gid_t group);
fchownat	unistd.h		chown, fchownat - change owner and group of a file relative to directory file descriptor	int fchownat(int fd, const char *path, uid_t owner, gid_t group, int flag);
fclose	stdio.h		fclose - close a stream	int fclose(FILE *stream);
fcntl	fcntl.h		fcntl - file control	int fcntl(int fildes, int cmd, ...);
fdatasync	unistd.h	SIO	fdatasync - synchronize the data of a file (<b>REALTIME</b>)	int fdatasync(int fildes);
fdim	math.h		fdim, fdimf, fdiml - compute positive difference between two floating-point numbers	double fdim(double x, double y);
fdimf	math.h		fdim, fdimf, fdiml - compute positive difference between two floating-point numbers	float fdimf(float x, float y);
fdiml	math.h		fdim, fdimf, fdiml - compute positive difference between two floating-point numbers	long double fdiml(long double x, long double y);
fdopen	stdio.h	CX	fdopen - associate a stream with a file descriptor	FILE *fdopen(int fildes, const char *mode);
fdopendir	dirent.h		fdopendir, opendir - open directory associated with file descriptor	DIR *fdopendir(int fd);
feclearexcept	fenv.h		feclearexcept - clear floating-point exception	int feclearexcept(int excepts);
fegetenv	fenv.h		fegetenv, fesetenv - get and set current floating-point environment	int fegetenv(fenv_t *envp);
fegetexceptflag	fenv.h		fegetexceptflag, fesetexceptflag - get and set floating-point status flags	int fegetexceptflag(fexcept_t *flagp, int excepts);
fegetround	fenv.h		fegetround, fesetround - get and set current rounding direction	int fegetround(void);
feholdexcept	fenv.h		feholdexcept - save current floating-point environment	int feholdexcept(fenv_t *envp);
feof	stdio.h		feof - test end-of-file indicator on a stream	int feof(FILE *stream);
feraiseexcept	fenv.h		feraiseexcept - raise floating-point exception	int feraiseexcept(int excepts);
ferror	stdio.h		ferror - test error indicator on a stream	int ferror(FILE *stream);
fesetenv	fenv.h		fegetenv, fesetenv - get and set current floating-point environment	int fesetenv(const fenv_t *envp);
fesetexceptflag	fenv.h		fegetexceptflag, fesetexceptflag - get and set floating-point status flags	int fesetexceptflag(const fexcept_t *flagp, int excepts);
fesetround	fenv.h		fegetround, fesetround - get and set current rounding direction	int fesetround(int round);
fetestexcept	fenv.h		fetestexcept - test floating-point exception flags	int fetestexcept(int excepts);
feupdateenv	fenv.h		feupdateenv - update floating-point environment	int feupdateenv(const fenv_t *envp);
fexecve	unistd.h		environ, execl, execle, execlp, execv, execve, execvp, fexecve - execute a file	int fexecve(int fd, char *const argv[], char *const envp[]);
fflush	stdio.h		fflush - flush a stream	int fflush(FILE *stream);
ffs	strings.h	XSI	ffs - find first set bit	int ffs(int i);
fgetc	stdio.h		fgetc - get a byte from a stream	int fgetc(FILE *stream);
fgetpos	stdio.h		fgetpos - get current file position information	int fgetpos(FILE *restrict stream, fpos_t *restrict pos);
fgets	stdio.h		fgets - get a string from a stream	char *fgets(char *restrict s, int n, FILE *restrict stream);
fgetwc	stdio.h wchar.h		fgetwc - get a wide-character code from a stream	wint_t fgetwc(FILE *stream);
fgetws	stdio.h wchar.h		fgetws - get a wide-character string from a stream	wchar_t *fgetws(wchar_t *restrict ws, int n, FILE *restrict stream);
fileno	stdio.h	CX	fileno - map a stream pointer to a file descriptor	int fileno(FILE *stream);
flockfile	stdio.h	CX	flockfile, ftrylockfile, funlockfile - stdio locking functions	void flockfile(FILE *file);
floor	math.h		floor, floorf, floorl - floor function	double floor(double x);
floorf	math.h		floor, floorf, floorl - floor function	float floorf(float x);
floorl	math.h		floor, floorf, floorl - floor function	long double floorl(long double x);
fma	math.h		fma, fmaf, fmal - floating-point multiply-add	double fma(double x, double y, double z);
fmaf	math.h		fma, fmaf, fmal - floating-point multiply-add	float fmaf(float x, float y, float z);
fmal	math.h		fma, fmaf, fmal - floating-point multiply-add	long double fmal(long double x, long double y, long double z);
fmax	math.h		fmax, fmaxf, fmaxl - determine maximum numeric value of two floating-point numbers	double fmax(double x, double y);
fmaxf	math.h		fmax, fmaxf, fmaxl - determine maximum numeric value of two floating-point numbers	float fmaxf(float x, float y);
fmaxl	math.h		fmax, fmaxf, fmaxl - determine maximum numeric value of two floating-point numbers	long double fmaxl(long double x, long double y);
fmemopen	stdio.h	CX	fmemopen - open a memory buffer stream	FILE *fmemopen(void *restrict buf, size_t size, const char *restrict mode);
fmin	math.h		fmin, fminf, fminl - determine minimum numeric value of two floating-point numbers	double fmin(double x, double y);
fminf	math.h		fmin, fminf, fminl - determine minimum numeric value of two floating-point numbers	float fminf(float x, float y);
fminl	math.h		fmin, fminf, fminl - determine minimum numeric value of two floating-point numbers	long double fminl(long double x, long double y);
fmod	math.h		fmod, fmodf, fmodl - floating-point remainder value function	double fmod(double x, double y);
fmodf	math.h		fmod, fmodf, fmodl - floating-point remainder value function	float fmodf(float x, float y);
fmodl	math.h		fmod, fmodf, fmodl - floating-point remainder value function	long double fmodl(long double x, long double y);
fmtmsg	fmtmsg.h	XSI	fmtmsg - display a message in the specified format on standard error and/or a system console	int fmtmsg(long classification, const char *label, int severity, const char *text, const char *action, const char *tag);
fnmatch	fnmatch.h		fnmatch - match a filename or a pathname	int fnmatch(const char *pattern, const char *string, int flags);
fopen	stdio.h		fopen - open a stream	FILE *fopen(const char *restrict filename, const char *restrict mode);
fork	unistd.h		fork - create a new process	pid_t fork(void);
fpathconf	unistd.h		fpathconf, pathconf - get configurable pathname variables	long fpathconf(int fildes, int name);
fpclassify	math.h		fpclassify - classify real floating type	int fpclassify(real-floating x);
fprintf	stdio.h		dprintf, fprintf, printf, snprintf, sprintf - print formatted output	int fprintf(FILE *restrict stream, const char *restrict format, ...);
fputc	stdio.h		fputc - put a byte on a stream	int fputc(int c, FILE *stream);
fputs	stdio.h		fputs - put a string on a stream	int fputs(const char *restrict s, FILE *restrict stream);
fputwc	stdio.h wchar.h		fputwc - put a wide-character code on a stream	wint_t fputwc(wchar_t wc, FILE *stream);
fputws	stdio.h wchar.h		fputws - put a wide-character string on a stream	int fputws(const wchar_t *restrict ws, FILE *restrict stream);
fread	stdio.h		fread - binary input	size_t fread(void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream);
free	stdlib.h		free - free allocated memory	void free(void *ptr);
freeaddrinfo	sys/socket.h netdb.h		freeaddrinfo, getaddrinfo - get address information	void freeaddrinfo(struct addrinfo *ai);
freelocale	locale.h	CX	freelocale - free resources allocated for a locale object	void freelocale(locale_t locobj);
freopen	stdio.h		freopen - open a stream	FILE *freopen(const char *restrict filename, const char *restrict mode, FILE *restrict stream);
frexp	math.h		frexp, frexpf, frexpl - extract mantissa and exponent from a double precision number	double frexp(double num, int *exp);
frexpf	math.h		frexp, frexpf, frexpl - extract mantissa and exponent from a double precision number	float frexpf(float num, int *exp);
frexpl	math.h		frexp, frexpf, frexpl - extract mantissa and exponent from a double precision number	long double frexpl(long double num, int *exp);
fscanf	stdio.h		fscanf, scanf, sscanf - convert formatted input	int fscanf(FILE *restrict stream, const char *restrict format, ...);
fseek	stdio.h		fseek, fseeko - reposition a file-position indicator in a stream	int fseek(FILE *stream, long offset, int whence);
fseeko	stdio.h	CX	fseek, fseeko - reposition a file-position indicator in a stream	int fseeko(FILE *stream, off_t offset, int whence);
fsetpos	stdio.h		fsetpos - set current file position	int fsetpos(FILE *stream, const fpos_t *pos);
fstat	sys/stat.h		fstat - get file status	int fstat(int fildes, struct stat *buf);
fstatat	sys/stat.h		fstatat, lstat, stat - get file status	int fstatat(int fd, const char *restrict path, struct stat *restrict buf, int flag);
fstatvfs	sys/statvfs.h		fstatvfs, statvfs - get file system information	int fstatvfs(int fildes, struct statvfs *buf);
fsync	unistd.h	FSC	fsync - synchronize changes to a file	int fsync(int fildes);
ftell	stdio.h		ftell, ftello - return a file offset in a stream	long ftell(FILE *stream);
ftello	stdio.h	CX	ftell, ftello - return a file offset in a stream	off_t ftello(FILE *stream);
ftok	sys/ipc.h	XSI	ftok - generate an IPC key	key_t ftok(const char *path, int id);
ftruncate	unistd.h		ftruncate - truncate a file to a specified length	int ftruncate(int fildes, off_t length);
ftrylockfile	stdio.h	CX	flockfile, ftrylockfile, funlockfile - stdio locking functions	int ftrylockfile(FILE *file);
ftw	ftw.h	OB XSI	ftw - traverse (walk) a file tree	int ftw(const char *path, int (*fn)(const char *, const struct stat *ptr, int flag), int ndirs);
funlockfile	stdio.h	CX	flockfile, ftrylockfile, funlockfile - stdio locking functions	void funlockfile(FILE *file);
futimens	sys/stat.h		futimens, utimensat, utimes - set file access and modification times	int futimens(int fd, const struct timespec times[2]);
fwide	stdio.h wchar.h		fwide - set stream orientation	int fwide(FILE *stream, int mode);
fwprintf	stdio.h wchar.h		fwprintf, swprintf, wprintf - print formatted wide-character output	int fwprintf(FILE *restrict stream, const wchar_t *restrict format, ...);
fwrite	stdio.h		fwrite - binary output	size_t fwrite(const void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream);
fwscanf	stdio.h wchar.h		fwscanf, swscanf, wscanf - convert formatted wide-character input	int fwscanf(FILE *restrict stream, const wchar_t *restrict format, ...);
gai_strerror	netdb.h		gai_strerror - address and name information error description	const char *gai_strerror(int ecode);
getaddrinfo	sys/socket.h netdb.h		freeaddrinfo, getaddrinfo - get address information	int getaddrinfo(const char *restrict nodename, const char *restrict servname, const struct addrinfo *restrict hints, struct addrinfo **restrict res);
getc	stdio.h		getc - get a byte from a stream	int getc(FILE *stream);
getc_unlocked	stdio.h	CX	getc_unlocked, getchar_unlocked, putc_unlocked, putchar_unlocked - stdio with explicit client locking	int getc_unlocked(FILE *stream);
getchar	stdio.h		getchar - get a byte from a .I stdin stream	int getchar(void);
getchar_unlocked	stdio.h	CX	getc_unlocked, getchar_unlocked, putc_unlocked, putchar_unlocked - stdio with explicit client locking	int getchar_unlocked(void);
getcwd	unistd.h		getcwd - get the pathname of the current working directory	char *getcwd(char *buf, size_t size);
getdate	time.h	XSI	getdate - convert user format date and time	struct tm *getdate(const char *string);
getdate_err	time.h	XSI	getdate - convert user format date and time	
getdelim	stdio.h	CX	getdelim, getline - read a delimited record from .I stream	ssize_t getdelim(char **restrict lineptr, size_t *restrict n, int delimiter, FILE *restrict stream);
getegid	unistd.h		getegid - get the effective group ID	gid_t getegid(void);
getenv	stdlib.h		getenv - get value of an environment variable	char *getenv(const char *name);
geteuid	unistd.h		geteuid - get the effective user ID	uid_t geteuid(void);
getgid	unistd.h		getgid - get the real group ID	gid_t getgid(void);
getgrent	grp.h	XSI	endgrent, getgrent, setgrent - group database entry functions	struct group *getgrent(void);
getgrgid	grp.h		getgrgid, getgrgid_r - get group database entry for a group ID	struct group *getgrgid(gid_t gid);
getgrgid_r	grp.h		getgrgid, getgrgid_r - get group database entry for a group ID	int getgrgid_r(gid_t gid, struct group *grp, char *buffer, size_t bufsize, struct group **result);
getgrnam	grp.h		getgrnam, getgrnam_r - search group database for a name	struct group *getgrnam(const char *name);
getgrnam_r	grp.h		getgrnam, getgrnam_r - search group database for a name	int getgrnam_r(const char *name, struct group *grp, char *buffer, size_t bufsize, struct group **result);
getgroups	unistd.h		getgroups - get supplementary group IDs	int getgroups(int gidsetsize, gid_t grouplist[]);
gethostent	netdb.h		endhostent, gethostent, sethostent - network host database functions	struct hostent *gethostent(void);
gethostid	unistd.h	XSI	gethostid - get an identifier for the current host	long gethostid(void);
gethostname	unistd.h		gethostname - get name of current host	int gethostname(char *name, size_t namelen);
getitimer	sys/time.h	OB XSI	getitimer, setitimer - get and set value of interval timer	int getitimer(int which, struct itimerval *value);
getline	stdio.h	CX	getdelim, getline - read a delimited record from .I stream	ssize_t getline(char **restrict lineptr, size_t *restrict n, FILE *restrict stream);
getlogin	unistd.h		getlogin, getlogin_r - get login name	char *getlogin(void);
getlogin_r	unistd.h		getlogin, getlogin_r - get login name	int getlogin_r(char *name, size_t namesize);
getnameinfo	sys/socket.h netdb.h		getnameinfo - get name information	int getnameinfo(const struct sockaddr *restrict sa, socklen_t salen, char *restrict node, socklen_t nodelen, char *restrict service, socklen_t servicelen, int flags);
getnetbyaddr	netdb.h		endnetent, getnetbyaddr, getnetbyname, getnetent, setnetent - network database functions	struct netent *getnetbyaddr(uint32_t net, int type);
getnetbyname	netdb.h		endnetent, getnetbyaddr, getnetbyname, getnetent, setnetent - network database functions	struct netent *getnetbyname(const char *name);
getnetent	netdb.h		endnetent, getnetbyaddr, getnetbyname, getnetent, setnetent - network database functions	struct netent *getnetent(void);
getopt	unistd.h		getopt, optarg, opterr, optind, optopt - command option parsing	int getopt(int argc, char * const argv[], const char *optstring);
getpeername	sys/socket.h		getpeername - get the name of the peer socket	int getpeername(int socket, struct sockaddr *restrict address, socklen_t *restrict address_len);
getpgid	unistd.h		getpgid - get the process group ID for a process	pid_t getpgid(pid_t pid);
getpgrp	unistd.h		getpgrp - get the process group ID of the calling process	pid_t getpgrp(void);
getpid	unistd.h		getpid - get the process ID	pid_t getpid(void);
getppid	unistd.h		getppid - get the parent process ID	pid_t getppid(void);
getpriority	sys/resource.h	XSI	getpriority, setpriority - get and set the nice value	int getpriority(int which, id_t who);
getprotobyname	netdb.h		endprotoent, getprotobyname, getprotobynumber, getprotoent, setprotoent - network protocol database functions	struct protoent *getprotobyname(const char *name);
getprotobynumber	netdb.h		endprotoent, getprotobyname, getprotobynumber, getprotoent, setprotoent - network protocol database functions	struct protoent *getprotobynumber(int proto);
getprotoent	netdb.h		endprotoent, getprotobyname, getprotobynumber, getprotoent, setprotoent - network protocol database functions	struct protoent *getprotoent(void);
getpwent	pwd.h	XSI	endpwent, getpwent, setpwent - user database functions	struct passwd *getpwent(void);
getpwnam	pwd.h		getpwnam, getpwnam_r - search user database for a name	struct passwd *getpwnam(const char *name);
getpwnam_r	pwd.h		getpwnam, getpwnam_r - search user database for a name	int getpwnam_r(const char *name, struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result);
getpwuid	pwd.h		getpwuid, getpwuid_r - search user database for a user ID	struct passwd *getpwuid(uid_t uid);
getpwuid_r	pwd.h		getpwuid, getpwuid_r - search user database for a user ID	int getpwuid_r(uid_t uid, struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result);
getrlimit	sys/resource.h	XSI	getrlimit, setrlimit - control maximum resource consumption	int getrlimit(int resource, struct rlimit *rlp);
getrusage	sys/resource.h	XSI	getrusage - get information about resource utilization	int getrusage(int who, struct rusage *r_usage);
gets	stdio.h	OB	gets - get a string from a .I stdin stream	char *gets(char *s);
getservbyname	netdb.h		endservent, getservbyname, getservbyport, getservent, setservent - network services database functions	struct servent *getservbyname(const char *name, const char *proto);
getservbyport	netdb.h		endservent, getservbyname, getservbyport, getservent, setservent - network services database functions	struct servent *getservbyport(int port, const char *proto);
getservent	netdb.h		endservent, getservbyname, getservbyport, getservent, setservent - network services database functions	struct servent *getservent(void);
getsid	unistd.h		getsid - get the process group ID of a session leader	pid_t getsid(pid_t pid);
getsockname	sys/socket.h		getsockname - get the socket name	int getsockname(int socket, struct sockaddr *restrict address, socklen_t *restrict address_len);
getsockopt	sys/socket.h		getsockopt - get the socket options	int getsockopt(int socket, int level, int option_name, void *restrict option_value, socklen_t *restrict option_len);
getsubopt	stdlib.h		getsubopt - parse suboption arguments from a string	int getsubopt(char **optionp, char * const *keylistp, char **valuep);
gettimeofday	sys/time.h	OB XSI	gettimeofday - get the date and time	int gettimeofday(struct timeval *restrict tp, void *restrict tzp);
getuid	unistd.h		getuid - get a real user ID	uid_t getuid(void);
getutxent	utmpx.h	XSI	endutxent, getutxent, getutxid, getutxline, pututxline, setutxent - user accounting database functions	struct utmpx *getutxent(void);
getutxid	utmpx.h	XSI	endutxent, getutxent, getutxid, getutxline, pututxline, setutxent - user accounting database functions	struct utmpx *getutxid(const struct utmpx *id);
getutxline	utmpx.h	XSI	endutxent, getutxent, getutxid, getutxline, pututxline, setutxent - user accounting database functions	struct utmpx *getutxline(const struct utmpx *line);
getwc	stdio.h wchar.h		getwc - get a wide character from a stream	wint_t getwc(FILE *stream);
getwchar	wchar.h		getwchar - get a wide character from a .I stdin stream	wint_t getwchar(void);
glob	glob.h		glob, globfree - generate pathnames matching a pattern	int glob(const char *restrict pattern, int flags, int(*errfunc)(const char *epath, int eerrno), glob_t *restrict pglob);
globfree	glob.h		glob, globfree - generate pathnames matching a pattern	void globfree(glob_t *pglob);
gmtime	time.h		gmtime, gmtime_r - convert a time value to a broken-down UTC time	struct tm *gmtime(const time_t *timer);
gmtime_r	time.h	CX	gmtime, gmtime_r - convert a time value to a broken-down UTC time	struct tm *gmtime_r(const time_t *restrict timer, struct tm *restrict result);
grantpt	stdlib.h	XSI	grantpt - grant access to the slave pseudo-terminal device	int grantpt(int fildes);
hcreate	search.h	XSI	hcreate, hdestroy, hsearch - manage hash search table	int hcreate(size_t nel);
hdestroy	search.h	XSI	hcreate, hdestroy, hsearch - manage hash search table	void hdestroy(void);
hsearch	search.h	XSI	hcreate, hdestroy, hsearch - manage hash search table	ENTRY *hsearch(ENTRY item, ACTION action);
htonl	arpa/inet.h		htonl, htons, ntohl, ntohs - convert values between host and network byte order	uint32_t htonl(uint32_t hostlong);
htons	arpa/inet.h		htonl, htons, ntohl, ntohs - convert values between host and network byte order	uint16_t htons(uint16_t hostshort);
hypot	math.h		hypot, hypotf, hypotl - Euclidean distance function	double hypot(double x, double y);
hypotf	math.h		hypot, hypotf, hypotl - Euclidean distance function	float hypotf(float x, float y);
hypotl	math.h		hypot, hypotf, hypotl - Euclidean distance function	long double hypotl(long double x, long double y);
iconv	iconv.h		iconv - codeset conversion function	size_t iconv(iconv_t cd, char **restrict inbuf, size_t *restrict inbytesleft, char **restrict outbuf, size_t *restrict outbytesleft);
iconv_close	iconv.h		iconv_close - codeset conversion deallocation function	int iconv_close(iconv_t cd);
iconv_open	iconv.h		iconv_open - codeset conversion allocation function	iconv_t iconv_open(const char *tocode, const char *fromcode);
if_freenameindex	net/if.h		if_freenameindex - free memory allocated by if_nameindex	void if_freenameindex(struct if_nameindex *ptr);
if_indextoname	net/if.h		if_indextoname - map a network interface index to its corresponding name	char *if_indextoname(unsigned ifindex, char *ifname);
if_nameindex	net/if.h		if_nameindex - return all network interface names and indexes	struct if_nameindex *if_nameindex(void);
if_nametoindex	net/if.h		if_nametoindex - map a network interface name to its corresponding index	unsigned if_nametoindex(const char *ifname);
ilogb	math.h		ilogb, ilogbf, ilogbl - return an unbiased exponent	int ilogb(double x);
ilogbf	math.h		ilogb, ilogbf, ilogbl - return an unbiased exponent	int ilogbf(float x);
ilogbl	math.h		ilogb, ilogbf, ilogbl - return an unbiased exponent	int ilogbl(long double x);
imaxabs	inttypes.h		imaxabs - return absolute value	intmax_t imaxabs(intmax_t j);
imaxdiv	inttypes.h		imaxdiv - return quotient and remainder	imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);
inet_addr	arpa/inet.h		inet_addr, inet_ntoa - IPv4 address manipulation	in_addr_t inet_addr(const char *cp);
inet_ntoa	arpa/inet.h		inet_addr, inet_ntoa - IPv4 address manipulation	char *inet_ntoa(struct in_addr in);
inet_ntop	arpa/inet.h		inet_ntop, inet_pton - convert IPv4 and IPv6 addresses between binary and text form	const char *inet_ntop(int af, const void *restrict src, char *restrict dst, socklen_t size);
inet_pton	arpa/inet.h		inet_ntop, inet_pton - convert IPv4 and IPv6 addresses between binary and text form	int inet_pton(int af, const char *restrict src, void *restrict dst);
initstate	stdlib.h	XSI	initstate, random, setstate, srandom - pseudo-random number functions	char *initstate(unsigned seed, char *state, size_t size);
insque	search.h	XSI	insque, remque - insert or remove an element in a queue	void insque(void *element, void *pred);
isalnum	ctype.h		isalnum, isalnum_l - test for an alphanumeric character	int isalnum(int c);
isalnum_l	ctype.h	CX	isalnum, isalnum_l - test for an alphanumeric character	int isalnum_l(int c, locale_t locale);
isalpha	ctype.h		isalpha, isalpha_l - test for an alphabetic character	int isalpha(int c);
isalpha_l	ctype.h	CX	isalpha, isalpha_l - test for an alphabetic character	int isalpha_l(int c, locale_t locale);
isascii	ctype.h	OB XSI	isascii - test for a 7-bit US-ASCII character	int isascii(int c);
isatty	unistd.h		isatty - test for a terminal device	int isatty(int fildes);
isblank	ctype.h		isblank, isblank_l - test for a blank character	int isblank(int c);
isblank_l	ctype.h	CX	isblank, isblank_l - test for a blank character	int isblank_l(int c, locale_t locale);
iscntrl	ctype.h		iscntrl, iscntrl_l - test for a control character	int iscntrl(int c);
iscntrl_l	ctype.h	CX	iscntrl, iscntrl_l - test for a control character	int iscntrl_l(int c, locale_t locale);
isdigit	ctype.h		isdigit, isdigit_l - test for a decimal digit	int isdigit(int c);
isdigit_l	ctype.h	CX	isdigit, isdigit_l - test for a decimal digit	int isdigit_l(int c, locale_t locale);
isfinite	math.h		isfinite - test for finite value	int isfinite(real-floating x);
isgraph	ctype.h		isgraph, isgraph_l - test for a visible character	int isgraph(int c);
isgraph_l	ctype.h	CX	isgraph, isgraph_l - test for a visible character	int isgraph_l(int c, locale_t locale);
isgreater	math.h		isgreater - test if x greater than y	int isgreater(real-floating x, real-floating y);
isgreaterequal	math.h		isgreaterequal - test if x is greater than or equal to y	int isgreaterequal(real-floating x, real-floating y);
isinf	math.h		isinf - test for infinity	int isinf(real-floating x);
isless	math.h		isless - test if x is less than y	int isless(real-floating x, real-floating y);
islessequal	math.h		islessequal - test if x is less than or equal to y	int islessequal(real-floating x, real-floating y);
islessgreater	math.h		islessgreater - test if x is less than or greater than y	int islessgreater(real-floating x, real-floating y);
islower	ctype.h		islower, islower_l - test for a lowercase letter	int islower(int c);
islower_l	ctype.h	CX	islower, islower_l - test for a lowercase letter	int islower_l(int c, locale_t locale);
isnan	math.h		isnan - test for a NaN	int isnan(real-floating x);
isnormal	math.h		isnormal - test for a normal value	int isnormal(real-floating x);
isprint	ctype.h		isprint, isprint_l - test for a printable character	int isprint(int c);
isprint_l	ctype.h	CX	isprint, isprint_l - test for a printable character	int isprint_l(int c, locale_t locale);
ispunct	ctype.h		ispunct, ispunct_l - test for a punctuation character	int ispunct(int c);
ispunct_l	ctype.h	CX	ispunct, ispunct_l - test for a punctuation character	int ispunct_l(int c, locale_t locale);
isspace	ctype.h		isspace, isspace_l - test for a white-space character	int isspace(int c);
isspace_l	ctype.h	CX	isspace, isspace_l - test for a white-space character	int isspace_l(int c, locale_t locale);
isunordered	math.h		isunordered - test if arguments are unordered	int isunordered(real-floating x, real-floating y);
isupper	ctype.h		isupper, isupper_l - test for an uppercase letter	int isupper(int c);
isupper_l	ctype.h	CX	isupper, isupper_l - test for an uppercase letter	int isupper_l(int c, locale_t locale);
iswalnum	wctype.h		iswalnum, iswalnum_l - test for an alphanumeric wide-character code	int iswalnum(wint_t wc);
iswalnum_l	wctype.h	CX	iswalnum, iswalnum_l - test for an alphanumeric wide-character code	int iswalnum_l(wint_t wc, locale_t locale);
iswalpha	wctype.h		iswalpha, iswalpha_l - test for an alphabetic wide-character code	int iswalpha(wint_t wc);
iswalpha_l	wctype.h	CX	iswalpha, iswalpha_l - test for an alphabetic wide-character code	int iswalpha_l(wint_t wc, locale_t locale);
iswblank	wctype.h		iswblank, iswblank_l - test for a blank wide-character code	int iswblank(wint_t wc);
iswblank_l	wctype.h	CX	iswblank, iswblank_l - test for a blank wide-character code	int iswblank_l(wint_t wc, locale_t locale);
iswcntrl	wctype.h		iswcntrl, iswcntrl_l - test for a control wide-character code	int iswcntrl(wint_t wc);
iswcntrl_l	wctype.h	CX	iswcntrl, iswcntrl_l - test for a control wide-character code	int iswcntrl_l(wint_t wc, locale_t locale);
iswctype	wctype.h		iswctype, iswctype_l - test character for a specified class	int iswctype(wint_t wc, wctype_t charclass);
iswctype_l	wctype.h	CX	iswctype, iswctype_l - test character for a specified class	int iswctype_l(wint_t wc, wctype_t charclass, locale_t locale);
iswdigit	wctype.h		iswdigit, iswdigit_l - test for a decimal digit wide-character code	int iswdigit(wint_t wc);
iswdigit_l	wctype.h	CX	iswdigit, iswdigit_l - test for a decimal digit wide-character code	int iswdigit_l(wint_t wc, locale_t locale);
iswgraph	wctype.h		iswgraph, iswgraph_l - test for a visible wide-character code	int iswgraph(wint_t wc);
iswgraph_l	wctype.h	CX	iswgraph, iswgraph_l - test for a visible wide-character code	int iswgraph_l(wint_t wc, locale_t locale);
iswlower	wctype.h		iswlower, iswlower_l - test for a lowercase letter wide-character code	int iswlower(wint_t wc);
iswlower_l	wctype.h	CX	iswlower, iswlower_l - test for a lowercase letter wide-character code	int iswlower_l(wint_t wc, locale_t locale);
iswprint	wctype.h		iswprint, iswprint_l - test for a printable wide-character code	int iswprint(wint_t wc);
iswprint_l	wctype.h	CX	iswprint, iswprint_l - test for a printable wide-character code	int iswprint_l(wint_t wc, locale_t locale);
iswpunct	wctype.h		iswpunct, iswpunct_l - test for a punctuation wide-character code	int iswpunct(wint_t wc);
iswpunct_l	wctype.h	CX	iswpunct, iswpunct_l - test for a punctuation wide-character code	int iswpunct_l(wint_t wc, locale_t locale);
iswspace	wctype.h		iswspace, iswspace_l - test for a white-space wide-character code	int iswspace(wint_t wc);
iswspace_l	wctype.h	CX	iswspace, iswspace_l - test for a white-space wide-character code	int iswspace_l(wint_t wc, locale_t locale);
iswupper	wctype.h		iswupper, iswupper_l - test for an uppercase letter wide-character code	int iswupper(wint_t wc);
iswupper_l	wctype.h	CX	iswupper, iswupper_l - test for an uppercase letter wide-character code	int iswupper_l(wint_t wc, locale_t locale);
iswxdigit	wctype.h		iswxdigit, iswxdigit_l - test for a hexadecimal digit wide-character code	int iswxdigit(wint_t wc);
iswxdigit_l	wctype.h	CX	iswxdigit, iswxdigit_l - test for a hexadecimal digit wide-character code	int iswxdigit_l(wint_t wc, locale_t locale);
isxdigit	ctype.h		isxdigit, isxdigit_l - test for a hexadecimal digit	int isxdigit(int c);
isxdigit_l	ctype.h	CX	isxdigit, isxdigit_l - test for a hexadecimal digit	int isxdigit_l(int c, locale_t locale);
j0	math.h	XSI	j0, j1, jn - Bessel functions of the first kind	double j0(double x);
j1	math.h	XSI	j0, j1, jn - Bessel functions of the first kind	double j1(double x);
jn	math.h	XSI	j0, j1, jn - Bessel functions of the first kind	double jn(int n, double x);
jrand48	stdlib.h	XSI	drand48, erand48, jrand48, lcong48, lrand48, mrand48, nrand48, seed48, srand48 - generate uniformly distributed pseudo-random numbers	long jrand48(unsigned short xsubi[3]);
kill	signal.h	CX	kill - send a signal to a process or a group of processes	int kill(pid_t pid, int sig);
killpg	signal.h	XSI	killpg - send a signal to a process group	int killpg(pid_t pgrp, int sig);
l64a	stdlib.h	XSI	a64l, l64a - convert between a 32-bit integer and a radix-64 ASCII string	char *l64a(long value);
labs	stdlib.h		labs, llabs - return a long integer absolute value	long labs(long i);
lchown	unistd.h		lchown - change the owner and group of a symbolic link	int lchown(const char *path, uid_t owner, gid_t group);
lcong48	stdlib.h	XSI	drand48, erand48, jrand48, lcong48, lrand48, mrand48, nrand48, seed48, srand48 - generate uniformly distributed pseudo-random numbers	void lcong48(unsigned short param[7]);
ldexp	math.h		ldexp, ldexpf, ldexpl - load exponent of a floating-point number	double ldexp(double x, int exp);
ldexpf	math.h		ldexp, ldexpf, ldexpl - load exponent of a floating-point number	float ldexpf(float x, int exp);
ldexpl	math.h		ldexp, ldexpf, ldexpl - load exponent of a floating-point number	long double ldexpl(long double x, int exp);
ldiv	stdlib.h		ldiv, lldiv - compute quotient and remainder of a long division	ldiv_t ldiv(long numer, long denom);
lfind	search.h	XSI	lsearch, lfind - linear search and update	void *lfind(const void *key, const void *base, size_t *nelp, size_t width, int (*compar)(const void *, const void *));
lgamma	math.h		lgamma, lgammaf, lgammal, signgam - log gamma function	double lgamma(double x);
lgammaf	math.h		lgamma, lgammaf, lgammal, signgam - log gamma function	float lgammaf(float x);
lgammal	math.h		lgamma, lgammaf, lgammal, signgam - log gamma function	long double lgammal(long double x);
link	unistd.h		link, linkat - link one file to another file relative to two directory file descriptors	int link(const char *path1, const char *path2);
linkat	unistd.h		link, linkat - link one file to another file relative to two directory file descriptors	int linkat(int fd1, const char *path1, int fd2, const char *path2, int flag);
lio_listio	aio.h		lio_listio - list directed I/O	int lio_listio(int mode, struct aiocb *restrict const list[restrict], int nent, struct sigevent *restrict sig);
listen	sys/socket.h		listen - listen for socket connections and limit the queue of incoming connections	int listen(int socket, int backlog);
llabs	stdlib.h		labs, llabs - return a long integer absolute value	long long llabs(long long i);
lldiv	stdlib.h		ldiv, lldiv - compute quotient and remainder of a long division	lldiv_t lldiv(long long numer, long long denom);
llrint	math.h		llrint, llrintf, llrintl - round to the nearest integer value using current rounding direction	long long llrint(double x);
llrintf	math.h		llrint, llrintf, llrintl - round to the nearest integer value using current rounding direction	long long llrintf(float x);
llrintl	math.h		llrint, llrintf, llrintl - round to the nearest integer value using current rounding direction	long long llrintl(long double x);
llround	math.h		llround, llroundf, llroundl - round to nearest integer value	long long llround(double x);
llroundf	math.h		llround, llroundf, llroundl - round to nearest integer value	long long llroundf(float x);
llroundl	math.h		llround, llroundf, llroundl - round to nearest integer value	long long llroundl(long double x);
localeconv	locale.h		localeconv - return locale-specific information	struct lconv *localeconv(void);
localtime	time.h		localtime, localtime_r - convert a time value to a broken-down local time	struct tm *localtime(const time_t *timer);
localtime_r	time.h	CX	localtime, localtime_r - convert a time value to a broken-down local time	struct tm *localtime_r(const time_t *restrict timer, struct tm *restrict result);
lockf	unistd.h	XSI	lockf - record locking on files	int lockf(int fildes, int function, off_t size);
log	math.h		log, logf, logl - natural logarithm function	double log(double x);
log10	math.h		log10, log10f, log10l - base 10 logarithm function	double log10(double x);
log10f	math.h		log10, log10f, log10l - base 10 logarithm function	float log10f(float x);
log10l	math.h		log10, log10f, log10l - base 10 logarithm function	long double log10l(long double x);
log1p	math.h		log1p, log1pf, log1pl - compute a natural logarithm	double log1p(double x);
log1pf	math.h		log1p, log1pf, log1pl - compute a natural logarithm	float log1pf(float x);
log1pl	math.h		log1p, log1pf, log1pl - compute a natural logarithm	long double log1pl(long double x);
log2	math.h		log2, log2f, log2l - compute base 2 logarithm functions	double log2(double x);
log2f	math.h		log2, log2f, log2l - compute base 2 logarithm functions	float log2f(float x);
log2l	math.h		log2, log2f, log2l - compute base 2 logarithm functions	long double log2l(long double x);
logb	math.h		logb, logbf, logbl - radix-independent exponent	double logb(double x);
logbf	math.h		logb, logbf, logbl - radix-independent exponent	float logbf(float x);
logbl	math.h		logb, logbf, logbl - radix-independent exponent	long double logbl(long double x);
logf	math.h		log, logf, logl - natural logarithm function	float logf(float x);
logl	math.h		log, logf, logl - natural logarithm function	long double logl(long double x);
longjmp	setjmp.h		longjmp - non-local goto	void longjmp(jmp_buf env, int val);
lrand48	stdlib.h	XSI	drand48, erand48, jrand48, lcong48, lrand48, mrand48, nrand48, seed48, srand48 - generate uniformly distributed pseudo-random numbers	long lrand48(void);
lrint	math.h		lrint, lrintf, lrintl - round to nearest integer value using current rounding direction	long lrint(double x);
lrintf	math.h		lrint, lrintf, lrintl - round to nearest integer value using current rounding direction	long lrintf(float x);
lrintl	math.h		lrint, lrintf, lrintl - round to nearest integer value using current rounding direction	long lrintl(long double x);
lround	math.h		lround, lroundf, lroundl - round to nearest integer value	long lround(double x);
lroundf	math.h		lround, lroundf, lroundl - round to nearest integer value	long lroundf(float x);
lroundl	math.h		lround, lroundf, lroundl - round to nearest integer value	long lroundl(long double x);
lsearch	search.h	XSI	lsearch, lfind - linear search and update	void *lsearch(const void *key, void *base, size_t *nelp, size_t width, int (*compar)(const void *, const void *));
lseek	unistd.h		lseek - move the read/write file offset	off_t lseek(int fildes, off_t offset, int whence);
lstat	sys/stat.h		fstatat, lstat, stat - get file status	int lstat(const char *restrict path, struct stat *restrict buf);
malloc	stdlib.h		malloc - a memory allocator	void *malloc(size_t size);
mblen	stdlib.h		mblen - get number of bytes in a character	int mblen(const char *s, size_t n);
mbrlen	wchar.h		mbrlen - get number of bytes in a character (restartable)	size_t mbrlen(const char *restrict s, size_t n, mbstate_t *restrict ps);
mbrtowc	wchar.h		mbrtowc - convert a character to a wide-character code (restartable)	size_t mbrtowc(wchar_t *restrict pwc, const char *restrict s, size_t n, mbstate_t *restrict ps);
mbsinit	wchar.h		mbsinit - determine conversion object status	int mbsinit(const mbstate_t *ps);
mbsnrtowcs	wchar.h	CX	mbsnrtowcs, mbsrtowcs - convert a character string to a wide-character string (restartable)	size_t mbsnrtowcs(wchar_t *restrict dst, const char **restrict src, size_t nmc, size_t len, mbstate_t *restrict ps);
mbsrtowcs	wchar.h		mbsnrtowcs, mbsrtowcs - convert a character string to a wide-character string (restartable)	size_t mbsrtowcs(wchar_t *restrict dst, const char **restrict src, size_t len, mbstate_t *restrict ps);
mbstowcs	stdlib.h		mbstowcs - convert a character string to a wide-character string	size_t mbstowcs(wchar_t *restrict pwcs, const char *restrict s, size_t n);
mbtowc	stdlib.h		mbtowc - convert a character to a wide-character code	int mbtowc(wchar_t *restrict pwc, const char *restrict s, size_t n);
memccpy	string.h	XSI	memccpy - copy bytes in memory	void *memccpy(void *restrict s1, const void *restrict s2, int c, size_t n);
memchr	string.h		memchr - find byte in memory	void *memchr(const void *s, int c, size_t n);
memcmp	string.h		memcmp - compare bytes in memory	int memcmp(const void *s1, const void *s2, size_t n);
memcpy	string.h		memcpy - copy bytes in memory	void *memcpy(void *restrict s1, const void *restrict s2, size_t n);
memmove	string.h		memmove - copy bytes in memory with overlapping areas	void *memmove(void *s1, const void *s2, size_t n);
memset	string.h		memset - set bytes in memory	void *memset(void *s, int c, size_t n);
mkdir	sys/stat.h		mkdir, mkdirat - make a directory relative to directory file descriptor	int mkdir(const char *path, mode_t mode);
mkdirat	sys/stat.h		mkdir, mkdirat - make a directory relative to directory file descriptor	int mkdirat(int fd, const char *path, mode_t mode);
mkdtemp	stdlib.h	CX	mkdtemp, mkstemp - create a unique directory or file	char *mkdtemp(char *template);
mkfifo	sys/stat.h		mkfifo, mkfifoat - make a FIFO special file relative to directory file descriptor	int mkfifo(const char *path, mode_t mode);
mkfifoat	sys/stat.h		mkfifo, mkfifoat - make a FIFO special file relative to directory file descriptor	int mkfifoat(int fd, const char *path, mode_t mode);
mknod	sys/stat.h	XSI	mknod, mknodat - make directory, special file, or regular file	int mknod(const char *path, mode_t mode, dev_t dev);
mknodat	sys/stat.h	XSI	mknod, mknodat - make directory, special file, or regular file	int mknodat(int fd, const char *path, mode_t mode, dev_t dev);
mkstemp	stdlib.h	CX	mkdtemp, mkstemp - create a unique directory or file	int mkstemp(char *template);
mktime	time.h		mktime - convert broken-down time into time since the Epoch	time_t mktime(struct tm *timeptr);
mlock	sys/mman.h	MLR	mlock, munlock - lock or unlock a range of process address space (<b>REALTIME</b>)	int mlock(const void *addr, size_t len);
mlockall	sys/mman.h	ML	mlockall, munlockall - lock/unlock the address space of a process (<b>REALTIME</b>)	int mlockall(int flags);
mmap	sys/mman.h		mmap - map pages of memory	void *mmap(void *addr, size_t len, int prot, int flags, int fildes, off_t off);
modf	math.h		modf, modff, modfl - decompose a floating-point number	double modf(double x, double *iptr);
modff	math.h		modf, modff, modfl - decompose a floating-point number	float modff(float value, float *iptr);
modfl	math.h		modf, modff, modfl - decompose a floating-point number	long double modfl(long double value, long double *iptr);
mprotect	sys/mman.h		mprotect - set protection of memory mapping	int mprotect(void *addr, size_t len, int prot);
mq_close	mqueue.h	MSG	mq_close - close a message queue (<b>REALTIME</b>)	int mq_close(mqd_t mqdes);
mq_getattr	mqueue.h	MSG	mq_getattr - get message queue attributes (<b>REALTIME</b>)	int mq_getattr(mqd_t mqdes, struct mq_attr *mqstat);
mq_notify	mqueue.h	MSG	mq_notify - notify process that a message is available (<b>REALTIME</b>)	int mq_notify(mqd_t mqdes, const struct sigevent *notification);
mq_open	mqueue.h	MSG	mq_open - open a message queue (<b>REALTIME</b>)	mqd_t mq_open(const char *name, int oflag, ...);
mq_receive	mqueue.h	MSG	mq_receive, mq_timedreceive - receive a message from a message queue (<b>REALTIME</b>)	ssize_t mq_receive(mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned *msg_prio);
mq_send	mqueue.h	MSG	mq_send, mq_timedsend - send a message to a message queue (<b>REALTIME</b>)	int mq_send(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned msg_prio);
mq_setattr	mqueue.h	MSG	mq_setattr - set message queue attributes (<b>REALTIME</b>)	int mq_setattr(mqd_t mqdes, const struct mq_attr *restrict mqstat, struct mq_attr *restrict omqstat);
mq_timedreceive	mqueue.h time.h	MSG	mq_receive, mq_timedreceive - receive a message from a message queue (<b>REALTIME</b>)	ssize_t mq_timedreceive(mqd_t mqdes, char *restrict msg_ptr, size_t msg_len, unsigned *restrict msg_prio, const struct timespec *restrict abstime);
mq_timedsend	mqueue.h time.h	MSG	mq_send, mq_timedsend - send a message to a message queue (<b>REALTIME</b>)	int mq_timedsend(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned msg_prio, const struct timespec *abstime);
mq_unlink	mqueue.h	MSG	mq_unlink - remove a message queue (<b>REALTIME</b>)	int mq_unlink(const char *name);
mrand48	stdlib.h	XSI	drand48, erand48, jrand48, lcong48, lrand48, mrand48, nrand48, seed48, srand48 - generate uniformly distributed pseudo-random numbers	long mrand48(void);
msgctl	sys/msg.h	XSI	msgctl - XSI message control operations	int msgctl(int msqid, int cmd, struct msqid_ds *buf);
msgget	sys/msg.h	XSI	msgget - get the XSI message queue identifier	int msgget(key_t key, int msgflg);
msgrcv	sys/msg.h	XSI	msgrcv - XSI message receive operation	ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);
msgsnd	sys/msg.h	XSI	msgsnd - XSI message send operation	int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
msync	sys/mman.h	XSI	msync - synchronize memory with physical storage	int msync(void *addr, size_t len, int flags);
munlock	sys/mman.h	MLR	mlock, munlock - lock or unlock a range of process address space (<b>REALTIME</b>)	int munlock(const void *addr, size_t len);
munlockall	sys/mman.h	ML	mlockall, munlockall - lock/unlock the address space of a process (<b>REALTIME</b>)	int munlockall(void);
munmap	sys/mman.h		munmap - unmap pages of memory	int munmap(void *addr, size_t len);
nan	math.h		nan, nanf, nanl - return quiet NaN	double nan(const char *tagp);
nanf	math.h		nan, nanf, nanl - return quiet NaN	float nanf(const char *tagp);
nanl	math.h		nan, nanf, nanl - return quiet NaN	long double nanl(const char *tagp);
nanosleep	time.h	CX	nanosleep - high resolution sleep	int nanosleep(const struct timespec *rqtp, struct timespec *rmtp);
nearbyint	math.h		nearbyint, nearbyintf, nearbyintl - floating-point rounding functions	double nearbyint(double x);
nearbyintf	math.h		nearbyint, nearbyintf, nearbyintl - floating-point rounding functions	float nearbyintf(float x);
nearbyintl	math.h		nearbyint, nearbyintf, nearbyintl - floating-point rounding functions	long double nearbyintl(long double x);
newlocale	locale.h	CX	newlocale - create or modify a locale object	locale_t newlocale(int category_mask, const char *locale, locale_t base);
nextafter	math.h		nextafter, nextafterf, nextafterl, nexttoward, nexttowardf, nexttowardl - next representable floating-point number	double nextafter(double x, double y);
nextafterf	math.h		nextafter, nextafterf, nextafterl, nexttoward, nexttowardf, nexttowardl - next representable floating-point number	float nextafterf(float x, float y);
nextafterl	math.h		nextafter, nextafterf, nextafterl, nexttoward, nexttowardf, nexttowardl - next representable floating-point number	long double nextafterl(long double x, long double y);
nexttoward	math.h		nextafter, nextafterf, nextafterl, nexttoward, nexttowardf, nexttowardl - next representable floating-point number	double nexttoward(double x, long double y);
nexttowardf	math.h		nextafter, nextafterf, nextafterl, nexttoward, nexttowardf, nexttowardl - next representable floating-point number	float nexttowardf(float x, long double y);
nexttowardl	math.h		nextafter, nextafterf, nextafterl, nexttoward, nexttowardf, nexttowardl - next representable floating-point number	long double nexttowardl(long double x, long double y);
nftw	ftw.h	XSI	nftw - walk a file tree	int nftw(const char *path, int (*fn)(const char *, const struct stat *, int, struct FTW *), int fd_limit, int flags);
nice	unistd.h	XSI	nice - change the nice value of a process	int nice(int incr);
nl_langinfo	langinfo.h		nl_langinfo, nl_langinfo_l - language information	char *nl_langinfo(nl_item item);
nl_langinfo_l	langinfo.h		nl_langinfo, nl_langinfo_l - language information	char *nl_langinfo_l(nl_item item, locale_t locale);
nrand48	stdlib.h	XSI	drand48, erand48, jrand48, lcong48, lrand48, mrand48, nrand48, seed48, srand48 - generate uniformly distributed pseudo-random numbers	long nrand48(unsigned short xsubi[3]);
ntohl	arpa/inet.h		htonl, htons, ntohl, ntohs - convert values between host and network byte order	uint32_t ntohl(uint32_t netlong);
ntohs	arpa/inet.h		htonl, htons, ntohl, ntohs - convert values between host and network byte order	uint16_t ntohs(uint16_t netshort);
open	sys/stat.h fcntl.h	OH	open, openat - open file relative to directory file descriptor	int open(const char *path, int oflag, ...);
open_memstream	stdio.h	CX	open_memstream, open_wmemstream - open a dynamic memory buffer stream	FILE *open_memstream(char **bufp, size_t *sizep);
open_wmemstream	wchar.h	CX	open_memstream, open_wmemstream - open a dynamic memory buffer stream	FILE *open_wmemstream(wchar_t **bufp, size_t *sizep);
openat	sys/stat.h fcntl.h	OH	open, openat - open file relative to directory file descriptor	int openat(int fd, const char *path, int oflag, ...);
opendir	dirent.h		fdopendir, opendir - open directory associated with file descriptor	DIR *opendir(const char *dirname);
openlog	syslog.h	XSI	closelog, openlog, setlogmask, syslog - control system log	void openlog(const char *ident, int logopt, int facility);
optarg	unistd.h		getopt, optarg, opterr, optind, optopt - command option parsing	
opterr	unistd.h		getopt, optarg, opterr, optind, optopt - command option parsing	
optind	unistd.h		getopt, optarg, opterr, optind, optopt - command option parsing	
optopt	unistd.h		getopt, optarg, opterr, optind, optopt - command option parsing	
pathconf	unistd.h		fpathconf, pathconf - get configurable pathname variables	long pathconf(const char *path, int name);
pause	unistd.h		pause - suspend the thread until a signal is received	int pause(void);
pclose	stdio.h	CX	pclose - close a pipe stream to or from a process	int pclose(FILE *stream);
perror	stdio.h		perror - write error messages to standard error	void perror(const char *s);
pipe	unistd.h		pipe - create an interprocess channel	int pipe(int fildes[2]);
poll	poll.h		poll - input/output multiplexing	int poll(struct pollfd fds[], nfds_t nfds, int timeout);
popen	stdio.h	CX	popen - initiate pipe streams to or from a process	FILE *popen(const char *command, const char *mode);
posix_fadvise	fcntl.h	ADV	posix_fadvise - file advisory information (<b>ADVANCED REALTIME</b>)	int posix_fadvise(int fd, off_t offset, off_t len, int advice);
posix_fallocate	fcntl.h	ADV	posix_fallocate - file space control (<b>ADVANCED REALTIME</b>)	int posix_fallocate(int fd, off_t offset, off_t len);
posix_madvise	sys/mman.h	ADV	posix_madvise - memory advisory information and alignment control (<b>ADVANCED REALTIME</b>)	int posix_madvise(void *addr, size_t len, int advice);
posix_mem_offset	sys/mman.h	TYM	posix_mem_offset - find offset and length of a mapped typed memory block (<b>ADVANCED REALTIME</b>)	int posix_mem_offset(const void *restrict addr, size_t len, off_t *restrict off, size_t *restrict contig_len, int *restrict fildes);
posix_memalign	stdlib.h	ADV	posix_memalign - aligned memory allocation (<b>ADVANCED REALTIME</b>)	int posix_memalign(void **memptr, size_t alignment, size_t size);
posix_openpt	stdlib.h fcntl.h	XSI	posix_openpt - open a pseudo-terminal device	int posix_openpt(int oflag);
posix_spawn	spawn.h	SPN	posix_spawn, posix_spawnp - spawn a process (<b>ADVANCED REALTIME</b>)	int posix_spawn(pid_t *restrict pid, const char *restrict path, const posix_spawn_file_actions_t *file_actions, const posix_spawnattr_t *restrict attrp, char *const argv[restrict], char *const envp[restrict]);
posix_spawn_file_actions_addclose	spawn.h	SPN	posix_spawn_file_actions_addclose, posix_spawn_file_actions_addopen - add close or open action to spawn file actions object (<b>ADVANCED REALTIME</b>)	int posix_spawn_file_actions_addclose(posix_spawn_file_actions_t *file_actions, int fildes);
posix_spawn_file_actions_adddup2	spawn.h	SPN	posix_spawn_file_actions_adddup2 - add dup2 action to spawn file actions object (<b>ADVANCED REALTIME</b>)	int posix_spawn_file_actions_adddup2(posix_spawn_file_actions_t *file_actions, int fildes, int newfildes);
posix_spawn_file_actions_addopen	spawn.h	SPN	posix_spawn_file_actions_addclose, posix_spawn_file_actions_addopen - add close or open action to spawn file actions object (<b>ADVANCED REALTIME</b>)	int posix_spawn_file_actions_addopen(posix_spawn_file_actions_t *restrict file_actions, int fildes, const char *restrict path, int oflag, mode_t mode);
posix_spawn_file_actions_destroy	spawn.h	SPN	posix_spawn_file_actions_destroy, posix_spawn_file_actions_init - destroy and initialize spawn file actions object (<b>ADVANCED REALTIME</b>)	int posix_spawn_file_actions_destroy(posix_spawn_file_actions_t *file_actions);
posix_spawn_file_actions_init	spawn.h	SPN	posix_spawn_file_actions_destroy, posix_spawn_file_actions_init - destroy and initialize spawn file actions object (<b>ADVANCED REALTIME</b>)	int posix_spawn_file_actions_init(posix_spawn_file_actions_t *file_actions);
posix_spawnattr_destroy	spawn.h	SPN	posix_spawnattr_destroy, posix_spawnattr_init - destroy and initialize spawn attributes object (<b>ADVANCED REALTIME</b>)	int posix_spawnattr_destroy(posix_spawnattr_t *attr);
posix_spawnattr_getflags	spawn.h	SPN	posix_spawnattr_getflags, posix_spawnattr_setflags - get and set the spawn-flags attribute of a spawn attributes object (<b>ADVANCED REALTIME</b>)	int posix_spawnattr_getflags(const posix_spawnattr_t *restrict attr, short *restrict flags);
posix_spawnattr_getpgroup	spawn.h	SPN	posix_spawnattr_getpgroup, posix_spawnattr_setpgroup - get and set the spawn-pgroup attribute of a spawn attributes object (<b>ADVANCED REALTIME</b>)	int posix_spawnattr_getpgroup(const posix_spawnattr_t *restrict attr, pid_t *restrict pgroup);
posix_spawnattr_getschedparam	spawn.h sched.h	SPN PS	posix_spawnattr_getschedparam, posix_spawnattr_setschedparam - get and set the spawn-schedparam attribute of a spawn attributes object (<b>ADVANCED REALTIME</b>)	int posix_spawnattr_getschedparam(const posix_spawnattr_t *restrict attr, struct sched_param *restrict schedparam);
posix_spawnattr_getschedpolicy	spawn.h sched.h	SPN PS	posix_spawnattr_getschedpolicy, posix_spawnattr_setschedpolicy - get and set the spawn-schedpolicy attribute of a spawn attributes object (<b>ADVANCED REALTIME</b>)	int posix_spawnattr_getschedpolicy(const posix_spawnattr_t *restrict attr, int *restrict schedpolicy);
posix_spawnattr_getsigdefault	signal.h spawn.h	SPN	posix_spawnattr_getsigdefault, posix_spawnattr_setsigdefault - get and set the spawn-sigdefault attribute of a spawn attributes object (<b>ADVANCED REALTIME</b>)	int posix_spawnattr_getsigdefault(const posix_spawnattr_t *restrict attr, sigset_t *restrict sigdefault);
posix_spawnattr_getsigmask	signal.h spawn.h	SPN	posix_spawnattr_getsigmask, posix_spawnattr_setsigmask - get and set the spawn-sigmask attribute of a spawn attributes object (<b>ADVANCED REALTIME</b>)	int posix_spawnattr_getsigmask(const posix_spawnattr_t *restrict attr, sigset_t *restrict sigmask);
posix_spawnattr_init	spawn.h	SPN	posix_spawnattr_destroy, posix_spawnattr_init - destroy and initialize spawn attributes object (<b>ADVANCED REALTIME</b>)	int posix_spawnattr_init(posix_spawnattr_t *attr);
posix_spawnattr_setflags	spawn.h	SPN	posix_spawnattr_getflags, posix_spawnattr_setflags - get and set the spawn-flags attribute of a spawn attributes object (<b>ADVANCED REALTIME</b>)	int posix_spawnattr_setflags(posix_spawnattr_t *attr, short flags);
posix_spawnattr_setpgroup	spawn.h	SPN	posix_spawnattr_getpgroup, posix_spawnattr_setpgroup - get and set the spawn-pgroup attribute of a spawn attributes object (<b>ADVANCED REALTIME</b>)	int posix_spawnattr_setpgroup(posix_spawnattr_t *attr, pid_t pgroup);
posix_spawnattr_setschedparam	spawn.h sched.h	SPN PS	posix_spawnattr_getschedparam, posix_spawnattr_setschedparam - get and set the spawn-schedparam attribute of a spawn attributes object (<b>ADVANCED REALTIME</b>)	int posix_spawnattr_setschedparam(posix_spawnattr_t *restrict attr, const struct sched_param *restrict schedparam);
posix_spawnattr_setschedpolicy	spawn.h sched.h	SPN PS	posix_spawnattr_getschedpolicy, posix_spawnattr_setschedpolicy - get and set the spawn-schedpolicy attribute of a spawn attributes object (<b>ADVANCED REALTIME</b>)	int posix_spawnattr_setschedpolicy(posix_spawnattr_t *attr, int schedpolicy);
posix_spawnattr_setsigdefault	signal.h spawn.h	SPN	posix_spawnattr_getsigdefault, posix_spawnattr_setsigdefault - get and set the spawn-sigdefault attribute of a spawn attributes object (<b>ADVANCED REALTIME</b>)	int posix_spawnattr_setsigdefault(posix_spawnattr_t *restrict attr, const sigset_t *restrict sigdefault);
posix_spawnattr_setsigmask	signal.h spawn.h	SPN	posix_spawnattr_getsigmask, posix_spawnattr_setsigmask - get and set the spawn-sigmask attribute of a spawn attributes object (<b>ADVANCED REALTIME</b>)	int posix_spawnattr_setsigmask(posix_spawnattr_t *restrict attr, const sigset_t *restrict sigmask);
posix_spawnp	spawn.h	SPN	posix_spawn, posix_spawnp - spawn a process (<b>ADVANCED REALTIME</b>)	int posix_spawnp(pid_t *restrict pid, const char *restrict file, const posix_spawn_file_actions_t *file_actions, const posix_spawnattr_t *restrict attrp, char *const argv[restrict], char *const envp[restrict]);
posix_typed_mem_get_info	sys/mman.h	TYM	posix_typed_mem_get_info - query typed memory information (<b>ADVANCED REALTIME</b>)	int posix_typed_mem_get_info(int fildes, struct posix_typed_mem_info *info);
posix_typed_mem_open	sys/mman.h	TYM	posix_typed_mem_open - open a typed memory object (<b>ADVANCED REALTIME</b>)	int posix_typed_mem_open(const char *name, int oflag, int tflag);
pow	math.h		pow, powf, powl - power function	double pow(double x, double y);
powf	math.h		pow, powf, powl - power function	float powf(float x, float y);
powl	math.h		pow, powf, powl - power function	long double powl(long double x, long double y);
pread	unistd.h		pread, read - read from a file	ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset);
printf	stdio.h		dprintf, fprintf, printf, snprintf, sprintf - print formatted output	int printf(const char *restrict format, ...);
pselect	sys/select.h		pselect, select - synchronous I/O multiplexing	int pselect(int nfds, fd_set *restrict readfds, fd_set *restrict writefds, fd_set *restrict errorfds, const struct timespec *restrict timeout, const sigset_t *restrict sigmask);
psiginfo	signal.h	CX	psiginfo, psignal - print signal information to standard error	void psiginfo(const siginfo_t *pinfo, const char *message);
psignal	signal.h	CX	psiginfo, psignal - print signal information to standard error	void psignal(int signum, const char *message);
pthread_atfork	pthread.h		pthread_atfork - register fork handlers	int pthread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void));
pthread_attr_destroy	pthread.h		pthread_attr_destroy, pthread_attr_init - destroy and initialize the thread attributes object	int pthread_attr_destroy(pthread_attr_t *attr);
pthread_attr_getdetachstate	pthread.h		pthread_attr_getdetachstate, pthread_attr_setdetachstate - get and set the detachstate attribute	int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);
pthread_attr_getguardsize	pthread.h		pthread_attr_getguardsize, pthread_attr_setguardsize - get and set the thread guardsize attribute	int pthread_attr_getguardsize(const pthread_attr_t *restrict attr, size_t *restrict guardsize);
pthread_attr_getinheritsched	pthread.h	TPS	pthread_attr_getinheritsched, pthread_attr_setinheritsched - get and set the inheritsched attribute (<b>REALTIME THREADS</b>)	int pthread_attr_getinheritsched(const pthread_attr_t *restrict attr, int *restrict inheritsched);
pthread_attr_getschedparam	pthread.h		pthread_attr_getschedparam, pthread_attr_setschedparam - get and set the schedparam attribute	int pthread_attr_getschedparam(const pthread_attr_t *restrict attr, struct sched_param *restrict param);
pthread_attr_getschedpolicy	pthread.h	TPS	pthread_attr_getschedpolicy, pthread_attr_setschedpolicy - get and set the schedpolicy attribute (<b>REALTIME THREADS</b>)	int pthread_attr_getschedpolicy(const pthread_attr_t *restrict attr, int *restrict policy);
pthread_attr_getscope	pthread.h	TPS	pthread_attr_getscope, pthread_attr_setscope - get and set the contentionscope attribute (<b>REALTIME THREADS</b>)	int pthread_attr_getscope(const pthread_attr_t *restrict attr, int *restrict contentionscope);
pthread_attr_getstack	pthread.h	TSA TSS	pthread_attr_getstack, pthread_attr_setstack - get and set stack attributes	int pthread_attr_getstack(const pthread_attr_t *restrict attr, void **restrict stackaddr, size_t *restrict stacksize);
pthread_attr_getstacksize	pthread.h	TSS	pthread_attr_getstacksize, pthread_attr_setstacksize - get and set the stacksize attribute	int pthread_attr_getstacksize(const pthread_attr_t *restrict attr, size_t *restrict stacksize);
pthread_attr_init	pthread.h		pthread_attr_destroy, pthread_attr_init - destroy and initialize the thread attributes object	int pthread_attr_init(pthread_attr_t *attr);
pthread_attr_setdetachstate	pthread.h		pthread_attr_getdetachstate, pthread_attr_setdetachstate - get and set the detachstate attribute	int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
pthread_attr_setguardsize	pthread.h		pthread_attr_getguardsize, pthread_attr_setguardsize - get and set the thread guardsize attribute	int pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize);
pthread_attr_setinheritsched	pthread.h	TPS	pthread_attr_getinheritsched, pthread_attr_setinheritsched - get and set the inheritsched attribute (<b>REALTIME THREADS</b>)	int pthread_attr_setinheritsched(pthread_attr_t *attr, int inheritsched);
pthread_attr_setschedparam	pthread.h		pthread_attr_getschedparam, pthread_attr_setschedparam - get and set the schedparam attribute	int pthread_attr_setschedparam(pthread_attr_t *restrict attr, const struct sched_param *restrict param);
pthread_attr_setschedpolicy	pthread.h	TPS	pthread_attr_getschedpolicy, pthread_attr_setschedpolicy - get and set the schedpolicy attribute (<b>REALTIME THREADS</b>)	int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy);
pthread_attr_setscope	pthread.h	TPS	pthread_attr_getscope, pthread_attr_setscope - get and set the contentionscope attribute (<b>REALTIME THREADS</b>)	int pthread_attr_setscope(pthread_attr_t *attr, int contentionscope);
pthread_attr_setstack	pthread.h	TSA TSS	pthread_attr_getstack, pthread_attr_setstack - get and set stack attributes	int pthread_attr_setstack(pthread_attr_t *attr, void *stackaddr, size_t stacksize);
pthread_attr_setstacksize	pthread.h	TSS	pthread_attr_getstacksize, pthread_attr_setstacksize - get and set the stacksize attribute	int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize);
pthread_barrier_destroy	pthread.h		pthread_barrier_destroy, pthread_barrier_init - destroy and initialize a barrier object	int pthread_barrier_destroy(pthread_barrier_t *barrier);
pthread_barrier_init	pthread.h		pthread_barrier_destroy, pthread_barrier_init - destroy and initialize a barrier object	int pthread_barrier_init(pthread_barrier_t *restrict barrier, const pthread_barrierattr_t *restrict attr, unsigned count);
pthread_barrier_wait	pthread.h		pthread_barrier_wait - synchronize at a barrier	int pthread_barrier_wait(pthread_barrier_t *barrier);
pthread_barrierattr_destroy	pthread.h		pthread_barrierattr_destroy, pthread_barrierattr_init - destroy and initialize the barrier attributes object	int pthread_barrierattr_destroy(pthread_barrierattr_t *attr);
pthread_barrierattr_getpshared	pthread.h	TSH	pthread_barrierattr_getpshared, pthread_barrierattr_setpshared - get and set the process-shared attribute of the barrier attributes object	int pthread_barrierattr_getpshared(const pthread_barrierattr_t *restrict attr, int *restrict pshared);
pthread_barrierattr_init	pthread.h		pthread_barrierattr_destroy, pthread_barrierattr_init - destroy and initialize the barrier attributes object	int pthread_barrierattr_init(pthread_barrierattr_t *attr);
pthread_barrierattr_setpshared	pthread.h	TSH	pthread_barrierattr_getpshared, pthread_barrierattr_setpshared - get and set the process-shared attribute of the barrier attributes object	int pthread_barrierattr_setpshared(pthread_barrierattr_t *attr, int pshared);
pthread_cancel	pthread.h		pthread_cancel - cancel execution of a thread	int pthread_cancel(pthread_t thread);
pthread_cleanup_pop	pthread.h		pthread_cleanup_pop, pthread_cleanup_push - establish cancellation handlers	void pthread_cleanup_pop(int execute);
pthread_cleanup_push	pthread.h		pthread_cleanup_pop, pthread_cleanup_push - establish cancellation handlers	void pthread_cleanup_push(void (*routine)(void*), void *arg);
pthread_cond_broadcast	pthread.h		pthread_cond_broadcast, pthread_cond_signal - broadcast or signal a condition	int pthread_cond_broadcast(pthread_cond_t *cond);
pthread_cond_destroy	pthread.h		pthread_cond_destroy, pthread_cond_init - destroy and initialize condition variables	int pthread_cond_destroy(pthread_cond_t *cond);
pthread_cond_init	pthread.h		pthread_cond_destroy, pthread_cond_init - destroy and initialize condition variables	int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
pthread_cond_signal	pthread.h		pthread_cond_broadcast, pthread_cond_signal - broadcast or signal a condition	int pthread_cond_signal(pthread_cond_t *cond);
pthread_cond_timedwait	pthread.h		pthread_cond_timedwait, pthread_cond_wait - wait on a condition	int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict abstime);
pthread_cond_wait	pthread.h		pthread_cond_timedwait, pthread_cond_wait - wait on a condition	int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
pthread_condattr_destroy	pthread.h		pthread_condattr_destroy, pthread_condattr_init - destroy and initialize the condition variable attributes object	int pthread_condattr_destroy(pthread_condattr_t *attr);
pthread_condattr_getclock	pthread.h		pthread_condattr_getclock, pthread_condattr_setclock - get and set the clock selection condition variable attribute	int pthread_condattr_getclock(const pthread_condattr_t *restrict attr, clockid_t *restrict clock_id);
pthread_condattr_getpshared	pthread.h	TSH	pthread_condattr_getpshared, pthread_condattr_setpshared - get and set the process-shared condition variable attributes	int pthread_condattr_getpshared(const pthread_condattr_t *restrict attr, int *restrict pshared);
pthread_condattr_init	pthread.h		pthread_condattr_destroy, pthread_condattr_init - destroy and initialize the condition variable attributes object	int pthread_condattr_init(pthread_condattr_t *attr);
pthread_condattr_setclock	pthread.h		pthread_condattr_getclock, pthread_condattr_setclock - get and set the clock selection condition variable attribute	int pthread_condattr_setclock(pthread_condattr_t *attr, clockid_t clock_id);
pthread_condattr_setpshared	pthread.h	TSH	pthread_condattr_getpshared, pthread_condattr_setpshared - get and set the process-shared condition variable attributes	int pthread_condattr_setpshared(pthread_condattr_t *attr, int pshared);
pthread_create	pthread.h		pthread_create - thread creation	int pthread_create(pthread_t *restrict thread, const pthread_attr_t *restrict attr, void *(*start_routine)(void*), void *restrict arg);
pthread_detach	pthread.h		pthread_detach - detach a thread	int pthread_detach(pthread_t thread);
pthread_equal	pthread.h		pthread_equal - compare thread IDs	int pthread_equal(pthread_t t1, pthread_t t2);
pthread_exit	pthread.h		pthread_exit - thread termination	void pthread_exit(void *value_ptr);
pthread_getconcurrency	pthread.h	OB XSI	pthread_getconcurrency, pthread_setconcurrency - get and set the level of concurrency	int pthread_getconcurrency(void);
pthread_getcpuclockid	pthread.h time.h	TCT	pthread_getcpuclockid - access a thread CPU-time clock (<b>ADVANCED REALTIME THREADS</b>)	int pthread_getcpuclockid(pthread_t thread_id, clockid_t *clock_id);
pthread_getschedparam	pthread.h	TPS	pthread_getschedparam, pthread_setschedparam - dynamic thread scheduling parameters access (<b>REALTIME THREADS</b>)	int pthread_getschedparam(pthread_t thread, int *restrict policy, struct sched_param *restrict param);
pthread_getspecific	pthread.h		pthread_getspecific, pthread_setspecific - thread-specific data management	void *pthread_getspecific(pthread_key_t key);
pthread_join	pthread.h		pthread_join - wait for thread termination	int pthread_join(pthread_t thread, void **value_ptr);
pthread_key_create	pthread.h		pthread_key_create - thread-specific data key creation	int pthread_key_create(pthread_key_t *key, void (*destructor)(void*));
pthread_key_delete	pthread.h		pthread_key_delete - thread-specific data key deletion	int pthread_key_delete(pthread_key_t key);
pthread_kill	signal.h	CX	pthread_kill - send a signal to a thread	int pthread_kill(pthread_t thread, int sig);
pthread_mutex_consistent	pthread.h		pthread_mutex_consistent - mark state protected by robust mutex as consistent	int pthread_mutex_consistent(pthread_mutex_t *mutex);
pthread_mutex_destroy	pthread.h		pthread_mutex_destroy, pthread_mutex_init - destroy and initialize a mutex	int pthread_mutex_destroy(pthread_mutex_t *mutex);
pthread_mutex_getprioceiling	pthread.h	RPP	pthread_mutex_getprioceiling, pthread_mutex_setprioceiling - get and set the priority ceiling of a mutex (<b>REALTIME THREADS</b>)	int pthread_mutex_getprioceiling(const pthread_mutex_t *restrict mutex, int *restrict prioceiling);
pthread_mutex_init	pthread.h		pthread_mutex_destroy, pthread_mutex_init - destroy and initialize a mutex	int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
pthread_mutex_lock	pthread.h		pthread_mutex_lock, pthread_mutex_trylock, pthread_mutex_unlock - lock and unlock a mutex	int pthread_mutex_lock(pthread_mutex_t *mutex);
pthread_mutex_setprioceiling	pthread.h	RPP	pthread_mutex_getprioceiling, pthread_mutex_setprioceiling - get and set the priority ceiling of a mutex (<b>REALTIME THREADS</b>)	int pthread_mutex_setprioceiling(pthread_mutex_t *restrict mutex, int prioceiling, int *restrict old_ceiling);
pthread_mutex_timedlock	pthread.h time.h		pthread_mutex_timedlock - lock a mutex	int pthread_mutex_timedlock(pthread_mutex_t *restrict mutex, const struct timespec *restrict abstime);
pthread_mutex_trylock	pthread.h		pthread_mutex_lock, pthread_mutex_trylock, pthread_mutex_unlock - lock and unlock a mutex	int pthread_mutex_trylock(pthread_mutex_t *mutex);
pthread_mutex_unlock	pthread.h		pthread_mutex_lock, pthread_mutex_trylock, pthread_mutex_unlock - lock and unlock a mutex	int pthread_mutex_unlock(pthread_mutex_t *mutex);
pthread_mutexattr_destroy	pthread.h		pthread_mutexattr_destroy, pthread_mutexattr_init - destroy and initialize the mutex attributes object	int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);
pthread_mutexattr_getprioceiling	pthread.h	RPP	pthread_mutexattr_getprioceiling, pthread_mutexattr_setprioceiling - get and set the prioceiling attribute of the mutex attributes object (<b>REALTIME THREADS</b>)	int pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *restrict attr, int *restrict prioceiling);
pthread_mutexattr_getprotocol	pthread.h	MC1	pthread_mutexattr_getprotocol, pthread_mutexattr_setprotocol - get and set the protocol attribute of the mutex attributes object (<b>REALTIME THREADS</b>)	int pthread_mutexattr_getprotocol(const pthread_mutexattr_t *restrict attr, int *restrict protocol);
pthread_mutexattr_getpshared	pthread.h	TSH	pthread_mutexattr_getpshared, pthread_mutexattr_setpshared - get and set the process-shared attribute	int pthread_mutexattr_getpshared(const pthread_mutexattr_t *restrict attr, int *restrict pshared);
pthread_mutexattr_getrobust	pthread.h		pthread_mutexattr_getrobust, pthread_mutexattr_setrobust - get and set the mutex robust attribute	int pthread_mutexattr_getrobust(const pthread_mutexattr_t *restrict attr, int *restrict robust);
pthread_mutexattr_gettype	pthread.h		pthread_mutexattr_gettype, pthread_mutexattr_settype - get and set the mutex type attribute	int pthread_mutexattr_gettype(const pthread_mutexattr_t *restrict attr, int *restrict type);
pthread_mutexattr_init	pthread.h		pthread_mutexattr_destroy, pthread_mutexattr_init - destroy and initialize the mutex attributes object	int pthread_mutexattr_init(pthread_mutexattr_t *attr);
pthread_mutexattr_setprioceiling	pthread.h	RPP	pthread_mutexattr_getprioceiling, pthread_mutexattr_setprioceiling - get and set the prioceiling attribute of the mutex attributes object (<b>REALTIME THREADS</b>)	int pthread_mutexattr_setprioceiling(pthread_mutexattr_t *attr, int prioceiling);
pthread_mutexattr_setprotocol	pthread.h	MC1	pthread_mutexattr_getprotocol, pthread_mutexattr_setprotocol - get and set the protocol attribute of the mutex attributes object (<b>REALTIME THREADS</b>)	int pthread_mutexattr_setprotocol(pthread_mutexattr_t *attr, int protocol);
pthread_mutexattr_setpshared	pthread.h	TSH	pthread_mutexattr_getpshared, pthread_mutexattr_setpshared - get and set the process-shared attribute	int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int pshared);
pthread_mutexattr_setrobust	pthread.h		pthread_mutexattr_getrobust, pthread_mutexattr_setrobust - get and set the mutex robust attribute	int pthread_mutexattr_setrobust(pthread_mutexattr_t *attr, int robust);
pthread_mutexattr_settype	pthread.h		pthread_mutexattr_gettype, pthread_mutexattr_settype - get and set the mutex type attribute	int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type);
pthread_once	pthread.h		pthread_once - dynamic package initialization	int pthread_once(pthread_once_t *once_control, void (*init_routine)(void));
pthread_rwlock_destroy	pthread.h		pthread_rwlock_destroy, pthread_rwlock_init - destroy and initialize a read-write lock object	int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
pthread_rwlock_init	pthread.h		pthread_rwlock_destroy, pthread_rwlock_init - destroy and initialize a read-write lock object	int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);
pthread_rwlock_rdlock	pthread.h		pthread_rwlock_rdlock, pthread_rwlock_tryrdlock - lock a read-write lock object for reading	int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
pthread_rwlock_timedrdlock	pthread.h time.h		pthread_rwlock_timedrdlock - lock a read-write lock for reading	int pthread_rwlock_timedrdlock(pthread_rwlock_t *restrict rwlock, const struct timespec *restrict abstime);
pthread_rwlock_timedwrlock	pthread.h time.h		pthread_rwlock_timedwrlock - lock a read-write lock for writing	int pthread_rwlock_timedwrlock(pthread_rwlock_t *restrict rwlock, const struct timespec *restrict abstime);
pthread_rwlock_tryrdlock	pthread.h		pthread_rwlock_rdlock, pthread_rwlock_tryrdlock - lock a read-write lock object for reading	int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
pthread_rwlock_trywrlock	pthread.h		pthread_rwlock_trywrlock, pthread_rwlock_wrlock - lock a read-write lock object for writing	int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
pthread_rwlock_unlock	pthread.h		pthread_rwlock_unlock - unlock a read-write lock object	int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
pthread_rwlock_wrlock	pthread.h		pthread_rwlock_trywrlock, pthread_rwlock_wrlock - lock a read-write lock object for writing	int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
pthread_rwlockattr_destroy	pthread.h		pthread_rwlockattr_destroy, pthread_rwlockattr_init - destroy and initialize the read-write lock attributes object	int pthread_rwlockattr_destroy(pthread_rwlockattr_t *attr);
pthread_rwlockattr_getpshared	pthread.h	TSH	pthread_rwlockattr_getpshared, pthread_rwlockattr_setpshared - get and set the process-shared attribute of the read-write lock attributes object	int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t *restrict attr, int *restrict pshared);
pthread_rwlockattr_init	pthread.h		pthread_rwlockattr_destroy, pthread_rwlockattr_init - destroy and initialize the read-write lock attributes object	int pthread_rwlockattr_init(pthread_rwlockattr_t *attr);
pthread_rwlockattr_setpshared	pthread.h	TSH	pthread_rwlockattr_getpshared, pthread_rwlockattr_setpshared - get and set the process-shared attribute of the read-write lock attributes object	int pthread_rwlockattr_setpshared(pthread_rwlockattr_t *attr, int pshared);
pthread_self	pthread.h		pthread_self - get the calling thread ID	pthread_t pthread_self(void);
pthread_setcancelstate	pthread.h		pthread_setcancelstate, pthread_setcanceltype, pthread_testcancel - set cancelability state	int pthread_setcancelstate(int state, int *oldstate);
pthread_setcanceltype	pthread.h		pthread_setcancelstate, pthread_setcanceltype, pthread_testcancel - set cancelability state	int pthread_setcanceltype(int type, int *oldtype);
pthread_setconcurrency	pthread.h	OB XSI	pthread_getconcurrency, pthread_setconcurrency - get and set the level of concurrency	int pthread_setconcurrency(int new_level);
pthread_setschedparam	pthread.h	TPS	pthread_getschedparam, pthread_setschedparam - dynamic thread scheduling parameters access (<b>REALTIME THREADS</b>)	int pthread_setschedparam(pthread_t thread, int policy, const struct sched_param *param);
pthread_setschedprio	pthread.h	TPS	pthread_setschedprio - dynamic thread scheduling parameters access (<b>REALTIME THREADS</b>)	int pthread_setschedprio(pthread_t thread, int prio);
pthread_setspecific	pthread.h		pthread_getspecific, pthread_setspecific - thread-specific data management	int pthread_setspecific(pthread_key_t key, const void *value);
pthread_sigmask	signal.h	CX	pthread_sigmask, sigprocmask - examine and change blocked signals	int pthread_sigmask(int how, const sigset_t *restrict set, sigset_t *restrict oset);
pthread_spin_destroy	pthread.h		pthread_spin_destroy, pthread_spin_init - destroy or initialize a spin lock object	int pthread_spin_destroy(pthread_spinlock_t *lock);
pthread_spin_init	pthread.h		pthread_spin_destroy, pthread_spin_init - destroy or initialize a spin lock object	int pthread_spin_init(pthread_spinlock_t *lock, int pshared);
pthread_spin_lock	pthread.h		pthread_spin_lock, pthread_spin_trylock - lock a spin lock object	int pthread_spin_lock(pthread_spinlock_t *lock);
pthread_spin_trylock	pthread.h		pthread_spin_lock, pthread_spin_trylock - lock a spin lock object	int pthread_spin_trylock(pthread_spinlock_t *lock);
pthread_spin_unlock	pthread.h		pthread_spin_unlock - unlock a spin lock object	int pthread_spin_unlock(pthread_spinlock_t *lock);
pthread_testcancel	pthread.h		pthread_setcancelstate, pthread_setcanceltype, pthread_testcancel - set cancelability state	void pthread_testcancel(void);
ptsname	stdlib.h	XSI	ptsname - get name of the slave pseudo-terminal device	char *ptsname(int fildes);
putc	stdio.h		putc - put a byte on a stream	int putc(int c, FILE *stream);
putc_unlocked	stdio.h	CX	getc_unlocked, getchar_unlocked, putc_unlocked, putchar_unlocked - stdio with explicit client locking	int putc_unlocked(int c, FILE *stream);
putchar	stdio.h		putchar - put a byte on a stdout stream	int putchar(int c);
putchar_unlocked	stdio.h	CX	getc_unlocked, getchar_unlocked, putc_unlocked, putchar_unlocked - stdio with explicit client locking	int putchar_unlocked(int c);
putenv	stdlib.h	XSI	putenv - change or add a value to an environment	int putenv(char *string);
puts	stdio.h		puts - put a string on standard output	int puts(const char *s);
pututxline	utmpx.h	XSI	endutxent, getutxent, getutxid, getutxline, pututxline, setutxent - user accounting database functions	struct utmpx *pututxline(const struct utmpx *utmpx);
putwc	stdio.h wchar.h		putwc - put a wide character on a stream	wint_t putwc(wchar_t wc, FILE *stream);
putwchar	wchar.h		putwchar - put a wide character on a stdout stream	wint_t putwchar(wchar_t wc);
pwrite	unistd.h		pwrite, write - write on a file	ssize_t pwrite(int fildes, const void *buf, size_t nbyte, off_t offset);
qsort	stdlib.h		qsort - sort a table of data	void qsort(void *base, size_t nel, size_t width, int (*compar)(const void *, const void *));
raise	signal.h		raise - send a signal to the executing process	int raise(int sig);
rand	stdlib.h		rand, rand_r, srand - pseudo-random number generator	int rand(void);
rand_r	stdlib.h	OB CX	rand, rand_r, srand - pseudo-random number generator	int rand_r(unsigned *seed);
random	stdlib.h	XSI	initstate, random, setstate, srandom - pseudo-random number functions	long random(void);
read	unistd.h		pread, read - read from a file	ssize_t read(int fildes, void *buf, size_t nbyte);
readdir	dirent.h		readdir, readdir_r - read a directory	struct dirent *readdir(DIR *dirp);
readdir_r	dirent.h		readdir, readdir_r - read a directory	int readdir_r(DIR *restrict dirp, struct dirent *restrict entry, struct dirent **restrict result);
readlink	unistd.h		readlink, readlinkat - read the contents of a symbolic link relative to a directory file descriptor	ssize_t readlink(const char *restrict path, char *restrict buf, size_t bufsize);
readlinkat	unistd.h		readlink, readlinkat - read the contents of a symbolic link relative to a directory file descriptor	ssize_t readlinkat(int fd, const char *restrict path, char *restrict buf, size_t bufsize);
readv	sys/uio.h	XSI	readv - read a vector	ssize_t readv(int fildes, const struct iovec *iov, int iovcnt);
realloc	stdlib.h		realloc - memory reallocator	void *realloc(void *ptr, size_t size);
realpath	stdlib.h	XSI	realpath - resolve a pathname	char *realpath(const char *restrict file_name, char *restrict resolved_name);
recv	sys/socket.h		recv - receive a message from a connected socket	ssize_t recv(int socket, void *buffer, size_t length, int flags);
recvfrom	sys/socket.h		recvfrom - receive a message from a socket	ssize_t recvfrom(int socket, void *restrict buffer, size_t length, int flags, struct sockaddr *restrict address, socklen_t *restrict address_len);
recvmsg	sys/socket.h		recvmsg - receive a message from a socket	ssize_t recvmsg(int socket, struct msghdr *message, int flags);
regcomp	regex.h		regcomp, regerror, regexec, regfree - regular expression matching	int regcomp(regex_t *restrict preg, const char *restrict pattern, int cflags);
regerror	regex.h		regcomp, regerror, regexec, regfree - regular expression matching	size_t regerror(int errcode, const regex_t *restrict preg, char *restrict errbuf, size_t errbuf_size);
regexec	regex.h		regcomp, regerror, regexec, regfree - regular expression matching	int regexec(const regex_t *restrict preg, const char *restrict string, size_t nmatch, regmatch_t pmatch[restrict], int eflags);
regfree	regex.h		regcomp, regerror, regexec, regfree - regular expression matching	void regfree(regex_t *preg);
remainder	math.h		remainder, remainderf, remainderl - remainder function	double remainder(double x, double y);
remainderf	math.h		remainder, remainderf, remainderl - remainder function	float remainderf(float x, float y);
remainderl	math.h		remainder, remainderf, remainderl - remainder function	long double remainderl(long double x, long double y);
remove	stdio.h		remove - remove a file	int remove(const char *path);
remque	search.h	XSI	insque, remque - insert or remove an element in a queue	void remque(void *element);
remquo	math.h		remquo, remquof, remquol - remainder functions	double remquo(double x, double y, int *quo);
remquof	math.h		remquo, remquof, remquol - remainder functions	float remquof(float x, float y, int *quo);
remquol	math.h		remquo, remquof, remquol - remainder functions	long double remquol(long double x, long double y, int *quo);
rename	stdio.h	CX	rename, renameat - rename file relative to directory file descriptor	int rename(const char *old, const char *new);
renameat	stdio.h	CX	rename, renameat - rename file relative to directory file descriptor	int renameat(int oldfd, const char *old, int newfd, const char *new);
rewind	stdio.h		rewind - reset the file position indicator in a stream	void rewind(FILE *stream);
rewinddir	dirent.h		rewinddir - reset the position of a directory stream to the beginning of a directory	void rewinddir(DIR *dirp);
rint	math.h		rint, rintf, rintl - round-to-nearest integral value	double rint(double x);
rintf	math.h		rint, rintf, rintl - round-to-nearest integral value	float rintf(float x);
rintl	math.h		rint, rintf, rintl - round-to-nearest integral value	long double rintl(long double x);
rmdir	unistd.h		rmdir - remove a directory	int rmdir(const char *path);
round	math.h		round, roundf, roundl - round to the nearest integer value in a floating-point format	double round(double x);
roundf	math.h		round, roundf, roundl - round to the nearest integer value in a floating-point format	float roundf(float x);
roundl	math.h		round, roundf, roundl - round to the nearest integer value in a floating-point format	long double roundl(long double x);
scalbln	math.h		scalbln, scalblnf, scalblnl, scalbn, scalbnf, scalbnl - compute exponent using FLT_RADIX	double scalbln(double x, long n);
scalblnf	math.h		scalbln, scalblnf, scalblnl, scalbn, scalbnf, scalbnl - compute exponent using FLT_RADIX	float scalblnf(float x, long n);
scalblnl	math.h		scalbln, scalblnf, scalblnl, scalbn, scalbnf, scalbnl - compute exponent using FLT_RADIX	long double scalblnl(long double x, long n);
scalbn	math.h		scalbln, scalblnf, scalblnl, scalbn, scalbnf, scalbnl - compute exponent using FLT_RADIX	double scalbn(double x, int n);
scalbnf	math.h		scalbln, scalblnf, scalblnl, scalbn, scalbnf, scalbnl - compute exponent using FLT_RADIX	float scalbnf(float x, int n);
scalbnl	math.h		scalbln, scalblnf, scalblnl, scalbn, scalbnf, scalbnl - compute exponent using FLT_RADIX	long double scalbnl(long double x, int n);
scandir	dirent.h		alphasort, scandir - scan a directory	int scandir(const char *dir, struct dirent ***namelist, int (*sel)(const struct dirent *), int (*compar)(const struct dirent **, const struct dirent **));
scanf	stdio.h		fscanf, scanf, sscanf - convert formatted input	int scanf(const char *restrict format, ...);
sched_get_priority_max	sched.h	PS	sched_get_priority_max, sched_get_priority_min - get priority limits (<b>REALTIME</b>)	int sched_get_priority_max(int policy);
sched_get_priority_min	sched.h	PS	sched_get_priority_max, sched_get_priority_min - get priority limits (<b>REALTIME</b>)	int sched_get_priority_min(int policy);
sched_getparam	sched.h	PS	sched_getparam - get scheduling parameters (<b>REALTIME</b>)	int sched_getparam(pid_t pid, struct sched_param *param);
sched_getscheduler	sched.h	PS	sched_getscheduler - get scheduling policy (<b>REALTIME</b>)	int sched_getscheduler(pid_t pid);
sched_rr_get_interval	sched.h	PS	sched_rr_get_interval - get execution time limits (<b>REALTIME</b>)	int sched_rr_get_interval(pid_t pid, struct timespec *interval);
sched_setparam	sched.h	PS	sched_setparam - set scheduling parameters (<b>REALTIME</b>)	int sched_setparam(pid_t pid, const struct sched_param *param);
sched_setscheduler	sched.h	PS	sched_setscheduler - set scheduling policy and parameters (<b>REALTIME</b>)	int sched_setscheduler(pid_t pid, int policy, const struct sched_param *param);
sched_yield	sched.h		sched_yield - yield the processor	int sched_yield(void);
seed48	stdlib.h	XSI	drand48, erand48, jrand48, lcong48, lrand48, mrand48, nrand48, seed48, srand48 - generate uniformly distributed pseudo-random numbers	unsigned short *seed48(unsigned short seed16v[3]);
seekdir	dirent.h	XSI	seekdir - set the position of a directory stream	void seekdir(DIR *dirp, long loc);
select	sys/select.h		pselect, select - synchronous I/O multiplexing	int select(int nfds, fd_set *restrict readfds, fd_set *restrict writefds, fd_set *restrict errorfds, struct timeval *restrict timeout);
sem_close	semaphore.h		sem_close - close a named semaphore	int sem_close(sem_t *sem);
sem_destroy	semaphore.h		sem_destroy - destroy an unnamed semaphore	int sem_destroy(sem_t *sem);
sem_getvalue	semaphore.h		sem_getvalue - get the value of a semaphore	int sem_getvalue(sem_t *restrict sem, int *restrict sval);
sem_init	semaphore.h		sem_init - initialize an unnamed semaphore	int sem_init(sem_t *sem, int pshared, unsigned value);
sem_open	semaphore.h		sem_open - initialize and open a named semaphore	sem_t *sem_open(const char *name, int oflag, ...);
sem_post	semaphore.h		sem_post - unlock a semaphore	int sem_post(sem_t *sem);
sem_timedwait	semaphore.h time.h		sem_timedwait - lock a semaphore	int sem_timedwait(sem_t *restrict sem, const struct timespec *restrict abstime);
sem_trywait	semaphore.h		sem_trywait, sem_wait - lock a semaphore	int sem_trywait(sem_t *sem);
sem_unlink	semaphore.h		sem_unlink - remove a named semaphore	int sem_unlink(const char *name);
sem_wait	semaphore.h		sem_trywait, sem_wait - lock a semaphore	int sem_wait(sem_t *sem);
semctl	sys/sem.h	XSI	semctl - XSI semaphore control operations	int semctl(int semid, int semnum, int cmd, ...);
semget	sys/sem.h	XSI	semget - get set of XSI semaphores	int semget(key_t key, int nsems, int semflg);
semop	sys/sem.h	XSI	semop - XSI semaphore operations	int semop(int semid, struct sembuf *sops, size_t nsops);
send	sys/socket.h		send - send a message on a socket	ssize_t send(int socket, const void *buffer, size_t length, int flags);
sendmsg	sys/socket.h		sendmsg - send a message on a socket using a message structure	ssize_t sendmsg(int socket, const struct msghdr *message, int flags);
sendto	sys/socket.h		sendto - send a message on a socket	ssize_t sendto(int socket, const void *message, size_t length, int flags, const struct sockaddr *dest_addr, socklen_t dest_len);
setbuf	stdio.h		setbuf - assign buffering to a stream	void setbuf(FILE *restrict stream, char *restrict buf);
setegid	unistd.h		setegid - set the effective group ID	int setegid(gid_t gid);
setenv	stdlib.h	CX	setenv - add or change environment variable	int setenv(const char *envname, const char *envval, int overwrite);
seteuid	unistd.h		seteuid - set effective user ID	int seteuid(uid_t uid);
setgid	unistd.h		setgid - set-group-ID	int setgid(gid_t gid);
setgrent	grp.h	XSI	endgrent, getgrent, setgrent - group database entry functions	void setgrent(void);
sethostent	netdb.h		endhostent, gethostent, sethostent - network host database functions	void sethostent(int stayopen);
setitimer	sys/time.h	OB XSI	getitimer, setitimer - get and set value of interval timer	int setitimer(int which, const struct itimerval *restrict value, struct itimerval *restrict ovalue);
setjmp	setjmp.h		setjmp - set jump point for a non-local goto	int setjmp(jmp_buf env);
setkey	stdlib.h	XSI	setkey - set encoding key (<b>CRYPT</b>)	void setkey(const char *key);
setlocale	locale.h		setlocale - set program locale	char *setlocale(int category, const char *locale);
setlogmask	syslog.h	XSI	closelog, openlog, setlogmask, syslog - control system log	int setlogmask(int maskpri);
setnetent	netdb.h		endnetent, getnetbyaddr, getnetbyname, getnetent, setnetent - network database functions	void setnetent(int stayopen);
setpgid	unistd.h		setpgid - set process group ID for job control	int setpgid(pid_t pid, pid_t pgid);
setpgrp	unistd.h	OB XSI	setpgrp - set the process group ID	pid_t setpgrp(void);
setpriority	sys/resource.h	XSI	getpriority, setpriority - get and set the nice value	int setpriority(int which, id_t who, int value);
setprotoent	netdb.h		endprotoent, getprotobyname, getprotobynumber, getprotoent, setprotoent - network protocol database functions	void setprotoent(int stayopen);
setpwent	pwd.h	XSI	endpwent, getpwent, setpwent - user database functions	void setpwent(void);
setregid	unistd.h	XSI	setregid - set real and effective group IDs	int setregid(gid_t rgid, gid_t egid);
setreuid	unistd.h	XSI	setreuid - set real and effective user IDs	int setreuid(uid_t ruid, uid_t euid);
setrlimit	sys/resource.h	XSI	getrlimit, setrlimit - control maximum resource consumption	int setrlimit(int resource, const struct rlimit *rlp);
setservent	netdb.h		endservent, getservbyname, getservbyport, getservent, setservent - network services database functions	void setservent(int stayopen);
setsid	unistd.h		setsid - create session and set process group ID	pid_t setsid(void);
setsockopt	sys/socket.h		setsockopt - set the socket options	int setsockopt(int socket, int level, int option_name, const void *option_value, socklen_t option_len);
setstate	stdlib.h	XSI	initstate, random, setstate, srandom - pseudo-random number functions	char *setstate(char *state);
setuid	unistd.h		setuid - set user ID	int setuid(uid_t uid);
setutxent	utmpx.h	XSI	endutxent, getutxent, getutxid, getutxline, pututxline, setutxent - user accounting database functions	void setutxent(void);
setvbuf	stdio.h		setvbuf - assign buffering to a stream	int setvbuf(FILE *restrict stream, char *restrict buf, int type, size_t size);
shm_open	sys/mman.h	SHM	shm_open - open a shared memory object (<b>REALTIME</b>)	int shm_open(const char *name, int oflag, mode_t mode);
shm_unlink	sys/mman.h	SHM	shm_unlink - remove a shared memory object (<b>REALTIME</b>)	int shm_unlink(const char *name);
shmat	sys/shm.h	XSI	shmat - XSI shared memory attach operation	void *shmat(int shmid, const void *shmaddr, int shmflg);
shmctl	sys/shm.h	XSI	shmctl - XSI shared memory control operations	int shmctl(int shmid, int cmd, struct shmid_ds *buf);
shmdt	sys/shm.h	XSI	shmdt - XSI shared memory detach operation	int shmdt(const void *shmaddr);
shmget	sys/shm.h	XSI	shmget - get an XSI shared memory segment	int shmget(key_t key, size_t size, int shmflg);
shutdown	sys/socket.h		shutdown - shut down socket send and receive operations	int shutdown(int socket, int how);
sigaction	signal.h	CX	sigaction - examine and change a signal action	int sigaction(int sig, const struct sigaction *restrict act, struct sigaction *restrict oact);
sigaddset	signal.h	CX	sigaddset - add a signal to a signal set	int sigaddset(sigset_t *set, int signo);
sigaltstack	signal.h	XSI	sigaltstack - set and get signal alternate stack context	int sigaltstack(const stack_t *restrict ss, stack_t *restrict oss);
sigdelset	signal.h	CX	sigdelset - delete a signal from a signal set	int sigdelset(sigset_t *set, int signo);
sigemptyset	signal.h	CX	sigemptyset - initialize and empty a signal set	int sigemptyset(sigset_t *set);
sigfillset	signal.h	CX	sigfillset - initialize and fill a signal set	int sigfillset(sigset_t *set);
sighold	signal.h	OB XSI	sighold, sigignore, sigpause, sigrelse, sigset - signal management	int sighold(int sig);
sigignore	signal.h	OB XSI	sighold, sigignore, sigpause, sigrelse, sigset - signal management	int sigignore(int sig);
siginterrupt	signal.h	OB XSI	siginterrupt - allow signals to interrupt functions	int siginterrupt(int sig, int flag);
sigismember	signal.h	CX	sigismember - test for a signal in a signal set	int sigismember(const sigset_t *set, int signo);
siglongjmp	setjmp.h	CX	siglongjmp - non-local goto with signal handling	void siglongjmp(sigjmp_buf env, int val);
signal	signal.h		signal - signal management	void (*signal(int sig, void (*func)(int)))(int);
signbit	math.h		signbit - test sign	int signbit(real-floating x);
signgam	math.h	XSI	lgamma, lgammaf, lgammal, signgam - log gamma function	
sigpause	signal.h	OB XSI	sighold, sigignore, sigpause, sigrelse, sigset - signal management	int sigpause(int sig);
sigpending	signal.h	CX	sigpending - examine pending signals	int sigpending(sigset_t *set);
sigprocmask	signal.h	CX	pthread_sigmask, sigprocmask - examine and change blocked signals	int sigprocmask(int how, const sigset_t *restrict set, sigset_t *restrict oset);
sigqueue	signal.h	CX	sigqueue - queue a signal to a process	int sigqueue(pid_t pid, int signo, const union sigval value);
sigrelse	signal.h	OB XSI	sighold, sigignore, sigpause, sigrelse, sigset - signal management	int sigrelse(int sig);
sigset	signal.h	OB XSI	sighold, sigignore, sigpause, sigrelse, sigset - signal management	void (*sigset(int sig, void (*disp)(int)))(int);
sigsetjmp	setjmp.h	CX	sigsetjmp - set jump point for a non-local goto	int sigsetjmp(sigjmp_buf env, int savemask);
sigsuspend	signal.h	CX	sigsuspend - wait for a signal	int sigsuspend(const sigset_t *sigmask);
sigtimedwait	signal.h	CX	sigtimedwait, sigwaitinfo - wait for queued signals	int sigtimedwait(const sigset_t *restrict set, siginfo_t *restrict info, const struct timespec *restrict timeout);
sigwait	signal.h	CX	sigwait - wait for queued signals	int sigwait(const sigset_t *restrict set, int *restrict sig);
sigwaitinfo	signal.h	CX	sigtimedwait, sigwaitinfo - wait for queued signals	int sigwaitinfo(const sigset_t *restrict set, siginfo_t *restrict info);
sin	math.h		sin, sinf, sinl - sine function	double sin(double x);
sinf	math.h		sin, sinf, sinl - sine function	float sinf(float x);
sinh	math.h		sinh, sinhf, sinhl - hyperbolic sine functions	double sinh(double x);
sinhf	math.h		sinh, sinhf, sinhl - hyperbolic sine functions	float sinhf(float x);
sinhl	math.h		sinh, sinhf, sinhl - hyperbolic sine functions	long double sinhl(long double x);
sinl	math.h		sin, sinf, sinl - sine function	long double sinl(long double x);
sleep	unistd.h		sleep - suspend execution for an interval of time	unsigned sleep(unsigned seconds);
snprintf	stdio.h		dprintf, fprintf, printf, snprintf, sprintf - print formatted output	int snprintf(char *restrict s, size_t n, const char *restrict format, ...);
sockatmark	sys/socket.h		sockatmark - determine whether a socket is at the out-of-band mark	int sockatmark(int s);
socket	sys/socket.h		socket - create an endpoint for communication	int socket(int domain, int type, int protocol);
socketpair	sys/socket.h		socketpair - create a pair of connected sockets	int socketpair(int domain, int type, int protocol, int socket_vector[2]);
sprintf	stdio.h		dprintf, fprintf, printf, snprintf, sprintf - print formatted output	int sprintf(char *restrict s, const char *restrict format, ...);
sqrt	math.h		sqrt, sqrtf, sqrtl - square root function	double sqrt(double x);
sqrtf	math.h		sqrt, sqrtf, sqrtl - square root function	float sqrtf(float x);
sqrtl	math.h		sqrt, sqrtf, sqrtl - square root function	long double sqrtl(long double x);
srand	stdlib.h		rand, rand_r, srand - pseudo-random number generator	void srand(unsigned seed);
srand48	stdlib.h	XSI	drand48, erand48, jrand48, lcong48, lrand48, mrand48, nrand48, seed48, srand48 - generate uniformly distributed pseudo-random numbers	void srand48(long seedval);
srandom	stdlib.h	XSI	initstate, random, setstate, srandom - pseudo-random number functions	void srandom(unsigned seed);
sscanf	stdio.h		fscanf, scanf, sscanf - convert formatted input	int sscanf(const char *restrict s, const char *restrict format, ...);
stat	sys/stat.h		fstatat, lstat, stat - get file status	int stat(const char *restrict path, struct stat *restrict buf);
statvfs	sys/statvfs.h		fstatvfs, statvfs - get file system information	int statvfs(const char *restrict path, struct statvfs *restrict buf);
stderr	stdio.h		stderr, stdin, stdout - standard I/O streams	
stdin	stdio.h		stderr, stdin, stdout - standard I/O streams	
stdout	stdio.h		stderr, stdin, stdout - standard I/O streams	
stpcpy	string.h	CX	stpcpy, strcpy - copy a string and return a pointer to the end of the result	char *stpcpy(char *restrict s1, const char *restrict s2);
stpncpy	string.h	CX	stpncpy, strncpy - copy fixed length string, returning a pointer to the array end	char *stpncpy(char *restrict s1, const char *restrict s2, size_t n);
strcasecmp	strings.h		strcasecmp, strcasecmp_l, strncasecmp, strncasecmp_l - case-insensitive string comparisons	int strcasecmp(const char *s1, const char *s2);
strcasecmp_l	strings.h		strcasecmp, strcasecmp_l, strncasecmp, strncasecmp_l - case-insensitive string comparisons	int strcasecmp_l(const char *s1, const char *s2, locale_t locale);
strcat	string.h		strcat - concatenate two strings	char *strcat(char *restrict s1, const char *restrict s2);
strchr	string.h		strchr - string scanning operation	char *strchr(const char *s, int c);
strcmp	string.h		strcmp - compare two strings	int strcmp(const char *s1, const char *s2);
strcoll	string.h		strcoll, strcoll_l - string comparison using collating information	int strcoll(const char *s1, const char *s2);
strcoll_l	string.h	CX	strcoll, strcoll_l - string comparison using collating information	int strcoll_l(const char *s1, const char *s2, locale_t locale);
strcpy	string.h		stpcpy, strcpy - copy a string and return a pointer to the end of the result	char *strcpy(char *restrict s1, const char *restrict s2);
strcspn	string.h		strcspn - get the length of a complementary substring	size_t strcspn(const char *s1, const char *s2);
strdup	string.h	CX	strdup, strndup - duplicate a specific number of bytes from a string	char *strdup(const char *s);
strerror	string.h		strerror, strerror_l, strerror_r - get error message string	char *strerror(int errnum);
strerror_l	string.h	CX	strerror, strerror_l, strerror_r - get error message string	char *strerror_l(int errnum, locale_t locale);
strerror_r	string.h	CX	strerror, strerror_l, strerror_r - get error message string	int strerror_r(int errnum, char *strerrbuf, size_t buflen);
strfmon	monetary.h		strfmon, strfmon_l - convert monetary value to a string	ssize_t strfmon(char *restrict s, size_t maxsize, const char *restrict format, ...);
strfmon_l	monetary.h		strfmon, strfmon_l - convert monetary value to a string	ssize_t strfmon_l(char *restrict s, size_t maxsize, locale_t locale, const char *restrict format, ...);
strftime	time.h		strftime, strftime_l - convert date and time to a string	size_t strftime(char *restrict s, size_t maxsize, const char *restrict format, const struct tm *restrict timeptr);
strftime_l	time.h	CX	strftime, strftime_l - convert date and time to a string	size_t strftime_l(char *restrict s, size_t maxsize, const char *restrict format, const struct tm *restrict timeptr, locale_t locale);
strlen	string.h		strlen, strnlen - get length of fixed size string	size_t strlen(const char *s);
strncasecmp	strings.h		strcasecmp, strcasecmp_l, strncasecmp, strncasecmp_l - case-insensitive string comparisons	int strncasecmp(const char *s1, const char *s2, size_t n);
strncasecmp_l	strings.h		strcasecmp, strcasecmp_l, strncasecmp, strncasecmp_l - case-insensitive string comparisons	int strncasecmp_l(const char *s1, const char *s2, size_t n, locale_t locale);
strncat	string.h		strncat - concatenate a string with part of another	char *strncat(char *restrict s1, const char *restrict s2, size_t n);
strncmp	string.h		strncmp - compare part of two strings	int strncmp(const char *s1, const char *s2, size_t n);
strncpy	string.h		stpncpy, strncpy - copy fixed length string, returning a pointer to the array end	char *strncpy(char *restrict s1, const char *restrict s2, size_t n);
strndup	string.h	CX	strdup, strndup - duplicate a specific number of bytes from a string	char *strndup(const char *s, size_t size);
strnlen	string.h	CX	strlen, strnlen - get length of fixed size string	size_t strnlen(const char *s, size_t maxlen);
strpbrk	string.h		strpbrk - scan a string for a byte	char *strpbrk(const char *s1, const char *s2);
strptime	time.h	XSI	strptime - date and time conversion	char *strptime(const char *restrict buf, const char *restrict format, struct tm *restrict tm);
strrchr	string.h		strrchr - string scanning operation	char *strrchr(const char *s, int c);
strsignal	string.h	CX	strsignal - get name of signal	char *strsignal(int signum);
strspn	string.h		strspn - get length of a substring	size_t strspn(const char *s1, const char *s2);
strstr	string.h		strstr - find a substring	char *strstr(const char *s1, const char *s2);
strtod	stdlib.h		strtod, strtof, strtold - convert a string to a double-precision number	double strtod(const char *restrict nptr, char **restrict endptr);
strtof	stdlib.h		strtod, strtof, strtold - convert a string to a double-precision number	float strtof(const char *restrict nptr, char **restrict endptr);
strtoimax	inttypes.h		strtoimax, strtoumax - convert string to integer type	intmax_t strtoimax(const char *restrict nptr, char **restrict endptr, int base);
strtok	string.h		strtok, strtok_r - split string into tokens	char *strtok(char *restrict s1, const char *restrict s2);
strtok_r	string.h	CX	strtok, strtok_r - split string into tokens	char *strtok_r(char *restrict s, const char *restrict sep, char **restrict lasts);
strtol	stdlib.h		strtol, strtoll - convert a string to a long integer	long strtol(const char *restrict str, char **restrict endptr, int base);
strtold	stdlib.h		strtod, strtof, strtold - convert a string to a double-precision number	long double strtold(const char *restrict nptr, char **restrict endptr);
strtoll	stdlib.h		strtol, strtoll - convert a string to a long integer	long long strtoll(const char *restrict str, char **restrict endptr, int base);
strtoul	stdlib.h		strtoul, strtoull - convert a string to an unsigned long	unsigned long strtoul(const char *restrict str, char **restrict endptr, int base);
strtoull	stdlib.h		strtoul, strtoull - convert a string to an unsigned long	unsigned long long strtoull(const char *restrict str, char **restrict endptr, int base);
strtoumax	inttypes.h		strtoimax, strtoumax - convert string to integer type	uintmax_t strtoumax(const char *restrict nptr, char **restrict endptr, int base);
strxfrm	string.h		strxfrm, strxfrm_l - string transformation	size_t strxfrm(char *restrict s1, const char *restrict s2, size_t n);
strxfrm_l	string.h	CX	strxfrm, strxfrm_l - string transformation	size_t strxfrm_l(char *restrict s1, const char *restrict s2, size_t n, locale_t locale);
swab	unistd.h	XSI	swab - swap bytes	void swab(const void *restrict src, void *restrict dest, ssize_t nbytes);
swprintf	stdio.h wchar.h		fwprintf, swprintf, wprintf - print formatted wide-character output	int swprintf(wchar_t *restrict ws, size_t n, const wchar_t *restrict format, ...);
swscanf	stdio.h wchar.h		fwscanf, swscanf, wscanf - convert formatted wide-character input	int swscanf(const wchar_t *restrict ws, const wchar_t *restrict format, ...);
symlink	unistd.h		symlink, symlinkat - make a symbolic link relative to directory file descriptor	int symlink(const char *path1, const char *path2);
symlinkat	unistd.h		symlink, symlinkat - make a symbolic link relative to directory file descriptor	int symlinkat(const char *path1, int fd, const char *path2);
sync	unistd.h	XSI	sync - schedule file system updates	void sync(void);
sysconf	unistd.h		sysconf - get configurable system variables	long sysconf(int name);
syslog	syslog.h	XSI	closelog, openlog, setlogmask, syslog - control system log	void syslog(int priority, const char *message, ... /* arguments */);
system	stdlib.h		system - issue a command	int system(const char *command);
tan	math.h		tan, tanf, tanl - tangent function	double tan(double x);
tanf	math.h		tan, tanf, tanl - tangent function	float tanf(float x);
tanh	math.h		tanh, tanhf, tanhl - hyperbolic tangent functions	double tanh(double x);
tanhf	math.h		tanh, tanhf, tanhl - hyperbolic tangent functions	float tanhf(float x);
tanhl	math.h		tanh, tanhf, tanhl - hyperbolic tangent functions	long double tanhl(long double x);
tanl	math.h		tan, tanf, tanl - tangent function	long double tanl(long double x);
tcdrain	termios.h		tcdrain - wait for transmission of output	int tcdrain(int fildes);
tcflow	termios.h		tcflow - suspend or restart the transmission or reception of data	int tcflow(int fildes, int action);
tcflush	termios.h		tcflush - flush non-transmitted output data, non-read input data, or both	int tcflush(int fildes, int queue_selector);
tcgetattr	termios.h		tcgetattr - get the parameters associated with the terminal	int tcgetattr(int fildes, struct termios *termios_p);
tcgetpgrp	unistd.h		tcgetpgrp - get the foreground process group ID	pid_t tcgetpgrp(int fildes);
tcgetsid	termios.h		tcgetsid - get the process group ID for the session leader for the controlling terminal	pid_t tcgetsid(int fildes);
tcsendbreak	termios.h		tcsendbreak - send a break for a specific duration	int tcsendbreak(int fildes, int duration);
tcsetattr	termios.h		tcsetattr - set the parameters associated with the terminal	int tcsetattr(int fildes, int optional_actions, const struct termios *termios_p);
tcsetpgrp	unistd.h		tcsetpgrp - set the foreground process group ID	int tcsetpgrp(int fildes, pid_t pgid_id);
tdelete	search.h	XSI	tdelete, tfind, tsearch, twalk - manage a binary search tree	void *tdelete(const void *restrict key, void **restrict rootp, int(*compar)(const void *, const void *));
telldir	dirent.h	XSI	telldir - current location of a named directory stream	long telldir(DIR *dirp);
tempnam	stdio.h	OB XSI	tempnam - create a name for a temporary file	char *tempnam(const char *dir, const char *pfx);
tfind	search.h	XSI	tdelete, tfind, tsearch, twalk - manage a binary search tree	void *tfind(const void *key, void *const *rootp, int(*compar)(const void *, const void *));
tgamma	math.h		tgamma, tgammaf, tgammal - compute gamma() function	double tgamma(double x);
tgammaf	math.h		tgamma, tgammaf, tgammal - compute gamma() function	float tgammaf(float x);
tgammal	math.h		tgamma, tgammaf, tgammal - compute gamma() function	long double tgammal(long double x);
time	time.h		time - get time	time_t time(time_t *tloc);
timer_create	signal.h time.h	CX	timer_create - create a per-process timer	int timer_create(clockid_t clockid, struct sigevent *restrict evp, timer_t *restrict timerid);
timer_delete	time.h	CX	timer_delete - delete a per-process timer	int timer_delete(timer_t timerid);
timer_getoverrun	time.h	CX	timer_getoverrun, timer_gettime, timer_settime - per-process timers	int timer_getoverrun(timer_t timerid);
timer_gettime	time.h	CX	timer_getoverrun, timer_gettime, timer_settime - per-process timers	int timer_gettime(timer_t timerid, struct itimerspec *value);
timer_settime	time.h	CX	timer_getoverrun, timer_gettime, timer_settime - per-process timers	int timer_settime(timer_t timerid, int flags, const struct itimerspec *restrict value, struct itimerspec *restrict ovalue);
times	sys/times.h		times - get process and waited-for child process times	clock_t times(struct tms *buffer);
timezone	time.h	XSI	daylight, timezone, tzname, tzset - set timezone conversion information	
tmpfile	stdio.h		tmpfile - create a temporary file	FILE *tmpfile(void);
tmpnam	stdio.h	OB	tmpnam - create a name for a temporary file	char *tmpnam(char *s);
toascii	ctype.h	OB XSI	toascii - translate an integer to a 7-bit ASCII character	int toascii(int c);
tolower	ctype.h		tolower, tolower_l - transliterate uppercase characters to lowercase	int tolower(int c);
tolower_l	ctype.h	CX	tolower, tolower_l - transliterate uppercase characters to lowercase	int tolower_l(int c, locale_t locale);
toupper	ctype.h		toupper, toupper_l - transliterate lowercase characters to uppercase	int toupper(int c);
toupper_l	ctype.h	CX	toupper, toupper_l - transliterate lowercase characters to uppercase	int toupper_l(int c, locale_t locale);
towctrans	wctype.h		towctrans, towctrans_l - wide-character transliteration	wint_t towctrans(wint_t wc, wctrans_t desc);
towctrans_l	wctype.h	CX	towctrans, towctrans_l - wide-character transliteration	wint_t towctrans_l(wint_t wc, wctrans_t desc, locale_t locale);
towlower	wctype.h		towlower, towlower_l - transliterate uppercase wide-character code to lowercase	wint_t towlower(wint_t wc);
towlower_l	wctype.h	CX	towlower, towlower_l - transliterate uppercase wide-character code to lowercase	wint_t towlower_l(wint_t wc, locale_t locale);
towupper	wctype.h		towupper, towupper_l - transliterate lowercase wide-character code to uppercase	wint_t towupper(wint_t wc);
towupper_l	wctype.h	CX	towupper, towupper_l - transliterate lowercase wide-character code to uppercase	wint_t towupper_l(wint_t wc, locale_t locale);
trunc	math.h		trunc, truncf, truncl - round to truncated integer value	double trunc(double x);
truncate	unistd.h		truncate - truncate a file to a specified length	int truncate(const char *path, off_t length);
truncf	math.h		trunc, truncf, truncl - round to truncated integer value	float truncf(float x);
truncl	math.h		trunc, truncf, truncl - round to truncated integer value	long double truncl(long double x);
tsearch	search.h	XSI	tdelete, tfind, tsearch, twalk - manage a binary search tree	void *tsearch(const void *key, void **rootp, int (*compar)(const void *, const void *));
ttyname	unistd.h		ttyname, ttyname_r - find the pathname of a terminal	char *ttyname(int fildes);
ttyname_r	unistd.h		ttyname, ttyname_r - find the pathname of a terminal	int ttyname_r(int fildes, char *name, size_t namesize);
twalk	search.h	XSI	tdelete, tfind, tsearch, twalk - manage a binary search tree	void twalk(const void *root, void (*action)(const void *, VISIT, int));
tzname	time.h	CX	daylight, timezone, tzname, tzset - set timezone conversion information	
tzset	time.h	CX	daylight, timezone, tzname, tzset - set timezone conversion information	void tzset(void);
ulimit	ulimit.h	OB XSI	ulimit - get and set process limits	long ulimit(int cmd, ...);
umask	sys/stat.h		umask - set and get the file mode creation mask	mode_t umask(mode_t cmask);
uname	sys/utsname.h		uname - get the name of the current system	int uname(struct utsname *name);
ungetc	stdio.h		ungetc - push byte back into input stream	int ungetc(int c, FILE *stream);
ungetwc	stdio.h wchar.h		ungetwc - push wide-character code back into the input stream	wint_t ungetwc(wint_t wc, FILE *stream);
unlink	unistd.h		unlink, unlinkat - remove a directory entry relative to directory file descriptor	int unlink(const char *path);
unlinkat	unistd.h		unlink, unlinkat - remove a directory entry relative to directory file descriptor	int unlinkat(int fd, const char *path, int flag);
unlockpt	stdlib.h	XSI	unlockpt - unlock a pseudo-terminal master/slave pair	int unlockpt(int fildes);
unsetenv	stdlib.h	CX	unsetenv - remove an environment variable	int unsetenv(const char *name);
uselocale	locale.h	CX	uselocale - use locale in current thread	locale_t uselocale(locale_t newloc);
utime	utime.h	OB	utime - set file access and modification times	int utime(const char *path, const struct utimbuf *times);
utimensat	sys/stat.h		futimens, utimensat, utimes - set file access and modification times	int utimensat(int fd, const char *path, const struct timespec times[2], int flag);
utimes	sys/time.h	XSI	futimens, utimensat, utimes - set file access and modification times	int utimes(const char *path, const struct timeval times[2]);
va_arg	stdarg.h		va_arg, va_copy, va_end, va_start - handle variable argument list	type va_arg(va_list ap, type);
va_copy	stdarg.h		va_arg, va_copy, va_end, va_start - handle variable argument list	void va_copy(va_list dest, va_list src);
va_end	stdarg.h		va_arg, va_copy, va_end, va_start - handle variable argument list	void va_end(va_list ap);
va_start	stdarg.h		va_arg, va_copy, va_end, va_start - handle variable argument list	void va_start(va_list ap, argN);
vdprintf	stdarg.h stdio.h	CX	vdprintf, vfprintf, vprintf, vsnprintf, vsprintf - format output of a stdarg argument list	int vdprintf(int fildes, const char *restrict format, va_list ap);
vfprintf	stdarg.h stdio.h		vdprintf, vfprintf, vprintf, vsnprintf, vsprintf - format output of a stdarg argument list	int vfprintf(FILE *restrict stream, const char *restrict format, va_list ap);
vfscanf	stdarg.h stdio.h		vfscanf, vscanf, vsscanf - format input of a stdarg argument list	int vfscanf(FILE *restrict stream, const char *restrict format, va_list arg);
vfwprintf	stdarg.h stdio.h wchar.h		vfwprintf, vswprintf, vwprintf - wide-character formatted output of a stdarg argument list	int vfwprintf(FILE *restrict stream, const wchar_t *restrict format, va_list arg);
vfwscanf	stdarg.h stdio.h wchar.h		vfwscanf, vswscanf, vwscanf - wide-character formatted input of a stdarg argument list	int vfwscanf(FILE *restrict stream, const wchar_t *restrict format, va_list arg);
vprintf	stdarg.h stdio.h		vdprintf, vfprintf, vprintf, vsnprintf, vsprintf - format output of a stdarg argument list	int vprintf(const char *restrict format, va_list ap);
vscanf	stdarg.h stdio.h		vfscanf, vscanf, vsscanf - format input of a stdarg argument list	int vscanf(const char *restrict format, va_list arg);
vsnprintf	stdarg.h stdio.h		vdprintf, vfprintf, vprintf, vsnprintf, vsprintf - format output of a stdarg argument list	int vsnprintf(char *restrict s, size_t n, const char *restrict format, va_list ap);
vsprintf	stdarg.h stdio.h		vdprintf, vfprintf, vprintf, vsnprintf, vsprintf - format output of a stdarg argument list	int vsprintf(char *restrict s, const char *restrict format, va_list ap);
vsscanf	stdarg.h stdio.h		vfscanf, vscanf, vsscanf - format input of a stdarg argument list	int vsscanf(const char *restrict s, const char *restrict format, va_list arg);
vswprintf	stdarg.h stdio.h wchar.h		vfwprintf, vswprintf, vwprintf - wide-character formatted output of a stdarg argument list	int vswprintf(wchar_t *restrict ws, size_t n, const wchar_t *restrict format, va_list arg);
vswscanf	stdarg.h stdio.h wchar.h		vfwscanf, vswscanf, vwscanf - wide-character formatted input of a stdarg argument list	int vswscanf(const wchar_t *restrict ws, const wchar_t *restrict format, va_list arg);
vwprintf	stdarg.h stdio.h wchar.h		vfwprintf, vswprintf, vwprintf - wide-character formatted output of a stdarg argument list	int vwprintf(const wchar_t *restrict format, va_list arg);
vwscanf	stdarg.h stdio.h wchar.h		vfwscanf, vswscanf, vwscanf - wide-character formatted input of a stdarg argument list	int vwscanf(const wchar_t *restrict format, va_list arg);
wait	sys/wait.h		wait, waitpid - wait for a child process to stop or terminate	pid_t wait(int *stat_loc);
waitid	sys/wait.h		waitid - wait for a child process to change state	int waitid(idtype_t idtype, id_t id, siginfo_t *infop, int options);
waitpid	sys/wait.h		wait, waitpid - wait for a child process to stop or terminate	pid_t waitpid(pid_t pid, int *stat_loc, int options);
wcpcpy	wchar.h	CX	wcpcpy, wcscpy - copy a wide-character string, returning a pointer to its end	wchar_t *wcpcpy(wchar_t *restrict ws1, const wchar_t *restrict ws2);
wcpncpy	wchar.h	CX	wcpncpy, wcsncpy - copy a fixed-size wide-character string, returning a pointer to its end	wchar_t *wcpncpy(wchar_t *restrict ws1, const wchar_t *restrict ws2, size_t n);
wcrtomb	wchar.h		wcrtomb - convert a wide-character code to a character (restartable)	size_t wcrtomb(char *restrict s, wchar_t wc, mbstate_t *restrict ps);
wcscasecmp	wchar.h	CX	wcscasecmp, wcscasecmp_l, wcsncasecmp, wcsncasecmp_l - case-insensitive wide-character string comparison	int wcscasecmp(const wchar_t *ws1, const wchar_t *ws2);
wcscasecmp_l	wchar.h	CX	wcscasecmp, wcscasecmp_l, wcsncasecmp, wcsncasecmp_l - case-insensitive wide-character string comparison	int wcscasecmp_l(const wchar_t *ws1, const wchar_t *ws2, locale_t locale);
wcscat	wchar.h		wcscat - concatenate two wide-character strings	wchar_t *wcscat(wchar_t *restrict ws1, const wchar_t *restrict ws2);
wcschr	wchar.h		wcschr - wide-character string scanning operation	wchar_t *wcschr(const wchar_t *ws, wchar_t wc);
wcscmp	wchar.h		wcscmp - compare two wide-character strings	int wcscmp(const wchar_t *ws1, const wchar_t *ws2);
wcscoll	wchar.h		wcscoll, wcscoll_l - wide-character string comparison using collating information	int wcscoll(const wchar_t *ws1, const wchar_t *ws2);
wcscoll_l	wchar.h	CX	wcscoll, wcscoll_l - wide-character string comparison using collating information	int wcscoll_l(const wchar_t *ws1, const wchar_t *ws2, locale_t locale);
wcscpy	wchar.h		wcpcpy, wcscpy - copy a wide-character string, returning a pointer to its end	wchar_t *wcscpy(wchar_t *restrict ws1, const wchar_t *restrict ws2);
wcscspn	wchar.h		wcscspn - get the length of a complementary wide substring	size_t wcscspn(const wchar_t *ws1, const wchar_t *ws2);
wcsdup	wchar.h	CX	wcsdup - duplicate a wide-character string	wchar_t *wcsdup(const wchar_t *string);
wcsftime	wchar.h		wcsftime - convert date and time to a wide-character string	size_t wcsftime(wchar_t *restrict wcs, size_t maxsize, const wchar_t *restrict format, const struct tm *restrict timeptr);
wcslen	wchar.h		wcslen, wcsnlen - get length of a fixed-sized wide-character string	size_t wcslen(const wchar_t *ws);
wcsncasecmp	wchar.h	CX	wcscasecmp, wcscasecmp_l, wcsncasecmp, wcsncasecmp_l - case-insensitive wide-character string comparison	int wcsncasecmp(const wchar_t *ws1, const wchar_t *ws2, size_t n);
wcsncasecmp_l	wchar.h	CX	wcscasecmp, wcscasecmp_l, wcsncasecmp, wcsncasecmp_l - case-insensitive wide-character string comparison	int wcsncasecmp_l(const wchar_t *ws1, const wchar_t *ws2, size_t n, locale_t locale);
wcsncat	wchar.h		wcsncat - concatenate a wide-character string with part of another	wchar_t *wcsncat(wchar_t *restrict ws1, const wchar_t *restrict ws2, size_t n);
wcsncmp	wchar.h		wcsncmp - compare part of two wide-character strings	int wcsncmp(const wchar_t *ws1, const wchar_t *ws2, size_t n);
wcsncpy	wchar.h		wcpncpy, wcsncpy - copy a fixed-size wide-character string, returning a pointer to its end	wchar_t *wcsncpy(wchar_t *restrict ws1, const wchar_t *restrict ws2, size_t n);
wcsnlen	wchar.h	CX	wcslen, wcsnlen - get length of a fixed-sized wide-character string	size_t wcsnlen(const wchar_t *ws, size_t maxlen);
wcsnrtombs	wchar.h	CX	wcsnrtombs, wcsrtombs - convert a wide-character string to a character string (restartable)	size_t wcsnrtombs(char *restrict dst, const wchar_t **restrict src, size_t nwc, size_t len, mbstate_t *restrict ps);
wcspbrk	wchar.h		wcspbrk - scan a wide-character string for a wide-character code	wchar_t *wcspbrk(const wchar_t *ws1, const wchar_t *ws2);
wcsrchr	wchar.h		wcsrchr - wide-character string scanning operation	wchar_t *wcsrchr(const wchar_t *ws, wchar_t wc);
wcsrtombs	wchar.h		wcsnrtombs, wcsrtombs - convert a wide-character string to a character string (restartable)	size_t wcsrtombs(char *restrict dst, const wchar_t **restrict src, size_t len, mbstate_t *restrict ps);
wcsspn	wchar.h		wcsspn - get the length of a wide substring	size_t wcsspn(const wchar_t *ws1, const wchar_t *ws2);
wcsstr	wchar.h		wcsstr - find a wide-character substring	wchar_t *wcsstr(const wchar_t *restrict ws1, const wchar_t *restrict ws2);
wcstod	wchar.h		wcstod, wcstof, wcstold - convert a wide-character string to a double-precision number	double wcstod(const wchar_t *restrict nptr, wchar_t **restrict endptr);
wcstof	wchar.h		wcstod, wcstof, wcstold - convert a wide-character string to a double-precision number	float wcstof(const wchar_t *restrict nptr, wchar_t **restrict endptr);
wcstoimax	stddef.h inttypes.h		wcstoimax, wcstoumax - convert a wide-character string to an integer type	intmax_t wcstoimax(const wchar_t *restrict nptr, wchar_t **restrict endptr, int base);
wcstok	wchar.h		wcstok - split a wide-character string into tokens	wchar_t *wcstok(wchar_t *restrict ws1, const wchar_t *restrict ws2, wchar_t **restrict ptr);
wcstol	wchar.h		wcstol, wcstoll - convert a wide-character string to a long integer	long wcstol(const wchar_t *restrict nptr, wchar_t **restrict endptr, int base);
wcstold	wchar.h		wcstod, wcstof, wcstold - convert a wide-character string to a double-precision number	long double wcstold(const wchar_t *restrict nptr, wchar_t **restrict endptr);
wcstoll	wchar.h		wcstol, wcstoll - convert a wide-character string to a long integer	long long wcstoll(const wchar_t *restrict nptr, wchar_t **restrict endptr, int base);
wcstombs	stdlib.h		wcstombs - convert a wide-character string to a character string	size_t wcstombs(char *restrict s, const wchar_t *restrict pwcs, size_t n);
wcstoul	wchar.h		wcstoul, wcstoull - convert a wide-character string to an unsigned long	unsigned long wcstoul(const wchar_t *restrict nptr, wchar_t **restrict endptr, int base);
wcstoull	wchar.h		wcstoul, wcstoull - convert a wide-character string to an unsigned long	unsigned long long wcstoull(const wchar_t *restrict nptr, wchar_t **restrict endptr, int base);
wcstoumax	stddef.h inttypes.h		wcstoimax, wcstoumax - convert a wide-character string to an integer type	uintmax_t wcstoumax(const wchar_t *restrict nptr, wchar_t **restrict endptr, int base);
wcswidth	wchar.h	XSI	wcswidth - number of column positions of a wide-character string	int wcswidth(const wchar_t *pwcs, size_t n);
wcsxfrm	wchar.h		wcsxfrm, wcsxfrm_l - wide-character string transformation	size_t wcsxfrm(wchar_t *restrict ws1, const wchar_t *restrict ws2, size_t n);
wcsxfrm_l	wchar.h	CX	wcsxfrm, wcsxfrm_l - wide-character string transformation	size_t wcsxfrm_l(wchar_t *restrict ws1, const wchar_t *restrict ws2, size_t n, locale_t locale);
wctob	stdio.h wchar.h		wctob - wide-character to single-byte conversion	int wctob(wint_t c);
wctomb	stdlib.h		wctomb - convert a wide-character code to a character	int wctomb(char *s, wchar_t wchar);
wctrans	wctype.h		wctrans, wctrans_l - define character mapping	wctrans_t wctrans(const char *charclass);
wctrans_l	wctype.h	CX	wctrans, wctrans_l - define character mapping	wctrans_t wctrans_l(const char *charclass, locale_t locale);
wctype	wctype.h		wctype, wctype_l - define character class	wctype_t wctype(const char *property);
wctype_l	wctype.h	CX	wctype, wctype_l - define character class	wctype_t wctype_l(const char *property, locale_t locale);
wcwidth	wchar.h	XSI	wcwidth - number of column positions of a wide-character code	int wcwidth(wchar_t wc);
wmemchr	wchar.h		wmemchr - find a wide character in memory	wchar_t *wmemchr(const wchar_t *ws, wchar_t wc, size_t n);
wmemcmp	wchar.h		wmemcmp - compare wide characters in memory	int wmemcmp(const wchar_t *ws1, const wchar_t *ws2, size_t n);
wmemcpy	wchar.h		wmemcpy - copy wide characters in memory	wchar_t *wmemcpy(wchar_t *restrict ws1, const wchar_t *restrict ws2, size_t n);
wmemmove	wchar.h		wmemmove - copy wide characters in memory with overlapping areas	wchar_t *wmemmove(wchar_t *ws1, const wchar_t *ws2, size_t n);
wmemset	wchar.h		wmemset - set wide characters in memory	wchar_t *wmemset(wchar_t *ws, wchar_t wc, size_t n);
wordexp	wordexp.h		wordexp, wordfree - perform word expansions	int wordexp(const char *restrict words, wordexp_t *restrict pwordexp, int flags);
wordfree	wordexp.h		wordexp, wordfree - perform word expansions	void wordfree(wordexp_t *pwordexp);
wprintf	stdio.h wchar.h		fwprintf, swprintf, wprintf - print formatted wide-character output	int wprintf(const wchar_t *restrict format, ...);
write	unistd.h		pwrite, write - write on a file	ssize_t write(int fildes, const void *buf, size_t nbyte);
writev	sys/uio.h	XSI	writev - write a vector	ssize_t writev(int fildes, const struct iovec *iov, int iovcnt);
wscanf	stdio.h wchar.h		fwscanf, swscanf, wscanf - convert formatted wide-character input	int wscanf(const wchar_t *restrict format, ...);
y0	math.h	XSI	y0, y1, yn - Bessel functions of the second kind	double y0(double x);
y1	math.h	XSI	y0, y1, yn - Bessel functions of the second kind	double y1(double x);
yn	math.h	XSI	y0, y1, yn - Bessel functions of the second kind	double yn(int n, double x);