main# ‡@ int main(int argc, char *argv[]); ‡A int main(void);
abort# void abort(void);
abs# int abs(int n);
labs# long labs(long n);
access# int access(const char *pathname, int mode);
assert# void assert(int expression);
atexit# int atexit(void (*func)(void));
onexit# onexit_t onexit(onexit_t func);
atoi# int atoi(const char *s);
atol# long atol(const char *s);
atof# double atof(const char *s);
bdos# char bdos(char funcno, int dx, char al);
bsearch# void *bsearch(const void *key, const void *base, size_t nmemb, size_t size, int (*compar)(const void *x, const void *y));
btom# int btom(const char *s, int n);
mtob# int mtob(const char *s, int n);
cgets# char *cgets(char *s);
chdir# int chdir(const char *pathname);
chkctype# int chkctype(char c, int type);
nthctype# int nthctype(const char *p, int n);
chmod# int chmod(const char *pathname, int mode);
chsize# int chsize(int fd, long size);
clearerr# void clearerr(FILE *fp);
close# int close(int fd);
cprintf# int cprintf(const char *format,...);
cscanf# int cscanf(const char *format, ...);
cputs# void cputs(const char *s);
creat# int creat(const char *path, int mode);
localtime# struct tm *localtime(const time_t *t);
gmtime# struct tm *gmtime(const time_t *t);
asctime# char *asctime(const struct tm *tm);
ctime# char *ctime(const time_t *t);
mktime# time_t mktime(struct tm *tm);
difftime# double difftime(time_t t1, time_t t2);
isalpha# int isalpha(char c);
isupper# int isupper(char c);
islower# int islower(char c);
isdigit# int isdigit(char c);
isspace# int isspace(char c);
isalnum# int isalnum(char c);
iscntrl# int iscntrl(char c);
isgraph# int isgraph(char c);
isprint# int isprint(char c);
ispunct# int ispunct(char c);
isxdigit# int isxdigit(char c);
isascii# int isascii(char c);
iscsymf# int iscsymf(char c);
iscsym# int iscsym(char c);
di# void di(void);
ei# void ei(void);
div# div_t div(int num, int denom);
ldiv# ldiv_t ldiv(long num, long denom);
_dos_allocmem# unsigned _dos_allocmem(unsigned size, unsigned *seg);
_dos_freemem# unsigned _dos_freemem(unsigned seg);
_dos_setblock# unsigned _dos_setblock(unsigned size, unsigned seg, unsigned *maxsize);
_dos_close# unsigned _dos_close(int handle);
_dos_creat# unsigned _dos_creat(const char *path, unsigned attr, int *handle);
_dos_creatnew# unsigned _dos_creatnew(const char *path, unsigned attr, int *handle);
_dos_findfirst# unsigned _dos_findfirst(const char *path, unsigned attr, struct find_t *buffer);
_dos_findnext# unsigned _dos_findnext(struct find_t *buffer);
_dos_getdate# void _dos_getdate(struct dosdate_t *date);
_dos_setdate# unsigned _dos_setdate(struct dosdate_t *date);
_dos_getdiskfree# unsigned _dos_getdiskfree(unsigned device, struct diskfree_t *diskspace);
_dos_getdrive# void _dos_getdrive(unsigned *drive);
_dos_setdrive# void _dos_setdrive(unsigned drivenum, unsigned *drives);
_dos_getfileattr# unsigned _dos_getfileattr(const char *path, unsigned *attr);
_dos_setfileattr# unsigned _dos_setfileattr(const char *path, unsigned attr);
_dos_getftime# unsigned _dos_getftime(int handle, unsigned *date, unsigned *time);
_dos_setftime# unsigned _dos_setftime(int handle, unsigned date, unsigned time);
_dos_gettime# void _dos_gettime(struct dostime_t *time);
_dos_settime# unsigned _dos_settime(struct dostime_t *time);
_dos_getvect# void (far *_dos_getvect(unsigned intnum))();
_dos_setvect# void _dos_setvect(unsigned intnum, void (far *handler)());
_dos_keep# void _dos_keep(unsigned retcode, unsigned memsize);
_dos_open# unsigned _dos_open(const char *path, unsigned mode, int *handle);
_dos_read# unsigned _dos_read(int handle, void far *buf, unsigned cnt, unsigned *bytes);
_dos_write# unsigned _dos_write(int handle, const void far *buf, unsigned cnt, unsigned *bytes);
dosexterr# int dosexterr(struct DOSERROR *buffer);
dup# int dup(int fd);
dup2# int dup2(int oldfd, int newfd);
ecvt# char *ecvt(double val, int prec, int *decpt, int *sign);
fcvt# char *fcvt(double val, int prec, int *decpt, int *sign);
gcvt# char *gcvt(double val, int prec, char *buf);
getenv# char *getenv(const char *name);
putenv# int putenv(const char *env);
eof# int eof(int fd);
execl# int execl(const char *prog, ...);
execlp# int execlp(const char *prog, ...);
execv# int execv(const char *prog, const char *const argv[]);
execvp# int execvp(const char *prog, const char *const argv[]);
execle# int execle(const char *prog, ..., char *envp[]);
execlpe# int execlpe(const char *prog, ..., char *envp[]);
execve# int execve(const char *prog, const char *const argv[], const char *const envp[]);
execvpe# int execvpe(const char *prog, const char *const argv[], const char *const envp[]);
exit# void exit(int n);
exp# double exp(double x);
log# double log(double x);
log10# double log10(double x);
pow# double pow(double x, double y);
fabs# double fabs(double x);
fmod# double fmod(double x, double y);
farmalloc# void far *farmalloc(unsigned long size);
farcalloc# void far *farcalloc(unsigned long nelem, unsigned long size);
farrealloc# void far *farrealloc(void far *fp, unsigned long size);
farfree# void farfree(void far *fp);
farcoreleft# unsigned long farcoreleft(void);
far_memset# void far *far_memset(void far *addr, char byte, size_t cnt);
far_setmem# void far *far_setmem(void far *addr, size_t cnt, char byte);
far_memcpy# void far *far_memcpy(void far *dst, const void far *src, size_t cnt);
far_memmove# void far *far_memmove(void far *dst, const void far *src, size_t cnt);
far_movmem# void far *far_movmem(const void far *src, void far *dst, size_t cnt);
far_memcmp# int far_memcmp(const void far *addr1, const void far *addr2, size_t n);
far_memchr# void far *far_memchr(const void far *addr, char byte, size_t cnt);
far_memccpy# void far *far_memccpy(void far *dest, void far *src, char c, size_t n);
far_memicmp# int far_memicmp(void far *addr1, void far *addr2, size_t n);
far_strcpy# char far *far_strcpy(char far *s, const char far *t);
far_strncpy# char far *far_strncpy(char far *s, const char far *t, size_t n);
far_strcmp# int far_strcmp(const char far *s, const char far *t);
far_strncmp# int far_strncmp(const char far *s, const char far *t, size_t n);
far_strcat# char far *far_strcat(char far *s, const char far *t);
far_strncat# char far *far_strncat(char far *s, const char far *t, size_t n);
far_strlen# size_t far_strlen(const char far *s);
far_strchr# char far *far_strchr(const char far *s, char c);
far_strrchr# char far *far_strrchr(const char far *s, char c);
far_strstr# char far *far_strstr(const char far *s, const char far *t);
far_strspn# size_t far_strspn(const char far *s, const char far *t);
far_strcspn# size_t far_strcspn(const char far *s, const char far *t);
far_strpbrk# char far *far_strpbrk(const char far *s, const char far *t);
far_strtok# char far *far_strtok(char far *s, const char far *t);
far_stpcpy# char far *far_stpcpy(char far *s, const char far *t);
far_strcmpi# int far_strcmpi(const char far *s, const char far *t);
far_stricmp# int far_stricmp(const char far *s, const char far *t);
far_strncmpi# int far_strncmpi(const char far *s, const char far *t, size_t n);
far_strnicmp# int far_strnicmp(const char far *s, const char far *t, size_t n);
far_strdup# char far *far_strdup(const char far *s);
far_strlwr# char far *far_strlwr(char far *s);
far_strupr# char far *far_strupr(char far *s);
far_strrev# char far *far_strrev(char far *s);
far_strset# char far *far_strset(char far *s, char c);
far_strnset# char far *far_strnset(char far *s, char c, size_t n);
fclose# int fclose(FILE *fp);
fcloseall# int fcloseall(void);
feof# int feof(FILE *fp);
ferror# int ferror(FILE *fp);
fflush# int fflush(FILE *fp);
flushall# int flushall(void);
fgetpos# int fgetpos(FILE *fp, fpos_t *ptr);
fsetpos# int fsetpos(FILE *fp, const fpos_t *ptr);
filelength# long filelength(int fd);
fileno# int fileno(FILE *fp);
fopen# FILE *fopen(const char *filename, const char *mode);
fdopen# FILE *fdopen(int fd, const char *mode);
FP_OFF# unsigned FP_OFF(void far *farptr);
FP_SEG# unsigned FP_SEG(void far *farptr);
MK_FP# void far *MK_FP(unsigned seg, unsigned off);
_fpreset# void _fpreset(void);
_control87# unsigned _control87(unsigned new, unsigned mask);
_clear87# unsigned _clear87(void);
_status87# unsigned _status87(void);
fread# int fread(void *ptr, size_t size, size_t nelem, FILE *fp);
fwrite# int fwrite(const void *ptr, size_t size, size_t nelem, FILE *fp);
freopen# FILE *freopen(const char *filename, const char *mode, FILE *fp);
fdreopen# FILE *fdreopen(int fd, const char *mode, FILE *fp);
frexp# double frexp(double x, int *p);
ldexp# double ldexp(double x, int p);
modf# double modf(double x, double *ip);
fseek# int fseek(FILE *fp, long offset, int ptrname);
fsetbin# void fsetbin(FILE *fp);
fsettext# void fsettext(FILE *fp);
fstat# int fstat(int fd, struct stat *sbuf);
ftell# long ftell(FILE *fp);
ftime# void ftime(struct timeb *buffer);
getc# int getc(FILE *fp);
fgetc# int fgetc(FILE *fp);
getchar# int getchar(void);
fgetchar# int fgetchar(void);
getch# char getch(void);
getche# char getche(void);
getcwd# char *getcwd(char *buf, int maxbuf);
getpid# int getpid(void);
gets# char *gets(char *s);
fgets# char *fgets(char *s, int n, FILE *fp);
getw# int getw(FILE *fp);
gftime# int gftime(const char *pathname, time_t times[2]);
_harderr# void _harderr(int (far *handler)());
_hardresume# void _hardresume(int result);
_hardretn# void _hardretn(int error);
sinh# double sinh(double x);
cosh# double cosh(double x);
tanh# double tanh(double x);
inp# char inp(int port);
inpw# unsigned inpw(int port);
inp8# char inp8(int port);
inp8w# unsigned inp8w(int port);
int86# int int86(int intno, union REGS *in, union REGS *out);
int86x# int int86x(int intno, union REGS *in, union REGS *out, struct SREGS *seg);
int86y# int int86y(int intno, union REGS *in, union REGS *out);
intdos# int intdos(union REGS *in, union REGS *out);
intdosx# int intdosx(union REGS *in, union REGS *out, struct SREGS *seg);
intdosy# int intdosy(union REGS *in, union REGS *out);
isatty# int isatty(int fd);
iskana# int iskana(char c);
iskpun# int iskpun(char c);
iskmoji# int iskmoji(char c);
isalkana# int isalkana(char c);
ispnkana# int ispnkana(char c);
isalnmkana# int isalnmkana(char c);
isprkana# int isprkana(char c);
isgrkana# int isgrkana(char c);
iskanji# int iskanji(char c);
iskanji2# int iskanji2(char c);
itoa# char *itoa(int val, char *buf, int radix);
ltoa# char *ltoa(long val, char *buf, int radix);
ultoa# char *ultoa(unsigned long val, char *buf, int radix);
jiszen# int jiszen(unsigned short c);
jisl0# int jisl0(unsigned short c);
jisl1# int jisl1(unsigned short c);
jisl2# int jisl2(unsigned short c);
jisalpha# int jisalpha(unsigned short c);
jisupper# int jisupper(unsigned short c);
jislower# int jislower(unsigned short c);
jisdigit# int jisdigit(unsigned short c);
jiskata# int jiskata(unsigned short c);
jishira# int jishira(unsigned short c);
jiskigou# int jiskigou(unsigned short c);
jisspace# int jisspace(unsigned short c);
jstradv# char *jstradv(const char *s, int n);
jstrchr# char *jstrchr(const char *s, unsigned short c);
jstrrchr# char *jstrrchr(const char *s, unsigned short c);
jstrcmp# int jstrcmp(const char *s, const char *t);
jstrncmp# int jstrncmp(const char *s, const char *t, size_t n);
jstrlen# int jstrlen(const char *s);
jstrmatch# char *jstrmatch(const char *s, const char *t);
jstrncat# char *jstrncat(char *s, const char *t, size_t n);
jstrncpy# char *jstrncpy(char *s, const char *t, size_t n);
jstrrev# char *jstrrev(char *s);
jstrskip# char *jstrskip(const char *s, const char *t);
jstrstr# char *jstrstr(const char *s, const char *t);
jstrtok# char *jstrtok(char *s, const char *t);
jtolower# unsigned short jtolower(unsigned short c);
jtoupper# unsigned short jtoupper(unsigned short c);
jtohira# unsigned short jtohira(unsigned short c);
jtokata# unsigned short jtokata(unsigned short c);
hantozen# unsigned short hantozen(unsigned short c);
zentohan# unsigned short zentohan(unsigned short c);
jmstojis# unsigned short jmstojis(unsigned short c);
jistojms# unsigned short jistojms(unsigned short c);
mstojis# unsigned short mstojis(unsigned short c);
jistoms# unsigned short jistoms(unsigned short c);
kbhit# int kbhit(void);
lseek# long lseek(int fd, long offset, int ptrname);
malloc# void *malloc(size_t n);
calloc# void *calloc(unsigned int nelem, size_t elsize);
realloc# void *realloc(void *ptr, size_t size);
free# void free(void *p);
matherr# int matherr(struct exception *x);
_matherr# double _matherr(int type, char *name, double *arg1, double *arg2, double r);
max# int max(int x, int y);
min# int min(int x, int y);
memccpy# void *memccpy(void *dest, const void *src, char c, size_t n);
memchr# void *memchr(const void *addr, char byte, size_t count);
memcmp# int memcmp(const void *addr1, const void *addr2, size_t n);
memicmp# int memicmp(const void *addr1, const void *addr2, size_t n);
memcpy# void *memcpy(void *dest, const void *source, size_t count);
memmove# void *memmove(void *dest, const void *source, size_t count);
movmem# void *movmem(const void *source, void *dest, size_t count);
memset# void *memset(void *addr, char byte, size_t count);
setmem# void *setmem(void *addr, size_t count, char byte);
mkdir# int mkdir(const char *pathname);
mktemp# char *mktemp(char *template);
movedata# void movedata(unsigned srcseg, unsigned srcoff, unsigned dstseg, unsigned dstoff, size_t nbytes);
_nullcheck# int _nullcheck(void);
open# int open(const char *path, int oflag [ , int mode ] );
outp# char outp(int port, char c);
outpw# unsigned outpw(int port, int c);
outp8# char outp8(int port, char c);
outp8w# unsigned outp8w(int port, int c);
perror# void perror(const char *s);
printf# int printf(const char *format, ...);
fprintf# int fprintf(FILE *fp, const char *format, ...);
sprintf# int sprintf(char *buf, const char *format, ...);
putc# int putc(char c, FILE *fp);
fputc# int fputc(char c, FILE *fp);
putchar# int putchar(char c);
fputchar# int fputchar(char c);
putch# char putch(char c);
puts# int puts(const char *s);
fputs# int fputs(const char *s, FILE *fp);
putw# int putw(int w, FILE *fp);
qsort# void qsort(void *base, size_t nel, size_t width, int(*compar)(const void *x, const void *y));
raise# int raise(int sig);
rand# int rand(void);
srand# void srand(unsigned int seed);
read# int read(int fd, void *buf, int n);
rename# int rename(const char *oldname, const char *newname);
rewind# void rewind(FILE *fp);
ceil# double ceil(double x);
floor# double floor(double x);
rmdir# int rmdir(const char *pathname);
rmtmp# int rmtmp(void);
_rotl# unsigned int _rotl(unsigned int val, char cnt);
_rotr# unsigned int _rotr(unsigned int val, char cnt);
_lrotl# unsigned long _lrotl(unsigned long val, int cnt);
_lrotr# unsigned long _lrotr(unsigned long val, int cnt);
sbrk# void *sbrk(size_t n);
scanf# int scanf(const char *format, ...);
fscanf# int fscanf(FILE *fp, const char *format, ...);
sscanf# int sscanf(const char *buf, const char *format, ...);
segread# int segread(struct SREGS *seg);
setbuf# void setbuf(FILE *fp, char *buf);
setvbuf# int setvbuf(FILE *fp, char *buf, int type, size_t size);
setjmp# int setjmp(jmp_buf env);
longjmp# void longjmp(jmp_buf env, int val);
# void (*signal(int sig, void (*handler)()))();
spawnl# int spawnl(int mode, const char *prog, ...);
spawnlp# int spawnlp(int mode, const char *prog, ...);
spawnv# int spawnv(int mode, const char *prog, const char *const argv[]);
spawnvp# int spawnvp(int mode, const char *prog, const char *const argv[]);
spawnle# int spawnle(int mode, const char *prog, ..., char *envp[]);
spawnlpe# int spawnlpe(int mode, const char *prog, ..., char *envp[]);
spawnve# int spawnve(int mode, const char *prog, const char *const argv[], const char *const envp[]);
spawnvpe# int spawnvpe(int mode, const char *prog, const char *const argv[], const char *const envp[]);
sqrt# double sqrt(double x);
stackavail# size_t stackavail(void);
stat# int stat(const char *pathname, struct stat *sbuf);
strcat# char *strcat(char *s, const char *t);
strncat# char *strncat(char *s, const char *t, size_t n);
strchr# char *strchr(const char *s, char c);
strrchr# char *strrchr(const char *s, char c);
strcmp# int strcmp(const char *s, const char *t);
strncmp# int strncmp(const char *s, const char *t, size_t n);
strcpy# char *strcpy(char *s, const char *t);
strncpy# char *strncpy(char *s, const char *t, size_t n);
stpcpy# char *stpcpy(char *s, const char *t);
strdup# char *strdup(const char *s);
strerror# char *strerror(int n);
strftime# size_t strftime(char *s, size_t smax, const char *fmt, const struct tm *tp);
stricmp# int stricmp(const char *s, const char *t);
strcmpi# int strcmpi(const char *s, const char *t);
strnicmp# int strnicmp(const char *s, const char *t, size_t n);
strncmpi# int strncmpi(const char *s, const char *t, size_t n);
strlen# size_t strlen(const char *s);
strlwr# char *strlwr(char *s);
strupr# char *strupr(char *s);
strpbrk# char *strpbrk(const char *s, const char *t);
strrev# char *strrev(char *s);
strset# char *strset(char *s, char c);
strnset# char *strnset(char *s, char c, size_t n);
strspn# size_t strspn(const char *s, const char *t);
strcspn# size_t strcspn(const char *s, const char *t);
strstr# char *strstr(const char *s, const char *t);
strtod# double strtod(const char *s, char **endptr);
strtok# char *strtok(char *s, const char *t);
strtol# long strtol(const char *s, char **endptr, int base);
strtoul# unsigned long strtoul(const char *s, char **endptr, int base);
swab# void swab(const char *src, char *dst, int n);
system# int system(const char *string);
tell# long tell(int fd);
tempnam# char *tempnam(const char *dir, const char *prefix);
time# time_t time(time_t *t);
clock# clock_t clock(void);
stime# void stime(const time_t *t);
tmpfile# FILE *tmpfile(void);
tmpnam# char *tmpnam(char s[L_tmpnam]);
toascii# int toascii(int c);
tolower# char tolower(char c);
_tolower# char _tolower(char c);
toupper# char toupper(char c);
_toupper# char _toupper(char c);
sin# double sin(double x);
cos# double cos(double x);
tan# double tan(double x);
asin# double asin(double x);
acos# double acos(double x);
atan# double atan(double x);
atan2# double atan2(double y, double x);
truncate# int truncate(const char *path, long size);
ftruncate# int ftruncate(int fd, long size);
tzset# void tzset(void);
umask# int umask(int mode);
ungetc# int ungetc(char c, FILE *fp);
ungetch# int ungetch(char c);
unlink# int unlink(const char *filename);
remove# int remove(const char *filename);
utime# int utime(const char *pathname, const time_t times[2]);
va_start# void va_start(va_list ap, rightparm);
va_arg# type va_arg(va_list ap, type);
va_end# void va_end(va_list ap);
vprintf# int vprintf(const char *format, va_list arg);
vfprintf# int vfprintf(FILE *fp, const char *format, va_list arg);
vsprintf# int vsprintf(char *buf, const char *format, va_list arg);
write# int write(int fd, const void *buf, int n);
xprintf# int xprintf(int (*put1)(char), const char *format, ...);
xscanf# int xscanf(int (*get1)(char), const char *format, ...);