Table 1

header file

functions

assert.h
complex.h
complex.h

d oub le comp lex ca cos(do ubl e comp lex z);

flo at co mple x c acosf(flo at co mple x z);

complex.h

l ong d oub le comp lex ca cosl(lon g do ubl e compl ex z);

complex.h

d oub le comp lex ca sin(d oub le co mp lex z);

complex.h

flo at co mple x c asinf(float compl ex z);

complex.h

l ong d oub le comp lex ca sinl(lo ng d oub le comp lex z);

complex.h

d oub le comp lex ca tan(dou ble co mple x z);

complex.h

flo at co mple x c atanf(floa t comp lex z);

complex.h

l ong d oub le comp lex ca tanl(l ong d ou ble co mplex z);

complex.h

d oub le comp lex cc os (dou ble co mple x z);

complex.h

flo at co mple x c cosf(floa t comp lex z);

complex.h

l ong d oub le comp lex cc os l(l ong d ou ble co mple x z);

complex.h

d oub le comp lex cs in(do ubl e compl ex z);

complex.h
complex.h

flo at co mple x c sinf(flo at co mple x z);

l ong d oub le comp lex cs inl(lon g do ubl e compl ex z);

complex.h

d oub le comp lex cta n(d oub le comp lex z);

complex.h

flo at co mple x c tanf(float compl ex z);

complex.h

l ong d oub le comp lex cta nl(lo ng do ub le comp lex z);

complex.h

d oub le comp lex ca caos(d oub le co mplex z);

complex.h

flo at co mple x c acoshf(floa t comp lex z);

complex.h

l ong d oub le comp lex ca coshl(l ong d ou ble co mple x z);

complex.h

d oub le comp lex ca sinh(do ubl e compl ex z);

complex.h

flo at co mple x c asinhf(flo at co mple x z);

complex.h
complex.h

l ong d oub le comp lex ca sinhl(lon g do ubl e compl ex z);

d oub le comp lex ca tanh(d oub le comp lex z);

complex.h

flo at co mple x c atanhf(float compl ex z);

complex.h

l ong d oub le comp lex ca tanhl(lo ng do ub le comp lex z);

complex.h

d oub le comp lex cc os h(d oub le comp lex z);

complex.h

flo at co mple x c coshf(float compl ex z);

complex.h

l ong d oub le comp lex cc os hl(lo ng d oub le comp lex z);

complex.h

d oub le comp lex cs inh(dou ble co mple x z);

complex.h

flo at co mple x c sinhf(floa t comp lex z);

complex.h

l ong d oub le comp lex cs inhl(l ong d ou ble co mplex z);

complex.h
complex.h

d oub le comp lex cta nh(do ubl e compl ex z);

flo at co mple x c tanhf(flo at co mplex z);

complex.h

l ong d oub le comp lex cta nhl(lon g do ubl e compl ex z);

complex.h

d oub le comp lex ce xp(dou ble co mple x z);

complex.h

flo at co mple x c expf(floa t comp lex z);

complex.h

l ong d oub le comp lex ce xpl(l ong d oub le co mplex z);

complex.h

d oub le comp lex clog(d oub le comp lex z);

complex.h

flo at co mple x c logf(float compl ex z);

complex.h

l ong d oub le comp lex clogl(lo ng do ub le comp lex z);

complex.h

d oub le ca bs (do ubl e compl ex z);

complex.h

flo at c absf(floa t comp lex z);

complex.h

l ong d oub le ca bsl(lon g dou ble co mple x z);

complex.h

d oub le comp lex cpow(d oub le comp lex x, d oub le comp lex y);

complex.h
complex.h

flo at co mple x c powf(flo at compl ex x, floa t comp lex y);

l ong d oub le comp lex cpowl(lo ng do ubl e comp lex x, lo ng d oub le comp lex y);

complex.h

d oub le comp lex cs qr t(dou ble co mpl ex z);

complex.h

flo at co mple x c sqrtf(floa t comp lex z);

complex.h

l ong d oub le comp lex cs qr tl(l ong dou ble co mple x z);

complex.h

d oub le ca rg(dou bl e compl ex z);

complex.h

flo at c argf(floa t comp lex z);

complex.h

l ong d oub le ca rgl(lon g dou ble co mple x z);

complex.h

d oub le cima g(d ou ble co mplex z);

complex.h

flo at c im agf(float compl ex z);

complex.h
complex.h

l ong d oub le cim agl(l ong d oub le comp lex z);

d oub le comp lex conj(d oub le comp lex z);

complex.h

flo at co mple x c onjf(float compl ex z);

complex.h

l ong d oub le comp lex conjl(lo ng do ub le comp lex z);

complex.h

d oub le comp lex cproj(dou ble co mple x z);

complex.h

flo at co mple x c pr ojf(floa t comp lex z);

complex.h

l ong d oub le comp lex cprojl(l ong d ou ble co mplex z);

complex.h

d oub le cr eal(do ub le comp lex z);

complex.h

flo at c rea lf(flo at co mple x z);

complex.h

l ong d oub le cr ea ll(lo ng do ubl e compl ex z);

ctype.h

i nt isa lnum(in t c);

ctype.h

i nt isa lpha(in t c);

ctype.h

i nt isblank(in t c);

ctype.h
ctype.h

i nt isc ntr l(i nt c);

i nt isdigit(in t c);

ctype.h

i nt isgra ph(in t c);

ctype.h

i nt islowe r(in t c);

ctype.h

i nt isprint(int c);

ctype.h

i nt ispunc t(int c);

ctype.h

i nt iss pa ce(i nt c);

ctype.h

i nt isuppe r(in t c);

ctype.h

i nt isx digit(i nt c);

ctype.h

i nt tolower(i nt c );

ctype.h

i nt toupper (int c);

errno.h
fenv.h

i nt fe clear exc ept(i nt e xce pts);

fenv.h

i nt fe ge te xce ptflag(fe xce pt_t *flag p, i nt e xce pts);

fenv.h

i nt fe raise exc ept(i nt e xce pts);

fenv.h

i nt fe setex ceptflag(const fexce pt_t * flagp , in t excep ts);

fenv.h

i nt fe te stex cept(in t excep ts);

fenv.h

int fegetround(void);

fenv.h

i nt fe setr ound(i nt ro und );

fenv.h

i nt fe ge te nv (fe nv_t *en vp);

fenv.h

i nt fe holdex cept(fenv_ t *e nvp);

fenv.h

i nt fe sete nv(co nst fen v_t * envp );

fenv.h

i nt fe updatee nv(co nst fen v_t * envp );

float.h
inttypes.h

i ntmax_t im axa bs (intmax_ t j);

inttypes.h

i maxdi v_t ima xdiv (intmax_ t n umer, in tma x_t den om);

inttypes.h

i ntmax_t strtoimax (const char * restrict nptr, cha r * * restrict e ndp tr, i nt b ase);

inttypes.h

u intmax_ t str touma x(con st cha r * re stri ct np tr, ch ar ** restrict end ptr, int base );

inttypes.h

i ntmax_t wc stoim ax(co nst w char_ t * restrict nptr, wcha r_t ** restrict e nd ptr, i nt b ase );

inttypes.h

u intmax_ t wcstoumax (const wcha r_t * re stri ct np tr, wch ar_ t ** re strict en dptr, int ba se);

iso646.h
limits.h
locale.h
locale.h
math.h

struct lcon v * loca le conv (vo id);

d oub le ac os (do ubl e x);
flo at a cosf(floa t x);

math.h

l ong d oub le ac osl(lon g dou ble x);

math.h

d oub le as in(do ub le x);

math.h

flo at a sinf(flo at x);

math.h

l ong d oub le as inl(lo ng do ubl e x);

math.h

d oub le ata n(d oub le x);

math.h

flo at a tanf(float x);

math.h

l ong d oub le ata nl(lo ng d oub le x);

math.h
math.h

d oub le ata n2 (dou bl e y, d ou ble x);

flo at a tan2f(floa t y, floa t x);

math.h

l ong d oub le ata n2 l(lon g dou ble y, l ong d oub le x);

math.h

d oub le cos(d oub le x);

math.h

flo at c os f(float x);

math.h

l ong d oub le cos l(lo ng d oub le x);

math.h

d oub le sin(dou ble x);

math.h

flo at s inf(floa t x);

math.h

l ong d oub le sinl(l on g dou ble x);

math.h

d oub le tan(do ubl e x);

math.h

flo at ta nf(flo at x);

math.h

l ong d oub le tanl(lon g do ubl e x);

math.h

d oub le ac os h(d ou ble x);

math.h
math.h

flo at a coshf(float x);

l ong d oub le ac oshl(l ong d oub le x);

math.h

d oub le as inh(dou bl e x);

math.h

flo at a sinhf(floa t x);

math.h

l ong d oub le as inhl(lon g dou ble x);

math.h

d oub le ata nh(do ubl e x);

math.h

flo at a tanhf(flo at x);

math.h

l ong d oub le ata nhl(lo ng do ubl e x);

math.h

d oub le cosh(do ub le x);

math.h

flo at c os hf(flo at x);

math.h
math.h

l ong d oub le cos hl(lo ng do ubl e x);

d oub le sinh(d oub le x);

math.h

flo at s inhf(float x);

math.h

l ong d oub le sinhl(lo ng d oub le x);

math.h

d oub le tanh(dou ble x);

math.h

flo at ta nhf(floa t x);

math.h

l ong d oub le tanhl(l ong dou ble x);

math.h

d oub le ex p(d oub le x);

math.h

flo at e xpf(float x);

math.h

l ong d oub le ex pl(lo ng do ub le x);

math.h
math.h

d oub le ex p2 (dou ble x);

flo at e xp2f(floa t x);

math.h

l ong d oub le ex p2 l(l ong d ou ble x);

math.h

d oub le ex pm 1(do ubl e x);

math.h

flo at e xpm1f(flo at x);

math.h

l ong d oub le ex pm 1l(lon g do ubl e x);

math.h

d oub le fre xp(dou ble va lue , in t *e xp);

math.h

flo at fr expf(floa t val ue, int *exp );

math.h

l ong d oub le fre xpl(l ong d ou ble val ue , in t *exp );

math.h

i nt ilogb(dou ble x);

math.h

i nt ilogbf(float x);

math.h

i nt ilogbl(l ong d oub le x);

math.h

d oub le lde xp(dou ble x, int exp);

math.h
math.h

flo at ldexpf(floa t x, i nt e xp);

l ong d oub le lde xpl(l ong d ou ble x, int exp);

math.h

d oub le log(do ubl e x);

math.h

flo at logf(flo at x);

math.h

l ong d oub le logl(lon g do ubl e x);

math.h

d oub le log10 (dou bl e x);

math.h

flo at log1 0f(floa t x);

math.h

l ong d oub le log10 1(l ong d oub le x);

math.h

d oub le log1p(do ubl e x);

math.h

flo at log1 pf(flo at x);

math.h
math.h

l ong d oub le log1pl(lo ng do ubl e x);

d oub le log2(d oub le x);

math.h

flo at log2 f(float x);

math.h

l ong d oub le log2l(lo ng d oub le x);

math.h

d oub le logb(dou ble x);

math.h

flo at logbf(floa t x);

math.h

l ong d oub le logbl(l ong dou ble x);

math.h

d oub le modf(dou ble va lue , do ub le *i ptr);

math.h

flo at m odf(floa t valu e, float *ip tr);

math.h

l ong d oub le modfl(l ong dou ble va lue , lo ng do ubl e *ip tr);

math.h

d oub le sc albn(do ub le x, i nt n );

math.h

flo at s calbnf(flo at x, int n);

math.h

l ong d oub le sc albnl(lo ng do ubl e x, in t n );

math.h
math.h

d oub le sc albln(do ubl e x, lo ng in t n);

flo at s calblnf(floa t x, l on g int n);

math.h

l ong d oub le sc alblnl(lon g dou ble x, lon g in t n);

math.h

d oub le cbrt(d ou ble x);

math.h

flo at c br tf(float x);

math.h

l ong d oub le cbr tl(l ong d oub le x);

math.h

d oub le fabs(d oub le x);

math.h

flo at fa bs f(float x);

math.h

l ong d oub le fabsl(lo ng d oub le x);

math.h

d oub le hypot(d oub le x, d oub le y);

math.h
math.h

flo at hypotf(flo at x , floa t y);

l ong d oub le hypotl(lo ng do ubl e x, lo ng d oub le y);

math.h

d oub le pow(do ubl e x, do ub le y);

math.h

flo at powf(flo at x, float y);

math.h

l ong d oub le powl(lon g do ubl e x, lo ng do ubl e y);

math.h

d oub le sqrt(d ou ble x);

math.h

flo at s qr tf(float x);

math.h

l ong d oub le sqr tl(l ong d oub le x);

math.h

d oub le er f(dou bl e x);

math.h

flo at e rf(floa t x);

math.h
math.h

l ong d oub le er fl(l on g dou ble x);

d oub le er fc(do ub le x);

math.h

flo at e rfcf(flo at x);

math.h

l ong d oub le er fcl(lo ng do ubl e x);

math.h

d oub le lga mma (dou bl e x);

math.h

flo at lgamm af(floa t x);

math.h

l ong d oub le lga mm al(lon g dou ble x);

math.h

d oub le tgamm a(do ub le x);

math.h

flo at tgam maf(flo at x);

math.h

l ong d oub le tgamm al(lo ng do ubl e x);

math.h

d oub le ce il(do ub le x);

math.h

flo at c eilf(flo at x);

math.h

l ong d oub le ce ill(lo ng do ubl e x);

math.h
math.h

d oub le floor(d oub le x);

flo at floor f(float x);

math.h

l ong d oub le floorl(lo ng do ub le x);

math.h

d oub le near by int(do ubl e x);

math.h

flo at nea rbyintf(flo at x);

math.h

l ong d oub le nea rby intl(lon g do ubl e x);

math.h

d oub le rint(dou ble x);

math.h

flo at r intf(floa t x);

math.h

l ong d oub le rintl(l ong dou ble x);

math.h

l ong i nt lrint(dou ble x);

math.h
math.h

l ong i nt lrintf(float x);

l ong i nt lrintl(l ong d ou ble x);

math.h

l ong l ong i nt luring(do ub le x);

math.h

l ong l ong i nt llrintf(flo at x);

math.h

l ong l ong i nt llrintl(lo ng d oub le x);

math.h

d oub le round(do ubl e x);

math.h

flo at r oundf(flo at x);

math.h

l ong d oub le roundl(lon g do ubl e x);

math.h

l ong i nt lround(do ubl e x);

math.h

l ong i nt lroundf(floa t x0;

math.h

l ong i nt lroundl(lon g do ubl e x);

math.h

l ong l ong i nt llround(do ubl e x);

math.h

l ong l ong i nt llroundf(float x);

math.h
math.h

l ong l ong i nt llroundl(l ong dou ble x);

d oub le trunc(do ubl e x);

math.h

flo at tr uncf(flo at x);

math.h

l ong d oub le truncl(lon g do ubl e x);

math.h

d oub le fmod(dou ble x, do ubl e y);

math.h

flo at fm odf(floa t x, flo at y);

math.h

l ong d oub le fmodl(l ong dou ble x, lon g dou bl e y);

math.h

d oub le re mainde r(do ub le x, d oub le y);

math.h

flo at r ema inder f(flo at x, floa t y);

math.h

l ong d oub le re ma inderl(lo ng do ubl e x, lo ng d oub le y);

math.h
math.h

d oub le re mquo(do ub le x, d oub le y, in t *q uo);

flo at r emquof(flo at x, float y, int *q uo);

math.h

l ong d oub le re mquol(lon g do ubl e x, lo ng do ub le y, in t *q uo);

math.h

d oub le copysign(d oub le x, d oub le y);

math.h

flo at c opysignf(flo at x, floa t y);

math.h

l ong d oub le copysignl(lo ng do ubl e x, l ong d oub le y);

math.h

d oub le nan(const char *tag p);

math.h

flo at nanf(con st cha r * ta gp);

math.h

l ong d oub le nanl(co nst ch ar *tag p);

math.h

d oub le nexta fter(d oub le x, d ou ble y);

math.h
math.h

flo at nex tafter f(float x, floa t y);

l ong d oub le nexta fterl(lo ng do ub le x, l ong d oub le y);

math.h

d oub le nexttowa rd(dou bl e x, lo ng do ubl e y);

math.h

flo at nex ttowardf(floa t x, l on g dou ble y);

math.h

l ong d oub le nexttowardl(lon g dou ble x, lon g do ubl e y);

math.h

d oub le fdim (dou ble x, do ubl e y);

math.h

flo at fdimf(floa t x, flo at y);

math.h

l ong d oub le fdim l(l ong dou ble x, lon g dou bl e y);

math.h

d oub le fma x(do ub le x, d oub le y);

math.h

flo at fm axf(flo at x, float y);

math.h

l ong d oub le fma xl(lo ng do ubl e x, lo ng d oub le y);

math.h

d oub le fmin(dou ble x, do ubl e y);

math.h

flo at fm inf(floa t x, flo at y);

math.h
math.h

ch ar *se tloca le (int catego ry, const cha r *l oca le);

math.h

l ong d oub le fminl(l ong dou ble x, lon g dou bl e y);

d oub le fma (dou ble x, do ubl e y, dou ble z);

math.h

flo at fm af(floa t x, flo at y, flo at z);

math.h

l ong d oub le fma l(l on g dou ble x, lon g do ubl e y, lon g dou ble z);

setjmp.h

_ Nore tu rn vo id longjmp(j mp_ buf env, in t val );

signal.h

voi d (*s ignal(int sig, void (* fu nc)(in t)))(i nt);

signal.h

i nt r aise(i nt si g);

stdalign.h
stdarg.h
stdatomic.h

voi d atomic_ init(vo latil e A *ob j, C val ue );

stdatomic.h

voi d atomic_ thr ead_fe nc e(memo ry_ord er orde r);

stdatomic.h

voi d atomic_ signal_fe nc e(memo ry_ord er orde r);

stdatomic.h
stdatomic.h

_ Bool a tom ic _is_lock_ fre e(con st vola ti le A *o bj);

voi d atomic_ stor e(vol atile A *o bj ect, C de sired );

stdatomic.h

voi d atomic_ stor e_ explic it(vol atile A *o bj ect, C de sired , memo ry_ord er orde r);

stdatomic.h

C a tom ic _loa d(vo latil e A * obj ect);

stdatomic.h

C a tom ic _loa d-e xplicit(vola ti le A *o bje ct, memory_ orde r orde r);

stdatomic.h

C a tom ic _exc ha nge(vo latil e A * obj ect, C d esire d);

stdatomic.h

C a tom ic _exc ha nge_ explic it(vo latil e A * obj ect, C d esire d, me mory_o rder ord er);

stdatomic.h

_ Bool a tom ic _compar e_e xchange_s trong(vol atile A *o bje ct, C *exp ected, C desi red);

stdatomic.h

_ Bool a tom ic _compar e_e xchange_s trong_e xplicit(vol atile A *o bje ct, *e xpected , C de sired , memo ry_o rder succe ss, memo ry_ord er fa ilu re);

stdatomic.h

_ Bool a to mic_co mpare _excha nge _we ak(vol atile A *o bj ect, C *exp ected, C de sired);

stdatomic.h
stdatomic.h

_ Bool a tom ic _compar e_e xchange_wea k_e xplicit(vol atile A *o bje ct, C *exp ected, C desi red, memor y_ord er success, memory_ ord er fa ilure );
C a to mic_fetch_ key(vo latil e A * obj ect, M op eran d);

stdatomic.h

C a tom ic _fetch_ key_ explic it(vo latil e A * obj ect, M ope rand , memo ry_o rder ord er);

stdatomic.h

_ Bool a tom ic _flag_tes t_and_se t(vola ti le atomi c_flag * obj ect);

stdatomic.h

_ Bool a tom ic _flag_tes t_and_se t_ex plicit(vola ti le atomi c_flag * obj ect, me mory_o rder ord er);

stdatomic.h

voi d atomic_ fla g_ clar(vo latil e atomic_ flag *o bje ct);

stdatomic.h

voi d atomic_ fla g_ clar_ explic it(vo latil e atomic_ flag *o bje ct, memor y_ord er orde r);

stdbool.h
stddef.h
stdint.h
stdio.h

i nt r emove(co nst ch ar *file na me);

stdio.h

i nt r ename (const char *o ld, con st cha r * new );

stdio.h

FILE *tmpfile (void );

stdio.h
stdio.h

ch ar *tmpnam(ch ar *s);
i nt fc lose (FILE *strea m);

stdio.h

i nt fflus h(FILE *stream);

stdio.h

FILE *fope n(co nst ch ar * restrict fil ena me, co nst ch ar * restrict mo de);

stdio.h

FILE *fre open(con st cha r * re stri ct file name , con st cha r * re stri ct stream);

stdio.h

voi d se tbuf(FILE * restrict stre am, ch ar * restrict b uf);

stdio.h

i nt s etvbuf(FILE * restrict strea m, ch ar * re stri ct bu f, in t mod e, si ze_t size);

stdio.h

i nt fprintf(FILE * restrict strea m, con st ch ar * re stri ct format, );

stdio.h

i nt fs canf(FIL E * re stri ct stream, const char * restrict fo rma t, );

stdio.h

i nt printf(const char * restrict fo rma t, );

stdio.h
stdio.h

i nt s canf(con st cha r * re stri ct format, );

i nt s nprintf(char * restrict s, size _t n , con st cha r * re stri ct format, );

stdio.h

i nt s pr intf(cha r * re stri ct s, co nst ch ar * restrict forma t, );

stdio.h

i nt s sca nf(co nst ch ar * restrict s, const char * restrict fo rmat, );

stdio.h

i nt v fpr intf(FIL E * re stri ct stre am, const char * restrict forma t, va_l ist a rg);

stdio.h

i nt v fsca nf(FILE * restrict strea m, con st cha r * re stri ct format, va_ list arg);

stdio.h

i nt v pr intf(con st cha r * re stri ct format, va_ list arg);

stdio.h

i nt v sca nf(co nst ch ar * restrict forma t, va _li st arg );

stdio.h

i nt v snpr intf(cha r * re strict s, size _t n, co nst ch ar * restrict forma t, va _l ist arg );

stdio.h

i nt v sprintf(ch ar * re stri ct s, c onst char * restrict forma t, va_l ist a rg);

stdio.h
stdio.h

i nt v ssc anf(const char * restrict fo rmat, va_ list a rg);

i nt fgetc (FILE *strea m);

stdio.h

ch ar *fgets(ch ar * restrict s, int n, FILE * restrict strea m);

stdio.h

i nt fputc(in t c, FILE *stream);

stdio.h

i nt fputs(con st cha r * re stri ct s, FILE * restrict strea m);

stdio.h

i nt getc (FILE *strea m);

stdio.h

i nt getc ha r(voi d);

stdio.h

i nt putc(in t c, FILE *stream);

stdio.h

i nt putchar(i nt c);

stdio.h

i nt puts(con st cha r * s);

stdio.h

i nt unge tc(in t c, FILE *stream);

stdio.h

si ze_t frea d(vo id * restrict ptr, si ze_t size, size _t n memb, FILE * restrict stre am);

stdio.h

si ze_t fwr ite (const vo id * re strict ptr, size_ t size , size _t nmemb , FIL E * re stri ct stre am);

stdio.h
stdio.h

i nt fgetpos(FIL E * re stri ct stre am, fp os_t * restri ct p os);

i nt fs eek (FILE *strea m, lo ng in t o ffset, in t wh ence );

stdio.h

i nt fs etpos (FILE *strea m, con st fpos_ t *p os);

stdio.h

l ong i nt fte ll(FIL E * stre am);

stdio.h

voi d re wind(FIL E *stre am);

stdio.h

voi d clea rer r(FIL E * stre am);

stdio.h

i nt fe of(FILE *stre am);

stdio.h

i nt fe rror(FILE *stream);

stdio.h

voi d perr or (const char *s);

stdlib.h

d oub le atof(con st cha r * nptr);

stdlib.h
stdlib.h

i nt a toi(con st cha r * nptr);

l ong i nt a tol(con st cha r * nptr);

stdlib.h

l ong l ong i nt a toll(const char *n ptr);

stdlib.h

d oub le str tod(con st cha r * re stri ct np tr, ch ar ** restrict end ptr);

stdlib.h

flo at s trtof(const char * restrict nptr, cha r * * restri ct e ndp tr);

stdlib.h

l ong d oub le str told(const cha r * restrict nptr, cha r * * restrict e ndp tr);

stdlib.h

l ong i nt s trtol(co nst ch ar * restrict n ptr, char ** re stri ct en dptr, in t ba se);

stdlib.h

l ong l ong i nt s trtoll(con st cha r * re stri ct np tr, ch ar ** restrict end ptr, int base );

stdlib.h

u nsig ned l ong i nt strtoul(co nst ch ar * restri ct n ptr, ch ar ** restrict end ptr, int base );

stdlib.h

u nsig ned l ong l on g int strtoull(con st cha r * re stri ct np tr, ch ar ** restrict e nd ptr, i nt b ase );

stdlib.h

i nt r and(vo id);

stdlib.h

voi d sr and(u nsig ned i nt se ed);

stdlib.h

voi d *a ligne d_ alloc(si ze_t ali gnme nt, si ze_t size);

stdlib.h
stdlib.h

voi d *c alloc(si ze_t nmemb , size _t si ze);

voi d fre e(void * ptr);

stdlib.h

voi d *m alloc(si ze_t size);

stdlib.h

voi d *r ealloc (vo id * ptr, si ze_t size );

stdlib.h

_ Nore tu rn vo id a bort(voi d);

stdlib.h

i nt a texit(void (* fu nc) (void ));

stdlib.h

i nt a t_quick _ex it(vo id (*fun c)(vo id ));

stdlib.h

_ Nore tu rn vo id ex it(i nt status);

stdlib.h

_ Nore tu rn vo id _ Exit(int sta tu s);

stdlib.h

ch ar *getenv(con st cha r * na me);

stdlib.h
stdlib.h

_ Nore tu rn vo id quic k_ex it(i nt sta tu s);

i nt s yste m(con st cha r * stri ng);

stdlib.h

voi d *bse arc h(co nst vo id *key, co nst vo id *b ase, size_ t nme mb, si ze_ t size , in t (*co mpar)(co nst vo id *, const vo id * ));

stdlib.h

voi d qsort(void * ba se, si ze_t nmemb , size _t si ze, int (*comp ar)(con st void * , co nst voi d *));

stdlib.h

i nt a bs (int j);

stdlib.h

l ong i nt labs(l ong i nt j);

stdlib.h

l ong l ong i nt llabs(lo ng l ong i nt j );

stdlib.h

d iv_t div(i nt n umer, i nt d eno m);

stdlib.h

l div_ t ldiv(l ong i nt n ume r, l ong int den om);

stdlib.h

l ldi v_t lldiv(l ong l ong int nume r, lon g lon g int den om);

stdlib.h
stdlib.h

i nt m blen(con st cha r * s, size _t n );

i nt m btowc (wcha r_t * re stri ct pw c, con st cha r * re stri ct s, si ze_t n);

stdlib.h

i nt wctomb(cha r * s, wch ar_t wc);

stdlib.h

si ze_t mbstowc s(wcha r_t * re stri ct pw cs, con st cha r * re stri ct s, si ze_t n);

stdlib.h

si ze_t wc stombs(cha r * re stri ct s, co nst w char_ t * restrict pwcs, si ze_ t n);

stdnoreturn.h
string.h
string.h

voi d *m emc py(vo id * restrict s1, co nst vo id * restrict s2, si ze_t n);
voi d *m emm ove (void * s1, co nst vo id *s2 , size _t n );

string.h

ch ar *str cpy(cha r * re strict s1, const char * restrict s2);

string.h

ch ar *str nc py (char * restrict s1, co nst ch ar * restrict s2 , size _t n );

string.h

ch ar *str cat(ch ar * restrict s1 , con st cha r * re stri ct s2);

string.h

ch ar *str nc at(cha r * re stri ct s1, const char * restrict s2, si ze_t n);

string.h

i nt m emc mp(const void * s1, co nst vo id *s2 , size _t n );

string.h
string.h

i nt s trcm p(co nst ch ar *s1, con st cha r * s2);

i nt s trcoll(co nst ch ar *s1, con st cha r * s2);

string.h

i nt s trncmp(con st cha r * s1, co nst ch ar *s2 , size _t n );

string.h

si ze_t strx frm(ch ar * restrict s1 , con st cha r * re stri ct s2, size_ t n );

string.h

voi d *m emc hr (const vo id * s, in t c, si ze_t n);

string.h

ch ar *str chr(con st cha r * s, in t c);

string.h

si ze_t strc spn(co nst ch ar *s1, con st cha r * s2);

string.h

ch ar *str pbrk (const char *s1 , con st cha r *s2);

string.h

ch ar *str rchr(co nst ch ar *s, i nt c);

string.h

si ze_t strs pn(con st cha r * s1, co nst ch ar *s2 );

string.h
string.h

ch ar *str str(co nst ch ar *s1, const cha r * s2);

ch ar *str tok (char * restrict s1, co nst ch ar * restrict s2 );

string.h

voi d *m ems et(void * s, in t c, size_ t n);

string.h

ch ar *str err or (int errnu m);

string.h

si ze_t strlen(con st cha r * s);

tgmath.h
threads.h
threads.h

i nt c nd_broadca st(cnd _t * con d);

voi d cnd_destr oy (cn d_ t *co nd);

threads.h

i nt c nd_init(cn d_t *con d);

threads.h

i nt c nd_s ignal(cnnd _t *con d);

threads.h

i nt c nd_time dwait(cnd _t * restrict co nd, mtx_ t *re stri ct mtx, con st struct time spec *re stri ct ts);

threads.h

i nt c nd_wait(cnd _t * cond , mtx_t *mtx);

threads.h
threads.h

voi d mtx _destr oy (mtx_ t *mtx);

i nt m tx_init(mtx_t *mtx, in t type );

threads.h

i nt m tx_lock(mtx_t *mtx);

threads.h

i nt m tx_time dlock(mtx_t *restrict mtx, const stru ct timesp ec *restrict ts);

threads.h

i nt m tx_tr yloc k(mtx_t *mtx);

threads.h

i nt m tx_unlock (mtx_ t *mtx);

threads.h

i nt thrd_c rea t(th rd_t *thr, thrd_ sta rt_ t fun c, void * arg);

threads.h

thrd _t thrd_c ur rent(voi d);

threads.h

i nt thrd_deta ch(th rd_t th r);

threads.h

i nt thrd_e qual(thrd_ t thr0, th rd_t th r1);

threads.h
threads.h

_ Nore tu rn vo id thrd_ex it(i nt re s);

i nt thrd_join(thrd_ t thr, in t *re s);

threads.h

i nt thrd_s le ep(const stru ct timesp ec *du ration , struct ti mespe c * remai nin g);

threads.h

voi d thrd_ yield(vo id);

threads.h

i nt ts s_c rea te(tss_t * key, tss_dtor_ t dtor);

threads.h

voi d tss _delete(tss_t ke y);

threads.h

voi d *ts s_get(tss_t ke y);

threads.h

i nt ts s_s et(tss_t key, vo id *va l);

time.h

cl ock_t cloc k(voi d);

time.h

d oub le diftime (ti me_t ti me1, ti me_t ti me0);

time.h
time.h

time _t m ktime(struct tm *time ptr);

time _t time (ti me_t *timer);

time.h

i nt time spec_ ge t(stru ct timesp ec *ts, in t b ase);

time.h

ch ar *as ctime(co nst struct tm *time ptr);

time.h

ch ar *ctime (const ti me_t *timer);

time.h

struct tm *gmtime (const ti me_t *timer);

time.h

struct tm *localtime(co nst time _t * ti mer);

time.h

si ze_t strftime (char * restrict s, size _t ma xsize , con st cha r * re strict fo rmat, co nst struct tm * restrict time ptr);

uchar.h

si ze_t mbrtoc16 (char1 6_t * restrict p c16, con st cha r * re strict s, si ze_t n, mb sta te _t * re stric t ps);

uchar.h

si ze_t c16 rtomb(char * restrict s, cha r16_ t c1 6, mn sta te_ t * restrict ps);

uchar.h

si ze_t mbrtoc32 (char3 2_t * restrict p c32, con st cha r * re strict s, si ze_t n, mb sta te _t * re stric t ps);

uchar.h

si ze_t c32 rtomb(char * restrict s, cha r32_ t c3 2, mb sta te_ t * restrict ps);

wchar.h

i nt fwprintf(FILE * rrestrict stream, con st wcha r_t * re stri ct format, );

wchar.h
wchar.h

i nt fwsc anf(FILE * restrict strea m, co nst wch ar_ t * restrict forma t, );

i nt s wprintf(wcha r_t * re stri ct s, si ze_t n, co nst w char_ t * restrict fo rmat, );

wchar.h

i nt s ws canf(con st wch ar_t * restrict s, const wcha r_t * re stri ct format, );

wchar.h

i nt v fwprintf(FILE * restrict strea m, co nst wch ar_ t * restrict forma t, va_l ist a rg);

wchar.h

i nt v fws canf(FIL E * re stri ct stre am, const wcha r_t * re strict fo rmat, va_ list arg);

wchar.h

i nt v swpr intf(wcha r_t * re stri ct s, si ze_ t n, const wcha r_t * re stri ct format, va_ list arg);

wchar.h

i nt v swsca nf(co nst w ch ar_ t * restrict s , con st wch ar_t * restri ct format, va _li st arg );

wchar.h

i nt v wprintf(const wcha r_t * re stri ct format, va_ list arg);

wchar.h

i nt v ws canf(con st wch ar_t * restrict forma t, va _l ist arg );

wchar.h

i nt wprintf(co nst w char_ t * restrict fo rma t, );

wchar.h
wchar.h

i nt wsc anf(const wcha r_t * re stri ct format, );

w int_t fge twc (FILE *strea m);

wchar.h

w char_ t *fgetws(wch ar_t * restrict s, int n, FILE * restrict strea m);

wchar.h

w int_t fputwc(cha r_t c, FILE *strea m);

wchar.h

i nt fputws (const wcha r_t * re strict s, FILE * restri ct stream);

wchar.h

i nt fwide (FILE *strea m, in t mod e);

wchar.h

w int_t ge twc (FILE *strea m);

wchar.h

w int_t ge twc ha r(void );w int_ t pu tw c(wcha r_ t c, FILE *strea m);

wchar.h

w int_t putwchar(w char_ t c);

wchar.h

w int_t ungetwc(wi nt_t c, FILE *strea m);

wchar.h

d oub le wcstod(const wcha r_t * re stri ct np tr, wch ar_t ** restrict end ptr);

wchar.h

flo at wcs tof(co nst wch ar_ t * ree strict np tr, wch ar_t ** restrict end ptr);

wchar.h

l ong d oub le wcstold(co nst w char_ t * restrict nptr, wch ar_t ** rrestrict e nd ptr);

wchar.h
wchar.h

l ong i nt wcs tol(con st wch ar_t * restrict n ptr, wchar_ t * * re stri ct en dptr, in t ba se);
l ong l ong i nt wcs toll(const wcha r_t * re stri ct np tr, w char_ t ** re strict en dptr, in t ba se);

wchar.h

u nsig ned l ong i nt wc stoul(con st wcha r_t * re stri ct np tr, w char_ t ** re stri ct en dptr, in t ba se);

wchar.h

u nsig ned l ong l on g int wc stoull(const wcha r_t * re strict nptr, wch ar_t ** restrict end ptr, int base );

wchar.h

w char_ t *wcs cpy(wcha r_t * re stri ct s1, con st wcha r_t * re stri ct s2);

wchar.h

w char_ t *wcs nc py (wchar_ t * restrict s1, co nst wchar_ t * restrict s2, si ze_ t n);

wchar.h

w char_ t *wme mcpy(wch ar_ t * restrict s1 , co nst wc har_ t * restrict s2 , si ze_t n);

wchar.h

w char_ t *wme mmove(w char_ t *s1 , con st wch ar_t *s2 , size _t n );

wchar.h

w char_ t *wcs cat(w char_ t * restrict s1, co nst w char_ t * restrict s2);

wchar.h

w char_ t *wcs nc at(scha r_t * re stri ct s1, const wcha r_t * re stri ct s2, size_ t n);

wchar.h
wchar.h

i nt wcs cmp(con st wch ar_t *s1, const wcha r_t * s2);

i nt wcs coll(con st wch ar_t *s1, const wcha r_t * s2);

wchar.h

i nt wcs nc mp(const wcha r_t * s1, co nst w char_ t *s2 , size _t n);

wchar.h

si ze_t wc sxfr m(wch ar_t * restrict s1 , con st wch ar_t * restrict s2 , size _t n );

wchar.h

i nt wme mcm p(co nst w char_ t *s1 , con st wch ar_t *s2 , size _t n );

wchar.h

w char_ t *wcs chr(con st wch ar_t *s, w char_ t c);

wchar.h

si ze_t wc scs pn(con st wch ar_t *s1, const wcha r_t * s2);

wchar.h

w char_ t *wcs pbrk (const wcha r_t * s1, co nst w char_ t *s2 );

wchar.h

w char_ t *wcs rchr(co nst w char_ t *s, wcha r_t c);

wchar.h

si ze_t wc sspn(const wcha r_t * s1, co nst w char_ t *s2 );

wchar.h
wchar.h

w char_ t *wcs str(co nst w char_ t *s1 , con st wch ar_t *s2);
w char_ t *wcs tok (wchar_ t * re strict s1, const wcha r_ t * re strict s2, wchar_ t * * re stri ct ptr);

wchar.h

w char_ t *wme mchr(co nst w char_ t *s, wcha r_t c, size_ t n );

wchar.h

si ze_t wc slen(const wcha r_t * s);

wchar.h

w char_ t *wme mse t(wcha r_t * s, wch ar_t c, size _t n );

wchar.h

si ze_t wc sftime(w char_ t * restrict s, size _t ma xsize, const wcha r_t * re stri ct format, co nst struct tm * restrict ti meptr);

wchar.h

w int_t bwowc(i nt c);

wchar.h

i nt wctob(w int_ t c);

wchar.h

i nt m bs init(const mbstate_t *ps);

wchar.h

si ze_t mbrlen(const char * restrict s, size _t n , mbstate_ t * restrict ps);

wchar.h

si ze_t mbrtowc (wcha r_ t * re strict pwc, const cha r * restrict s, size _t n, mb sta te_ t * restrict ps);

wchar.h

si ze_t wc rtomb(char * restrict s, wch ar_t wc, mb sta te_ t * restrict ps);

wchar.h

si ze_t mbsrtowcs(w char_ t * restrict dst, con st cha r * * restri ct src, si ze_t le n, mb sta te_ t * re strict ps);

wchar.h
wctype.h

si ze_t wc srtombs(ch ar * restrict d st, const wcha r_t * * restrict src, size_ t le n, mb sta te _t * re stri ct ps);
i nt iswalnum (win t_ t wc);

wctype.h

i nt iswalpha (win t_ t wc);

wctype.h

i nt iswbla nk (win t_ t wc);

wctype.h

i nt iswcntrl(wi nt_t w c);

wctype.h

i nt iswdigit(win t_ t wc);

wctype.h

i nt iswgraph(win t_ t wc);

wctype.h

i nt iswlower (win t_ t wc);

wctype.h

i nt iswprint(w int_t wc);

wctype.h

i nt iswpunct(w int_t wc);

wctype.h
wctype.h

i nt iswspac e(wi nt_t w c);

i nt iswupper (win t_ t wc);

wctype.h

i nt iswxdigit(wi nt_t w c);

wctype.h

i nt iswcty pe (win t_ t wc, wctype_ t de sc);

wctype.h

voi d ca ll_once(o nce_ flag * fla g, vo id (* fu nc)(void ));

threads.h

w ctyp e_t wc type(con st cha r * prop erty);

wctype.h

w int_t towlower(w int_t wc);

wctype.h

w int_t towupper (w in t_ t wc);

wctype.h

w int_t towctra ns(win t_t wc, wctrans_ t d esc);

wctype.h

w ctran s_t wc trans(co nst ch ar *pro perty);