#_exit: void _exit(int status );
#accept: int accept(int s , struct sockaddr * addr , int * addrlen );
#access: int access(const char * pathname , int mode );
#acct: int acct(const char * filename );
#adjtimex: int adjtimex(struct timex * buf );
#alarm: unsigned int alarm(unsigned int seconds );
#bdflush: int bdflush(int func, long * address);
#bdflush: int bdflush(int func, long data);
#bind: int bind(int sockfd , struct sockaddr * my_addr , int addrlen );
#brk: int brk(void * end_data_segment );
#sbrk: void *sbrk(ptrdiff_t increment );
#cacheflush: int cacheflush(char * addr , int nbytes , int cache );
#chdir: int chdir(const char * path );
#fchdir: int fchdir(int fd );
#chmod: int chmod(const char * path , mode_t mode );
#fchmod: int fchmod(int fildes , mode_t mode );
#chown: int chown(const char * path , uid_t owner , gid_t group );
#fchown: int fchown(int fd , uid_t owner , gid_t group );
#lchown: int lchown(const char * path , uid_t owner , gid_t group );
#chroot: int chroot(const char * path );
#clone: pid_t clone(void * sp , unsigned long flags )
#close: int close(int fd );
#connect: int connect(int sockfd , struct sockaddr * serv_addr , int addrlen );
#create_module: caddr_t create_module(const char * name , size_t size );
#create_module: caddr_t create_module(const char * name , size_t size );
#delete_module: int delete_module(const char * name );
#delete_module: int delete_module(const char * name );
#dup: int dup(int oldfd );
#dup2: int dup2(int oldfd , int newfd );
#execve: int execve (const char * filename , char *const argv [], char *const envp []);
#fcntl: int fcntl(int fd , int cmd );
#fcntl: int fcntl(int fd , int cmd , long arg );
#fdatasync: int fdatasync(int fd );
#flock: int flock(int fd , int operation )
#fork: pid_t fork(void);
#vfork: pid_t vfork(void);
#fsync: int fsync(int fd );
#get_kernel_syms: int get_kernel_syms(struct kernel_sym * table );
#get_kernel_syms: int get_kernel_syms(struct kernel_sym * table );
#_syscall3: _syscall3(int, getdents, uint, fd, struct dirent *, dirp, uint, count);
#getdents: int getdents(unsigned int fd , struct dirent * dirp , unsigned int count );
#getdomainname: int getdomainname(char * name , size_t len );
#setdomainname: int setdomainname(const char * name , size_t len );
#getdtablesize: int getdtablesize(void);
#getgid: gid_t getgid(void);
#getegid: gid_t getegid(void);
#getgroups: int getgroups(int size , gid_t list []);
#setgroups: int setgroups(size_t size , const gid_t * list );
#gethostid: long int gethostid(void);
#sethostid: int sethostid(long int hostid );
#gethostname: int gethostname(char * name , size_t len );
#sethostname: int sethostname(const char * name , size_t len );
#getitimer: int getitimer(int which , struct itimerval * value );
#setitimer: int setitimer(int which , const struct itimerval * value , struct itimerval * ovalue );
#getpagesize: size_t getpagesize(void);
#getpeername: int getpeername(int s , struct sockaddr * name , int * namelen );
#getpid: pid_t getpid(void);
#getppid: pid_t getppid(void);
#getpriority: int getpriority(int which , int who );
#setpriority: int setpriority(int which , int who , int prio );
#getresuid: int getresuid(uid_t * ruid , uid_t * euid , uid_t * suid );
#getresgid: int getresgid(gid_t * rgid , gid_t * egid , gid_t * sgid ); 
#getrlimit: int getrlimit (int resource , struct rlimit * rlim );
#getrusage: int getrusage (int who , struct rusage * usage );
#setrlimit: int setrlimit (int resource , const struct rlimit * rlim );
#getsid: pid_t getsid(void);
#getsockname: int getsockname(int s , struct sockaddr * name , int * namelen )
#getsockopt: int getsockopt(int s , int level , int optname , void * optval , int * optlen );
#setsockopt: int setsockopt(int s , int level , int optname , const void * optval , int optlen );
#gettimeofday: int gettimeofday(struct timeval * tv , struct timezone * tz );
#settimeofday: int settimeofday(const struct timeval * tv , const struct timezone * tz );
#getuid: uid_t getuid(void);
#geteuid: uid_t geteuid(void);
#idle: void idle(void);
#init_module: int init_module(const char * name , struct module * image );
#init_module: int init_module(const char * name , struct module * image );
#ioctl: int ioctl(int d , int request , ...)
#ioperm: int ioperm(unsigned long from , unsigned long num , int turn_on );
#iopl: int iopl(int level );
#ipc: int ipc(unsigned int call, int first, int second, int third, void * ptr, long fifth);
#kill: int kill(pid_t pid , int sig );
#killpg: int killpg(int pgrp , int sig );
#link: int link(const char * oldpath , const char * newpath );
#listen: int listen(int s , int backlog );
#_syscall5: _syscall5(int, _llseek, uint, fd, ulong, hi, ulong, lo, loff_t *, res, uint, wh);
#_llseek: int _llseek(unsigned int fd , unsigned long offset_high , unsigned long offset_low , loff_t * result , unsigned int whence );
#lseek: off_t lseek(int fildes , off_t offset , int whence );
#mkdir: int mkdir(const char * pathname , mode_t mode );
#mknod: int mknod(const char * pathname , mode_t mode , dev_t dev );
#mlock:int mlock(const void *addr, size_t len);
#mlockall:int mlockall(int flags);
#mmap: void * mmap(void * start , size_t length , int prot , int flags , int fd , off_t offset );
#munmap: int munmap(void * start , size_t length );
#_syscall3: _syscall3( int, modify_ldt, int, func, void *, ptr, unsigned long, bytecount )
#modify_ldt: int modify_ldt(int func , void * ptr , unsigned long bytecount );
#mount: int mount(const char * specialfile , const char * dir , const char * filesystemtype , unsigned long rwflag , const void * data );
#umount: int umount(const char * specialfile );
#umount: int umount(const char * dir );
#mprotect:int mprotect(const void *addr, size_t len, int prot);
#mremap: void * mremap(void * old_address , size_t old_size , size_t new_size , unsigned long flags );
#msgctl: int msgctl ( int msqid , int cmd , struct msqid_ds * buf )
#msgget: int msgget ( key_t key , int msgflg )
#msgsnd: int msgsnd ( int msqid , struct msgbuf * msgp , int msgsz , int msgflg )
#msgrcv: int msgrcv ( int msqid , struct msgbuf * msgp , int msgsz , long msgtyp , int msgflg )
#msync: int msync(const void * start , size_t length , int flags );
#munlock:int munlock(const void *addr, size_t len);
#munlockall:int munlockall(void);
#nanosleep:int nanosleep(const struct timespec *req, struct timespec *rem);
#nfsservctl: nfsservctl(int cmd , struct nfsctl_arg * argp , union nfsctl_res * resp );
#nice: int nice(int inc );
#open: int open(const char * pathname , int flags );
#open: int open(const char * pathname , int flags , mode_t mode );
#creat: int creat(const char * pathname , mode_t mode );
#pause: int pause(void);
#personality: int personality(unsigned long persona );
#phys: int phys(int physnum , char * virtaddr , long size , char * physaddr );
#pipe: int pipe(int filedes [2]);
#poll: int poll(struct pollfd * ufds , unsigned int nfds , int timeout );
#prctl: int prctl(int option , unsigned long arg2 , unsigned long arg3 , unsigned long arg4 , unsigned long arg5 );
#profil: int profil(char * buf , int bufsiz , int offset , int scale );
#ptrace: int ptrace(int request , int pid , int addr , int data );
#query_module:int query_module(const char *name, int which,void *buf, size_t bufsize, size_t *ret);
#query_module:int query_module(const char *name, int which,void *buf, size_t bufsize, size_t *ret);
#quotactl: int quotactl (int cmd , const char * special , int id , caddr_t addr );
#_syscall4: _syscall4(int, quotactl, int, cmd , const char *, special , int, id , caddr_t, addr );
#read: ssize_t read(int fd , void * buf , size_t count );
#_syscall3: _syscall3(int, readdir, uint, fd, struct dirent *, dirp, uint, count);
#readdir: int readdir(unsigned int fd , struct dirent * dirp , unsigned int count );
#readlink: int readlink(const char * path , char * buf , size_t bufsiz );
#readv: int readv(int fd , const struct iovec * vector , size_t count );
#writev: int writev(int fd , const struct iovec * vector , size_t count );
#reboot: int reboot (int magic , int magic_too , int flag );
#recv: int recv(int s , void * buf , int len , unsigned int flags );
#recvfrom: int recvfrom(int s , void * buf , int len , unsigned int flags struct sockaddr * from , int * fromlen );
#recvmsg: int recvmsg(int s , struct msghdr * msg , unsigned int flags );
#rename: int rename(const char * oldpath , const char * newpath );
#rmdir: int rmdir(const char * pathname );
#sched_get_priority_max:int sched_get_priority_max(int policy);
#sched_get_priority_min:int sched_get_priority_min(int policy);
#sched_rr_get_interval:int sched_rr_get_interval(pid_t pid, struct timespec *tp);
#sched_setparam:int sched_setparam(pid_t pid, const struct sched_param *p);
#sched_getparam:int sched_getparam(pid_t pid, struct sched_param *p);
#sched_setscheduler:int sched_setscheduler(pid_t pid, int policy, const struct sched_param *p);
#sched_getscheduler:int sched_getscheduler(pid_t pid);
#sched_yield:int sched_yield(void);
#select:int select(int n, fd_set *readfds,fd_set *writefds, fd_set *exceptfds,struct timeval *timeout);
#FD_CLR: FD_CLR(int fd , fd_set * set );
#FD_ISSET: FD_ISSET(int fd , fd_set * set );
#FD_SET: FD_SET(int fd , fd_set * set );
#FD_ZERO: FD_ZERO(fd_set * set );
#semctl: int semctl ( int semid , int semnun , int cmd , union semun arg )
#semget: int semget ( key_t key , int nsems , int semflg )
#semop: int semop ( int semid , struct sembuf * sops , unsigned nsops )
#send: int send(int s , const void * msg , int len , unsigned int flags );
#sendto: int sendto(int s , const void * msg , int len , unsigned int flags , const struct sockaddr * to , int tolen );
#sendmsg: int sendmsg(int s , const struct msghdr * msg , unsigned int flags );
#setfsgid: int setfsgid(uid_t fsgid )
#setfsuid: int setfsuid(uid_t fsuid )
#setgid: int setgid(gid_t gid )
#setpgid: int setpgid(pid_t pid , pid_t pgid );
#getpgid: pid_t getpgid(pid_t pid );
#setpgrp: int setpgrp(void);
#getpgrp: pid_t getpgrp(void);
#setregid: int setregid(gid_t rgid , gid_t egid );
#setegid: int setegid(gid_t egid );
#setresuid: int setresuid(uid_t ruid , uid_t euid , uid_t suid );
#setresgid: int setresgid(gid_t rgid , gid_t egid , gid_t sgid ); 
#setreuid: int setreuid(uid_t ruid , uid_t euid );
#seteuid: int seteuid(uid_t euid );
#setsid: pid_t setsid(void);
#setuid: int setuid(uid_t uid )
#_syscall0: _syscall0(int, setup);
#setup: int setup(void);
#shmctl: int shmctl(int shmid , int cmd , struct shmid_ds * buf );
#shmget: int shmget(key_t key , int size , int shmflg );
#shmat: char *shmat ( int shmid , char * shmaddr , int shmflg )
#shmdt: int shmdt ( char * shmaddr )
#shutdown: int shutdown(int s , int how );
#sigaction: int sigaction(int signum , const struct sigaction * act , struct sigaction * oldact );
#sigprocmask: int sigprocmask(int how , const sigset_t * set , sigset_t * oldset );
#sigpending: int sigpending(sigset_t * set );
#sigsuspend: int sigsuspend(const sigset_t * mask );
#sigblock: int sigblock(int mask );
#siggetmask: int siggetmask(void);
#sigsetmask: int sigsetmask(int mask );
#sigmask: int sigmask(int signum );
#void: void (*signal(int signum , void (* handler )(int)))(int);
#sigpause: int sigpause(int sigmask );
#sigreturn: int sigreturn(unsigned long __unused );
#sigvec: int sigvec(int sig , struct sigvec * vec , struct sigvec * ovec );
#socket: int socket(int domain , int type , int protocol );
#socketcall: int socketcall(int call, unsigned long * args);
#socketpair: int socketpair(int d , int type , int protocol , int sv [2]);
#stat: int stat(const char * file_name , struct stat * buf );
#fstat: int fstat(int filedes , struct stat * buf );
#lstat: int lstat(const char * file_name , struct stat * buf );
#statfs: int statfs(const char * path , struct statfs * buf );
#fstatfs: int fstatfs(int fd , struct statfs * buf );
#stime: int stime(time_t * t );
#swapon: int swapon(const char * path , int swapflags );
#swapoff: int swapoff(const char * path );
#symlink: int symlink(const char * oldpath , const char * newpath );
#sync: int sync(void);
#_syscall1: _syscall1(int, _sysctl, struct __sysctl_args *, args);
#_sysctl: int _sysctl(struct __sysctl_args * args );
#sysfs: int sysfs(int option , const char * fsname );
#sysfs: int sysfs(int option , unsigned int fs_index , char * buf );
#sysfs: int sysfs(int option );
#sysinfo: int sysinfo(struct sysinfo * info );
#_syscall3: _syscall3(int, syslog, int, type, char *, bufp, int, len);
#syslog: int syslog(int type , char * bufp , int len );
#time: time_t time(time_t * t );
#times: clock_t times(struct tms * buf );
#truncate: int truncate(const char * path , size_t length );
#ftruncate: int ftruncate(int fd , size_t length );
#umask: int umask(int mask );
#uname: int uname(struct utsname * buf );
#unlink: int unlink(const char * pathname );
#uselib: int uselib(const char * library );
#ustat: int ustat(dev_t dev , struct ustat * ubuf );
#utime: int utime(const char * filename , struct utimbuf * buf );
#utimes: int utimes(char * filename , struct timeval * tvp );
#vhangup: int vhangup(void);
#vm86old: int vm86old(struct vm86_struct * info );
#vm86: int vm86(unsigned long fn , struct vm86plus_struct * v86 );
#wait: pid_t wait(int * status )
#waitpid: pid_t waitpid(pid_t pid , int * status , int options );
#wait3: pid_t wait3(int * status , int options , struct rusage * rusage )
#wait4: pid_t wait4(pid_t pid , int * status , int options , struct rusage * rusage )
#write: ssize_t write(int fd , const void * buf , size_t count );
#BlackPixel:BlackPixel(display, screen_number)
#WhitePixel:WhitePixel(display, screen_number)
#ConnectionNumber:ConnectionNumber(display)
#DefaultColormap:DefaultColormap(display, screen_number)
#DefaultDepth:DefaultDepth(display, screen_number)
#XListDepths:int *XListDepths(display, screen_number, count_return)
#DefaultGC:DefaultGC(display, screen_number)
#DefaultRootWindow:DefaultRootWindow(display)
#DefaultScreenOfDisplay:DefaultScreenOfDisplay(display)
#DefaultScreen:DefaultScreen(display)
#DefaultVisual:DefaultVisual(display, screen_number)
#DisplayCells:DisplayCells(display, screen_number)
#DisplayPlanes:DisplayPlanes(display, screen_number)
#DisplayString:DisplayString(display)
#XMaxRequestSize:long XMaxRequestSize(display)
#XExtendedMaxRequestSize:long XExtendedMaxRequestSize(display)
#LastKnownRequestProcessed:LastKnownRequestProcessed(display)
#NextRequest:NextRequest(display)
#ProtocolVersion:ProtocolVersion(display)
#ProtocolRevision:ProtocolRevision(display)
#QLength:QLength(display)
#RootWindow:RootWindow(display, screen_number)
#ScreenCount:ScreenCount(display)
#ScreenOfDisplay:ScreenOfDisplay(display, screen_number)
#ServerVendor:ServerVendor(display)
#VendorRelease:VendorRelease(display)
#BlackPixelOfScreen:BlackPixelOfScreen(screen)
#WhitePixelOfScreen:WhitePixelOfScreen(screen)
#CellsOfScreen:CellsOfScreen(screen)
#DefaultColormapOfScreen:DefaultColormapOfScreen(screen)
#DefaultDepthOfScreen:DefaultDepthOfScreen(screen)
#DefaultGCOfScreen:DefaultGCOfScreen(screen)
#DefaultVisualOfScreen:DefaultVisualOfScreen(screen)
#DoesBackingStore:DoesBackingStore(screen)
#DoesSaveUnders:DoesSaveUnders(screen)
#DisplayOfScreen:DisplayOfScreen(screen)
#XScreenNumberOfScreen:int XScreenNumberOfScreen(screen)
#EventMaskOfScreen:EventMaskOfScreen(screen)
#HeightOfScreen:HeightOfScreen(screen)
#HeightMMOfScreen:HeightMMOfScreen(screen)
#MaxCmapsOfScreen:MaxCmapsOfScreen(screen)
#MinCmapsOfScreen:MinCmapsOfScreen(screen)
#PlanesOfScreen:PlanesOfScreen(screen)
#RootWindowOfScreen:RootWindowOfScreen(screen)
#WidthOfScreen:WidthOfScreen(screen)
#WidthMMOfScreen:WidthMMOfScreen(screen)
#Extension:The Double Buffer Extension (DBE) provides a standard way to utilize
#DebianNet::add_service: DebianNet::add_service($newentry, $group);
#DebianNet::remove_service: DebianNet::remove_service($entry);
#DebianNet::enable_service: DebianNet::enable_service($service, $pattern);
#DebianNet::disable_service: DebianNet::disable_service($service, $pattern);
#DisplayOfCCC:DisplayOfCCC(ccc)
#VisualOfCCC:VisualOfCCC(ccc)
#ScreenNumberOfCCC:ScreenNumberOfCCC(ccc)
#ScreenWhitePointOfCCC:ScreenWhitePointOfCCC(ccc)
#ClientWhitePointOfCCC:ClientWhitePointOfCCC(ccc)
#XListPixmapFormats:XPixmapFormatValues *XListPixmapFormats(display, count_return)
#ImageByteOrder:ImageByteOrder(display)
#BitmapBitOrder:BitmapBitOrder(display)
#BitmapPad:BitmapPad(display)
#BitmapUnit:BitmapUnit(display)
#DisplayHeight:DisplayHeight(display, screen_number)
#DisplayHeightMM:DisplayHeightMM(display, screen_number)
#DisplayWidth:DisplayWidth(display, screen_number)
#DisplayWidthMM:DisplayWidthMM(display, screen_number)
#IsCursorKey:IsCursorKey(keysym)
#IsFunctionKey:IsFunctionKey(keysym)
#IsKeypadKey:IsKeypadKey(keysym)
#IsMiscFunctionKey:IsMiscFunctionKey(keysym)
#IsModifierKey:IsModifierKey(keysym)
#IsPFKey:IsPFKey(keysym)
#IsPrivateKeypadKey:IsPrivateKeypadKey(keysym)
#__setfpucw: void __setfpucw((unsigned short) control_word );
#abort: void abort(void);
#abs: int abs(int j );
#acos: double acos(double x );
#acosh: double acosh(double x );
#alloca: void *alloca( size_t size );
#asin: double asin(double x );
#asinh: double asinh(double x );
#assert: void assert (int expression );
#atan: double atan(double x );
#atan2: double atan2(double y , double x );
#atanh: double atanh(double x );
#atexit: int atexit(void (* function )(void));
#atof: double atof(const char * nptr );
#atoi: int atoi(const char * nptr );
#atol: long atol(const char * nptr );
#bcmp: int bcmp(const void * s1 , const void * s2 , int n );
#bcopy: void bcopy (const void * src , void * dest , int n );
#bsearch: void *bsearch(const void * key , const void * base , size_t nmemb , size_t size , int (* compar )(const void *, const void *));
#bcmp: int bcmp(const void * s1 , const void * s2 , int n );
#bcopy: void bcopy(const void * src , void * dest , int n );
#bzero: void bzero(void * s , int n );
#memccpy: void *memccpy(void * dest , const void * src , int c , size_t n );
#memchr: void *memchr(const void * s , int c , size_t n );
#memcmp: int memcmp(const void * s1 , const void * s2 , size_t n );
#memcpy: void *memcpy(void * dest , const void * src , size_t n );
#memfrob: void *memfrob(void * s , size_t n );
#memmem: void *memmem(const void * needle , size_t needlelen , const void * haystack , size_t haystacklen );
#memmove: void *memmove(void * dest , const void * src , size_t n );
#memset: void *memset(void * s , int c , size_t n );
#htonl: unsigned long int htonl(unsigned long int hostlong );
#htons: unsigned short int htons(unsigned short int hostshort );
#ntohl: unsigned long int ntohl(unsigned long int netlong );
#ntohs: unsigned short int ntohs(unsigned short int netshort );
#bzero: void bzero(void * s , int n );
#catgets:char *catgets(catalog, set_number, message_number, message)
#catopen:nl_catd catopen(name, flag)
#catclose:void catclose(catalog)
#cbrt: double cbrt ( double x );
#ceil: double ceil (double x );
#clock: clock_t clock(void);
#closedir: int closedir(DIR * dir );
#confstr: size_t confstr(int name , char * buf , size_t len );
#copysign: double copysign(double x , double y );
#cos: double cos(double x );
#cosh: double cosh(double x );
#crypt: char *crypt(const char * key , const char * salt );
#ctermid: char *ctermid(char * s );
#asctime: char *asctime(const struct tm * timeptr );
#ctime: char *ctime(const time_t * timep );
#gmtime: struct tm *gmtime(const time_t * timep );
#localtime: struct tm *localtime(const time_t * timep );
#mktime: time_t mktime(struct tm * timeptr );
#addch:int addch(chtype ch);
#waddch:int waddch(WINDOW *win, chtype ch);
#mvaddch:int mvaddch(int y, int x, chtype ch);
#mvwaddch:int mvwaddch(WINDOW *win, int y, int x, chtype ch);
#echochar:int echochar(chtype ch);
#wechochar:int wechochar(WINDOW *win, chtype ch);
#addchstr:int addchstr(const chtype *chstr);
#addchnstr:int addchnstr(const chtype *chstr, int n);
#waddchstr:int waddchstr(WINDOW *win, const chtype *chstr);
#waddchnstr:int waddchnstr(WINDOW *win, const chtype *chstr, int n);
#mvaddchstr:int mvaddchstr(int y, int x, const chtype *chstr);
#mvaddchnstr:int mvaddchnstr(int y, int x, const chtype *chstr, int n);
#mvwaddchstr:int mvwaddchstr(WINDOW *win, int y, int x, const chtype *chstr);
#mvwaddchnstr:int mvwaddchnstr(WINDOW *win, int y, int x, const chtype *chstr, int n);
#addstr:int addstr(const char *str);
#addnstr:int addnstr(const char *str, int n);
#waddstr:int waddstr(WINDOW *win, const char *str);
#waddnstr:int waddnstr(WINDOW *win, const char *str, int n);
#mvaddstr:int mvaddstr(int y, int x, const char *str);
#mvaddnstr:int mvaddnstr(int y, int x, const char *str, int n);
#mvwaddstr:int mvwaddstr(WINDOW *win, int y, int x, const char *str);
#mvwaddnstr:int mvwaddnstr(WINDOW *win, int y, int x, const char *str, int n);
#attroff:int attroff(int attrs);
#wattroff:int wattroff(WINDOW *win, int attrs);
#attron:int attron(int attrs);
#wattron:int wattron(WINDOW *win, int attrs);
#attrset:int attrset(int attrs);
#wattrset:int wattrset(WINDOW *win, int attrs);
#color_set:int color_set(short color_pair_number, void* opts);
#wcolor_set:int wcolor_set(WINDOW *win, short color_pair_number, void* opts);
#standend:int standend(void);
#wstandend:int wstandend(WINDOW *win);
#standout:int standout(void);
#wstandout:int wstandout(WINDOW *win);
#attr_get:int attr_get(attr_t *attrs, short *pair, void *opts);
#wattr_get:int wattr_get(WINDOW *win, attr_t *attrs, short *pair, void *opts);
#attr_off:int attr_off(attr_t attrs, void *opts);
#wattr_off:int wattr_off(WINDOW *win, attr_t attrs, void *opts);
#attr_on:int attr_on(attr_t attrs, void *opts);
#wattr_on:int wattr_on(WINDOW *win, attr_t attrs, void *opts);
#attr_set:int attr_set(attr_t attrs, void *opts);
#wattr_set:int wattr_set(WINDOW *win, attr_t attrs, void *opts);
#chgat:int chgat(int n, attr_t attr, short color, const void *opts)
#wchgat:int wchgat(WINDOW *win, int n, attr_t attr, short color, const void *opts)
#mvchgat:int mvchgat(int y, int x, int n, attr_t attr, short color, const void *opts)
#mvwchgat:int mvwchgat(WINDOW *win, int y, int x, int n, attr_t attr, short color, const void *opts)
#beep:int beep(void);
#flash:int flash(void);
#bkgdset:void bkgdset(const chtype ch);
#wbkgdset:void wbkgdset(WINDOW *win, const chtype ch);
#bkgd:int bkgd(const chtype ch);
#wbkgd:int wbkgd(WINDOW *win, const chtype ch);
#getbkgd:chtype getbkgd(WINDOW *win);
#border:int border(chtype ls, chtype rs, chtype ts, chtype bs, chtype tl, chtype tr, chtype bl, chtype br);
#wborder:int wborder(WINDOW *win, chtype ls, chtype rs, chtype ts, chtype bs, chtype tl, chtype tr, chtype bl, chtype br);
#box:int box(WINDOW *win, chtype verch, chtype horch);
#hline:int hline(chtype ch, int n);
#whline:int whline(WINDOW *win, chtype ch, int n);
#vline:int vline(chtype ch, int n);
#wvline:int wvline(WINDOW *win, chtype ch, int n);
#mvhline:mvhline(int y, int x, chtype ch, int n);
#mvwhline:mvwhline(WINDOW *, int y, int x, chtype ch, int n);
#mvvline:int mvvline(int y, int x, chtype ch, int n);
#mvwvline:int mvwvline(WINDOW *, int y, int x, chtype ch, int n);
#erase:int erase(void);
#werase:int werase(WINDOW *win);
#clear:int clear(void);
#wclear:int wclear(WINDOW *win);
#clrtobot:int clrtobot(void);
#wclrtobot:int wclrtobot(WINDOW *win);
#clrtoeol:int clrtoeol(void);
#wclrtoeol:int wclrtoeol(WINDOW *win);
#start_color:int start_color(void);
#init_pair:int init_pair(short pair, short f, short b);
#init_color:int init_color(short color, short r, short g, short b);
#has_colors:bool has_colors(void);
#can_change_color:bool can_change_color(void);
#color_content:int color_content(short color, short *r, short *g, short *b);
#pair_content:int pair_content(short pair, short *f, short *b);
#delch:int delch(void);
#wdelch:int wdelch(WINDOW *win);
#mvdelch:int mvdelch(int y, int x);
#mvwdelch:int mvwdelch(WINDOW *win, int y, int x);
#deleteln:int deleteln(void);
#wdeleteln:int wdeleteln(WINDOW *win);
#insdelln:int insdelln(int n);
#winsdelln:int winsdelln(WINDOW *win, int n);
#insertln:int insertln(void);
#winsertln:int winsertln(WINDOW *win);
#getch:int getch(void);
#wgetch:int wgetch(WINDOW *win);
#mvgetch:int mvgetch(int y, int x);
#mvwgetch:int mvwgetch(WINDOW *win, int y, int x);
#ungetch:int ungetch(int ch);
#has_key:int has_key(int ch);
#getstr:int getstr(char *str);
#getnstr:int getnstr(char *str, int n);
#wgetstr:int wgetstr(WINDOW *win, char *str);
#mvgetstr:int mvgetstr(int y, int x, char *str);
#mvwgetstr:int mvwgetstr(WINDOW *win, int y, int x, char *str);
#mvgetnstr:int mvgetnstr(int y, int x, char *str, int n);
#mvwgetnstr:int mvwgetnstr(WINDOW *, int y, int x, char *str, int n);
#wgetnstr:int wgetnstr(WINDOW *win, char *str, int n);
#getyx:void getyx(WINDOW *win, int y, int x);
#getparyx:void getparyx(WINDOW *win, int y, int x);
#getbegyx:void getbegyx(WINDOW *win, int y, int x);
#getmaxyx:void getmaxyx(WINDOW *win, int y, int x);
#inch:chtype inch(void);
#winch:chtype winch(WINDOW *win);
#mvinch:chtype mvinch(int y, int x);
#mvwinch:chtype mvwinch(WINDOW *win, int y, int x);
#inchstr:int inchstr(chtype *chstr);
#inchnstr:int inchnstr(chtype *chstr, int n);
#winchstr:int winchstr(WINDOW *win, chtype *chstr);
#winchnstr:int winchnstr(WINDOW *win, chtype *chstr, int n);
#mvinchstr:int mvinchstr(int y, int x, chtype *chstr);
#mvinchnstr:int mvinchnstr(int y, int x, chtype *chstr, int n);
#mvwinchstr:int mvwinchstr(WINDOW *win, int y, int x, chtype *chstr);
#mvwinchnstr:int mvwinchnstr(WINDOW *win, int y, int x, chtype *chstr, int n);
#initscr:WINDOW *initscr(void);
#endwin:int endwin(void);
#isendwin:int isendwin(void);
#newterm:SCREEN *newterm(const char *type, FILE *outfd, FILE *infd);
#set_term:SCREEN *set_term(SCREEN *new);
#delscreen:void delscreen(SCREEN* sp);
#cbreak:int cbreak(void);
#nocbreak:int nocbreak(void);
#echo:int echo(void);
#noecho:int noecho(void);
#halfdelay:int halfdelay(int tenths);
#intrflush:int intrflush(WINDOW *win, bool bf);
#keypad:int keypad(WINDOW *win, bool bf);
#meta:int meta(WINDOW *win, bool bf);
#nodelay:int nodelay(WINDOW *win, bool bf);
#raw:int raw(void);
#noraw:int noraw(void);
#noqiflush:void noqiflush(void);
#qiflush:void qiflush(void);
#notimeout:int notimeout(WINDOW *win, bool bf);
#timeout:void timeout(int delay);
#wtimeout:void wtimeout(WINDOW *win, int delay);
#typeahead:int typeahead(int fd);
#insch:int insch(chtype ch);
#winsch:int winsch(WINDOW *win, chtype ch);
#mvinsch:int mvinsch(int y, int x, chtype ch);
#mvwinsch:int mvwinsch(WINDOW *win, int y, int x, chtype ch);
#insstr:int insstr(const char *str);
#insnstr:int insnstr(const char *str, int n);
#winsstr:int winsstr(WINDOW *win, const char *str);
#winsnstr:int winsnstr(WINDOW *win, const char *str, int n);
#mvinsstr:int mvinsstr(int y, int x, const char *str);
#mvinsnstr:int mvinsnstr(int y, int x, const char *str, int n);
#mvwinsstr:int mvwinsstr(WINDOW *win, int y, int x, const char *str);
#mvwinsnstr:int mvwinsnstr(WINDOW *win, int y, int x, const char *str, int n);
#instr:int instr(char *str);
#innstr:int innstr(char *str, int n);
#winstr:int winstr(WINDOW *win, char *str);
#winnstr:int winnstr(WINDOW *win, char *str, int n);
#mvinstr:int mvinstr(int y, int x, char *str);
#mvinnstr:int mvinnstr(int y, int x, char *str, int n);
#mvwinstr:int mvwinstr(WINDOW *win, int y, int x, char *str);
#mvwinnstr:int mvwinnstr(WINDOW *win, int y, int x, char *str, int n);
#def_prog_mode:int def_prog_mode(void);
#def_shell_mode:int def_shell_mode(void);
#reset_prog_mode:int reset_prog_mode(void);
#reset_shell_mode:int reset_shell_mode(void);
#resetty:int resetty(void);
#savetty:int savetty(void);
#getsyx:void getsyx(int y, int x);
#setsyx:void setsyx(int y, int x);
#ripoffline:int ripoffline(int line, int (*init)(WINDOW *, int));
#curs_set:int curs_set(int visibility);
#napms:int napms(int ms);
#getmouse:int getmouse(MEVENT *event);
#ungetmouse:int ungetmouse(MEVENT *event);
#mousemask:mmask_t mousemask(mmask_t newmask, mmask_t *oldmask);
#wenclose:bool wenclose(WINDOW *win, int y, int x);
#wmouse_trafo:bool wmouse_trafo(const WINDOW* win, int* pY, int* pX, bool to_screen);
#mouseinterval:int mouseinterval(int erval);
#move:int move(int y, int x);
#wmove:int wmove(WINDOW *win, int y, int x);
#clearok:int clearok(WINDOW *win, bool bf);
#idlok:int idlok(WINDOW *win, bool bf);
#idcok:void idcok(WINDOW *win, bool bf);
#immedok:void immedok(WINDOW *win, bool bf);
#leaveok:int leaveok(WINDOW *win, bool bf);
#setscrreg:int setscrreg(int top, int bot);
#wsetscrreg:int wsetscrreg(WINDOW *win, int top, int bot);
#scrollok:int scrollok(WINDOW *win, bool bf);
#nl:int nl(void);
#nonl:int nonl(void);
#overlay:int overlay(const WINDOW *srcwin, WINDOW *dstwin);
#overwrite:int overwrite(const WINDOW *srcwin, WINDOW *dstwin);
#copywin:int copywin(WINDOW *srcwin, WINDOW *dstwin, int sminrow, int smincol, int dminrow, int dmincol, int dmaxrow, int dmaxcol, int overlay);
#newpad:WINDOW *newpad(int nlines, int ncols);
#subpad:WINDOW *subpad(WINDOW *orig, int nlines, int ncols, int begin_y, int begin_x);
#prefresh:int prefresh(WINDOW *pad, int pminrow, int pmincol, int sminrow, int smincol, int smaxrow, int smaxcol);
#pnoutrefresh:int pnoutrefresh(WINDOW *pad, int pminrow, int pmincol, int sminrow, int smincol, int smaxrow, int smaxcol);
#pechochar:int pechochar(WINDOW *pad, chtype ch);
#mcprint:int mcprint(char *data, int len);
#printw:int printw(char *fmt [, arg] ...);
#wprintw:int wprintw(WINDOW *win, char *fmt [, arg] ...);
#mvprintw:int mvprintw(int y, int x, char *fmt [, arg] ...);
#mvwprintw:int mvwprintw(WINDOW *win, int y, int x, char *fmt [, arg] ...);
#vwprintw:int vwprintw(WINDOW *win, char *fmt, varglist);
#refresh:int refresh(void);
#wrefresh:int wrefresh(WINDOW *win);
#wnoutrefresh:int wnoutrefresh(WINDOW *win);
#doupdate:int doupdate(void);
#redrawwin:int redrawwin(WINDOW *win);
#wredrawln:int wredrawln(WINDOW *win, int beg_line, int num_lines);
#scanw:int scanw(char *fmt [, arg] ...);
#wscanw:int wscanw(WINDOW *win, char *fmt [, arg] ...);
#mvscanw:int mvscanw(int y, int x, char *fmt [, arg] ...);
#mvwscanw:int mvwscanw(WINDOW *win, int y, int x, char *fmt [, arg] ...);
#vwscanw:int vwscanw(WINDOW *win, char *fmt, va_list varglist);
#scr_dump:int scr_dump(const char *filename);
#scr_restore:int scr_restore(const char *filename);
#scr_init:int scr_init(const char *filename);
#scr_set:int scr_set(const char *filename);
#scr_dump:int scr_dump(const char *filename);
#scr_restore:int scr_restore(const char *filename);
#scr_init:int scr_init(const char *filename);
#scr_set:int scr_set(const char *filename);
#scroll:int scroll(WINDOW *win);
#scrl:int scrl(int n);
#wscrl:int wscrl(WINDOW *win, int n);
#slk_init:int slk_init(int fmt);
#slk_set:int slk_set(int labnum, const char *label, int fmt);
#slk_refresh:int slk_refresh(void);
#slk_noutrefresh:int slk_noutrefresh(void);
#slk_label:char *slk_label(int labnum);
#slk_clear:int slk_clear(void);
#slk_restore:int slk_restore(void);
#slk_touch:int slk_touch(void);
#slk_attron:int slk_attron(const chtype attrs);
#slk_attrset:int slk_attrset(const chtype attrs);
#slk_attr:attr_t slk_attr(void);
#slk_attroff:int slk_attroff(const chtype attrs);
#slk_color:int slk_color(short color_pair_number);
#baudrate:int baudrate(void);
#erasechar:char erasechar(void);
#has_ic:int has_ic(void);
#has_il:int has_il(void);
#killchar:char killchar(void);
#longname:char *longname(void);
#termattrs:attr_t termattrs(void);
#termname:char *termname(void);
#tgetent:int tgetent(const char *bp, char *name);
#tgetflag:int tgetflag(const char *id);
#tgetnum:int tgetnum(const char *id);
#tgetstr:char *tgetstr(const char *id, char **area);
#tgoto:char *tgoto(const char *cap, int col, int row);
#tputs:int tputs(const char *str, int affcnt, int (*putc)(int));
#setupterm:int setupterm(const char *term, int fildes, int *errret);
#setterm:int setterm(const char *term);
#set_curterm:TERMINAL *set_curterm(TERMINAL *nterm);
#del_curterm:int del_curterm(TERMINAL *oterm);
#restartterm:int restartterm(const char *term, int fildes, int *errret);
#tparm:char *tparm(const char *str, ...);
#tputs:int tputs(const char *str, int affcnt, int (*putc)(int));
#putp:int putp(const char *str);
#vidputs:int vidputs(chtype attrs, int (*putc)(char));
#vidattr:int vidattr(chtype attrs);
#mvcur:int mvcur(int oldrow, int oldcol, int newrow, int newcol);
#tigetflag:int tigetflag(const char *capname);
#tigetnum:int tigetnum(const char *capname);
#tigetstr:char *tigetstr(const char *capname);
#touchwin:int touchwin(WINDOW *win);
#touchline:int touchline(WINDOW *win, int start, int count);
#untouchwin:int untouchwin(WINDOW *win);
#wtouchln:int wtouchln(WINDOW *win, int y, int n, int changed);
#is_linetouched:int is_linetouched(WINDOW *win, int line);
#is_wintouched:int is_wintouched(WINDOW *win);
#unctrl:char *unctrl(chtype c);
#keyname:char *keyname(int c);
#filter:void filter(void);
#use_env:void use_env(char bool);
#putwin:int putwin(WINDOW *win, FILE *filep);
#getwin:WINDOW *getwin(FILE *filep);
#delay_output:int delay_output(int ms);
#flushinp:int flushinp(void);
#newwin:WINDOW *newwin(int nlines, int ncols, int begin_y, int begin_x);
#delwin:int delwin(WINDOW *win);
#mvwin:int mvwin(WINDOW *win, int y, int x);
#subwin:WINDOW *subwin(WINDOW *orig, int nlines, int ncols, int begin_y, int begin_x);
#derwin:WINDOW *derwin(WINDOW *orig, int nlines, int ncols, int begin_y, int begin_x);
#mvderwin:int mvderwin(WINDOW *win, int par_y, int par_x);
#dupwin:WINDOW *dupwin(WINDOW *win);
#wsyncup:void wsyncup(WINDOW *win);
#syncok:int syncok(WINDOW *win, bool bf);
#wcursyncup:void wcursyncup(WINDOW *win);
#wsyncdown:void wsyncdown(WINDOW *win);
#define_key:int define_key(char *definition, int keycode);
#use_default_colors:int use_default_colors(void);
#difftime: double difftime(time_t time1 , time_t time0 );
#div: div_t div(int numer , int denom );
#dlopen: void *dlopen (const char * filename , int flag );
#dlerror: const char *dlerror(void);
#dlsym: void *dlsym(void *handle , char *symbol );
#dlclose: int dlclose (void *handle );
#dlopen: void *dlopen (const char * filename , int flag );
#dlerror: const char *dlerror(void);
#dlsym: void *dlsym(void *handle , char *symbol );
#dlclose: int dlclose (void *handle );
#dlopen: void *dlopen (const char * filename , int flag );
#dlerror: const char *dlerror(void);
#dlsym: void *dlsym(void *handle , char *symbol );
#dlclose: int dlclose (void *handle );
#drand48: double drand48(void);
#erand48: double erand48(unsigned short int xsubi [3]);
#lrand48: long int lrand48(void);
#nrand48: long int nrand48(unsigned short int xsubi [3]);
#mrand48: long int mrand48(void);
#jrand48: long int jrand48(unsigned short int xsubi [3]);
#srand48: void srand48(long int seedval );
#seed48: unsigned short int * seed48(unsigned short int seed16v [3]);
#lcong48: void lcong48(unsigned short int param [7]);
#drem: double drem(double x , double y );
#ecvt: char *ecvt(double number , size_t ndigits , int * decpt , int * sign );
#fcvt: char *fcvt(double number , size_t ndigits , int * decpt , int * sign );
#malloc:void * malloc (size_t size);
#free:void free (void *ptr);
#realloc:void * realloc (void *ptr, size_t size);
#calloc:void * calloc (size_t nelem, size_t elsize);
#memalign:void * memalign (size_t alignment, size_t size);
#valloc:void * valloc (size_t size);
#erf: double erf(double x );
#erfc: double erfc (double x );
#execl: int execl( const char * path , const char * arg , ...);
#execlp: int execlp( const char * file , const char * arg , ...);
#execle: int execle( const char * path , const char * arg , ..., char * const envp []);
#execv: int execv( const char * path , char *const argv []);
#execvp: int execvp( const char * file , char *const argv []);
#exit: void exit(int status );
#exp: double exp(double x );
#log: double log(double x );
#log10: double log10(double x );
#pow: double pow(double x , double y );
#expm1: double expm1 ( double x );
#log1p: double log1p ( double x );
#fabs: double fabs(double x );
#fclose: int fclose( FILE * stream );
#clearerr: void clearerr( FILE * stream );
#feof: int feof( FILE * stream );
#ferror: int ferror( FILE * stream );
#fileno: int fileno( FILE * stream );
#fflush: int fflush(FILE * stream );
#ffs: int ffs(int i );
#fgetgrent: struct group *fgetgrent(FILE * stream );
#fgetpwent: struct passwd *fgetpwent(FILE * stream );
#fieldread:extern field_t *fieldread (FILE * file, char * delims, int flags, int maxf);
#fieldmake:extern field_t *fieldmake (char * line, int allocated, char * delims, int flags, int maxf);
#fieldwrite:extern int fieldwrite (FILE * file, field_t * fieldp, int delim);
#fieldfree:extern void fieldfree (field_t * fieldp);
#floor: double floor(double x );
#fmod: double fmod(double x , double y );
#fnmatch: int fnmatch(const char * pattern , const char * strings , int flags );
#fopen: FILE *fopen (const char * path , const char * mode );
#fdopen: FILE *fdopen (int fildes , const char * mode );
#freopen: FILE *freopen (const char * path , const char * mode , FILE * stream );
#pos_form_cursor:int pos_form_cursor(FORM *form);
#data_ahead:bool data_ahead(const FORM *form);
#data_behind:bool data_behind(const FORM *form);
#form_driver:int form_driver(FORM *form, int c);
#set_form_fields:int set_form_fields(FORM *form, FIELD **fields);
#form_fields:FIELD **form_fields(const FORM *form);
#field_count:int field_count(const FORM *form);
#move_field:int move_field(FIELD *field, int frow, int fcol);
#set_field_fore:int set_field_fore(FIELD *field, chtype attr);
#field_fore:chtype field_fore(const FIELD *field);
#set_field_back:int set_field_back(FIELD *field, chtype attr);
#field_back:chtype field_back(const FIELD *field);
#set_field_pad:int set_field_pad(FIELD *field, int pad);
#field_pad:chtype field_pad(const FIELD *field);
#set_field_buffer:int set_field_buffer(FIELD *field, int buf, const char *value);
#field_buffer:char *field_buffer(const FIELD *field, int buffer);
#set_field_status:int set_field_status(FIELD *field, bool status);
#field_status:bool field_status(const FIELD *field);
#set_max_field:int set_max_field(FIELD *field, int max);
#field_info:int field_info(const FIELD *field, int *rows, int *cols, int *frow, int *fcol, int *nrow, int *nbuf);
#dynamic_field_info:int dynamic_field_info(const FIELD *field, int *rows, int *cols, *max);
#set_field_just:int set_field_just(FIELD *field, int justification);
#field_just:int field_just(const FIELD *field);
#new_field:FIELD *new_field(int height, int width, int toprow, int leftcol, int offscreen, int nbuffers);
#dup_field:FIELD *dup_field(FIELD *field, int toprow, int leftcol);
#link_field:FIELD *link_field(FIELD *field, int toprow, int leftcol);
#free_field:int free_field(FIELD *field);
#set_field_opts:int set_field_opts(FIELD *field, OPTIONS opts);
#field_opts_on:int field_opts_on(FIELD *field, OPTIONS opts);
#field_opts_off:int field_opts_off(FIELD *field, OPTIONS opts);
#field_opts:OPTIONS field_opts(const FIELD *field);
#set_field_userptr:int set_field_userptr(FIELD *field, void*userptr);
#field_userptr:void *field_userptr(const FIELD *field);
#set_field_type:int set_field_type(FIELD *field, FIELDTYPE *type, ...);
#field_type:FIELDTYPE *field_type(const FIELD *field);
#field_arg:void *field_arg(const FIELD *field);
#new_fieldtype:FIELDTYPE *new_fieldtype( bool (* const field_check)(FIELD *, const void *), bool (* const char_check)(int, const void *));int free_fieldtype(FIELDTYPE *fieldtype);int set_fieldtype_arg( FIELDTYPE *fieldtype, void *(* const make_arg)(va_list *), void *(* const copy_arg)(const void *), void (* const free_arg)(void *));int set_fieldtype_choice( FIELDTYPE *fieldtype bool (* const next_choice)(FIELD *, const void *), bool (* const prev_choice)(FIELD *, const void *));FIELDTYPE *link_fieldtype(FIELDTYPE *type1, FIELDTYPE *type2);
#set_field_init:int set_field_init(FORM *form, void (*func)(FORM *));
#void:void (*)(FORM *) field_init(const FORM *form);
#set_field_term:int set_field_term(FORM *form, void (*func)(FORM *));
#void:void (*)(FORM *) field_term(const FORM *form);
#set_form_init:int set_form_init(FORM *form, void (*func)(FORM *));
#void:void (*)(FORM *) form_init(const FORM *form);
#set_form_term:int set_form_term(FORM *form, void (*func)(FORM *));
#void:void (*)(FORM *) form_term(const FORM *form);
#new_form:FORM *new_form(FIELD **fields);
#free_form:int free_form(FORM *form);
#set_new_page:int set_new_page(FIELD *field, bool new_page_flag);
#new_page:bool new_page(const FIELD *field);
#set_form_opts:int set_form_opts(FORM *form, OPTIONS opts);
#form_opts_on:int form_opts_on(FORM *form, OPTIONS opts);
#form_opts_off:int form_opts_off(FORM *form, OPTIONS opts);
#form_opts:OPTIONS form_opts(const FORM *form);
#set_current_field:int set_current_field(FORM *form, FIELD *field);
#current_field:FIELD *current_field(const FORM *);
#set_form_page:int set_form_page(FORM *form, int n);
#form_page:int form_page(const FORM *form);
#field_index:int field_index(const FIELD *field);
#post_form:int post_form(FORM *form);
#unpost_form:int unpost_form(FORM *form);
#form_request_name:const char *form_request_name(int request);
#form_request_by_name:int form_request_by_name(const char *name);
#set_form_userptr:int set_form_userptr(FORM *form, void *userptr);
#form_userptr:void* form_userptr(const FORM *form);
#set_form_win:int set_form_win(FORM *form, WINDOW *win);
#form_win:WINDOW *form_win(const FORM *form);
#set_form_sub:int set_form_sub(FORM *form, WINDOW *sub);
#form_sub:WINDOW *form_sub(const FORM *form);
#scale_form:int scale_form(const FORM *form, int *rows, int *columns);
#fpathconf: long fpathconf(int filedes , int name );
#pathconf: long pathconf(char * path , int name );
#fread: size_t fread( void * ptr , size_t size , size_t nmemb , FILE * stream );
#fwrite: size_t fwrite( const void * ptr , size_t size , size_t nmemb , FILE * stream );
#frexp: double frexp(double x , int * exp );
#fseek: int fseek( FILE * stream , long offset , int whence );
#ftell: long ftell( FILE * stream );
#rewind: void rewind( FILE * stream );
#fgetpos: int fgetpos( FILE * stream , fpos_t * pos );
#fsetpos: int fsetpos( FILE * stream , fpos_t * pos );
#ftime: int ftime(struct timeb * tp );
#ftok: key_t ftok ( char * pathname , char proj )
#ftw: int ftw(const char * directory , int (* funcptr )(const char * file , struct stat * sb , int flag ), int depth );
#gcvt: char *gcvt(double number , size_t ndigit , char * buf );
#gdbm_open: gdbm_open (name, block_size, read_write, mode, fatal_func)
#void: void (*fatal_func) ();
#gdbm_close: gdbm_close (dbf)
#gdbm_store: gdbm_store (dbf, key, content, flag)
#gdbm_fetch: gdbm_fetch (dbf, key)
#gdbm_delete: gdbm_delete (dbf, key)
#gdbm_firstkey: gdbm_firstkey (dbf)
#gdbm_nextkey: gdbm_nextkey (dbf, key)
#gdbm_reorganize: gdbm_reorganize (dbf)
#gdbm_sync: gdbm_sync (dbf)
#gdbm_exists: gdbm_exists (dbf, key)
#gdbm_strerror: gdbm_strerror (errno)
#gdbm_setopt: gdbm_setopt (dbf, option, value, size)
#dbminit: dbminit (name)
#store: store (key, content)
#fetch: fetch (key)
#delete: delete (key)
#firstkey: firstkey ()
#nextkey: nextkey (key)
#dbmclose: dbmclose ()
#dbm_open: *dbm_open (name, flags, mode)
#dbm_close: dbm_close (file)
#dbm_fetch: dbm_fetch (file, key)
#dbm_store: dbm_store (file, key, content, flags)
#dbm_delete: dbm_delete (file, key)
#dbm_firstkey: dbm_firstkey (file)
#dbm_nextkey: dbm_nextkey (file)
#dbm_error: dbm_error (file)
#dbm_clearerr: dbm_clearerr (file)
#dbm_pagfno: dbm_pagfno (file)
#dbm_dirfno: dbm_dirfno (file)
#dbm_rdonly: dbm_rdonly (file)
#getcwd: char *getcwd(char * buf , size_t size );
#get_current_working_dir_name: char *get_current_working_dir_name(void);
#getwd: char *getwd(char * buf );
#getdirentries: ssize_t getdirentries(int fd , char * buf , size_t nbytes , off_t * basep );
#getenv: char *getenv(const char * name );
#getgrent: struct group *getgrent(void);
#setgrent: void setgrent(void);
#endgrent: void endgrent(void);
#getgrnam: struct group *getgrnam(const char * name );
#getgrgid: struct group *getgrgid(gid_t gid );
#gethostbyname: struct hostent *gethostbyname(const char * name );
#gethostbyaddr: struct hostent *gethostbyaddr(const char * addr , int len , int type );
#sethostent: void sethostent(int stayopen );
#endhostent: void endhostent(void);
#herror: void herror(const char * s );
#getlogin: char * getlogin ( void );
#cuserid: char * cuserid ( char * string );
#setmntent: FILE *setmntent(const char * filename , const char * type );
#getmntent: struct mntent *getmntent(FILE * filep );
#addmntent: int addmntent(FILE * filep , const struct mntent * mnt );
#endmntent: int endmntent(FILE * filep );
#hasmntopt: char *hasmntopt(const struct mntent * mnt , const char * opt );
#getnetent: struct netent *getnetent(void);
#getnetbyname: struct netent *getnetbyname(const char * name );
#getnetbyaddr: struct netent *getnetbyaddr(long net , int type );
#setnetent: void setnetent(int stayopen );
#endnetent: void endnetent(void);
#getopt: int getopt(int argc , char * const argv[] , const char * optstring );
#getopt_long: int getopt_long(int argc , char * const argv[] , const char * optstring , const struct option * longopts , int * longindex );
#getopt_long_only: int getopt_long_only(int argc , char * const argv[] , const char * optstring , const struct option * longopts , int * longindex );
#getpass: char *getpass( const char * prompt );
#getprotoent: struct protoent *getprotoent(void);
#getprotobyname: struct protoent *getprotobyname(const char * name );
#getprotobynumber: struct protoent *getprotobynumber(int proto );
#setprotoent: void setprotoent(int stayopen );
#endprotoent: void endprotoent(void);
#getpw: int getpw(uid_t uid , char * buf );
#getpwent: struct passwd *getpwent(void);
#setpwent: void setpwent(void);
#endpwent: void endpwent(void);
#getpwnam: struct passwd *getpwnam(const char * name );
#getpwuid: struct passwd *getpwuid(uid_t uid );
#fgetc: int fgetc(FILE * stream );
#fgets: char *fgets(char * s , int size , FILE * stream );
#getc: int getc(FILE * stream );
#getchar: int getchar(void);
#gets: char *gets(char * s );
#ungetc: int ungetc(int c , FILE * stream );
#getservent: struct servent *getservent(void);
#getservbyname: struct servent *getservbyname(const char * name , const char * proto );
#getservbyport: struct servent *getservbyport(int port , const char * proto );
#setservent: void setservent(int stayopen );
#endservent: void endservent(void);
#getusershell: char *getusershell(void);
#setusershell: void setusershell(void);
#endusershell: void endusershell(void);
#getutent: struct utmp *getutent(void);
#getutid: struct utmp *getutid(struct utmp * ut );
#getutline: struct utmp *getutline(struct utmp * ut );
#pututline: void pututline(struct utmp * ut );
#setutent: void setutent(void);
#endutent: void endutent(void);
#utmpname: void utmpname(const char * file );
#getw: int getw(FILE * stream );
#putw: int putw(int w , FILE * stream );
#gl_allocatecontext: GraphicsContext *gl_allocatecontext(void);
#gl_circle: void gl_circle(int x , int y , int r , int c );
#gl_clearscreen: void gl_clearscreen(int c );
#gl_colorfont: void gl_colorfont(int fw , int fh , int c , void * fp );
#gl_compileboxmask: void gl_compileboxmask(int w , int h , void * sdp , void * ddp );
#gl_compiledboxmasksize: int gl_compiledboxmasksize(int w , int h , void * sdp );
#gl_copybox: void gl_copybox(int x1 , int y1 , int w , int h , int x2 , int y2 );
#gl_copyboxfromcontext: void gl_copyboxfromcontext(GraphicsContext * gc , int x1 , int y1 , int w , int h , int x2 , int y2 );
#gl_copyboxtocontext: void gl_copyboxtocontext(int x1 , int y1 , int w , int h , GraphicsContext * gc , int x2 , int y2 );
#gl_copyscreen: void gl_copyscreen(GraphicsContext * gc );
#gl_disableclipping: void gl_disableclipping(void);
#gl_enableclipping: void gl_enableclipping(void);
#gl_enablepageflipping: int gl_enablepageflipping(GraphicsContext * gc );
#gl_expandfont: void gl_expandfont(int fw , int fh , int c , void * sfp , void * dfp );
#gl_fillbox: void gl_fillbox(int x , int y , int w , int h , int c );
#gl_freecontext: void gl_freecontext(GraphicsContext * gc );
#gl_getbox: void gl_getbox(int x , int y , int w , int h , void * dp );
#gl_getcontext: void gl_getcontext(GraphicsContext * gc );
#gl_getpalettecolor: void gl_getpalettecolor(int c , int * r , int * g , int * b );
#gl_getpalettecolors: void gl_getpalettecolors(int s , int n , void * dp );
#gl_getpalette: void gl_getpalette(void * dp );
#gl_getpixel: int gl_getpixel(int x , int y );
#gl_getpixelrgb: void gl_getpixelrgb(int x , int y , int * r , int * g , int * b );
#gl_hline: void gl_hline(int x1 , int y , int x2 , int c );
#gl_line: void gl_line(int x1 , int y1 , int x2 , int y2 , int c );
#gl_printf: int gl_printf(int x , int y , const char * fmt , ...);
#gl_putbox: void gl_putbox(int x , int y , int w , int h , void * dp );
#gl_putboxmask: void gl_putboxmask(int x , int y , int w , int h , void * dp );
#gl_putboxmaskcompiled: void gl_putboxmaskcompiled(int x , int y , int w , int h , void * dp );
#gl_putboxpart: void gl_putboxpart(int x , int y , int w , int h , int bw , int bh , void * dp , int xo , int yo );
#gl_rgbcolor: int gl_rgbcolor(int r , int g , int b );
#gl_scalebox: void gl_scalebox(int w1 , int h1 , void * sdp , int w2 , int h2 , void * ddp );
#gl_setclippingwindow: void gl_setclippingwindow(int x1 , int y1 , int x2 , int y2 );
#gl_setcontext: void gl_setcontext(GraphicsContext * gc );
#gl_setcontextvga: int gl_setcontextvga(int mode );
#gl_setcontextvgavirtual: int gl_setcontextvgavirtual(int mode );
#gl_setcontextvirtual: void gl_setcontextvirtual(int w , int h , int bpp , int bitspp , void * vbuf );
#gl_setcontextwidth: void gl_setcontextwidth(int w );
#gl_setcontextheight: void gl_setcontextheight(int h );
#gl_setdisplaystart: vga gl_setdisplaystart(int x , int y );
#gl_setfont: void gl_setfont(int fw , int fh , void * fp );
#gl_setfontcolors: void gl_setfontcolors(int bg , int fg );
#gl_setpalettecolor: void gl_setpalettecolor(int c , int r , int g , int b );
#gl_setpalettecolors: void gl_setpalettecolors(int s , int n , void * sp );
#gl_setpalette: void gl_setpalette(void * sp );
#gl_setpixel: void gl_setpixel(int x , int y , int c ),
#gl_setpixelrgb: void gl_setpixelrgb(int x , int y , int r , int g , int b );
#gl_setrgbpalette: void gl_setrgbpalette(void)
#gl_setscreenoffset: void gl_setscreenoffset(int o );
#gl_setwritemode: void gl_setwritemode(int m );
#gl_striangle: void gl_striangle(int x0 , int y0 , int x1 , int y1 , int x2 , int y2 , int color , int bf );
#gl_swtriangle: void gl_swtriangle(int x0 , int y0 , int xd0 , int yd0 , int x1 , int y1 , int xd1 , int yd1 , int x2 , int y2 , int xd2 , int yd2 , int c , TD_tridata * tri );
#gl_triangle: void gl_triangle(int x0 , int y0 , int z0 , int x1 , int y1 , int z1 , int x2 , int y2 , int z2 , int bf );
#gl_trisetcolorlookup: void gl_trisetcolorlookup(int i , long color );
#gl_trigetcolorlookup: long gl_trigetcolorlookup(int i );
#gl_trisetdrawpoint: void gl_trisetdrawpoint(void ( setpixelfunc ) (int x , int y , int color ) );
#gl_write: void gl_write(int x , int y , char * s );
#gl_writen: void gl_writen(int x , int y , int n ,char * s );
#gl_wtriangle: void gl_wtriangle(int x0 , int y0 , int xd0 , int yd0 , int z0 , int x1 , int y1 , int xd1 , int yd1 , int z1 , int x2 , int y2 , int xd2 , int yd2 , int z2 , TD_tridata * tri );
#request_init:struct request_info *request_init(request, key, value, ..., 0)
#request_set:struct request_info *request_set(request, key, value, ..., 0)
#hosts_access:int hosts_access(request)
#hosts_ctl:int hosts_ctl(daemon, client_name, client_addr, client_user)
#hsearch: ENTRY *hsearch(ENTRY item , ACTION action );
#hcreate: int hcreate(unsigned nel );
#hdestroy: void hdestroy(void);
#hypot: double hypot(double x , double y );
#index: char *index(const char * s , int c );
#rindex: char *rindex(const char * s , int c );
#inet_aton: int inet_aton(const char * cp , struct in_addr * inp );
#inet_addr: unsigned long int inet_addr(const char * cp );
#inet_network: unsigned long int inet_network(const char * cp );
#inet_ntoa: char *inet_ntoa(struct in_addr in );
#inet_makeaddr: struct in_addr inet_makeaddr(int net , int host );
#inet_lnaof: unsigned long int inet_lnaof(struct in_addr in );
#inet_netof: unsigned long int inet_netof(struct in_addr in );
#infnan: double infnan(int error );
#initgroups: int initgroups(const char * user , gid_t group );
#insque: void insque(struct qelem * elem , struct qelem * prev );
#remque: void remque(struct qelem * elem );
#isalnum: int isalnum (int c );
#isalpha: int isalpha (int c );
#isascii: int isascii (int c );
#isblank: int isblank (int c );
#iscntrl: int iscntrl (int c );
#isdigit: int isdigit (int c );
#isgraph: int isgraph (int c );
#islower: int islower (int c );
#isprint: int isprint (int c );
#ispunct: int ispunct (int c );
#isspace: int isspace (int c );
#isupper: int isupper (int c );
#isxdigit: int isxdigit (int c );
#isatty: int isatty ( int desc );
#isinf: int isinf(double value );
#isnan: int isnan(double value );
#finite: int finite(double value );
#j0: double j0(double x );
#j1: double j1(double x );
#jn: double jn(int n , double x );
#y0: double y0(double x );
#y1: double y1(double x );
#yn: double yn(int n , double x );
#joystick_close: void joystick_close(int joydev );
#joystick_getaxis: char joystick_getaxis(int joydev , int a );
#joystick_getbutton: char joystick_getbutton(int joydev , int b );
#joystick_getnumaxes: char joystick_getnumaxes(int joydev );
#joystick_getnumbuttons: char joystick_getnumbuttons(int joydev );
#void: typedef void (* __joystick_output ) (const char * msg );
#joystick_init: int joystick_init(int joydev , __joystick_output jo );
#void: typedef void (* __joystick_handler ) (int event , int number , char
#joystick_sethandler: void joystick_sethandler(int joydev , __joystick_handler jh );
#joystick_setdefaulthandler: void joystick_setdefaulthandler(int joydev );
#joystick_update: int joystick_update(void);
#keyboard_clearstate: void keyboard_clearstate(void);
#keyboard_close: void keyboard_close(void);
#keyboard_getstate: char *keyboard_getstate(void);
#keyboard_init: int keyboard_init(void);
#keyboard_init_return_fd: int keyboard_init_return_fd(void);
#keyboard_keypressed: int keyboard_keypressed(int scancode );
#void: typedef void (* __keyboard_handler ) (int scancode , int press );
#keyboard_seteventhandler: void keyboard_seteventhandler(__keyboard_handler handler );
#keyboard_setdefaulteventhandler: void keyboard_setdefaulteventhandler(void);
#keyboard_translatekeys: void keyboard_translatekeys(int mask );
#keyboard_update: int keyboard_update(void);
#keyboard_waitforupdate: void keyboard_waitforupdate(void);
#keybound:int keybound(int keycode, int count);
#keyok:int keyok(int keycode, bool enable);
#killpg: int killpg(pid_t pidgrp , int signal );
#labs: long int labs(long int j );
#ldexp: double ldexp(double x , int exp );
#ldiv: ldiv_t ldiv(long int numer , long int denom );
#lgamma: double lgamma(double x );
#localeconv: struct lconv *localeconv(void);
#longjmp: void longjmp(jmp_buf env , int val );
#siglongjmp: void siglongjmp(sigjmp_buf env , int val );
#lfind: void *lfind(const void * key , const void * base , size_t * nmemb , size_t size , int (* compar )(const void *, const void *)); void *lsearch(const void * key , const void * base , size_t * nmemb , size_t size , int (* compar )(const void *, const void *));
#calloc: void *calloc(size_t nmemb , size_t size );
#malloc: void *malloc(size_t size );
#free: void free(void *ptr );
#realloc: void *realloc(void *ptr , size_t size );
#mblen: int mblen(const char * s , size_t n );
#mbstowcs: size_t mbstowcs(wchar_t * pwcs , const char * s , size_t n );
#mbtowc: int mbtowc(wchar_t * pwc , const char * s , size_t n );
#memccpy: void *memccpy(void * dest , const void * src , int c , size_t n );
#memchr: void *memchr(const void * s , int c , size_t n );
#memcmp: int memcmp(const void * s1 , const void * s2 , size_t n );
#memcpy: void *memcpy(void * dest , const void * src , size_t n );
#memfrob: void *memfrob(void * s , size_t n );
#memmem: void *memmem(const void * haystack , size_t haystacklen , const void * needle , size_t needlelen );
#memmove: void *memmove(void * dest , const void * src , size_t n );
#memset: void *memset(void * s , int c , size_t n );
#set_menu_fore:int set_menu_fore(MENU *menu, chtype attr);
#menu_fore:chtype menu_fore(const MENU *menu);
#set_menu_back:int set_menu_back(MENU *menu, chtype attr);
#menu_back:chtype menu_back(const MENU *menu);
#set_menu_grey:int set_menu_grey(MENU *menu, chtype attr);
#menu_grey:chtype menu_grey(const MENU *menu);
#set_menu_pad:int set_menu_pad(MENU *menu, int pad);
#menu_pad:int menu_pad(const MENU *menu);
#pos_menu_cursor:int pos_menu_cursor(const MENU *menu);
#menu_driver:int menu_driver(MENU *menu, int c);
#set_menu_format:int set_menu_format(MENU *menu, int rows, int cols);
#menu_format:int menu_format(const MENU *menu, int *rows, int *cols);
#set_item_init:int set_item_init(MENU *menu, void (*func)(MENU *));
#void:void (*)(MENU *) item_init(const MENU *menu);
#set_item_term:int set_item_term(MENU *menu, void (*func)(MENU *));
#void:void (*)(MENU *) item_term(const MENU *menu);
#set_menu_init:int set_menu_init(MENU *menu, void (*func)(MENU *));
#void:void (*)(MENU *) menu_init(const MENU *menu);
#set_menu_term:int set_menu_term(MENU *menu, void (*func)(MENU *));
#void:void (*)(MENU *) menu_term(const MENU *menu);
#set_menu_items:int set_menu_items(MENU *menu, ITEM **items);
#menu_items:ITEM **menu_items(const MENU *menu);
#item_count:int item_count(const MENU *menu);
#set_menu_mark:int set_menu_mark(MENU *menu, const char *mark);
#menu_mark:const char *menu_mark(const MENU *menu);
#new_menu:MENU *new_menu(ITEM **items);
#free_menu:int free_menu(MENU *menu);
#set_menu_opts:int set_menu_opts(MENU *menu, OPTIONS opts);
#menu_opts_on:int menu_opts_on(MENU *menu, OPTIONS opts);
#menu_opts_off:int menu_opts_off(MENU *menu, OPTIONS opts);
#menu_opts:OPTIONS menu_opts(const MENU *menu);
#set_menu_pattern:int set_menu_pattern(MENU *menu, const char *pattern);
#menu_pattern:char *menu_pattern(const MENU *menu);
#post_menu:int post_menu(MENU *menu);
#unpost_menu:int unpost_menu(MENU *menu);
#menu_request_name:const char *menu_request_name(int request);
#menu_request_by_name:int menu_request_by_name(const char *name);
#set_menu_spacing:int set_menu_spacing(MENU *menu, int spc_description int spc_rows, int spc_columns);
#menu_spacing:int menu_spacing(const MENU *menu, int* spc_description int* spc_rows, int* spc_columns);
#set_menu_userptr:int set_menu_userptr(MENU *menu, void *userptr);
#menu_userptr:void *menu_userptr(const MENU *menu);
#set_menu_win:int set_menu_win(MENU *menu, WINDOW *win);
#menu_win:WINDOW *menu_win(const MENU *menu);
#set_menu_sub:int set_menu_sub(MENU *menu, WINDOW *sub);
#menu_sub:WINDOW *menu_sub(const MENU *menu);
#scale_menu:int scale_menu(const MENU *menu, int *rows, int *columns);
#set_current_item:int set_current_item(MENU *menu, const ITEM *item);
#current_item:ITEM *current_item(const MENU *menu);
#set_top_row:int set_top_row(MENU *menu, int row);
#top_row:int top_row(const MENU *menu);
#item_index:int item_index(const ITEM *item);
#item_name:const char *item_name(const ITEM *item);
#item_description:const char *item_description(const ITEM *item);
#new_item:ITEM *new_item(const char *name, const char *description);
#free_item:int free_item(ITEM *item);
#set_item_opts:int set_item_opts(ITEM *item, OPTIONS opts);
#item_opts_on:int item_opts_on(ITEM *item, OPTIONS opts);
#item_opts_off:int item_opts_off(ITEM *item, OPTIONS opts);
#item_opts:OPTIONS item_opts(const ITEM *item);
#set_item_userptr:int set_item_userptr(ITEM *item, void *userptr);
#item_userptr:void *item_userptr(const ITEM *item);
#set_item_value:int set_item_value(ITEM *item, bool value);
#item_value:bool item_value(const ITEM *item);
#item_visible:bool item_visible(const ITEM *item);
#mkfifo: int mkfifo ( const char * pathname , mode_t mode );
#mkstemp: int mkstemp(char * template );
#mktemp: char *mktemp(char * template );
#modf: double modf(double x , double * iptr );
#mouse_close: void mouse_close(void);
#mouse_getcaps: int mouse_getcaps(struct MouseCaps * caps );
#mouse_getposition_6d: void mouse_getposition_6d(int * x , int * y , int * z , int * rx , int * ry , int * rz );
#mouse_setposition_6d: void mouse_setposition_6d(int x , int y , int z , int rx , int ry , int rz , int dim_mask );
#mouse_setrange_6d: void mouse_setrange_6d(int x1 , int x2 , int y1 , int y2 , int z1 , int z2 , int rx1 , int rx2 , int ry1 , int ry2 , int rz1 , int rz2 , int dim_mask );
#mouse_getx: int mouse_getx(void);
#mouse_gety: int mouse_gety(void);
#mouse_getbutton: int mouse_getbutton(void);
#mouse_init: int mouse_init(char * dev , int type , int samplerate );
#mouse_init_return_fd: int mouse_init_return_fd(char * dev , int type , int samplerate );
#void: typedef void (* __mouse_handler ) (int button , int dx , int dy , int dz
#mouse_seteventhandler: void mouse_seteventhandler(__mouse_handler handler );
#mouse_setdefaulteventhandler: void mouse_setdefaulteventhandler(void);
#mouse_setposition: void mouse_setposition(int x , int y );
#mouse_setscale: void mouse_setscale(int s );
#mouse_setwrap: void mouse_setwrap(int state );
#mouse_setxrange: void mouse_setxrange(int x1 , int x2 );
#mouse_setyrange: void mouse_setyrange(int y1 , int y2 );
#mouse_update: int mouse_update(void);
#mouse_waitforupdate: void mouse_waitforupdate(void);
#on_exit: int on_exit(void (* function )(int , void *), void * arg );
#opendir: DIR *opendir(const char * name );
#new_panel:PANEL *new_panel(WINDOW *win)
#bottom_panel:int bottom_panel(PANEL *pan)
#top_panel:int top_panel(PANEL *pan)
#show_panel:int show_panel(PANEL *pan)
#update_panels:void update_panels();
#hide_panel:int hide_panel(PANEL *pan)
#panel_window:WINDOW *panel_window(const PANEL *pan)
#replace_panel:int replace_panel(PANEL *pan, WINDOW *window)
#move_panel:int move_panel(PANEL *pan, int starty, int startx)
#panel_hidden:int panel_hidden(const PANEL *pan)
#panel_above:PANEL *panel_above(const PANEL *pan)
#panel_below:PANEL *panel_below(const PANEL *pan)
#set_panel_userptr:int set_panel_userptr(PANEL *pan, const void *ptr)
#panel_userptr:const void *panel_userptr(const PANEL *pan)
#del_panel:int del_panel(PANEL *pan)
#perror: void perror(const char *s );
#popen: FILE *popen(const char * command , const char * type );
#pclose: int pclose(FILE * stream );
#printf: int printf(const char * format , ...);
#fprintf: int fprintf(FILE * stream , const char * format , ...);
#sprintf: int sprintf(char * str , const char * format , ...);
#snprintf: int snprintf(char * str , size_t size , const char * format , ...);
#vprintf: int vprintf(const char * format , va_list ap );
#vfprintf: int vfprintf(FILE * stream , const char * format , va_list ap );
#vsprintf: int vsprintf(char * str , const char * format , va_list ap );
#vsnprintf: int vsnprintf(char * str , size_t size , const char * format , va_list ap );
#psignal: void psignal(int sig , const char * s );
#pthread_atfork:int pthread_atfork(void (*prepare)(void), void (*parent)(void), void (*child)(void));
#pthread_atfork: int pthread_atfork(void (* prepare )(void), void (* parent )(void), void (* child )(void));
#pthread_attr_init:int pthread_attr_init(pthread_attr_t *attr);
#pthread_attr_destroy:int pthread_attr_destroy(pthread_attr_t *attr);
#pthread_attr_setdetachstate:int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
#pthread_attr_getdetachstate:int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);
#pthread_attr_setschedpolicy:int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy);
#pthread_attr_getschedpolicy:int pthread_attr_getschedpolicy(const pthread_attr_t *attr, int *policy);
#pthread_attr_setschedparam:int pthread_attr_setschedparam(pthread_attr_t *attr, const struct sched_param *param);
#pthread_attr_getschedparam:int pthread_attr_getschedparam(const pthread_attr_t *attr, struct sched_param *param);
#pthread_attr_setinheritsched:int pthread_attr_setinheritsched(pthread_attr_t *attr, int inherit);
#pthread_attr_getinheritsched:int pthread_attr_getinheritsched(const pthread_attr_t *attr, int *inherit);
#pthread_attr_setscope:int pthread_attr_setscope(pthread_attr_t *attr, int scope);
#pthread_attr_getscope:int pthread_attr_getscope(const pthread_attr_t *attr, int *scope);
#pthread_attr_init: int pthread_attr_init(pthread_attr_t * attr );
#pthread_attr_destroy: int pthread_attr_destroy(pthread_attr_t * attr );
#pthread_attr_setdetachstate: int pthread_attr_setdetachstate(pthread_attr_t * attr , int detachstate );
#pthread_attr_getdetachstate: int pthread_attr_getdetachstate(const pthread_attr_t * attr , int * detachstate );
#pthread_attr_setschedpolicy: int pthread_attr_setschedpolicy(pthread_attr_t * attr , int policy );
#pthread_attr_getschedpolicy: int pthread_attr_getschedpolicy(const pthread_attr_t * attr , int * policy );
#pthread_attr_setschedparam: int pthread_attr_setschedparam(pthread_attr_t * attr , const struct sched_param * param );
#pthread_attr_getschedparam: int pthread_attr_getschedparam(const pthread_attr_t * attr , struct sched_param * param );
#pthread_attr_setinheritsched: int pthread_attr_setinheritsched(pthread_attr_t * attr , int inherit );
#pthread_attr_getinheritsched: int pthread_attr_getinheritsched(const pthread_attr_t * attr , int * inherit );
#pthread_attr_setscope: int pthread_attr_setscope(pthread_attr_t * attr , int scope );
#pthread_attr_getscope: int pthread_attr_getscope(const pthread_attr_t * attr , int * scope );
#pthread_cancel:int pthread_cancel(pthread_t thread);
#pthread_setcancelstate:int pthread_setcancelstate(int state, int *oldstate);
#pthread_setcanceltype:int pthread_setcanceltype(int type, int *oldtype);
#pthread_testcancel:void pthread_testcancel(void);
#pthread_cancel: int pthread_cancel(pthread_t thread );
#pthread_setcancelstate: int pthread_setcancelstate(int state , int * oldstate );
#pthread_setcanceltype: int pthread_setcanceltype(int type , int * oldtype );
#pthread_testcancel: void pthread_testcancel(void);
#pthread_cleanup_push:void pthread_cleanup_push(void (*routine) (void *), void *arg);
#pthread_cleanup_pop:void pthread_cleanup_pop(int execute);
#pthread_cleanup_push_defer_np:void pthread_cleanup_push_defer_np(void (*routine) (void *), void *arg);
#pthread_cleanup_pop_restore_np:void pthread_cleanup_pop_restore_np(int execute);
#pthread_cleanup_push: void pthread_cleanup_push(void (* routine ) (void *), void * arg );
#pthread_cleanup_pop: void pthread_cleanup_pop(int execute );
#pthread_cleanup_push_defer_np: void pthread_cleanup_push_defer_np(void (* routine ) (void *), void * arg );
#pthread_cleanup_pop_restore_np: void pthread_cleanup_pop_restore_np(int execute );
#pthread_cond_init:int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);
#pthread_cond_signal:int pthread_cond_signal(pthread_cond_t *cond);
#pthread_cond_broadcast:int pthread_cond_broadcast(pthread_cond_t *cond);
#pthread_cond_wait:int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
#pthread_cond_timedwait:int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);
#pthread_cond_destroy:int pthread_cond_destroy(pthread_cond_t *cond);
#pthread_cond_init: int pthread_cond_init(pthread_cond_t * cond , pthread_condattr_t * cond_attr );
#pthread_cond_signal: int pthread_cond_signal(pthread_cond_t * cond );
#pthread_cond_broadcast: int pthread_cond_broadcast(pthread_cond_t * cond );
#pthread_cond_wait: int pthread_cond_wait(pthread_cond_t * cond , pthread_mutex_t * mutex );
#pthread_cond_timedwait: int pthread_cond_timedwait(pthread_cond_t * cond , pthread_mutex_t * mutex , const struct timespec * abstime );
#pthread_cond_destroy: int pthread_cond_destroy(pthread_cond_t * cond );
#pthread_condattr_init:int pthread_condattr_init(pthread_condattr_t *attr);
#pthread_condattr_destroy:int pthread_condattr_destroy(pthread_condattr_t *attr);
#pthread_condattr_init: int pthread_condattr_init(pthread_condattr_t * attr );
#pthread_condattr_destroy: int pthread_condattr_destroy(pthread_condattr_t * attr );
#pthread_create:int pthread_create(pthread_t * thread, pthread_attr_t * attr, void * (*start_routine)(void *), void * arg);
#pthread_create: int pthread_create(pthread_t * thread , pthread_attr_t * attr , void * (* start_routine )(void *), void * arg );
#pthread_detach:int pthread_detach(pthread_t th);
#pthread_detach: int pthread_detach(pthread_t th );
#pthread_equal:int pthread_equal(pthread_t thread1, pthread_t thread2);
#pthread_equal: int pthread_equal(pthread_t thread1 , pthread_t thread2 );
#pthread_exit:void pthread_exit(void *retval);
#pthread_exit: void pthread_exit(void * retval );
#pthread_join:int pthread_join(pthread_t th, void **thread_return);
#pthread_join: int pthread_join(pthread_t th , void ** thread_return );
#pthread_key_create:int pthread_key_create(pthread_key_t *key, void (*destr_function) (void *));
#pthread_key_delete:int pthread_key_delete(pthread_key_t key);
#pthread_setspecific:int pthread_setspecific(pthread_key_t key, const void *pointer);
#pthread_getspecific:void * pthread_getspecific(pthread_key_t key);
#pthread_key_create: int pthread_key_create(pthread_key_t * key , void (* destr_function ) (void *));
#pthread_key_delete: int pthread_key_delete(pthread_key_t key );
#pthread_setspecific: int pthread_setspecific(pthread_key_t key , const void * pointer );
#pthread_getspecific: void * pthread_getspecific(pthread_key_t key );
#pthread_kill_other_threads_np:void pthread_kill_other_threads_np(void);
#pthread_kill_other_threads_np: void pthread_kill_other_threads_np(void);
#pthread_mutex_init:int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);
#pthread_mutex_lock:int pthread_mutex_lock(pthread_mutex_t *mutex));
#pthread_mutex_trylock:int pthread_mutex_trylock(pthread_mutex_t *mutex);
#pthread_mutex_unlock:int pthread_mutex_unlock(pthread_mutex_t *mutex);
#pthread_mutex_destroy:int pthread_mutex_destroy(pthread_mutex_t *mutex);
#pthread_mutex_init: int pthread_mutex_init(pthread_mutex_t * mutex , const pthread_mutexattr_t * mutexattr );
#pthread_mutex_lock: int pthread_mutex_lock(pthread_mutex_t * mutex ));
#pthread_mutex_trylock: int pthread_mutex_trylock(pthread_mutex_t * mutex );
#pthread_mutex_unlock: int pthread_mutex_unlock(pthread_mutex_t * mutex );
#pthread_mutex_destroy: int pthread_mutex_destroy(pthread_mutex_t * mutex );
#pthread_mutexattr_init:int pthread_mutexattr_init(pthread_mutexattr_t *attr);
#pthread_mutexattr_destroy:int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);
#pthread_mutexattr_setkind_np:int pthread_mutexattr_setkind_np(pthread_mutexattr_t *attr, int kind);
#pthread_mutexattr_getkind_np:int pthread_mutexattr_getkind_np(const pthread_mutexattr_t *attr, int *kind);
#pthread_mutexattr_init: int pthread_mutexattr_init(pthread_mutexattr_t * attr );
#pthread_mutexattr_destroy: int pthread_mutexattr_destroy(pthread_mutexattr_t * attr );
#pthread_mutexattr_setkind_np: int pthread_mutexattr_setkind_np(pthread_mutexattr_t * attr , int kind );
#pthread_mutexattr_getkind_np: int pthread_mutexattr_getkind_np(const pthread_mutexattr_t * attr , int * kind );
#pthread_once:int pthread_once(pthread_once_t *once_control, void (*init_routine) (void));
#pthread_once: int pthread_once(pthread_once_t * once_control , void (* init_routine ) (void));
#pthread_self:pthread_t pthread_self(void);
#pthread_self: pthread_t pthread_self(void);
#pthread_setschedparam:int pthread_setschedparam(pthread_t target_thread, int policy, const struct sched_param *param);
#pthread_getschedparam:int pthread_getschedparam(pthread_t target_thread, int *policy, struct sched_param *param);
#pthread_setschedparam: int pthread_setschedparam(pthread_t target_thread , int policy , const struct sched_param * param );
#pthread_getschedparam: int pthread_getschedparam(pthread_t target_thread , int * policy , struct sched_param * param );
#pthread_sigmask:int pthread_sigmask(int how, const sigset_t *newmask, sigset_t *oldmask);
#pthread_kill:int pthread_kill(pthread_t thread, int signo);
#sigwait:int sigwait(const sigset_t *set, int *sig);
#pthread_sigmask: int pthread_sigmask(int how , const sigset_t * newmask , sigset_t * oldmask );
#pthread_kill: int pthread_kill(pthread_t thread , int signo );
#sigwait: int sigwait(const sigset_t * set , int * sig );
#putenv: int putenv(const char * string );
#putpwent: int putpwent(const struct passwd * p , FILE * stream );
#fputc: int fputc(int c , FILE * stream );
#fputs: int fputs(const char * s , FILE * stream );
#putc: int putc(int c , FILE * stream );
#putchar: int putchar(int c );
#puts: int puts(const char * s );
#ungetc: int ungetc(int c , FILE * stream );
#qsort: void qsort(void * base , size_t nmemb , size_t size , int (* compar )(const void *, const void *))
#raise: int raise (int sig );
#rand: int rand(void);
#srand: void srand(unsigned int seed );
#random: long int random(void);
#srandom: void srandom(unsigned int seed );
#initstate: char *initstate(unsigned int seed , char * state , int n );
#setstate: char *setstate(char * state );
#re_comp: char *re_comp(char * regex );
#re_exec: int re_exec(char * string );
#readdir: struct dirent *readdir(DIR * dir );
#Function:typedef int Function ();
#readline:char *readline (prompt)
#rl_add_defun:int rl_add_defun (name, function, key)
#rl_bind_key:int rl_bind_key (key, function)
#rl_unbind_key:int rl_unbind_key (key)
#rl_bind_key_in_map:int rl_bind_key_in_map (key, function, keymap)
#rl_unbind_key_in_map:int rl_unbind_key_in_map (key, keymap)
#rl_macro_bind:int rl_macro_bind (keyseq, macro, keymap)
#rl_variable_bind:int rl_variable_bind (variable, value)
#rl_parse_and_bind:int rl_parse_and_bind (line)
#rl_translate_keyseq:int rl_translate_keyseq (keyseq, array, len)
#rl_named_function:Function *rl_named_function (command)
#rl_function_of_keyseq:Function *rl_function_of_keyseq (keyseq, keymap, type)
#rl_invoking_keyseqs:char **rl_invoking_keyseqs (function)
#rl_invoking_keyseqs_in_map:char **rl_invoking_keyseqs_in_map (function, keymap)
#rl_function_dumper:void rl_function_dumper (readable)
#rl_funmap_names:char **rl_funmap_names ()
#readv: int readv(int filedes , const struct iovec * vector , size_t count );
#writev: int writev(int filedes , const struct iovec * vector , size_t count );
#realpath: char *realpath(char * path , char resolved_path[] ); 
#: ('u int regcomp(regex_t * preg , const char * regex , int cflags ); ('u int regexec(const regex_t * preg , const char * string , size_t nmatch , regmatch_t pmatch[] , int eflags ); ('u size_t regerror(int errcode , const regex_t * preg , char * errbuf , size_t errbuf_size ); (' void regfree(regex_t * preg );
#remove: int remove(const char * pathname );
#resizeterm:int resizeterm(int lines, int columns);
#res_init: int res_init(void);
#res_query: int res_query(const char * dname , int class , int type , unsigned char * answer , int anslen );
#res_search: int res_search(const char * dname , int class , int type , unsigned char * answer , int anslen );
#res_querydomain: int res_querydomain(const char * name , const char * domain , int class , int type , unsigned char * answer , int anslen );
#res_mkquery: int res_mkquery(int op , const char * dname , int class , int type , char * data , int datalen , struct rrec * newrr , char * buf , int buflen );
#res_send: int res_send(const char * msg , int msglen , char * answer , int anslen );
#dn_comp: int dn_comp(unsigned char * exp_dn , unsigned char * comp_dn , int length , unsigned char ** dnptrs , unsigned char * exp_dn , unsigned char ** lastdnptr );
#dn_expand: int dn_expand(unsigned char * msg , unsigned char * eomorig , unsigned char * comp_dn , unsigned char * exp_dn , int length );
#rewinddir: void rewinddir(DIR * dir );
#rint: double rint(double x );
#scandir: int scandir(const char * dir , struct dirent *** namelist , int (* select )(const struct dirent *), int (* compar )(const struct dirent **, const struct dirent **)); int alphasort(const struct dirent ** a , const struct dirent ** b );
#scanf: int scanf( const char * format , ... );
#fscanf: int fscanf( FILE * stream , const char * format , ... );
#sscanf: int sscanf( const char * str , const char * format , ... );
#vscanf: int vscanf( const char * format , va_list ap );
#vsscanf: int vsscanf( const char * str , const char * format , va_list ap );
#vfscanf: int vfscanf( FILE * stream , const char * format , va_list ap );
#seekdir: void seekdir(DIR * dir , off_t offset );
#sem_init:int sem_init(sem_t *sem, int pshared, unsigned int value);
#sem_wait:int sem_wait(sem_t * sem);
#sem_trywait:int sem_trywait(sem_t * sem);
#sem_post:int sem_post(sem_t * sem);
#sem_getvalue:int sem_getvalue(sem_t * sem, int * sval);
#sem_destroy:int sem_destroy(sem_t * sem);
#sem_init: int sem_init(sem_t * sem , int pshared , unsigned int value );
#sem_wait: int sem_wait(sem_t * sem );
#sem_trywait: int sem_trywait(sem_t * sem );
#sem_post: int sem_post(sem_t * sem );
#sem_getvalue: int sem_getvalue(sem_t * sem , int * sval );
#sem_destroy: int sem_destroy(sem_t * sem );
#setbuf: int setbuf(FILE * stream , char * buf );
#setbuffer: int setbuffer(FILE * stream , char * buf , size_t size );
#setlinebuf: int setlinebuf(FILE * stream );
#setvbuf: int setvbuf(FILE * stream , char * buf , int mode , size_t size );
#setenv: int setenv(const char * name , const char * value , int overwrite );
#unsetenv: void unsetenv(const char * name );
#setjmp: int setjmp(jmp_buf env );
#sigsetjmp: int sigsetjmp(sigjmp_buf env , int savesigs );
#setlocale: char *setlocale(int category , const char * locale );
#getspent: struct spwd *getspent();
#getspnam: struct spwd *getspnam(char *name );
#setspent: void setspent();
#endspent: void endspent();
#fgetspent: struct spwd *fgetspent(FILE *fp );
#sgetspent: struct spwd *sgetspent(char *cp );
#putspent: int putspent(struct spwd *p, FILE *fp );
#lckpwdf: int lckpwdf();
#ulckpwdf: int ulckpwdf();
#siginterrupt: int siginterrupt(int sig , int flag );
#sigemptyset: int sigemptyset(sigset_t * set );
#sigfillset: int sigfillset(sigset_t * set );
#sigaddset: int sigaddset(sigset_t * set , int signum );
#sigdelset: int sigdelset(sigset_t * set , int signum );
#sigismember: int sigismember(const sigset_t * set , int signum );
#sin: double sin(double x );
#sinh: double sinh(double x );
#sleep: unsigned int sleep(unsigned int seconds );
#snprintf: int snprintf ( char * str , size_t n , const char * format , ... );
#vsnprintf: int vsnprintf ( char * str , size_t n , const char * format , va_list ap );
#sqrt: double sqrt(double x );
#va_start: void va_start( va_list ap , last );
#va_arg: type va_arg( va_list ap , type );
#va_end: void va_end( va_list ap );
#stpcpy: char *stpcpy(char * dest , const char * src );
#strcasecmp: int strcasecmp(const char * s1 , const char * s2 );
#strncasecmp: int strncasecmp(const char * s1 , const char * s2 , size_t n );
#strcat: char *strcat(char * dest , const char * src );
#strncat: char *strncat(char * dest , const char * src , size_t n );
#strchr: char *strchr(const char * s , int c );
#strrchr: char *strrchr(const char * s , int c );
#strcmp: int strcmp(const char * s1 , const char * s2 );
#strncmp: int strncmp(const char * s1 , const char * s2 , size_t n );
#strcoll: int strcoll(const char * s1 , const char * s2 );
#strcpy: char *strcpy(char * dest , const char * src );
#strncpy: char *strncpy(char * dest , const char * src , size_t n );
#strdup: char *strdup(const char * s );
#strerror: char *strerror(int errnum );
#strfry: char *strfry(char * string );
#strftime: size_t strftime(char * s , size_t max , const char * format , const struct tm * tm );
#strcasecmp: int strcasecmp(const char * s1 , const char * s2 );
#strcat: char *strcat(char * dest , const char * src );
#strchr: char *strchr(const char * s , int c );
#strcmp: int strcmp(const char * s1 , const char * s2 );
#strcoll: int strcoll(const char * s1 , const char * s2 );
#strcpy: char *strcpy(char * dest , const char * src );
#strcspn: size_t strcspn(const char * s , const char * reject );
#strdup: char *strdup(const char * s );
#strfry: char *strfry(char * string );
#strlen: size_t strlen(const char * s );
#strncat: char *strncat(char * dest , const char * src , size_t n );
#strncmp: int strncmp(const char * s1 , const char * s2 , size_t n );
#strncpy: char *strncpy(char * dest , const char * src , size_t n );
#strncasecmp: int strncasecmp(const char * s1 , const char * s2 , size_t n );
#strpbrk: char *strpbrk(const char * s , const char * accept );
#strrchr: char *strrchr(const char * s , int c );
#strsep: char *strsep(char ** stringp , const char * delim );
#strspn: size_t strspn(const char * s , const char * accept );
#strstr: char *strstr(const char * haystack , const char * needle );
#strtok: char *strtok(char * s , const char * delim );
#strxfrm: size_t strxfrm(char * dest , const char * src , size_t n );
#index: char *index(const char * s , int c );
#rindex: char *rindex(const char * s , int c );
#strlen: size_t strlen(const char * s );
#strpbrk: char *strpbrk(const char * s , const char * accept );
#strptime: char *strptime(char * buf , const char * format , const struct tm * tm );
#strsep: char *strsep(char ** stringp , const char * delim );
#strsignal: char *strsignal(int sig );
#strspn: size_t strspn(const char * s , const char * accept );
#strcspn: size_t strcspn(const char * s , const char * reject );
#strstr: char *strstr(const char * haystack , const char * needle );
#strtod: double strtod(const char * nptr , char ** endptr );
#strtok: char *strtok(char * s , const char * delim );
#strtol: long int strtol(const char * nptr , char ** endptr , int base );
#strtoul: unsigned long int strtoul(const char * nptr , char ** endptr , int base )
#strxfrm: size_t strxfrm(char * dest , const char * src , size_t n );
#swab: void swab(const void * from , void * to , size_t n );
#sysconf: long sysconf(int name );
#openlog: void openlog( char *ident , int option , int facility )
#syslog: void syslog( int priority , char *format , ...)
#closelog: void closelog( void )
#system: int system (const char * string );
#tan: double tan(double x );
#tanh: double tanh(double x );
#telldir: off_t telldir(DIR * dir );
#tempnam: char *tempnam(const char * dir , const char * pfx );
#tcgetattr: int tcgetattr ( int fd , struct termios * termios_p );
#tcsetattr: int tcsetattr ( int fd , int optional_actions , struct termios * termios_p );
#tcsendbreak: int tcsendbreak ( int fd , int duration );
#tcdrain: int tcdrain ( int fd );
#tcflush: int tcflush ( int fd , int queue_selector );
#tcflow: int tcflow ( int fd , int action );
#cfmakeraw: int cfmakeraw ( struct termios * termios_p );
#cfgetospeed: speed_t cfgetospeed ( struct termios * termios_p );
#cfsetospeed: int cfsetospeed ( struct termios * termios_p , speed_t speed );
#cfgetispeed: speed_t cfgetispeed ( struct termios * termios_p );
#cfsetispeed: int cfsetispeed ( struct termios * termios_p , speed_t speed );
#tcgetpgrp: pid_t tcgetpgrp ( int fd );
#tcsetpgrp: int tcsetpgrp ( int fd , pid_t pgrpid );
#tmpfile: FILE *tmpfile (void);
#tmpnam: char *tmpnam(char * s );
#toascii: int toascii (int c );
#toupper: int toupper (int c );
#tolower: int tolower (int c );
#tsearch: void *tsearch (const void * key , void ** rootp , int (* compar )(const void *, const void *)); void *tfind (const void * key , const void ** rootp , int (* compar )(const void *, const void *)); void *tdelete (const void * key , void ** rootp , int (* compar )(const void *, const void *)); void twalk (const void * root , void (* action ) (const void * nodep , const VISIT which , const int depth ));
#ttyname: char *ttyname ( int desc );
#tzset: void tzset (void);
#updwtmp: void updwtmp(const char * wtmp_file , const struct utmp * ut );
#logwtmp: void logwtmp(const char * line , const char * name , const char * host );
#usleep: void usleep(unsigned long usec );
#vga_accel: int vga_accel(unsigned operation , ... );
#vga_bitblt: void vga_bitblt(int srcaddr , int destaddr , int w , int h , int pitch );
#vga_blitwait: void vga_blitwait(void);
#vga_claimvideomemory: int vga_claimvideomemory(int m );
#vga_clear: int vga_clear(void);
#vga_copytoplanar16: void vga_copytoplanar16(unsigned char * virtual , int pitch , int voffset , int vpitch , int w , int h );
#vga_copytoplanar256: void vga_copytoplanar256(unsigned char * virtual , int pitch , int voffset , int vpitch , int w , int h );
#vga_copytoplane: void vga_copytoplane(unsigned char * virtual , int pitch , int voffset , int vpitch , int w , int h , int plane );
#vga_disabledriverreport: void vga_disabledriverreport(void);
#vga_drawline: int vga_drawline(int x1 , int y1 , int x2 , int y2 );
#vga_drawpixel: int vga_drawpixel(int x , int y );
#vga_drawscanline: int vga_drawscanline(int line , unsigned char * color );
#vga_drawscansegment: int vga_drawscansegment(unsigned char * colors , int x , int y , int length );
#vga_dumpregs: int vga_dumpregs(void);
#vga_ext_set: int vga_ext_set(unsigned what , ... );
#vga_fillblt: void vga_fillblt(int destaddr , int w , int h , int pitch , int color );
#vga_flip: int vga_flip(void);
#vga_getch: int vga_getch(void);
#vga_getcurrentchipset: int vga_getcurrentchipset(void);
#vga_getcurrentmode: int vga_getcurrentmode(void);
#vga_getdefaultmode: int vga_getdefaultmode(void);
#vga_getgraphmem: unsigned char *vga_getgraphmem(void);
#vga_getkey: int vga_getkey(void);
#vga_getmodeinfo: vga_modeinfo *vga_getmodeinfo(int mode );
#vga_getmodename: char *vga_getmodename(int mode );
#vga_getmodenumber: int vga_getmodenumber(char * name );
#vga_getmonitortype: int vga_getmonitortype(void);
#vga_getmousetype: int vga_getmousetype(void);
#vga_getpalette: void vga_getpalette(int index , int * r , int * g , int * b );
#vga_getpalvec: int vga_getpalvec(int start , int num , int * pal );
#vga_getpixel: int vga_getpixel(int x , int y );
#vga_getscansegment: int vga_getscansegment(unsigned char * colors , int x , int y , int length );
#vga_gettextfont: void vga_gettextfont(void *font);
#vga_puttextfont: void vga_puttextfont(void *font);
#vga_gettextmoderegs: void vga_gettextmoderegs(void *state);
#vga_settextmoderegs: void vga_settextmoderegs(void *state);
#vga_getxdim: int vga_getxdim(void);
#vga_getydim: int vga_getydim(void);
#vga_getcolors: int vga_getcolors(void);
#vga_hasmode: int vga_hasmode(int mode );
#vga_hlinelistblt: void vga_hlinelistblt(int ymin , int n , int * xmin , int * xmax , int pitch , int c );
#vga_imageblt: void vga_imageblt(void * srcaddr , int destaddr , int w , int h , int pitch );
#vga_init: int vga_init(void);
#vga_lastmodenumber: int vga_lastmodenumber(void);
#vga_lockvc: void vga_lockvc(void);
#vga_oktowrite: int vga_oktowrite(void);
#vga_runinbackground: void vga_runinbackground(int stat );
#vga_runinbackground_version: int vga_runinbackground_version(void);
#vga_safety_fork: void vga_safety_fork(void (* shutdown_routine )(void))
#vga_screenoff: int vga_screenoff(void);
#vga_screenon: int vga_screenon(void);
#vga_setchipset: void vga_setchipset(int chipset );
#vga_setchipsetandfeatures: void vga_setchipsetandfeatures(int chipset , int par1 , int par2 );
#vga_setcolor: void vga_setcolor(int color );
#vga_setdisplaystart: void vga_setdisplaystart(int a );
#vga_setegacolor: void vga_setegacolor(int color );
#vga_setflipchar: int vga_setflipchar(int c );
#vga_setlinearaddressing: int vga_setlinearaddressing(void);
#vga_setlogicalwidth: void vga_setlogicalwidth(int l );
#vga_setmode: int vga_setmode(int mode );
#vga_setmodeX: void vga_setmodeX(void);
#vga_setmousesupport: void vga_setmousesupport(int stat );
#vga_setpage: void vga_setpage(int page );
#vga_setpalette: void vga_setpalette(int index , int r , int g , int b );
#vga_setpalvec: int vga_setpalvec(int start , int num , int * pal );
#vga_setreadpage: void vga_setreadpage(int page );
#vga_setrgbcolor: void vga_setrgbcolor(int r , int g , int b );
#vga_setwritepage: void vga_setwritepage(int page );
#vga_unlockvc: void vga_unlockvc(void);
#vga_waitevent: int vga_waitevent(int which , fd_set * input , fd_set * output , fd_set * except , struct timeval * timeout)
#vga_waitretrace: void vga_waitretrace(void);
#vga_white: int vga_white(void);
#wcstombs: size_t wcstombs(char * s , const wchar_t * pwcs , size_t n );
#wctomb: int wctomb(char * s , wchar_t wchar );
#wresize:int wresize(WINDOW *win, int lines, int columns);
#BlackPixel:BlackPixel(display, screen_number)
#WhitePixel:WhitePixel(display, screen_number)
#ConnectionNumber:ConnectionNumber(display)
#DefaultColormap:DefaultColormap(display, screen_number)
#DefaultDepth:DefaultDepth(display, screen_number)
#XListDepths:int *XListDepths(display, screen_number, count_return)
#DefaultGC:DefaultGC(display, screen_number)
#DefaultRootWindow:DefaultRootWindow(display)
#DefaultScreenOfDisplay:DefaultScreenOfDisplay(display)
#DefaultScreen:DefaultScreen(display)
#DefaultVisual:DefaultVisual(display, screen_number)
#DisplayCells:DisplayCells(display, screen_number)
#DisplayPlanes:DisplayPlanes(display, screen_number)
#DisplayString:DisplayString(display)
#XMaxRequestSize:long XMaxRequestSize(display)
#XExtendedMaxRequestSize:long XExtendedMaxRequestSize(display)
#LastKnownRequestProcessed:LastKnownRequestProcessed(display)
#NextRequest:NextRequest(display)
#ProtocolVersion:ProtocolVersion(display)
#ProtocolRevision:ProtocolRevision(display)
#QLength:QLength(display)
#RootWindow:RootWindow(display, screen_number)
#ScreenCount:ScreenCount(display)
#ScreenOfDisplay:ScreenOfDisplay(display, screen_number)
#ServerVendor:ServerVendor(display)
#VendorRelease:VendorRelease(display)
#BlackPixelOfScreen:BlackPixelOfScreen(screen)
#WhitePixelOfScreen:WhitePixelOfScreen(screen)
#CellsOfScreen:CellsOfScreen(screen)
#DefaultColormapOfScreen:DefaultColormapOfScreen(screen)
#DefaultDepthOfScreen:DefaultDepthOfScreen(screen)
#DefaultGCOfScreen:DefaultGCOfScreen(screen)
#DefaultVisualOfScreen:DefaultVisualOfScreen(screen)
#DoesBackingStore:DoesBackingStore(screen)
#DoesSaveUnders:DoesSaveUnders(screen)
#DisplayOfScreen:DisplayOfScreen(screen)
#XScreenNumberOfScreen:int XScreenNumberOfScreen(screen)
#EventMaskOfScreen:EventMaskOfScreen(screen)
#HeightOfScreen:HeightOfScreen(screen)
#HeightMMOfScreen:HeightMMOfScreen(screen)
#MaxCmapsOfScreen:MaxCmapsOfScreen(screen)
#MinCmapsOfScreen:MinCmapsOfScreen(screen)
#PlanesOfScreen:PlanesOfScreen(screen)
#RootWindowOfScreen:RootWindowOfScreen(screen)
#WidthOfScreen:WidthOfScreen(screen)
#WidthMMOfScreen:WidthMMOfScreen(screen)
#Extension:The Double Buffer Extension (DBE) provides a standard way to utilize
#DisplayOfCCC:DisplayOfCCC(ccc)
#VisualOfCCC:VisualOfCCC(ccc)
#ScreenNumberOfCCC:ScreenNumberOfCCC(ccc)
#ScreenWhitePointOfCCC:ScreenWhitePointOfCCC(ccc)
#ClientWhitePointOfCCC:ClientWhitePointOfCCC(ccc)
#XListPixmapFormats:XPixmapFormatValues *XListPixmapFormats(display, count_return)
#ImageByteOrder:ImageByteOrder(display)
#BitmapBitOrder:BitmapBitOrder(display)
#BitmapPad:BitmapPad(display)
#BitmapUnit:BitmapUnit(display)
#DisplayHeight:DisplayHeight(display, screen_number)
#DisplayHeightMM:DisplayHeightMM(display, screen_number)
#DisplayWidth:DisplayWidth(display, screen_number)
#DisplayWidthMM:DisplayWidthMM(display, screen_number)
#IsCursorKey:IsCursorKey(keysym)
#IsFunctionKey:IsFunctionKey(keysym)
#IsKeypadKey:IsKeypadKey(keysym)
#IsMiscFunctionKey:IsMiscFunctionKey(keysym)
#IsModifierKey:IsModifierKey(keysym)
#IsPFKey:IsPFKey(keysym)
#IsPrivateKeypadKey:IsPrivateKeypadKey(keysym)
#void:typedef void (*XConnectionWatchProc)(display, client_data, fd, opening, watch_data)
#XAddConnectionWatch:Status XAddConnectionWatch(display, procedure, client_data)
#XRemoveConnectionWatch:Status XRemoveConnectionWatch(display, procedure, client_data)
#XProcessInternalConnection:void XProcessInternalConnection(display, fd)
#XProcessInternalConnection:void XProcessInternalConnection(display, fd)
#XInternalConnectionNumbers:Status XInternalConnectionNumbers(display, fd_return, count_return)
#XAddHost:XAddHost(display, host)
#XAddHosts:XAddHosts(display, hosts, num_hosts)
#XListHosts:XHostAddress *XListHosts(display, nhosts_return, state_return)
#XRemoveHost:XRemoveHost(display, host)
#XRemoveHosts:XRemoveHosts(display, hosts, num_hosts)
#XSetAccessControl:XSetAccessControl(display, mode)
#XEnableAccessControl:XEnableAccessControl(display)
#XDisableAccessControl:XDisableAccessControl(display)
#XAllocClassHint:XClassHint *XAllocClassHint()
#XSetClassHint:XSetClassHint(display, w, class_hints)
#XGetClassHint:Status XGetClassHint(display, w, class_hints_return)
#XAllocColor:Status XAllocColor(display, colormap, screen_in_out)
#XAllocNamedColor:Status XAllocNamedColor(display, colormap, fIcolor_name, screen_def_return, exact_def_return)
#XAllocColorCells:Status XAllocColorCells(display, colormap, contig, fIplane_masks_return, nplanes, pixels_return, npixels)
#XAllocColorPlanes:Status XAllocColorPlanes(display, colormap, contig, pixels_return, ncolors, nreds, ngreens, nblues, rmask_return, gmask_return, bmask_return)
#XFreeColors:XFreeColors(display, colormap, pixels, npixels, planes)
#XAllocIconSize:XIconSize *XAllocIconSize()
#XSetIconSizes:XSetIconSizes(display, w, size_list, count)
#XGetIconSizes:Status XGetIconSizes(display, w, size_list_return, count_return)
#XAllocSizeHints:XSizeHints *XAllocSizeHints()
#XSetWMNormalHints:void XSetWMNormalHints(display, w, hints)
#XGetWMNormalHints:Status XGetWMNormalHints(display, w, hints_return, fIsupplied_return)
#XSetWMSizeHints:void XSetWMSizeHints(display, w, hints, property)
#XGetWMSizeHints:Status XGetWMSizeHints(display, w, hints_return, fIsupplied_return, property)
#XAllocStandardColormap:XStandardColormap *XAllocStandardColormap()
#XSetRGBColormaps:void XSetRGBColormaps(display, w, std_colormap, fIcount, property)
#XGetRGBColormaps:Status XGetRGBColormaps(display, w, std_colormap_return, fIcount_return, property)
#XAllocWMHints:XWMHints *XAllocWMHints()
#XSetWMHints:XSetWMHints(display, w, wmhints)
#XGetWMHints:XWMHints *XGetWMHints(display, w)
#XAllowDeviceEvents:XAllowDeviceEvents(display, device, event_mode, time)
#XAllowEvents:XAllowEvents(display, event_mode, time)
#XChangeDeviceDontPropagateList:XChangeDeviceDontPropagateList(display, window,count, event_list, mode)
#XGetDeviceDontPropagateList:XEventClass *XGetDeviceDontPropagateList(display, window, count)
#XChangeKeyboardControl:XChangeKeyboardControl(display, value_mask, values)
#XGetKeyboardControl:XGetKeyboardControl(display, values_return)
#XAutoRepeatOn:XAutoRepeatOn(display)
#XAutoRepeatOff:XAutoRepeatOff(display)
#XBell:XBell(display, percent)
#XQueryKeymap:XQueryKeymap(display, keys_return)
#XChangeKeyboardDevice:Status XChangeKeyboardDevice(display, device)
#XChangeKeyboardMapping:XChangeKeyboardMapping(display, first_keycode, keysyms_per_keycode, keysyms, num_codes)
#XGetKeyboardMapping:KeySym *XGetKeyboardMapping(display, first_keycode, keycode_count, keysyms_per_keycode_return)
#XDisplayKeycodes:XDisplayKeycodes(display, min_keycodes_return, fImax_keycodes_return)
#XSetModifierMapping:int XSetModifierMapping(display, modmap)
#XGetModifierMapping:XModifierKeymap *XGetModifierMapping(display)
#XNewModifiermap:XModifierKeymap *XNewModifiermap(max_keys_per_mod)
#XInsertModifiermapEntry:XModifierKeymap *XInsertModifiermapEntry(modmap, fIkeycode_entry, modifier)
#XDeleteModifiermapEntry:XModifierKeymap *XDeleteModifiermapEntry(modmap, fIkeycode_entry, modifier)
#XFreeModifiermap:XFreeModifiermap(modmap)
#XChangePointerControl:XChangePointerControl(display, do_accel, do_threshold, accel_numerator, accel_denominator, threshold)
#XGetPointerControl:XGetPointerControl(display, accel_numerator_return, accel_denominator_return, threshold_return)
#XChangePointerDevice:Status XChangePointerDevice(display, device xaxis, yaxis)
#XChangeSaveSet:XChangeSaveSet(display, w, change_mode)
#XAddToSaveSet:XAddToSaveSet(display, w)
#XRemoveFromSaveSet:XRemoveFromSaveSet(display, w)
#XChangeWindowAttributes:XChangeWindowAttributes(display, w, valuemask, attributes)
#XSetWindowBackground:XSetWindowBackground(display, w, background_pixel)
#XSetWindowBackgroundPixmap:XSetWindowBackgroundPixmap(display, w, background_pixmap)
#XSetWindowBorder:XSetWindowBorder(display, w, border_pixel)
#XSetWindowBorderPixmap:XSetWindowBorderPixmap(display, w, border_pixmap)
#XSetWindowColormap:XSetWindowColormap(display, w, colormap)
#XClearArea:XClearArea(display, w, x, y, width, height, exposures)
#XClearWindow:XClearWindow(display, w)
#XConfigureWindow:XConfigureWindow(display, w, value_mask, values)
#XMoveWindow:XMoveWindow(display, w, x, y)
#XResizeWindow:XResizeWindow(display, w, width, height)
#XMoveResizeWindow:XMoveResizeWindow(display, w, x, y, width, height)
#XSetWindowBorderWidth:XSetWindowBorderWidth(display, w, width)
#XCopyArea:XCopyArea(display, src, dest, gc, src_x, src_y, width, height, dest_x, dest_y)
#XCopyPlane:XCopyPlane(display, src, dest, gc, src_x, src_y, width, height, dest_x, dest_y, plane)
#XCreateColormap:Colormap XCreateColormap(display, w, visual, alloc)
#XCopyColormapAndFree:Colormap XCopyColormapAndFree(display, colormap)
#XFreeColormap:XFreeColormap(display, colormap)
#XCreateFontCursor:Cursor XCreateFontCursor(display, shape)
#XCreatePixmapCursor:Cursor XCreatePixmapCursor(display, source, mask, foreground_color, background_color, x, y)
#XCreateGlyphCursor:Cursor XCreateGlyphCursor(display, source_font, mask_font, source_char, mask_char, foreground_color, background_color)
#XCreateFontSet:XFontSet XCreateFontSet(display, base_font_name_list, missing_charset_list_return, missing_charset_count_return, def_string_return)
#XFreeFontSet:void XFreeFontSet(display, font_set)
#XCreateGC:GC XCreateGC(display, d, valuemask, values)
#XCopyGC:XCopyGC(display, src, valuemask, dest)
#XChangeGC:XChangeGC(display, gc, valuemask, values)
#XGetGCValues:Status XGetGCValues(display, gc, valuemask, fIvalues_return)
#XFreeGC:XFreeGC(display, gc)
#XGContextFromGC:GContext XGContextFromGC(gc)
#XCreateIC:XIC XCreateIC(im, ...)
#XDestroyIC:void XDestroyIC(ic)
#XIMOfIC:XIM XIMOfIC(ic)
#XCreateOC:XOC XCreateOC(om, ...)
#XDestroyOC:void XDestroyOC(oc)
#XSetOCValues:char * XSetOCValues(oc, ...)
#XGetOCValues:char * XGetOCValues(oc, ...)
#XOMOfOC:XOM XOMOfOC(oc)
#XCreatePixmap:Pixmap XCreatePixmap(display, d, width, height, depth)
#XFreePixmap:XFreePixmap(display, pixmap)
#XCreateRegion:Region XCreateRegion()
#XSetRegion:XSetRegion(display, gc, r)
#XDestroyRegion:XDestroyRegion(r)
#XCreateWindow:Window XCreateWindow(display, parent, x, y, width, height, border_width, depth, class, visual, valuemask, attributes)
#XCreateSimpleWindow:Window XCreateSimpleWindow(display, parent, x, y, width, height, border_width, border, background)
#XDefineCursor:XDefineCursor(display, w, cursor)
#XUndefineCursor:XUndefineCursor(display, w)
#XDestroyWindow:XDestroyWindow(display, w)
#XDestroySubwindows:XDestroySubwindows(display, w)
#XDeviceBell:Status XDeviceBell(display, device, feedbackclass, feedbackid, percent)
#XDrawArc:XDrawArc(display, d, gc, x, y, width, height, angle1, angle2)
#XDrawArcs:XDrawArcs(display, d, gc, arcs, narcs)
#XDrawImageString:XDrawImageString(display, d, gc, x, y, string, length)
#XDrawImageString16:XDrawImageString16(display, d, gc, x, y, string, length)
#XDrawLine:XDrawLine(display, d, gc, x1, y1, x2, y2)
#XDrawLines:XDrawLines(display, d, gc, points, npoints, mode)
#XDrawSegments:XDrawSegments(display, d, gc, segments, nsegments)
#XDrawPoint:XDrawPoint(display, d, gc, x, y)
#XDrawPoints:XDrawPoints(display, d, gc, points, npoints, mode)
#XDrawRectangle:XDrawRectangle(display, d, gc, x, y, width, height)
#XDrawRectangles:XDrawRectangles(display, d, gc, rectangles, nrectangles)
#XDrawString:XDrawString(display, d, gc, x, y, string, length)
#XDrawString16:XDrawString16(display, d, gc, x, y, string, length)
#XDrawText:XDrawText(display, d, gc, x, y, items, nitems)
#XDrawText16:XDrawText16(display, d, gc, x, y, items, nitems)
#XEmptyRegion:Bool XEmptyRegion(r)
#XEqualRegion:Bool XEqualRegion(r1, r2)
#XPointInRegion:Bool XPointInRegion(r, x, y)
#XRectInRegion:int XRectInRegion(r, x, y, width, height)
#XExtentsOfFontSet:XFontSetExtents *XExtentsOfFontSet(font_set)
#XF86DGAQueryExtension:Bool XF86DGAQueryExtension( Display *display, int *event_base_return, int *error_base_return);
#XF86DGAQueryVersion:Bool XF86DGAQueryVersion( Display *display, int *major_version_return, int *minor_version_return);
#XF86DGAQueryDirectVideo:Bool XF86DGAQueryDirectVideo( Display *display, int screen, int *flags_return);
#XF86DGAGetVideo:Bool XF86DGAGetVideo( Display *display, int screen, char **addr_return, int *width_return, int *banksize_return, int *memsize_return);
#XF86DGADirectVideo:Bool XF86DGADirectVideo( Display *display, int screen, int flags);
#XF86DGASetVidPage:Bool XF86DGASetVidPage( Display *display, int screen, int page);
#XF86DGASetViewPort:Bool XF86DGASetViewPort( Display *display, int screen, int x, int y);
#XF86DGAViewPortChanged:Bool XF86DGAViewPortChanged( Display *display, int screen, int num_pages);
#XF86DGAGetViewPortSize:Bool XF86DGAGetViewPortSize( Display *display, int screen, int *viewport_width_return, int *viewport_height_return);
#XF86DGAInstallColormap:Bool XF86DGAInstallColormap( Display *display, int screen, Colormap cmap);
#XF86DGAForkApp:int XF86DGAForkApp( int screen);
#XF86MiscQueryExtension:Bool XF86MiscQueryExtension( Display *display, int *event_base_return, int *error_base_return);
#XF86MiscQueryVersion:Bool XF86MiscQueryVersion( Display *display, int *major_version_return, int *minor_version_return);
#XF86MiscGetSaver:Status XF86MiscGetSaver( Display *display, int screen, int *suspend_time_return, int *off_time_return);
#XF86MiscSetSaver:Status XF86MiscSetSaver( Display *display, int screen, int suspend_time, int off_time);
#XF86MiscGetMouseSettings:Status XF86MiscGetMouseSettings( Display *display, XF86MiscMouseSettings *mseinfo);
#XF86MiscSetMouseSettings:Status XF86MiscSetMouseSettings( Display *display, XF86MiscMouseSettings *mseinfo);
#XF86MiscGetKbdSettings:Status XF86MiscGetKbdSettings( Display *display, XF86MiscKbdSettings *kbdinfo);
#XF86MiscSetKbdSettings:Status XF86MiscSetKbdSettings( Display *display, XF86MiscKbdSettings *kbdinfo);
#XF86VidModeQueryExtension:Bool XF86VidModeQueryExtension( Display *display, int *event_base_return, int *error_base_return);
#XF86VidModeQueryVersion:Bool XF86VidModeQueryVersion( Display *display, int *major_version_return, int *minor_version_return);
#XF86VidModeGetModeLine:Bool XF86VidModeGetModeLine( Display *display, int screen, int *dotclock_return, XF86VidModeModeLine *modeline);
#XF86VidModeGetAllModeLines:Bool XF86VidModeGetAllModeLines( Display *display, int screen, int *modecount_return, XF86VidModeModeInfo **modesinfo);
#XF86VidModeAddModeLine:Bool XF86VidModeAddModeLine( Display *display, int screen, XF86VidModeModeInfo *modeline XF86VidModeModeInfo *aftermode);
#XF86VidModeDeleteModeLine:Bool XF86VidModeDeleteModeLine( Display *display, int screen, XF86VidModeModeInfo *modeline);
#XF86VidModeModModeLine:Bool XF86VidModeModModeLine( Display *display, int screen, XF86VidModeModeLine *modeline);
#XF86VidModeValidateModeLine:Status XF86VidModeValidateModeLine( Display *display, int screen, XF86VidModeModeLine *modeline);
#XF86VidModeSwitchMode:Bool XF86VidModeSwitchMode( Display *display, int screen, int zoom);
#XF86VidModeSwitchToMode:Bool XF86VidModeSwitchToMode( Display *display, int screen, XF86VidModeModeInfo *modeline);
#XF86VidModeLockModeSwitch:Bool XF86VidModeLockModeSwitch( Display *display, int screen, int lock);
#XF86VidModeGetMonitor:Bool XF86VidModeGetMonitor( Display *display, int screen, XF86VidModeMonitor *monitor);
#XF86VidModeGetViewPort:Bool XF86VidModeGetViewPort( Display *display, int screen, int *x_return, int *y_return);
#XF86VidModeSetViewPort:Bool XF86VidModeSetViewPort( Display *display, int screen, int x, int y);
#XFillRectangle:XFillRectangle(display, d, gc, x, y, width, height)
#XFillRectangles:XFillRectangles(display, d, gc, rectangles, nrectangles)
#XFillPolygon:XFillPolygon(display, d, gc, points, npoints, shape, mode)
#XFillArc:XFillArc(display, d, gc, x, y, width, height, angle1, angle2)
#XFillArcs:XFillArcs(display, d, gc, arcs, narcs)
#XFilterEvent:Bool XFilterEvent(event, w)
#XFlush:XFlush(display)
#XSync:XSync(display, discard)
#XEventsQueued:int XEventsQueued(display, mode)
#XPending:int XPending(display)
#XFontsOfFontSet:int XFontsOfFontSet(font_set, font_struct_list_return, font_name_list_return)
#XBaseFontNameListOfFontSet:char *XBaseFontNameListOfFontSet(font_set)
#XLocaleOfFontSet:char *XLocaleOfFontSet(font_set)
#XContextDependentDrawing:Bool XContextDependentDrawing(font_set)
#XContextualDrawing:Bool XContextualDrawing(font_set)
#XDirectionalDependentDrawing:Bool XDirectionalDependentDrawing(font_set)
#XFree:XFree(data)
#XGetDeviceControl:XGetDeviceControl(display, device, control)
#XChangeDeviceControl:int XChangeDeviceControl(display, device, controlType, control)
#XChangeDeviceKeyMapping:XChangeDeviceKeyMapping(display, device, first_keycode, keysyms_per_keycode, keysyms, keycode_count)
#XGetDeviceKeyMapping:KeySym *XGetDeviceKeyMapping(display, device, first_keycode, keycode_count,keysyms_per_keycode_return)
#XSetDeviceModifierMapping:XSetDeviceModifierMapping(display, device, modmap)
#XGetDeviceModifierMapping:XModifierKeymap *XGetDeviceModifierMapping(display, device)
#XGetDeviceMotionEvents:XDeviceTimeCoord *XGetDeviceMotionEvents(display, device,start, stop,nevents_return, mode_return, axis_count_return)
#XGetExtensionVersion:XExtensionVersion *XGetExtensionVersion(display, name)
#XGetFeedbackControl:XGetFeedbackControl(display, device, num_feedbacks)
#XChangeFeedbackControl:int XChangeFeedbackControl(display, device, mask, control)
#XGetVisualInfo:XVisualInfo *XGetVisualInfo(display, vinfo_mask, vinfo_template, nitems_return)
#XMatchVisualInfo:Status XMatchVisualInfo(display, screen, depth, class, vinfo_return)
#XVisualIDFromVisual:VisualID XVisualIDFromVisual(visual)
#XGetWindowAttributes:Status XGetWindowAttributes(display, w, window_attributes_return)
#XGetGeometry:Status XGetGeometry(display, d, root_return, x_return, y_return, width_return, height_return, border_width_return, depth_return)
#XGetWindowProperty:int XGetWindowProperty(display, w, property, long_offset, long_length, delete, req_type, actual_type_return, actual_format_return, nitems_return, bytes_after_return, prop_return)
#XListProperties:Atom *XListProperties(display, w, num_prop_return)
#XChangeProperty:XChangeProperty(display, w, property, type, format, mode, data, nelements)
#XRotateWindowProperties:XRotateWindowProperties(display, w, properties, num_prop, npositions)
#XDeleteProperty:XDeleteProperty(display, w, property)
#XGrabButton:XGrabButton(display, button, modifiers, grab_window, owner_events, event_mask, pointer_mode, keyboard_mode, confine_to, cursor)
#XUngrabButton:XUngrabButton(display, button, modifiers, grab_window)
#XGrabDevice:int XGrabDevice(display, device, grab_window, owner_events, event_count, event_list,this_device_mode, other_devices_mode, time)
#XUngrabDevice:XUngrabDevice(display, device, time)
#XGrabDeviceButton:XGrabDeviceButton(display, device, button, modifiers, modifier_device, grab_window,owner_events, event_count, event_list, this_device_mode, other_devices_mode)
#XUngrabDeviceButton:XUngrabDeviceButton(display, device, button, modifiers, modifier_device, grab_window)
#XGrabDeviceKey:XGrabDeviceKey(display, device, Key, modifiers, modifier_device, grab_window, owner_events, event_count, event_list, this_device_mode, other_devices_mode)
#XUngrabDeviceKey:XUngrabDeviceKey(display, device, Key, modifiers, modifier_device, grab_window)
#XGrabKey:XGrabKey(display, keycode, modifiers, grab_window, owner_events, pointer_mode, keyboard_mode)
#XUngrabKey:XUngrabKey(display, keycode, modifiers, grab_window)
#XGrabKeyboard:int XGrabKeyboard(display, grab_window, owner_events, pointer_mode, keyboard_mode, time)
#XUngrabKeyboard:XUngrabKeyboard(display, time)
#XGrabPointer:int XGrabPointer(display, grab_window, owner_events, event_mask, pointer_mode, keyboard_mode, confine_to, cursor, time)
#XUngrabPointer:XUngrabPointer(display, time)
#XChangeActivePointerGrab:XChangeActivePointerGrab(display, event_mask, cursor, time)
#XGrabServer:XGrabServer(display)
#XUngrabServer:XUngrabServer(display)
#XIconifyWindow:Status XIconifyWindow(display, w, screen_number)
#XWithdrawWindow:Status XWithdrawWindow(display, w, screen_number)
#XReconfigureWMWindow:Status XReconfigureWMWindow(display, w, screen_number, fIvalue_mask, values)
#XIfEvent:XIfEvent(display, event_return, predicate, arg)
#Bool: Bool (*predicate)();
#XCheckIfEvent:Bool XCheckIfEvent(display, event_return, predicate, arg)
#Bool: Bool (*predicate)();
#XPeekIfEvent:XPeekIfEvent(display, event_return, predicate, arg)
#Bool: Bool (*predicate)();
#XInitImage:Status XInitImage(image)
#XCreateImage:XImage *XCreateImage(display, visual, depth, format, offset, data, width, height, bitmap_pad, bytes_per_line)
#XGetPixel:unsigned long XGetPixel(ximage, x, y)
#XPutPixel:XPutPixel(ximage, x, y, pixel)
#XSubImage:XImage *XSubImage(ximage, x, y, subimage_width, subimage_height)
#XAddPixel:XAddPixel(ximage, value)
#XDestroyImage:XDestroyImage(ximage)
#XInitThreads:Status XInitThreads();
#XLockDisplay:void XLockDisplay(display)
#XUnlockDisplay:void XUnlockDisplay(display)
#XInstallColormap:XInstallColormap(display, colormap)
#XUninstallColormap:XUninstallColormap(display, colormap)
#XListInstalledColormaps:Colormap *XListInstalledColormaps(display, w, num_return)
#XInternAtom:Atom XInternAtom(display, atom_name, only_if_exists)
#XInternAtoms:Status XInternAtoms(display, names, count, only_if_exists, atoms_return)
#XGetAtomName:char *XGetAtomName(display, atom)
#XGetAtomNames:Status XGetAtomNames(display, atoms, count, names_return)
#XIntersectRegion:XIntersectRegion(sra, srb, dr_return)
#XUnionRegion:XUnionRegion(sra, srb, dr_return)
#XUnionRectWithRegion:XUnionRectWithRegion(rectangle, src_region, fIdest_region_return)
#XSubtractRegion:XSubtractRegion(sra, srb, dr_return)
#XXorRegion:XXorRegion(sra, srb, dr_return)
#XOffsetRegion:XOffsetRegion(r, dx, dy)
#XShrinkRegion:XShrinkRegion(r, dx, dy)
#XListFonts:char **XListFonts(display, pattern, maxnames, actual_count_return)
#XFreeFontNames:XFreeFontNames(list)
#XListFontsWithInfo:char **XListFontsWithInfo(display, pattern, maxnames, count_return, info_return)
#XFreeFontInfo:XFreeFontInfo(names, free_info, actual_count)
#XListInputDevices:XDeviceInfo *XListInputDevices(display, ndevices_return)
#XFreeDeviceList:XFreeDeviceList(list)
#XLoadFont:Font XLoadFont(display, name)
#XQueryFont:XFontStruct *XQueryFont(display, font_ID)
#XLoadQueryFont:XFontStruct *XLoadQueryFont(display, name)
#XFreeFont:XFreeFont(display, font_struct)
#XGetFontProperty:Bool XGetFontProperty(font_struct, atom, value_return)
#XUnloadFont:XUnloadFont(display, font)
#XLookupKeysym:KeySym XLookupKeysym(key_event, index)
#XRefreshKeyboardMapping:XRefreshKeyboardMapping(event_map)
#XLookupString:int XLookupString(event_struct, buffer_return, bytes_buffer, keysym_return, status_in_out)
#XRebindKeysym:XRebindKeysym(display, keysym, list, mod_count, string, num_bytes)
#XMapWindow:XMapWindow(display, w)
#XMapRaised:XMapRaised(display, w)
#XMapSubwindows:XMapSubwindows(display, w)
#XNextEvent:XNextEvent(display, event_return)
#XPeekEvent:XPeekEvent(display, event_return)
#XWindowEvent:XWindowEvent(display, w, event_mask, event_return)
#XCheckWindowEvent:Bool XCheckWindowEvent(display, w, event_mask, event_return)
#XMaskEvent:XMaskEvent(display, event_mask, event_return)
#XCheckMaskEvent:Bool XCheckMaskEvent(display, event_mask, event_return)
#XCheckTypedEvent:Bool XCheckTypedEvent(display, event_type, event_return)
#XCheckTypedWindowEvent:Bool XCheckTypedWindowEvent(display, w, event_type, event_return)
#XNoOp:XNoOp(display)
#XOpenDevice:XDevice *XOpenDevice(display, device_id)
#XCloseDevice:XCloseDevice(display, device)
#XOpenDisplay:Display *XOpenDisplay(display_name)
#XCloseDisplay:XCloseDisplay(display)
#XOpenIM:XIM XOpenIM(display, db, res_name, res_class)
#XCloseIM:Status XCloseIM(im)
#XSetIMValues:char * XSetIMValues(im, ...)
#XGetIMValues:char * XGetIMValues(im, ...)
#XDisplayOfIM:Display * XDisplayOfIM(im)
#XLocaleOfIM:char * XLocaleOfIM(im)
#XRegisterIMInstantiateCallback:Bool XRegisterIMInstantiateCallback(display, db, res_name, res_class, callback, client_data)
#XUnregisterIMInstantiateCallback:Bool XUnregisterIMInstantiateCallback(display, db, res_name, res_class, callback, client_data)
#XOpenOM:XOM XOpenOM(display, db, res_name, res_class)
#XCloseOM:Status XCloseOM(om)
#XSetOMValues:char * XSetOMValues(om, ...)
#XGetOMValues:char * XGetOMValues(om, ...)
#XDisplayOfOM:Display * XDisplayOfOM(om)
#XLocaleOfOM:char * XLocaleOfOM(om)
#XParseGeometry:int XParseGeometry(parsestring, x_return, y_return, width_return, height_return)
#XWMGeometry:int XWMGeometry(display, screen, user_geom, fIdef_geom, bwidth, hints, x_return, y_return, width_return, height_return, gravity_return)
#XPolygonRegion:Region XPolygonRegion(points, n, fill_rule)
#XClipBox:XClipBox(r, rect_return)
#XPutBackEvent:XPutBackEvent(display, event)
#XPutImage:XPutImage(display, d, gc, image, src_x, src_y, dest_x, dest_y, width, height)
#XGetImage:XImage *XGetImage(display, d, x, y, width, height, plane_mask, format)
#XGetSubImage:XImage *XGetSubImage(display, d, x, y, width, height, plane_mask, format, dest_image, dest_x, dest_y)
#XQueryBestSize:Status XQueryBestSize(display, class, which_screen, width, height, width_return, height_return) 
#XQueryBestTile:Status XQueryBestTile(display, which_screen, width, height, width_return, height_return) 
#XQueryBestStipple:Status XQueryBestStipple(display, which_screen, width, height, width_return, height_return) 
#XQueryColor:XQueryColor(display, colormap, def_in_out)
#XQueryColors:XQueryColors(display, colormap, defs_in_out, ncolors)
#XLookupColor:Status XLookupColor(display, colormap, color_name, fIexact_def_return, screen_def_return)
#XParseColor:Status XParseColor(display, colormap, spec, exact_def_return)
#XQueryDeviceState:XQueryDeviceState(display, device)
#XQueryPointer:Bool XQueryPointer(display, w, root_return, child_return, root_x_return, root_y_return, win_x_return, win_y_return, mask_return)
#XQueryTree:Status XQueryTree(display, w, root_return, parent_return, children_return, nchildren_return)
#XRaiseWindow:XRaiseWindow(display, w)
#XLowerWindow:XLowerWindow(display, w)
#XCirculateSubwindows:XCirculateSubwindows(display, w, direction)
#XCirculateSubwindowsUp:XCirculateSubwindowsUp(display, w)
#XCirculateSubwindowsDown:XCirculateSubwindowsDown(display, w)
#XRestackWindows:XRestackWindows(display, windows, nwindows);
#XReadBitmapFile:int XReadBitmapFile(display, d, filename, width_return, height_return, bitmap_return, x_hot_return, y_hot_return)
#XReadBitmapFileData:int XReadBitmapFileData(filename, width_return, height_return, data_return, x_hot_return, y_hot_return)
#XWriteBitmapFile:int XWriteBitmapFile(display, filename, bitmap, width, height, x_hot, y_hot)
#XCreatePixmapFromBitmapData:Pixmap XCreatePixmapFromBitmapData(display, d, data, width, height, fg, bg, depth)
#XCreateBitmapFromData:Pixmap XCreateBitmapFromData(display, d, data, width, height)
#XRecolorCursor:XRecolorCursor(display, cursor, foreground_color, background_color)
#XFreeCursor:XFreeCursor(display, cursor)
#XQueryBestCursor:Status XQueryBestCursor(display, d, width, height, width_return, height_return)
#XReparentWindow:XReparentWindow(display, w, parent, x, y)
#XResourceManagerString:char *XResourceManagerString(display)
#XScreenResourceString:char *XScreenResourceString(screen)
#XSaveContext:int XSaveContext(display, rid, context, data)
#XFindContext:int XFindContext(display, rid, context, data_return)
#XDeleteContext:int XDeleteContext(display, rid, context)
#XUniqueContext:XContext XUniqueContext()
#XSelectExtensionEvent:XSelectExtensionEvent(display, w, event_list, event_count)
#XGetSelectedExtensionEvents:XGetSelectedExtensionEvents(display, w, this_client_event_count_return, this_client_event_list_return, all_clients_event_count_return,all_clients_event_list_return)
#XSelectInput:XSelectInput(display, w, event_mask)
#XSendEvent:Status XSendEvent(display, w, propagate, event_mask, event_send)
#XDisplayMotionBufferSize:unsigned long XDisplayMotionBufferSize(display)
#XGetMotionEvents:XTimeCoord *XGetMotionEvents(display, w, start, stop, nevents_return)
#XSendExtensionEvent:Status XSendExtensionEvent(display, device, destination, propagate, event_count, event_list, event_send)
#XSetArcMode:XSetArcMode(display, gc, arc_mode)
#XSetSubwindowMode:XSetSubwindowMode(display, gc, subwindow_mode)
#XSetGraphicsExposures:XSetGraphicsExposures(display, gc, graphics_exposures)
#XSetClipOrigin:XSetClipOrigin(display, gc, clip_x_origin, clip_y_origin)
#XSetClipMask:XSetClipMask(display, gc, pixmap)
#XSetClipRectangles:XSetClipRectangles(display, gc, clip_x_origin, clip_y_origin, rectangles, n, ordering)
#XSetCloseDownMode:XSetCloseDownMode(display, close_mode)
#XKillClient:XKillClient(display, resource)
#XSetCommand:XSetCommand(display, w, argv, argc)
#XGetCommand:Status XGetCommand(display, w, argv_return, fIargc_return)
#XSetDeviceButtonMapping:int XSetDeviceButtonMapping(display, device, map, nmap)
#XGetDeviceButtonMapping:int XGetDeviceButtonMapping(display, device, map_return, nmap)
#XSetDeviceFocus:XSetDeviceFocus(display, device, focus, revert_to, time)
#XGetDeviceFocus:XGetDeviceFocus(display, device, focus_return, revert_to_return, time_return)
#XSetDeviceMode:XSetDeviceMode(display, device, mode)
#XSetDeviceValuators:XSetDeviceValuators(display, device, valuators, first_valuator, num_valuators)
#int:int (*XSetErrorHandler(handler))()
#int: int (*handler)(Display *, XErrorEvent *)
#XGetErrorText:XGetErrorText(display, code, buffer_return, length)
#XDisplayName:char *XDisplayName(string)
#int:int (*XSetIOErrorHandler(handler))()
#int: int (*handler)(Display *);
#XGetErrorDatabaseText:XGetErrorDatabaseText(display, name, message, default_string, buffer_return, length)
#XSetFillStyle:XSetFillStyle(display, gc, fill_style)
#XSetFillRule:XSetFillRule(display, gc, fill_rule)
#XSetFont:XSetFont(display, gc, font)
#XSetFontPath:XSetFontPath(display, directories, ndirs)
#XGetFontPath:char **XGetFontPath(display, npaths_return)
#XFreeFontPath:XFreeFontPath(list)
#XSetICFocus:void XSetICFocus(ic)
#XUnsetICFocus:void XUnsetICFocus(ic)
#XSetICValues:char * XSetICValues(ic, ...)
#XGetICValues:char * XGetICValues(ic, ...)
#XSetInputFocus:XSetInputFocus(display, focus, revert_to, time)
#XGetInputFocus:XGetInputFocus(display, focus_return, revert_to_return)
#XSetLineAttributes:XSetLineAttributes(display, gc, line_width, line_style, cap_style, join_style)
#XSetDashes:XSetDashes(display, gc, dash_offset, dash_list, n)
#XSetPointerMapping:int XSetPointerMapping(display, map, nmap)
#XGetPointerMapping:int XGetPointerMapping(display, map_return, nmap)
#XSetScreenSaver:XSetScreenSaver(display, timeout, interval, prefer_blanking, allow_exposures)
#XForceScreenSaver:XForceScreenSaver(display, mode)
#XActivateScreenSaver:XActivateScreenSaver(display)
#XResetScreenSaver:XResetScreenSaver(display)
#XGetScreenSaver:XGetScreenSaver(display, timeout_return, interval_return, prefer_blanking_return, allow_exposures_return)
#XSetSelectionOwner:XSetSelectionOwner(display, selection, owner, time)
#XGetSelectionOwner:Window XGetSelectionOwner(display, selection)
#XConvertSelection:XConvertSelection(display, selection, target, property, requestor, time)
#XSetState:XSetState(display, gc, foreground, background, function, plane_mask)
#XSetFunction:XSetFunction(display, gc, function)
#XSetPlaneMask:XSetPlaneMask(display, gc, plane_mask)
#XSetForeground:XSetForeground(display, gc, foreground)
#XSetBackground:XSetBackground(display, gc, background)
#XSetTextProperty:void XSetTextProperty(display, w, text_prop, fIproperty)
#XGetTextProperty:Status XGetTextProperty(display, w, text_prop_return, fIproperty)
#XSetTile:XSetTile(display, gc, tile)
#XSetStipple:XSetStipple(display, gc, stipple)
#XSetTSOrigin:XSetTSOrigin(display, gc, ts_x_origin, ts_y_origin)
#XSetTransientForHint:XSetTransientForHint(display, w, prop_window)
#XGetTransientForHint:Status XGetTransientForHint(display, w, prop_window_return)
#XSetWMClientMachine:void XSetWMClientMachine(display, w, text_prop)
#XGetWMClientMachine:Status XGetWMClientMachine(display, w, text_prop_return)
#XSetWMColormapWindows:Status XSetWMColormapWindows(display, w, fIcolormap_windows, count)
#XGetWMColormapWindows:Status XGetWMColormapWindows(display, w, fIcolormap_windows_return, count_return)
#XSetWMIconName:void XSetWMIconName(display, w, text_prop)
#XGetWMIconName:Status XGetWMIconName(display, w, text_prop_return)
#XSetIconName:XSetIconName(display, w, icon_name)
#XGetIconName:Status XGetIconName(display, w, icon_name_return)
#XSetWMName:void XSetWMName(display, w, text_prop)
#XGetWMName:Status XGetWMName(display, w, text_prop_return)
#XStoreName:XStoreName(display, w, window_name)
#XFetchName:Status XFetchName(display, w, window_name_return)
#XSetWMProperties:void XSetWMProperties(display, w, window_name, fIicon_name, argv, argc, normal_hints, wm_hints, fIclass_hints)
#XmbSetWMProperties:void XmbSetWMProperties(display, w, window_name, icon_name, argv, argc, normal_hints, wm_hints, class_hints)
#XSetWMProtocols:Status XSetWMProtocols(display, w, protocols, fIcount)
#XGetWMProtocols:Status XGetWMProtocols(display, w, protocols_return, fIcount_return)
#XShapeQueryExtension:Bool XShapeQueryExtension (	Display *dpy, int *event_basep, int *error_basep);
#XShapeQueryVersion:Status XShapeQueryVersion (	Display *dpy, int *major_versionp, int *minor_versionp);
#XShapeCombineRegion:void XShapeCombineRegion (	Display *dpy, Window dest, int destKind, int xOff, int yOff, struct _XRegion *r, int op);
#XShapeCombineRectangles:void XShapeCombineRectangles (	Display *dpy, XID dest, int destKind, int xOff, int yOff, XRectangle *rects, int n_rects, int op, int ordering);
#XShapeCombineMask:void XShapeCombineMask (	Display *dpy, XID dest, int destKind, int xOff, int yOff, Pixmap src, int op);
#XShapeCombineShape:void XShapeCombineShape (	Display *dpy, XID dest, int destKind, int xOff, int yOff, Pixmap src, int srcKind, int op);
#XShapeOffsetShape:void XShapeOffsetShape (	Display *dpy, XID dest, int destKind, int xOff, int yOff);
#XShapeQueryExtents:Status XShapeQueryExtents (	Display *dpy, Window window, int *bShaped, int *xbs, int *ybs, unsigned int *wbs, unsigned int *hbs, int *cShaped, int *xcs, int *ycs, unsigned int *wcs, unsigned int *hcs);
#XShapeSelectInput:void XShapeSelectInput (	Display *dpy, Window window, unsigned longmask);
#XShapeInputSelected:unsigned long XShapeInputSelected (	Display *dpy, Window window);
#XShapeGetRectangles:XRectangle *XShapeGetRectangles (	Display *dpy, Window window, int kind, int *count, int *ordering);
#XStoreBytes:XStoreBytes(display, bytes, nbytes)
#XStoreBuffer:XStoreBuffer(display, bytes, nbytes, buffer)
#XFetchBytes:char *XFetchBytes(display, nbytes_return)
#XFetchBuffer:char *XFetchBuffer(display, nbytes_return, buffer)
#XRotateBuffers:XRotateBuffers(display, rotate)
#XStoreColors:XStoreColors(display, colormap, color, ncolors)
#XStoreColor:XStoreColor(display, colormap, color)
#XStoreNamedColor:XStoreNamedColor(display, colormap, color, pixel, flags)
#XStringListToTextProperty:Status XStringListToTextProperty(list, count, fItext_prop_return)
#XTextPropertyToStringList:Status XTextPropertyToStringList(text_prop, list_return, fIcount_return)
#XFreeStringList:void XFreeStringList(list)
#XStringToKeysym:KeySym XStringToKeysym(string)
#XKeysymToString:char *XKeysymToString(keysym)
#XKeycodeToKeysym:KeySym XKeycodeToKeysym(display, keycode, index)
#XKeysymToKeycode:KeyCode XKeysymToKeycode(display, keysym)
#XConvertCase:void XConvertCase(keysym, lower_return, upper_return)
#XSupportsLocale:Bool XSupportsLocale()
#XSetLocaleModifiers:char *XSetLocaleModifiers(modifier_list)
#int:int (*XSynchronize(display, onoff))()
#int:int (*XSetAfterFunction(display, procedure))()
#int: int (*procedure)();
#XTextExtents:XTextExtents(font_struct, string, nchars, fIdirection_return, font_ascent_return, font_descent_return, overall_return)
#XTextExtents16:XTextExtents16(font_struct, string, nchars, fIdirection_return, font_ascent_return, font_descent_return, overall_return)
#XQueryTextExtents:XQueryTextExtents(display, font_ID, string, fInchars, direction_return, font_ascent_return, font_descent_return, overall_return)
#XQueryTextExtents16:XQueryTextExtents16(display, font_ID, string, fInchars, direction_return, font_ascent_return, font_descent_return, overall_return)
#XTextWidth:int XTextWidth(font_struct, string, count)
#XTextWidth16:int XTextWidth16(font_struct, string, count)
#XTranslateCoordinates:Bool XTranslateCoordinates(display, src_w, dest_w, src_x, src_y, dest_x_return, dest_y_return, child_return)
#XUnmapWindow:XUnmapWindow(display, w)
#XUnmapSubwindows:XUnmapSubwindows(display, w)
#XVaCreateNestedList:XVaNestedList XVaCreateNestedList(dummy, ...)
#XWarpPointer:XWarpPointer(display, src_w, dest_w, src_x, src_y, src_width, src_height, dest_x, dest_y)
#XauFileName:char *XauFileName ()
#XauReadAuth:Xauth *XauReadAuth (auth_file)
#XauWriteAuth:int XauWriteAuth (auth_file, auth)
#XauGetAuthByAddr:Xauth *XauGetAuthByAddr (Afamily,|u'address_length, address,|u'number_length, number)
#XauGetBestAuthByAddr:Xauth *XauGetBestAuthByAddr (Afamily,|u'address_length, address,|u'number_length, number,|u'types_length, types, type_lengths)
#XauLockAuth:int XauLockAuth (file_name, retries, timeout, dead)
#XauUnlockAuth:int XauUnlockAuth (file_name)
#XauDisposeAuth:XauDisposeAuth (auth)
#XcmsAllocColor:Status XcmsAllocColor(display, colormap, color_in_out, result_format)
#XcmsAllocNamedColor:Status XcmsAllocNamedColor(display, colormap, color_string, color_screen_return, color_exact_return, result_format)
#XcmsCCCOfColormap:XcmsCCC XcmsCCCOfColormap(display, colormap)
#XcmsSetCCCOfColormap:XcmsCCC XcmsSetCCCOfColormap(display, colormap, ccc)
#XcmsCIELabQueryMaxC:Status XcmsCIELabQueryMaxC(ccc, hue_angle, L_star, color_return)
#XcmsCIELabQueryMaxL:Status XcmsCIELabQueryMaxL(ccc, hue_angle, chroma, color_return)
#XcmsCIELabQueryMaxLC:Status XcmsCIELabQueryMaxLC(ccc, hue_angle, color_return)
#XcmsCIELabQueryMinL:Status XcmsCIELabQueryMinL(ccc, hue_angle, chroma, color_return)
#XcmsCIELuvQueryMaxC:Status XcmsCIELuvQueryMaxC(ccc, hue_angle, L_star, color_return)
#XcmsCIELuvQueryMaxL:Status XcmsCIELuvQueryMaxL(ccc, hue_angle, chroma, color_return)
#XcmsCIELuvQueryMaxLC:Status XcmsCIELuvQueryMaxLC(ccc, hue_angle, color_return)
#XcmsCIELuvQueryMinL:Status XcmsCIELuvQueryMinL(ccc, hue_angle, chroma, color_return)
#XcmsConvertColors:Status XcmsConvertColors(ccc, colors_in_out, ncolors, target_format, compression_flags_return)
#XcmsCreateCCC:XcmsCCC XcmsCreateCCC(display, screen_number, visual, client_white_point, compression_proc, compression_client_data, white_adjust_proc, white_adjust_client_data)
#XcmsFreeCCC:void XcmsFreeCCC(ccc)
#XcmsDefaultCCC:XcmsCCC XcmsDefaultCCC(display, screen_number)
#XcmsQueryBlack:Status XcmsQueryBlack(ccc, target_format, color_return)
#XcmsQueryBlue:Status XcmsQueryBlue(ccc, target_format, color_return)
#XcmsQueryGreen:Status XcmsQueryGreen(ccc, target_format, color_return)
#XcmsQueryRed:Status XcmsQueryRed(ccc, target_format, color_return)
#XcmsQueryWhite:Status XcmsQueryWhite(ccc, target_format, color_return)
#XcmsQueryColor:Status XcmsQueryColor(display, colormap, color_in_out, result_format)
#XcmsQueryColors:Status XcmsQueryColors(display, colormap, colors_in_out, ncolors, result_format)
#XcmsLookupColor:Status XcmsLookupColor(display, colormap, color_string, color_exact_return, color_screen_return, result_format)
#XcmsSetWhitePoint:Status XcmsSetWhitePoint(ccc, color)
#XcmsSetWhiteAdjustProc:XcmsWhiteAdjustProc XcmsSetWhiteAdjustProc(ccc, white_adjust_proc, client_data)
#XcmsStoreColor:Status XcmsStoreColor(display, colormap, color)
#XcmsStoreColors:Status XcmsStoreColors(display, colormap, colors, ncolors, compression_flags_return)
#XcmsTekHVCQueryMaxC:Status XcmsTekHVCQueryMaxC(ccc, hue, value, color_return)
#XcmsTekHVCQueryMaxV:Status XcmsTekHVCQueryMaxV(ccc, hue, chroma, color_return)
#XcmsTekHVCQueryMaxVC:Status XcmsTekHVCQueryMaxVC(ccc, hue, color_return)
#XcmsTekHVCQueryMaxVSamples:Status XcmsTekHVCQueryMaxVSamples(ccc, hue, colors_return, nsamples)
#XcmsTekHVCQueryMinV:Status XcmsTekHVCQueryMinV(ccc, hue, chroma, color_return)
#XdbeAllocateBackBufferName:XdbeBackBuffer XdbeAllocateBackBufferName( Display *dpy, Window window, XdbeSwapAction swap_action)
#XdbeBeginIdiom:Status XdbeBeginIdiom( Display *dpy)
#XdbeDeallocateBackBufferName:Status XdbeDeallocateBackBufferName( Display *dpy, XdbeBackBuffer buffer)
#XdbeEndIdiom:Status XdbeEndIdiom( Display *dpy)
#XdbeFreeVisualInfo:void XdbeFreeVisualInfo( XdbeScreenVisualInfo *visual_info)
#XdbeGetBackBufferAttributes:XdbeBackBufferAttributes *XdbeGetBackBufferAttributes( Display *dpy, XdbeBackBuffer buffer)
#XdbeGetVisualInfo:XdbeScreenVisualInfo *XdbeGetVisualInfo( Display *dpy, Drawable *screen_specifiers, int *num_screens)
#XdbeQueryExtension:Status XdbeQueryExtension( Display *dpy, int *major_version_return, int *minor_version_return)
#XdbeSwapBuffers:Status XdbeSwapBuffers( Display *dpy, XdbeSwapInfo *swap_info, int num_windows)
#XmbDrawImageString:void XmbDrawImageString(display, d, font_set, gc, x, y, string, num_bytes)
#XwcDrawImageString:void XwcDrawImageString(display, d, font_set, gc, x, y, string, num_wchars)
#XmbDrawString:void XmbDrawString(display, d, font_set, gc, x, y, string, num_bytes)
#XwcDrawString:void XwcDrawString(display, d, font_set, gc, x, y, string, num_wchars)
#XmbDrawText:void XmbDrawText(display, d, gc, x, y, items, nitems)
#XwcDrawText:void XwcDrawText(display, d, gc, x, y, items, nitems)
#XmbLookupString:int XmbLookupString(ic, event, buffer_return, bytes_buffer, keysym_return, status_return)
#XwcLookupString:int XwcLookupString(ic, event, buffer_return, bytes_buffer, keysym_return, status_return)
#XmbResetIC:char * XmbResetIC(ic)
#XwcResetIC:wchar_t * XwcResetIC(ic)
#XmbTextEscapement:int XmbTextEscapement(font_set, string, num_bytes)
#XwcTextEscapement:int XwcTextEscapement(font_set, string, num_wchars)
#XmbTextExtents:int XmbTextExtents(font_set, string, num_bytes, overall_return)
#XwcTextExtents:int XwcTextExtents(font_set, string, num_wchars, overall_return)
#XmbTextListToTextProperty:int XmbTextListToTextProperty(display, list, count, style, text_prop_return)
#XwcTextListToTextProperty:int XwcTextListToTextProperty(display, list, count, style, text_prop_return)
#XmbTextPropertyToTextList:int XmbTextPropertyToTextList(display, text_prop, list_return, count_return)
#XwcTextPropertyToTextList:int XwcTextPropertyToTextList(display, text_prop, list_return, count_return)
#XwcFreeStringList:void XwcFreeStringList(list)
#XDefaultString:char *XDefaultString()
#XmbTextPerCharExtents:Status XmbTextPerCharExtents(font_set, string, num_bytes, ink_array_return, logical_array_return, array_size, num_chars_return, overall_return)
#XwcTextPerCharExtents:Status XwcTextPerCharExtents(font_set, string, num_wchars, ink_array_return, logical_array_return, array_size, num_chars_return, overall_return)
#XmbufQueryExtension:Bool XmbufQueryExtension( Display *dpy, Display *dpy, int *event_base_return, int *error_base_return);
#XmbufGetVersion:Status XmbufGetVersion( Display *dpy, int *major_version_return, int *minor_version_return);
#XmbufCreateBuffers:int XmbufCreateBuffers( Display *dpy, Window window, int count, int update_action, int update_hint, Multibuffer *buffers_update);
#XmbufDestroyBuffers:void XmbufDestroyBuffers( Display *dpy, Window window);
#XmbufDisplayBuffers:void XmbufDisplayBuffers( Display *dpy, int count, Multibuffer *buffers, int min_delay, int max_delay);
#XmbufGetWindowAttributes:Status XmbufGetWindowAttributes( Display *dpy, Window window, XmbufWindowAttributes *attributes);
#XmbufChangeWindowAttributes:void XmbufChangeWindowAttributes( Display *dpy, Window window, unsigned long valuemask, XmbufSetWindowAttributes *attributes);
#XmbufGetBufferAttributes:Status XmbufGetBufferAttributes( Display *dpy, Multibuffer buffer, XmbufBufferAttributes *attributes);
#XmbufChangeBufferAttributes:void XmbufChangeBufferAttributes( Display *dpy, Multibuffer buffer, unsigned long valuemask, XmbufSetBufferAttributes *attributes);
#XmbufGetScreenInfo:Status XmbufGetScreenInfo( Display *dpy, Drawable drawable, int *nmono_return, XmbufBufferInfo **mono_info_return, int *nstereo_return, XmbufBufferInfo **stereo_info_return);
#XmbufCreateStereoWindow:Window XmbufCreateStereoWindow( Display *dpy, Window parent, int x, int y, unsigned int width, unsigned int height, unsigned int border_width, int depth, unsigned int class, /* InputOutput, InputOnly*/ Visual *visual, unsigned long valuemask, XSetWindowAttributes *attributes, Multibuffer *left_return, Multibuffer *right_return);
#lw:lw(.5i) lw(2i) lw(2.5i).
#XrmEnumerateDatabase:Bool XrmEnumerateDatabase(database, name_prefix, class_prefix, mode, proc, arg)
#Bool: Bool (*proc)();
#XrmGetFileDatabase:XrmDatabase XrmGetFileDatabase(filename)
#XrmPutFileDatabase:void XrmPutFileDatabase(database, stored_db)
#XrmGetStringDatabase:XrmDatabase XrmGetStringDatabase(data)
#XrmLocaleOfDatabase:char *XrmLocaleOfDatabase(database)
#XrmGetDatabase:XrmDatabase XrmGetDatabase(display)
#XrmSetDatabase:void XrmSetDatabase(display, database)
#XrmDestroyDatabase:void XrmDestroyDatabase(database)
#XrmGetResource:Bool XrmGetResource(database, str_name, str_class, fIstr_type_return, value_return)
#XrmQGetResource:Bool XrmQGetResource(database, quark_name, quark_class, fIquark_type_return, value_return)
#XrmQGetSearchList:Bool XrmQGetSearchList(database, names, classes, fIlist_return, list_length)
#XrmQGetSearchResource:Bool XrmQGetSearchResource(list, name, class, fItype_return, value_return)
#XrmInitialize:void XrmInitialize();
#XrmParseCommand:void XrmParseCommand(database, table, table_count, ^name, argc_in_out, argv_in_out)
#XrmMergeDatabases:void XrmMergeDatabases(source_db, target_db)
#XrmCombineDatabase:void XrmCombineDatabase(source_db, target_db, override)
#XrmCombineFileDatabase:Status XrmCombineFileDatabase(filename, target_db, override)
#XrmPutResource:void XrmPutResource(database, specifier, type, value)
#XrmQPutResource:void XrmQPutResource(database, bindings, quarks, fItype, value)
#XrmPutStringResource:void XrmPutStringResource(database, specifier, value)
#XrmQPutStringResource:void XrmQPutStringResource(database, bindings, quarks, fIvalue)
#XrmPutLineResource:void XrmPutLineResource(database, line)
#XrmUniqueQuark:XrmQuark XrmUniqueQuark()
#XrmStringToName:#define XrmStringToName(string) XrmStringToQuark(string)
#XrmStringToClass:#define XrmStringToClass(string) XrmStringToQuark(string)
#XrmStringToRepresentation:#define XrmStringToRepresentation(string) XrmStringToQuark(string)
#XrmStringToQuark:XrmQuark XrmStringToQuark(string)
#XrmPermStringToQuark:XrmQuark XrmPermStringToQuark(string)
#XrmStringToName:#define XrmStringToName(string) XrmStringToQuark(string)
#XrmStringToClass:#define XrmStringToClass(string) XrmStringToQuark(string)
#XrmStringToRepresentation:#define XrmStringToRepresentation(string) XrmStringToQuark(string)
#XrmStringToQuark:XrmQuark XrmStringToQuark(string)
#XrmPermStringToQuark:XrmQuark XrmPermStringToQuark(string)
#XrmNameToString:#define XrmNameToString(name) XrmQuarkToString(name)
#XrmClassToString:#define XrmClassToString(class) XrmQuarkToString(class)
#XrmRepresentationToString:#define XrmRepresentationToString(type) XrmQuarkToString(type)
#XrmQuarkToString:char *XrmQuarkToString(quark)
#XrmStringToNameList:#define XrmStringToNameList(str, name) XrmStringToQuarkList((str), (name))
#XrmStringToClassList:#define XrmStringToClassList(str,class) XrmStringToQuarkList((str), (class))
#XrmStringToQuarkList:void XrmStringToQuarkList(string, quarks_return)
#XrmStringToBindingQuarkList:XrmStringToBindingQuarkList(string, bindings_return, fIquarks_return)
#XtAddActions:void XtAddActions(actions, num_actions)
#XtAddCallback:void XtAddCallback(w, callback_name, callback, fIclient_data)
#XtAddCallbacks:void XtAddCallbacks(w, callback_name, callbacks)
#XtRemoveCallback:void XtRemoveCallback(w, callback_name, callback, fIclient_data)
#XtRemoveCallbacks:void XtRemoveCallbacks(w, callback_name, callbacks)
#XtRemoveAllCallbacks:void XtRemoveAllCallbacks(w, callback_name)
#XtAddEventHandler:void XtAddEventHandler(w, event_mask, nonmaskable, fIproc, client_data)
#XtAddRawEventHandler:void XtAddRawEventHandler(w, event_mask, nonmaskable, fIproc, client_data)
#XtRemoveEventHandler:void XtRemoveEventHandler(w, event_mask, nonmaskable, fIproc, client_data)
#XtRemoveRawEventHandler:void XtRemoveRawEventHandler(w, event_mask, nonmaskable, fIproc, client_data)
#XtInsertEventHandler:void XtInsertEventHandler(w, event_mask, nonmaskable, fIproc, client_data, position)
#XtInsertRawEventHandler:void XtInsertRawEventHandler(w, event_mask, nonmaskable, fIproc, client_data, position)
#XtAddExposureToRegion:void XtAddExposureToRegion(event, region)
#XtAddGrab:void XtAddGrab(w, exclusive, spring_loaded)
#XtRemoveGrab:void XtRemoveGrab(w)
#XtAddInput:XtInputId XtAddInput(source, condition, proc, fIclient_data)
#XtAddTimeout:XtIntervalId XtAddTimeout(interval, proc, client_data)
#XtAddWorkProc:XtWorkProcId XtAddWorkProc(proc, client_data)
#XtAllocateGC:GC XtAllocateGC(w, depth, value_mask, values, fIdynamic_mask, unused_mask)
#XtAppAddActionHook:XtActionHookId XtAppAddActionHook(app_context, proc, fIclient_data)
#XtRemoveActionHook:void XtRemoveActionHook(idP)
#XtAppAddActions:void XtAppAddActions(app_context, actions, num_actions)
#XtAppAddBlockHook:XtBlockHookId XtAppAddBlockHook(app_context, proc, fIclient_data)
#XtRemoveBlockHook:void XtRemoveBlockHook(idP)
#XtAppAddConverter:void XtAppAddConverter(app_context, from_type, to_type, fIconverter, convert_args, num_args)
#XtAddConverter:void XtAddConverter(from_type, to_type, converter, fIconvert_args, num_args)
#XtAppAddInput:XtInputId XtAppAddInput(app_context, source, condition, fIproc, client_data)
#XtRemoveInput:void XtRemoveInput(id)
#XtAppAddSignal:XtSignalId XtAppAddSignal(app_context, proc, client_data)
#XtRemoveSignal:void XtRemoveSignal(id)
#XtNoticeSignal:void XtNoticeSignal(id)
#XtAppAddTimeOut:XtIntervalId XtAppAddTimeOut(app_context, interval, proc, fIclient_data)
#XtRemoveTimeOut:void XtRemoveTimeOut(timer)
#XtAppAddWorkProc:XtWorkProcId XtAppAddWorkProc(app_context, proc, client_data)
#XtRemoveWorkProc:void XtRemoveWorkProc(id)
#XtAppCreateShell:Widget XtAppCreateShell(application_name, fIapplication_class, widget_class, display, fIargs, num_args)
#XtVaAppCreateShell:Widget XtVaAppCreateShell(application_name, fIapplication_class, widget_class, display, ...)
#XtAppError:void XtAppError(app_context, message)
#XtAppSetErrorHandler:void XtAppSetErrorHandler(app_context, handler)
#XtAppSetWarningHandler:void XtAppSetWarningHandler(app_context, handler)
#XtAppWarning:void XtAppWarning(app_context, message)
#XtAppErrorMsg:void XtAppErrorMsg(app_context, name, type, class, fIdefault, params, num_params)
#XtAppSetErrorMsgHandler:void XtAppSetErrorMsgHandler(app_context, msg_handler)
#XtAppSetWarningMsgHandler:void XtAppSetWarningMsgHandler(app_context, msg_handler)
#XtAppWarningMsg:void XtAppWarningMsg(app_context, name, type, class, default, params, num_params)
#XtAppGetErrorDatabase:XrmDatabase *XtAppGetErrorDatabase(app_context)
#XtAppGetErrorDatabaseText:void XtAppGetErrorDatabaseText(app_context, name, type, class, default, buffer_return, nbytes, database)
#XtAppGetSelectionTimeout:unsigned long XtAppGetSelectionTimeout(app_context)
#XtAppSetSelectionTimeout:void XtAppSetSelectionTimeout(app_context, timeout)
#XtAppInitialize:Widget XtAppInitialize(app_context_return, application_class, fIoptions, num_options, argc_in_out, argv_in_out, fIfallback_resources, args, num_args)
#XtVaAppInitialize:Widget XtVaAppInitialize(app_context_return, application_class, fIoptions, num_options, argc_in_out, argv_in_out, fIfallback_resources, ...)
#XtAppLock:void XtAppLock(app_context)
#XtAppUnlock:void XtAppUnlock(app_context)
#XtAppNextEvent:void XtAppNextEvent(app_context, event_return)
#XtAppPeekEvent:Boolean XtAppPeekEvent(app_context, event_return)
#XtAppPending:XtInputMask XtAppPending(app_context)
#XtAppProcessEvent:void XtAppProcessEvent(app_context, mask)
#XtDispatchEvent:Boolean XtDispatchEvent(event)
#XtAppMainLoop:void XtAppMainLoop(app_context)
#XtAppReleaseCacheRefs:void XtAppReleaseCacheRefs(app_context, refs)
#XtAppSetExitFlag:void XtAppSetExitFlag(app_context)
#XtAppGetExitFlag:Boolean XtAppGetExitFlag(app_context)
#XtAppSetFallbackResources:void XtAppSetFallbackResources(app_context, specification_list)
#XtAppSetTypeConverter:void XtAppSetTypeConverter(app_context, from_type, to_type, fIconverter, convert_args, num_args, fIcache_type, destructor)
#XtSetTypeConverter:void XtSetTypeConverter(from_type, to_type, converter, fIconvert_args, num_args, cache_type, destructor)
#XtBuildEventMask:EventMask XtBuildEventMask(w)
#XtCallAcceptFocus:Boolean XtCallAcceptFocus(w, time)
#XtCallActionProc:void XtCallActionProc(widget, action, event, fIparams, num_params)
#XtCallCallbacks:void XtCallCallbacks(w, callback_name, call_data)
#XtCallCallbackList:void XtCallCallbackList(w, callbacks, call_data)
#XtHasCallbacks:XtCallbackStatus XtHasCallbacks(w, callback_name)
#XtClass:WidgetClass XtClass(w)
#XtSuperclass:WidgetClass XtSuperclass(w)
#XtIsSubclass:Boolean XtIsSubclass(w, widget_class)
#XtCheckSubclass:void XtCheckSubclass(widget, widget_class, message)
#XtIsObject:Boolean XtIsObject(w)
#XtIsRectObj:Boolean XtIsRectObj(w)
#XtIsWidget:Boolean XtIsWidget(w)
#XtIsComposite:Boolean XtIsComposite(w)
#XtIsConstraint:Boolean XtIsConstraint(w)
#XtIsShell:Boolean XtIsShell(w)
#XtIsOverrideShell:Boolean XtIsOverrideShell(w)
#XtIsWMShell:Boolean XtIsWMShell(w)
#XtIsVendorShell:Boolean XtIsVendorShell(w)
#XtIsTransientShell:Boolean XtIsTransientShell(w)
#XtIsTopLevelShell:Boolean XtIsTopLevelShell(w)
#XtIsApplicationShell:Boolean XtIsApplicationShell(w)
#XtIsSessionShell:Boolean XtIsSessionShell(w)
#XtConfigureWidget:void XtConfigureWidget(w, x, y, width, height, fIborder_width)
#XtMoveWidget:void XtMoveWidget(w, x, y)
#XtResizeWidget:void XtResizeWidget(w, width, height, border_width)
#XtResizeWindow:void XtResizeWindow(w)
#XtConvert:void XtConvert(w, from_type, from, to_type, fIto_return)
#XtDirectConvert:void XtDirectConvert(converter, args, num_args, from, fIto_return)
#XtConvertAndStore:Boolean XtConvertAndStore(widget, from_type, from, fIto_type, to_in_out)
#XtCallConverter:void XtCallConverter(dpy, converter, args, fInum_args, from, to_in_out, cache_ref_return)
#XtCreateApplicationContext:XtAppContext XtCreateApplicationContext()
#XtDestroyApplicationContext:void XtDestroyApplicationContext(app_context)
#XtWidgetToApplicationContext:XtAppContext XtWidgetToApplicationContext(w)
#XtToolkitInitialize:void XtToolkitInitialize()
#XtCreateApplicationShell:Widget XtCreateApplicationShell(name, widget_class, fIargs, num_args)
#XtCreatePopupShell:Widget XtCreatePopupShell(name, widget_class, parent, fIargs, num_args)
#XtVaCreatePopupShell:Widget XtVaCreatePopupShell(name, widget_class, parent, ...)
#XtCreateSelectionRequest:void XtCreateSelectionRequest(requestor, selection)
#XtSendSelectionRequest:void XtSendSelectionRequest(requestor, selection, time)
#XtCancelSelectionRequest:void XtCancelSelectionRequest(requestor, selection)
#XtCreateWidget:Widget XtCreateWidget(name, widget_class, parent, fIargs, num_args)
#XtVaCreateWidget:Widget XtVaCreateWidget(name, widget_class, parent, ...)
#XtCreateManagedWidget:Widget XtCreateManagedWidget(name, widget_class, parent, fIargs, num_args)
#XtVaCreateManagedWidget:Widget XtVaCreateManagedWidget(name, widget_class, parent, ...)
#XtDestroyWidget:void XtDestroyWidget(w)
#XtCreateWindow:void XtCreateWindow(w, window_class, visual, fIvalue_mask, attributes)
#XtDisplay:Display *XtDisplay(w)
#XtDisplayOfObject:Display *XtDisplayOfObject(object)
#XtScreen:Screen *XtScreen(w)
#XtScreenOfObject:Screen *XtScreenOfObject(object)
#XtWindow:Window XtWindow(w)
#XtWindowOfObject:Window XtWindowOfObject(object)
#XtDisplayInitialize:void XtDisplayInitialize(app_context, display, fIapplication_name, application_class, options, num_options, argc, argv)
#XtOpenDisplay:Display *XtOpenDisplay(app_context, display_string, fIapplication_name, application_class, options, num_options, argc, argv)
#XtCloseDisplay:void XtCloseDisplay(display)
#XtDatabase:XrmDatabase XtDatabase(display)
#XtScreenDatabase:XrmDatabase XtScreenDatabase(screen)
#XtDisplayStringConversionWarning:void XtDisplayStringConversionWarning(display, from_value, fIto_type)
#XtDisplayToApplicationContext:XtAppContext XtDisplayToApplicationContext(dpy)
#XtError:void XtError(message)
#XtSetErrorHandler:void XtSetErrorHandler(handler)
#XtSetWarningHandler:void XtSetWarningHandler(handler)
#XtWarning:void XtWarning(message)
#XtErrorMsg:void XtErrorMsg(name, type, class, fIdefault, params, num_params)
#XtSetErrorMsgHandler:void XtSetErrorMsgHandler(msg_handler)
#XtSetWarningMsgHandler:void XtSetWarningMsgHandler(msg_handler)
#XtWarningMsg:void XtWarningMsg(name, type, class, fIdefault, params, num_params)
#XtFindFile:String XtFindFile(path, substitutions, num_substitutions,fIpredicate)
#XtGetActionKeysym:KeySym XtGetActionKeysym(event, modifiers_return)
#XtGetActionList:void XtGetActionList(widget_class, actions_return, fInum_actions_return)
#XtGetApplicationNameAndClass:void XtGetApplicationNameAndClass(display, name_return, fIclass_return)
#XtGetApplicationResources:void XtGetApplicationResources(w, base, resources, fInum_resources, args, num_args)
#XtVaGetApplicationResources:void XtVaGetApplicationResources(w, base, resources, fInum_resources,...)
#XtGetClassExtension:XtPointer XtGetClassExtension(object_class, byte_offset fItype, version, record_size)
#XtGetDisplays:void XtGetDisplays(app_context, dpy_return, num_dpy_return)
#XtGetErrorDatabase:XrmDatabase *XtGetErrorDatabase()
#XtGetErrorDatabaseText:void XtGetErrorDatabaseText(name, type, class, fIdefault, buffer_return, nbytes, database)
#XtGetGC:GC XtGetGC(w, value_mask, values)
#XtReleaseGC:void XtReleaseGC(w, gc)
#XtGetKeyboardFocusWidget:Widget XtGetKeyboardFocusWidget(widget)
#XtGetKeysymTable:Keysym* XtGetKeysymTable(display, min_keycode_return, fIkeysyms_per_keycode_return)
#XtKeysymToKeycodeList:void XtKeysymToKeycodeList(display, keysym, fIkeycodes_return, keycount_return)
#XtGetResourceList:void XtGetResourceList(class, resources_return, num_resources_return);
#XtGetConstraintResourceList:void XtGetConstraintResourceList(class, resources_return, fInum_resources_return);
#XtGetSelectionParameters:void XtGetSelectionParameters(owner, selection, request_id, fItype_return, value_return, length_return, format_return)
#XtGetSelectionRequest:XSelectionRequestEvent* XtGetSelectionRequest(w, selection, fIrequest_id)
#XtGetSelectionTimeout:unsigned long XtGetSelectionTimeout()
#XtSetSelectionTimeout:void XtSetSelectionTimeout(timeout)
#XtGetSelectionValue:void XtGetSelectionValue(w, selection, target, fIcallback, client_data, time)
#XtGetSelectionValues:void XtGetSelectionValues(w, selection, targets, fIcount, callback, client_data, time)
#XtGetSelectionValueIncremental:void XtGetSelectionValueIncremental(w, selection, target, fIcallback, client_data, time)
#XtGetSelectionValuesIncremental:void XtGetSelectionValuesIncremental(w, selection, targets, fIcount, callback, client_data, time)
#XtGetSubresources:void XtGetSubresources(w, base, name, class, fIresources, num_resources, args, num_args)
#XtVaGetSubresources:void XtVaGetSubresources(w, base, name, class, fIresources, num_resources, ...)
#XtGrabKey:void XtGrabKey(widget, keycode, modifiers, fIowner_events, pointer_mode, keyboard_mode)
#XtUngrabKey:void XtUngrabKey(widget, keycode, modifiers)
#XtGrabKeyboard:int XtGrabKeyboard(widget, owner_events, pointer_mode, fIkeyboard_mode, time)
#XtUngrabKeyboard:void XtUngrabKeyboard(widget, time)
#XtGrabButton:void XtGrabButton(widget, button, modifiers, fIowner_events, event_mask, pointer_mode, keyboard_mode, fIconfine_to, cursor)
#XtUngrabButton:void XtUngrabButton(widget, button, modifiers)
#XtGrabPointer:int XtGrabPointer(widget, owner_events, event_mask, fIpointer_mode, keyboard_mode, confine_to, cursor, fItime)
#XtUngrabPointer:void XtUngrabPointer(widget, time)
#XtHooksOfDisplay:Widget XtHooksOfDisplay(display)
#XtInitialize:Widget XtInitialize(shell_name, application_class, fIoptions, num_options, argc, argv)
#XtInitializeWidgetClass:void XtInitializeWidgetClass(object_class)
#XtInsertEventTypeHandler:void XtInsertEventTypeHandler(widget, event_type, fIselect_data, proc, client_data, position)
#XtRemoveEventTypeHandler:void XtRemoveEventTypeHandler(widget, event_type, fIselect_data, proc, client_data)
#XtRegisterExtensionSelector:void XtRegisterExtensionSelector(display, min_event_type, fImax_event_type, proc, client_data)
#XtSetEventDispatcher:XtEventDispatchProc XtSetEventDispatcher(display, event_type, fIproc)
#XtDispatchEventToWidget:Boolean XtDispatchEventToWidget(widget, event)
#XtLastEventProcessed:XEvent* XtLastEventProcessed(display)
#XtLastTimestampProcessed:Time XtLastTimestampProcessed(display)
#XtMakeGeometryRequest:XtGeometryResult XtMakeGeometryRequest(w, request, fIreply_return)
#XtMakeResizeRequest:XtGeometryResult XtMakeResizeRequest(w, width, height, fIwidth_return, height_return)
#XtMalloc:char *XtMalloc(size);
#XtCalloc:char *XtCalloc(num, size);
#XtRealloc:char *XtRealloc(ptr, num);
#XtFree:void XtFree(ptr);
#XtNew:type *XtNew(type);
#XtNewString:String XtNewString(string);
#XtManageChildren:void XtManageChildren(children, num_children)
#XtManageChild:void XtManageChild(child)
#XtUnmanageChildren:void XtUnmanageChildren(children, num_children)
#XtUnmanageChild:void XtUnmanageChild(child)
#XtChangeManagedSet:void XtChangeManagedSet(unmanage_children, num_unmanage_children, manage_children, num_manage_children, post_unmanage_pre_manage_hook, client_data)
#XtIsManaged:Boolean XtIsManaged(widget)
#XtMapWidget:XtMapWidget(w)
#XtSetMappedWhenManaged:void XtSetMappedWhenManaged(w, map_when_managed)
#XtUnmapWidget:XtUnmapWidget(w)
#XtName:Widget XtName(w)
#XtNameToWidget:Widget XtNameToWidget(reference, names);
#XtWindowToWidget:Widget XtWindowToWidget(display, window)
#XtNextEvent:void XtNextEvent(event_return)
#XtPeekEvent:Boolean XtPeekEvent(event_return)
#XtPending:XtInputMask XtPending()
#XtProcessEvent:void XtProcessEvent(mask)
#XtMainLoop:void XtMainLoop()
#XtOffset:Cardinal XtOffset(pointer_type, field_name)
#XtOffsetOf:Cardinal XtOffsetOf(structure_type, field_name)
#XtNumber:Cardinal XtNumber(array)
#XtOpenApplication:Widget XtOpenApplication(app_context_return, application_class, fIoptions, num_options, argc_in_out, argv_in_out, fIfallback_resources, widget_class, args, num_args)
#XtVaOpenApplication:Widget XtVaOpenApplication(app_context_return, application_class, fIoptions, num_options, argc_in_out, argv_in_out, fIfallback_resources, widget_class, ...)
#XtOwnSelection:Boolean XtOwnSelection(w, selection, time, fIconvert_proc, lose_selection, done_proc)
#XtOwnSelectionIncremental:Boolean XtOwnSelectionIncremental(w, selection, time, fIconvert_callback, lose_callback, done_callback, fIcancel_callback, client_data)
#XtDisownSelection:void XtDisownSelection(w, selection, time)
#XtParent:Widget XtParent(w)
#XtParseAcceleratorTable:XtAccelerators XtParseAcceleratorTable(source)
#XtInstallAccelerators:void XtInstallAccelerators(destination, source)
#XtInstallAllAccelerators:void XtInstallAllAccelerators(destination, source)
#XtParseTranslationTable:XtTranslations XtParseTranslationTable(table)
#XtAugmentTranslations:void XtAugmentTranslations(w, translations)
#XtOverrideTranslations:void XtOverrideTranslations(w, translations)
#XtUninstallTranslations:void XtUninstallTranslations(w)
#XtPopdown:void XtPopdown(popup_shell)
#XtCallbackPopdown:void XtCallbackPopdown(w, client_data, call_data)
#MenuPopdown:void MenuPopdown(shell_name)
#XtPopup:void XtPopup(popup_shell, grab_kind)
#XtPopupSpringLoaded:void XtPopupSpringLoaded(popup_shell)
#XtCallbackNone:void XtCallbackNone(w, client_data, call_data)
#XtCallbackNonexclusive:void XtCallbackNonexclusive(w, client_data, call_data)
#XtCallbackExclusive:void XtCallbackExclusive(w, client_data, call_data)
#MenuPopup:void MenuPopup(shell_name)
#XtProcessLock:void XtProcessLock()
#XtProcessUnlock:void XtProcessUnlock()
#XtQueryGeometry:XtGeometryResult XtQueryGeometry(w, intended, fIpreferred_return)
#XtRealizeWidget:void XtRealizeWidget(w)
#XtIsRealized:Boolean XtIsRealized(w)
#XtUnrealizeWidget:void XtUnrealizeWidget(w)
#XtRegisterDrawable:void XtRegisterDrawable(display, drawable, widget)
#XtUnregisterDrawable:void XtUnregisterDrawable(display, drawable)
#XtRegisterGrabAction:void XtRegisterGrabAction(action_proc, owner_events, fIevent_mask, pointer_mode, keyboard_mode)
#XtReservePropertyAtom:Widget XtReservePropertyAtom(w)
#XtReleasePropertyAtome:void XtReleasePropertyAtome(w, atom)
#XtResolvePathname:String XtResolvePathname(display, type, filename, suffix, fIpath, substitutions, num_substitutions, predicate)
#XtSessionGetToken:XtCheckpointToken XtSessionGetToken(w, type)
#XtSessionReturntoken:void XtSessionReturntoken(token)
#XtSetArg:XtSetArg(arg, name, value)
#XtMergeArgLists:ArgList XtMergeArgLists(args1, num_args1, args2, fInum_args2)
#XtSetKeyTranslator:void XtSetKeyTranslator(display, proc)
#XtTranslateKeycode:void XtTranslateKeycode(display, keycode, modifiers, fImodifiers_return, keysym_return)
#XtRegisterCaseConverter:void XtRegisterCaseConverter(display, proc, start, stop)
#XtConvertCase:void XtConvertCase(display, keysym, lower_return, fIupper_return)
#XtSetKeyboardFocus:XtSetKeyboardFocus(subtree descendant)
#XtSetLanguageProc:Widget XtSetLanguageProc(app_context, proc, client_data)
#XtSetMultiClickTime:void XtSetMultiClickTime(display, time)
#XtGetMultiClickTime:int XtGetMultiClickTime(display)
#XtSetSelectionParameters:void XtSetSelectionParameters(requestor, selection, type, fIvalue, length, format)
#XtSetSensitive:void XtSetSensitive(w, sensitive)
#XtIsSensitive:Boolean XtIsSensitive(w)
#XtSetValues:void XtSetValues(w, args, num_args)
#XtVaSetValues:void XtVaSetValues(w, ...)
#XtSetSubvalues:void XtSetSubvalues(base, resources, num_resources, fIargs, num_args)
#XtVaSetSubvalues:void XtVaSetSubvalues(base, resources, num_resources, ...)
#XtGetValues:void XtGetValues(w, args, num_args)
#XtVaGetValues:void XtVaGetValues(w, ...)
#XtGetSubvalues:void XtGetSubvalues(base, resources, num_resources, fIargs, num_args)
#XtVaGetSubvalues:void XtVaGetSubvalues(base, resources, num_resources, ...)
#XtSetWMColormapWindows:void XtSetWMColormapWindows(widget, list, count)
#XtStringConversionWarning:void XtStringConversionWarning(src, dst_type)
#XtToolkitThreadInitialize:Boolean XtToolkitThreadInitialize()
#XtTranslateCoords:void XtTranslateCoords(w, x, y, rootx_return, fIrooty_return)
#XtVaCreateArgsList:XtVarArgsList XtVaCreateArgsList(unused, ...)
