/*	@(#)llib-lc 1.49 90/08/14 SMI; from S5R2 2.14	*/
/*LINTLIBRARY*/

/*
 * All include files, no particular order.
 */
#include <stdio.h>
#include <errno.h>
#include <sys/param.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/sem.h>
#include <pwd.h>
#include <signal.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <sys/uio.h>
#include <sys/stat.h>
#include <sys/stropts.h>
#include <sys/resource.h>
#include <sys/poll.h>
#include <sys/ptrace.h>
#include <sys/shm.h>
#include <sys/times.h>
#include <sys/utsname.h>
#include <ustat.h>
#include <utime.h>
#include <sys/wait.h>
#include <net/if.h>
#include <netinet/in.h>
#include <netinet/if_ether.h>
#include <dirent.h>
#include <exportent.h>
#include <fstab.h>
#include <grp.h>
#include <netdb.h>
#include <mntent.h>
#include <ttyent.h>
#include <search.h>
#include <arpa/inet.h>
#include <malloc.h>
#include <mon.h>
#include <ndbm.h>
#include <a.out.h>
#include <setjmp.h>
#include <termios.h>
#include <varargs.h>
#include <rpcsvc/ypclnt.h>
#include <rpc/rpc.h>
#include <grpadj.h>
#include <sys/label.h>
#include <sys/audit.h>
#include <pwdadj.h>
#include <nfs/nfs.h>
#include <nfs/export.h>
#include <sys/vfs.h>
#include <floatingpoint.h>
#include <sys/mman.h>
#include <rpcsvc/pwdnm.h>
#include <rpc/key_prot.h>
#include <rpc/pmap_prot.h>
#include <rpc/pmap_rmt.h>
#include <locale.h>

/*
 * All undefs, alpha order
 */
#undef assert
#undef clearerr
#undef feof
#undef ferror
#undef fileno
#undef getc
#undef getchar
#undef htonl
#undef htons
#undef isalnum
#undef isalpha
#undef isascii
#undef iscntrl
#undef isdigit
#undef isgraph
#undef islower
#undef isprint
#undef ispunct
#undef isspace
#undef isupper
#undef isxdigit
#undef ntohl
#undef ntohs
#undef putc
#undef putchar
#undef rewinddir
#undef toascii
#undef _tolower
#undef _toupper

/*
 * Gross garbage for yp people.  Clean up your act, RPC!
 */
#ifndef	bool
#define	bool	bool_t
#endif

/*
 * All externs (yuck).
 * !}sort +1 order
 */
char	_ctype_[129];
FILE	_iob[];
int	daylight;
int	end, etext, edata;
char**	environ;
int	errno;
char*	optarg;
int	opterr;
int	optind;
int	optopt; /* undocumented */
char*	sys_errlist[1];
int	sys_nerr;
char*	sys_siglist[1];
long	timezone;
char*	tzname[2];
struct	qelem { struct qelem *q_forw, *q_back; char q_data[1]; };
struct	rpc_createerr rpc_createerr;	/* rpc_commondata */
fd_set svc_fdset;			/* rpc_commondata */

/*
 * All function names, alpha order by function name
 * Note: _foo and foo are considered alphabetically very close, with
 * _foo coming second.
 */
long		a64l(s) char *s; { return (0L); }
void		abort() {}
int		abs(i) { return (i); }
int		accept(s, a, l) struct sockaddr *a; int *l; { return (s); }
int		access(f, m) char *f; mode_t m; { return (m); }
int		acct(f) char *f; { return (0); }
int		addexportent(f, d, o) FILE *f; char *d, *o; {}
int		addmntent(f, m) FILE *f; struct mntent *m; { return (0); }
int		adjtime(delta, odelta) struct timeval *delta, *odelta; { return 0; }
int		advfs(fs, nm, flg, cl) char *fs, *nm, *cl; { return (flg); }
unsigned	alarm(s) unsigned s; { return (s); }
int		alphasort(d1, d2) struct dirent **d1, **d2; { return (0); }
char		*asctime(t) struct tm *t; { static char *x; return (x); }
void		_assert(a, f, n) char *a, *f; {}
void		assert(exp) {}
void		async_daemon() {}
double		atof(s) char *s; { return (0.0); }
int		atoi(s) char *s; { return (0); }
long		atol(s) char *s; { return (0L); }
int		audit(r) audit_record_t *r; { return (0); }
void		audit_args(event, argc, argv) char** argv; { }
void		audit_text(event, e, r, argc, argv) char** argv; { }
int		auditon(c) { return (c); }
int		auditsvc(f, l) { return (f); }
AUTH		*authdes_create(servername, window, syncaddr, ckey) char *servername; u_int window; struct sockaddr *syncaddr; des_block *ckey; { return ((AUTH *)0); }
int		authdes_getucred(adc, uid, gid, grouplen, groups) struct authdes_cred *adc; short *uid, *gid, *grouplen; int *groups; { return (0); }
AUTH		*authnone_create() { return ((AUTH *)0); }
AUTH		*authunix_create(host, uid, gid, len, aup_gids) char *host; int uid, gid, len, *aup_gids; { return ((AUTH *)0); }
AUTH		*authunix_create_default() { return ((AUTH *)0); }
int		bcmp(b1, b2, l) char *b1, *b2; { return (0); }
void		bcopy(b1, b2, l) char *b1, *b2; {}
int		bind(s, n, l) struct sockaddr *n; { return (0); }
int		bindresvport(d, s) struct sockaddr_in *s; { return (0); }
int		brk(e) char *e; { return (0); }
void		*bsearch(k, b, n, w, c) void *k, *b; size_t n, w; int (*c)(); { return (k); }
void		bzero(b, l) char *b; {}
void		*calloc(n, e) size_t n, e; { static void *x; return (x); }
int		callrpc(host, prog, vers, proc, inproc, in, outproc, out) char *host; u_long prog, vers, proc; xdrproc_t inproc, outproc; char *in, *out; { return (0); }
int		cbc_crypt(key, buf, len, mode, ivec) char *key, *buf, *ivec; unsigned len, mode; { return (0); }
speed_t		cfgetispeed(t) struct termios *t; { static speed_t x; return (x); }
speed_t		cfgetospeed(t) struct termios *t; { static speed_t x; return (x); }
void		cfree(p) char* p; { }
int		cfsetispeed(t, s) struct termios *t; speed_t s; { return (0); }
int		cfsetospeed(t, s) struct termios *t; speed_t s; { return (0); }
int		chdir(s) char *s; { return (0); }
int		chmod(s, m) char *s; mode_t m; { return (0); }
int		chown(s, o, g) char *s; uid_t o; gid_t g; { return (o); }
int		chroot(p) char *p; { return (0); }
void		clearerr(f) FILE *f; {}
enum clnt_stat	clnt_broadcast(prog, vers, proc, xargs, argsp, xresults, resultsp, eachresult) u_long prog, vers, proc; xdrproc_t xargs; char *argsp; xdrproc_t xresults; char *resultsp; bool_t (*eachresult)(); { return ((enum clnt_stat)0); }
CLIENT		*clnt_create(hostname, prog, vers, proto) char *hostname; u_long prog, vers; char *proto; { return ((CLIENT *)0); }
CLIENT		*clnt_create_vers(hostname, prog, vers_out, low, high, proto) char *hostname; unsigned prog, vers_out; unsigned low, high; char *proto; { return ((CLIENT *)0); }
void		clnt_pcreateerror(s) char *s; {}
void		clnt_perrno(num) enum clnt_stat num; {}
void		clnt_perror(rpch, s) CLIENT *rpch; char *s; {}
char		*clnt_spcreateerror(s) char *s; { return (""); }
char		*clnt_sperrno(num) enum clnt_stat num; { return (""); }
char		*clnt_sperror(rpch, s) CLIENT *rpch; char *s; { return (""); }
CLIENT		*clntraw_create(prog, vers) u_long prog, vers; { return ((CLIENT *)0); }
CLIENT		*clnttcp_create(raddr, prog, vers, sockp, sendsz, recvsz) struct sockaddr_in *raddr; u_long prog, vers; int *sockp; u_int sendsz, recvsz; { return ((CLIENT *)0); }
CLIENT		*clntudp_bufcreate(raddr, prog, vers, waittime, sockp, sendsz, recvsz) struct sockaddr_in *raddr; u_long prog, vers; struct timeval waittime; int *sockp; u_int sendsz, recvsz; { return ((CLIENT *)0); }
CLIENT		*clntudp_create(raddr, prog, vers, waittime, sockp) struct sockaddr_in *raddr; u_long prog, vers; struct timeval waittime; int *sockp; { return ((CLIENT *)0); }
long		clock() { return (0L); }
int		close(f) { return (0); }
int		closedir(d) DIR *d; { return (0); }
void		closelog() {}
int		connect(s, n, l) struct sockaddr *n; { return (0); }
double		copysign(x,y) double x,y; { return (x); }
int		creat(s, m) char *s; mode_t m; { return (m); }
char		*crypt(k, s) char *k, *s; { return (k); }
char		*ctermid(s) char *s; { return (s); }
char		*ctime(t) time_t *t; { static char *x; return (x); }
char		*cuserid(s) char *s; { return (s); }
void		dbm_close(db) DBM *db; { ; }
int		dbm_close_status(d) DBM *d; { return (0); }
int		dbm_delete(db, key) DBM *db; datum key; { return 0; }
datum		dbm_nextkey(db) DBM *db; { datum key; return key; }
datum		dbm_fetch(db, key) DBM *db; datum key; { return key; }
datum		dbm_firsthash(db, h) DBM *db; long h; { datum key; return key; }
datum		dbm_firstkey(db) DBM *db; { datum key; return key; }
int		dbm_flush(d) DBM *d; { return (0); }
int		dbm_flushdir(d) DBM *d; { return (0); }
int		dbm_flushpag(d) DBM *d; { return (0); }
long		dbm_forder(d,k) DBM *d; datum k; { return (0L); }
void		dbm_setdefwrite(d) DBM *d; {}
DBM		*dbm_open(file, flags, mode) char *file; { return (DBM *) 0; }
int		dbm_store(db, key, cont, flags) DBM *db; datum key, cont; { return 0; }
void		decimal_to_double(px, pm, pd, ps) double *px ; decimal_mode *pm; decimal_record *pd; fp_exception_field_type *ps; {}
void		decimal_to_extended(px, pm, pd, ps) extended *px ; decimal_mode *pm; decimal_record *pd; fp_exception_field_type *ps; {}
void		decimal_to_quadruple(px, pm, pd, ps) quadruple *px; decimal_mode *pm; decimal_record *pd; fp_exception_field_type *ps; {}
void		decimal_to_single(px, pm, pd, ps) single *px ; decimal_mode *pm; decimal_record *pd; fp_exception_field_type *ps; {}
void		des_setparity(p) char *p; { }
void		double_to_decimal(px, pm, pd, ps) double *px ; decimal_mode *pm; decimal_record *pd; fp_exception_field_type *ps; {}
double		drand48() { return (0.0); }
int		dup(f) { return (f); }
int		dup2(f1, f2) { return (f2); }
int		dysize(x) { return (x); }
int		ecb_crypt(key, buf, len, mode) char *key, *buf; unsigned len, mode; { return (0); }
char		*ecvt(v, n, d, s) double v; int *d, *s; { return (""); }
char		*econvert(v, n, d, s, b) double v; int *d, *s; char *b; { return (""); }
void		encrypt(b, e) char *b; {}
void		endac() {}
void		endexportent(f) FILE *f; {}
int		endfsent() { return (0); }
void		endgrent() {}
void		endgraent() {}
void		endhostent() {}
int		endmntent(f) FILE *f; { return (0); }
void		endnetent() {}
void		endnetgrent() {}
void		endprotoent() {}
void		endpwent() {}
void		endpwaent() {}
void		endrpcent() {}
void		endservent() {}
void		endttyent() {}
void		endusershell() {}
double		erand48(x) unsigned short x[3]; { return (0.0); }
struct ether_addr *ether_aton(s) char *s; { return ((struct ether_addr*)0); }
int		ether_hostton(h, e) char *h; struct ether_addr *e; { return (0); }
int		ether_line(l, e, h) char *l, *h; struct ether_addr *e; { return (0); }
char		*ether_ntoa(e) struct ether_addr *e; { return (""); }
int		ether_ntohost(h, e) char *h; struct ether_addr *e; { return (0); }
		/*VARARGS2*/
int		execl(f, a) char *f, *a; { return (0); }
		/*VARARGS3*/
int		execle(f, a, e) char *f, *a, *e[]; { return (0); }
		/*VARARGS2*/
int		execlp(f, a) char *f, *a; { return (0); }
int		execv(s, v) char *s, *v[]; { return (0); }
int		execve(f, a, e) char *f, *a[], *e[]; { return (0); }
int		execvp(s, v) char *s, *v[]; { return (0); }
void		exit(s) {}
void		_exit(s) {}
int		exportfs(d, uex) char *d; struct export *uex; { return (0); }
void		extended_to_decimal(px, pm, pd, ps) extended *px ; decimal_mode *pm; decimal_record *pd; fp_exception_field_type *ps; { }
double		fabs(x) double x; { return (x); }
int		fchdir(d) { return (d); }
int		fchmod(f, m) { return (m); }
int		fchown(f, o, g) { return (o); }
int		fchroot(d) { return (d); }
int		fclose(f) FILE *f; { return (0); }
		/*VARARGS2*/
int		fcntl(f, c, a) { return (f); }
char		*fcvt(v, n, d, s) double v; int *d, *s; { return (""); }
char		*fconvert(v, n, d, s, b) double v; int *d, *s; char *b; { return (""); }
FILE		*fdopen(f, t) char *t; { return (stdin); }
int		feof(f) FILE *f; { return (0); }
int		ferror(f) FILE *f; { return (0); }
int		fflush(f) FILE *f; { return (0); }
int		ffs(i) int i; { return (0); }
int		fgetc(f) FILE *f; { return (0); }
struct group	*fgetgrent(f) FILE *f; { static struct group x; return (&x); }
struct group_adjunct	*fgetgraent(f) FILE *f; { static struct group_adjunct x; return (&x); }
struct passwd	*fgetpwent(f) FILE *f; { static struct passwd x; return (&x); }
struct passwd_adjunct	*fgetpwaent(f) FILE *f; { static struct passwd_adjunct x; return (&x); }
char		*fgets(s, n, f) char *s; FILE *f; { return (s); }
int		_filbuf(f) FILE *f; { return (0); }
int		fileno(f) FILE *f; { static int fd; return (fd); }
void		file_to_decimal(pc,nmax,fortran_conventions,pd,pform,pechar,pf,pnread) char **pc; int nmax; int fortran_conventions; decimal_record *pd; enum decimal_string_form *pform; char **pechar; FILE *pf; int *pnread; {}
int		flock(f, o) { return (f); }
int		_flsbuf(c, f) FILE *f; { return (c); }
double		fmod(x,y) double x, y; { return (x); }
FILE		*fopen(f, t) char *f, *t; { return (stdin); }
pid_t		fork() { static pid_t x; return (x); }
long		fpathconf(f, n) { static long x; return (x); }
		/*VARARGS2 PRINTFLIKE2*/
int		fprintf(f, s) FILE *f; char *s; { return (0); }
int		fputc(c, f) FILE *f; { return (c); }
int		fputs(s, f) char *s; FILE *f; { return (0); }
size_t		fread(b, s, n, f) void *b; size_t s, n; FILE *f; { return (n); }
void		free(s) void *s; {}
FILE		*freopen(f, t, s) char *f, *t; FILE *s; { return (s); }
double		frexp(x, e) double x; int *e; { return (x); }
		/*VARARGS2 SCANFLIKE2*/
int		fscanf(f, s) FILE *f; char *s; { return (0); }
int		fseek(f, o, p) FILE *f; long o; { return (0); }
int		fstat(f, b) struct stat *b; { return (0); }
int		fstatfs(f, b) struct statfs *b; { return (0); }
int		fsync(f) { return (0); }
long		ftell(f) FILE *f; { static long p; return (p); }
key_t		ftok(s, i) char *s; { return ((key_t)0); }
int		ftruncate(d, l) off_t l; { return (0); }
int		ftw(p, f, d) char *p; int (*f)(); { return (d); }
size_t		fwrite(b, s, n, f) char *b; size_t s, n; FILE *f; { return (n); }
void		func_to_decimal(pc,nmax,fortran_conventions,pd,pform,pechar,pget,pnread,punget) char **pc; int nmax; int fortran_conventions; decimal_record *pd; enum decimal_string_form *pform; char **pechar; int (*pget)(); int *pnread; int (*punget)(); {}
char		*gcvt(v, n, b) double v; char *b; { return (b); }
char		*gconvert(v, n, t, b) double v; char *b; { return (b); }
void		get_myaddress(addr) struct sockaddr_in *addr; { }
int		getacdir(dir, len) char *dir; { return (len); }
int		getacflg(as, l) char* as; { return (l); }
int		getacmin(m) int *m; { return (0); }
int		getauditflagsbin(a, m) char *a; audit_state_t *m; { return (0); }
int		getauditflagschar(a, m, v) char *a; audit_state_t *m; { return (0); }
int		getauid() { return (0); }
int		getfauditflags(a, b, c) audit_state_t *a, *b, *c; { return (0); }
int		getc(f) FILE *f; { return (0); }
int		getchar() { return (0); }
char		*getcwd(b, s) char *b; { return (b); }
int		getdents(d, b, n) char *b; { return (0); }
int		getdirentries(d, b, n, p) char *b; long *p; { return (0); }
int		getdomainname(n, l) char *n; int l; { return (0) ;}
int		getdtablesize() { return (0); }
gid_t		getegid() { static gid_t x; return (x); }
char		*getenv(n) char *n; { return (n); }
uid_t		geteuid() { static uid_t x; return (x); }
struct exportent	*getexportent(f) FILE *f; { return (0); }
char		*getexportopt(x, o) struct exportent *x; char *o; { return (0); }
struct fstab	*getfsent() { return (struct fstab *)0; }
struct fstab	*getfsfile(n) char *n; { return (struct fstab *)0; }
struct fstab	*getfsspec(n) char *n; { return (struct fstab *)0; }
struct fstab	*getfstype(t) char *t; { return (struct fstab *)0; }
gid_t		getgid() { static gid_t x; return (x); }
struct group	*getgrent() { static struct group x; return (&x); }
struct group_adjunct	*getgraent() { static struct group_adjunct x; return (&x); }
struct group	*getgrgid(g) gid_t g; { static struct group x; return (&x); }
struct group	*getgrnam(n) char *n; { static struct group x; return (&x); }
struct group_adjunct	*getgranam(n) char *n; { static struct group_adjunct x; return (&x); }
int		getgroups(n, g) gid_t *g; { return (n); }
struct hostent	*gethostbyaddr(a, l, t) char *a; { static struct hostent x; return (&x); }
struct hostent	*gethostbyname(n) char *n; { static struct hostent x; return (&x); }
struct hostent	*gethostent() { static struct hostent x; return (&x); }
long		gethostid() { return (0L); }
int		gethostname(n, l) char *n; int l; { return (0) ;}
int		getitimer(w, v) struct itimerval *v; { return (0); }
int		getlocale_ctype(l, c, n) char *l, *c, *n; { return (0); }
char		*getlocale_numeric(l, lc) char *l; struct lconv *lc; { return (""); }
char		*getlocale_time() { return (""); }
char		*getlogin() { static char *x; return (x); }
struct mntent	*getmntent(f) FILE *f; { static struct mntent x; return (&x); }
int		getmsg(fd, c, d, fl) struct strbuf *c, *d; int *fl; { return (0); }
struct netent	*getnetbyaddr(n, t) { static struct netent x; return (&x); }
struct netent	*getnetbyname(n) char *n; { static struct netent x; return (&x); }
struct netent	*getnetent() { static struct netent x; return (&x); }
int		getnetgrent(m, u, d) char **m, **u, **d; { return (0); }
int		getnetname(name) char *name; { return (0); }
int		getopt(c, v, o) char **v, *o; { return (c); }
int		getpagesize() { return (0); }
char		*getpass(s) char *s; { return (s); }
int		getpeername(s, n, l) struct sockaddr *n; int *l; { return (0); }
pid_t		getpgrp() { return (0); }
pid_t		getpid() { return (0); }
pid_t		getppid() { return (0); }
int		getpriority(w, who) { return (0); }
struct protoent	*getprotobyname(n) char *n; { static struct protoent x; return (&x); }
struct protoent	*getprotobynumber(p) { static struct protoent x; return (&x); }
struct protoent	*getprotoent() { static struct protoent x; return (&x); }
int		getpw(u, b) char *b; { return (u); }
struct passwd	*getpwent() { static struct passwd x; return (&x); }
struct passwd_adjunct	*getpwaent() { static struct passwd_adjunct x; return (&x); }
struct passwd	*getpwnam(n) char *n; { static struct passwd x; return (&x); }
struct passwd_adjunct	*getpwanam(n) char *n; { static struct passwd_adjunct x; return (&x); }
struct passwd	*getpwuid(u) uid_t u; { static struct passwd x; return (&x); }
int		getrlimit(res, rip) struct rlimit *rip; { return (0); }
struct rpcent	*getrpcbyname(n) char *n; { return ((struct rpcent*)0); }
struct rpcent	*getrpcbynumber(n) { return ((struct rpcent*)0); }
struct rpcent	*getrpcent() { return ((struct rpcent*)0); }
int		getrpcport(h, p, v, pr) char *h; { return (0); }
int		getrusage(res, rip) struct rusage *rip; { return (0); }
char		*gets(s) char *s; { return (s); }
struct servent	*getservbyname(n, p) char *n, *p; { static struct servent x; return (&x); }
struct servent	*getservbyport(port, p) char *p; { static struct servent x; return (&x); }
struct servent	*getservent() { static struct servent x; return (&x); }
int		getsockname(s, name, namelen) struct sockaddr *name; int *namelen; { return (0); }
int		getsockopt(s, level, opt, buf, lenp) char *buf; int *lenp; { return (0); }
int		getsubopt(o, t, v) char **o, **t, **v; { return (0); }
int		gettimeofday(t, z) struct timeval *t; struct timezone *z; { return (0);}
struct ttyent	*getttyent() { return (struct ttyent *) 0; }
struct ttyent	*getttynam(name) char *name; { return (struct ttyent *) 0; }
uid_t		getuid() { static uid_t x; return (x); }
char		*getusershell() { return (char *) 0; }
int		getw(f) FILE *f; { return (0); }
char		*getwd(p) char *p; { return (p); }
struct tm	*gmtime(c) time_t *c; { static struct tm x; return (&x); }
int		grpauth(g, passwd) char *g; char* passwd; { return (0); }
int		gsignal(s) { return (s); }
int		gtty(f, buf) struct sgtty *buf; { return (0); }
char		*hasmntopt(m, o) struct mntent *m; char *o; { return (0); }
int		hcreate(n) unsigned n; { return (0); }
void		hdestroy() {}
int		host2netname(netname, host, domain) char *netname, *host, *domain; { return (0); }
unsigned long	htonl(l) unsigned long l; { return (l); }
unsigned short	htons(l) unsigned short l; { return (l); }
ENTRY		*hsearch(i, a) ENTRY i; ACTION a; { return (&i); }
char		*index(a, b) char *a, b; { return (a); }
u_long		inet_addr(cp) char *cp; { return (0); }
int		inet_lnaof(in) struct in_addr in; { return (0); }
struct in_addr	inet_makeaddr(n, l) { static struct in_addr x; return (x); }
int		inet_netof(in) struct in_addr in; { return (0); }
u_long		inet_network(cp) char *cp; { return (0); }
char		*inet_ntoa(in) struct in_addr in; { return (""); }
int		initgroups(n, g) char *n; { return (0); }
char		*initstate(s, st, n) unsigned s; char *st; { return st; }
int		innetgr(g, m, u, d) char *g, *m, *u, *d; { return (0); }
void		insque(e, p) struct qelem *e, *p; {}
		/*VARARGS2*/
int		ioctl(f, r, a) { return (f); }
int		isalnum(c) { return (c); }
int		isalpha(c) { return (c); }
int		isascii(c) { return (c); }
int		isatty(f) { return (1); }
int		iscntrl(c) { return (c); }
int		isdigit(c) { return (c); }
int		isgraph(c) { return (c); }
/*???int		isinf(v) double v; { return (0); }*/
int		islower(c) { return (c); }
/*???int		isnan(v) double v; { return (0); }*/
int		isprint(c) { return (c); }
int		ispunct(c) { return (c); }
int		issecure() { return (0); }
int		isspace(c) { return (c); }
int		isupper(c) { return (c); }
int		isxdigit(c) { return (c); }
long		jrand48(x) unsigned short x[3]; { return (0L); }
int		key_decryptsession(remotename, deskey) char *remotename; des_block *deskey; { return (0); }
int		key_encryptsession(remotename, deskey) char *remotename; des_block *deskey; { return (0); }
int		key_gendes(key) des_block *key; { return (0); }
int		key_setsecret(secretkey) char *secretkey; { return (0); }
int		kill(i, s) pid_t i; { return (s); }
int		killpg(pg, s) { return (0); }
/*???void		l3tol(l, c, n) long *l; char *c; {}*/
char		*l64a(l) long l; { return (""); }
char		*labeltostring(p, b, v) blabel_t *v; { return (""); }
void		labelfromstring(p, l, v) char *l; blabel_t *v; {}
void		lcong48(p) unsigned short p[7]; {}
double		ldexp(v, e) double v; { return (v); }
char		*lfind(k, b, n, w, c) char *k, *b; unsigned *n, w; int (*c)(); { return (k); }
int		link(a, b) char *a, *b; { return (0); }
int		listen(s, b) { return (0); }
struct tm	*localtime(c) time_t *c; { static struct tm x; return (&x); }
struct lconv	*localeconv() { return ((struct lconv*)0); }
int		lockf(fd, cmd, size) long size; { return (0); }
void		longjmp(e, v) jmp_buf e; {}
void		_longjmp(e, v) jmp_buf e; {}
long		lrand48() { return (0L); }
char		*lsearch(k, b, n, w, c) char *k, *b; unsigned *n, w; int (*c)(); { return (k); }
off_t		lseek(f, o, w) off_t o; { return (o); }
int		lstat(s, b) char *s; struct stat *b; { return (0); }
/*???void		ltol3(c, l, n) char *c; long *l; {}*/
int		madvise(a, l, b) char *a; int l, b; { return (0); }
struct mallinfo	mallinfo() { struct mallinfo s; return (s); }
void		*malloc(s) size_t s; { static void *x; return (x); }
int		mallopt (cmd, value) int cmd, value; { return cmd+value; }
int		mbstowcs(pwcs, s, n) wchar_t * pwcs; char *s; size_t n; { return (0); }
int		mbtowc(pwc, s, n) wchar_t * pwc; char *s; size_t n; { return (0); }
char		*memalign(a, s) unsigned a, s; { return (""); }
char		*memccpy(a, b, c, n) char *a, *b; { return (a); }
char		*memchr(s, c, n) char *s; { return (s); }
int		memcmp(a, b, n) char *a, *b; { return (n); }
char		*memcpy(a, b, n) char *a, *b; { return (a); }
char		*memset(s, c, n) char *s; { return (s); }
int		mincore(a, l, v) caddr_t a; int l; char *v; { return (0); }
int		mkdir(p, m) char *p; mode_t m; { return (0); }
int		mkfifo(p, m) char *p; mode_t m; { return (0); }
int		mknod(n, m, d) char *n; { return (m); }
int		mkstemp(p) char *p; { return (0); }
char		*mktemp(t) char *t; { return (t); }
time_t		mktime(t) struct tm *t; { static time_t x; return (x); }
int		mlock(a, l) caddr_t a; u_int l; { return (0); }
int		mlockall(l) { return (0); }
caddr_t		mmap(a, l, p, s, f, o) caddr_t a; off_t o; { return (0); }
double		modf(v, i) double v, *i; { return (v); }
void		moncontrol(m) int m; {}
void		monitor(l, h, b, s, n) int (*l)(), (*h)(); WORD *b; {}
void		monstartup(l, h) int (*l)(), (*h)(); {}
int		mount(s, d, r) char *s, *d; { return (r); }
int		mprotect(a, l, p) char *a; { return (0); }
long		mrand48() { return (0L); }
/*???int		mremap(a, l, p, s, f) char *a, f; { return (0); }*/
int		msgctl(m, c, b) struct msqid_ds *b; { return (m); }
int		msgget(k, m) key_t k; { return (m); }
int		msgrcv(q, p, s, t, f) struct msgbuf *p; long t; { return (q); }
int		msgsnd(q, p, s, f) struct msgbuf *p; { return (q); }
int		msync(addr, len, flags) caddr_t addr; u_int len; { return (0); }
int		munlock(a, l) caddr_t a; u_int l; { return (0); }
int		munlockall() { return (0); }
int		munmap(a, l) char *a; { return (0); }
int		netname2host(netname, hostname, hostlen) char *netname, *hostname; int hostlen; { return (0); }
int		netname2user(name, uid, gid, len, groups) char *name; int *uid, *gid, *len, *groups; { return (0); }
void		nfssvc(s) int s; {}
int		nice(i) { return (i); }
int		nlist(f, n) char *f; struct nlist *n; { return (0); }
char		*nl_ascxtime(tmptr, fmt) struct tm *tmptr; char *fmt; { return (""); }
char		*nl_cxtime(clk, fmt) struct tm *clk; char *fmt; { return (""); }
int		nl_strncmp(s1, s2, n) char *s1, *s2; { return (0); }
long		nrand48(x) unsigned short x[3]; { return (0L); }
u_long		ntohl(netlong) u_long netlong; { return netlong; }
u_short		ntohs(netshort) u_short netshort; { return netshort; }
struct tm 	*offtime(timep, offset) time_t *timep; long offset; { return ((struct tm*)0); }
int		on_exit(p, a) void (*p)(); caddr_t a; { return (0); }
		/*VARARGS2*/
int		open(f, o, m) char *f; { return (o); }
DIR		*opendir(f) char *f; { return (DIR *)0; }
int		openlocale(c, id, l, n) char *c, *l, *n; { return (0); }
int		openlog(s, f, l) char *s; {}
long		pathconf(p, n) char *p; { static long x; return (x); }
int		pause() { return (0); }
int		pclose(f) FILE *f; { return (0); }
void		perror(s) char *s; {}
int		pipe(f) int f[2]; { return (0); }
int		plock(o) { return (o); }
struct pmaplist	*pmap_getmaps(address) struct sockaddr_in *address; { return ((struct pmaplist *)0); }
u_short		pmap_getport(address, prog, vers, prot) struct sockaddr_in *address; u_long prog, vers; u_int prot; { return ((u_short)0); }
enum	clnt_stat	pmap_rmtcall(addr, prog, vers, proc, xdrargs, argsp, xdrres, resp, tout, port_ptr) struct sockaddr_in *addr; u_long prog, vers, proc; xdrproc_t xdrargs, xdrres; caddr_t argsp, resp; struct timeval tout; u_long *port_ptr; { return ((enum clnt_stat)0); }
bool_t		pmap_set(prog, vers, prot, port) u_long prog, vers; int prot; u_short port; { return (0); }
bool_t		pmap_unset(prog, vers) u_long prog, vers; { return (0); }
int		poll(fds, nfds, t) struct pollfd *fds; unsigned long nfds; { return (0); }
FILE		*popen(c, t) char *c, *t; { return (stdin); }
		/*VARARGS1 PRINTFLIKE1*/
int		printf(s) char *s; { return (0); }
void		profil(b, s, o, i) char *b; {}
void		psignal(sig, s) unsigned sig; char *s; {}
		/*VARARGS4*/
int		ptrace(r, p, a1, d, a2) enum ptracereq r; char *a1; { return (0); }
int		putc(c, f) FILE *f; { return (c); }
int		putchar(c) { return (c); }
int		putenv(s) char *s; { return (0); }
int		putmsg(fd, c, d, fl) struct strbuf *c, *d; { return (0); }
int		putpwent(s, f) struct passwd *s; FILE *f; { return (0); }
int		puts(s) char *s; { return (0); }
int		putw(w, f) FILE *f; { return (w); }
int		pwdauth(u, p) char *u, *p; { return (0); }
char		*qeconvert(a, n, d, s, b) quadruple *a; int *d, *s; char *b; { return (b); }
char		*qfconvert(a, n, d, s, b) quadruple *a; int *d, *s; char *b; { return (b); }
char		*qgconvert(a, n, d, b) quadruple *a; char *b; { return (b); }
void		qsort(b, n, w, c) void *b; size_t n, w; int (*c)(); {}
void		quadruple_to_decimal(px, pm, pd, ps) quadruple *px; decimal_mode *pm; decimal_record *pd; fp_exception_field_type *ps; {}
int		quotactl(c, d, u, a) char *d, *a; { return (0); }
int		rand() { return (0); }
long		random() { return (0L); }
int		rcmd(a, i, l, r, c, f) char **a; u_short i; char *l, *r, *c; int *f; { return (0); }
char		*re_comp(s) char *s; { return (s); }
int		re_exec(s) char *s; { return (0); }
int		read(f, b, n) char *b; unsigned n; { return (f); }
struct dirent	*readdir(d) DIR *d; { return (struct dirent *)0; }
int		readlink(p, b, s) char *p, *b; { return (0); }
int		readv(f, v, l) struct iovec *v; { return (f); }
void		*realloc(s, n) void *s; size_t n; { return (s); }
char		*realpath(f, n) char* f, *n; { return (n); }
		/*VARARGS1*/
int		reboot(h) { return (0); }
int		recv(s, b, l, f) char *b; { return (l); }
int		recvfrom(s, b, l, f, fr, fl) char *b; struct sockaddr *fr; int *fl; { return (l); }
int		recvmsg(s, m, f) struct msghdr m[]; { return (0); }
int		registerrpc(prog, vers, proc, progname, inproc, outproc) u_long prog, vers, proc; char *(*progname)(); xdrproc_t inproc, outproc; { return (0); }
int		remexportent(f, d) FILE *f; char *d; { return (0); }
int		remove(f) char *f; { return (0); }
void		remque(e) struct qelem *e; {}
int		rename(f, t) char *f, *t; { return (0); }
void		rewind(f) FILE *f; {}
void		rewinddir(dirp) DIR *dirp; {}
int		rexec(a, i, u, p, c, f) char **a; u_short i; char *u, *p, *c; int *f; { return (0); }
int		rfstart() { return (0); }
int		rfstop() { return (0); }
		/*VARARGS*/
int		rfsys() { return (0); }
char		*rindex(a, b) char *a, b; { return (a); }
int		rmdir(p) char *p; { return (0); }
int		rresvport(p) int *p; { return (0); }
int		rtime(addrp, timep, timeout) struct sockaddr_in *addrp; struct timeval *timep, *timeout; { return (0); }
int		ruserok(rhost, s, r, l) char *rhost, *r, *l; { return (0); }
char		*sbrk(i) { return (""); }
int		scandir(d, n, s, c) char *d; struct dirent *(*n[]); int (*s)(),(*c)(); { return (0); }
		/*VARARGS1 SCANFLIKE1*/
int		scanf(s) char *s; { return (0); }
char		*seconvert(value, ndigit, decpt, sign, buf) single *value; int *decpt, *sign; char *buf; { return (buf); }
unsigned short	*seed48(s) unsigned short s[3]; { return (s); }
void		seekdir(d, l) DIR *d; long l; {}
int		select( n, r, w, e, t ) fd_set *r, *w, *e; struct timeval *t; { return n; }
		/*VARARGS4*/
int		semctl(i, n, c, a) union semun a; { return (i); }
int		semget(k, n, s) key_t k; { return (n); }
int		semop(i, o, n) struct sembuf *o; { return (i); }
int		send(s, m, l, f) char *m; { return (l); }
int		sendmsg(s, m, l) struct msghdr m[]; { return (l); }
int		sendto(s, m, l, f, t, tl) char *m; struct sockaddr *t; { return (l); }
void		setac() {}
int		setaudit(s) audit_state_t *s; { return (0); }
int		setauid(a) { return (a); }
void		setbuf(f, b) FILE *f; char *b; {}
void		setbuffer(f, b, n) FILE *f; char *b; {}
int		setdomainname(n, l) char *n; int l; { return (0) ;}
int		setegid(g) int g; { return (0); }
int		seteuid(u) int u; { return (0); }
FILE		*setexportent() { return (0); }
int		setfsent() { return (0); }
int		setgid(g) gid_t g; { return (0); }
void		setgrent() {}
void		setgraent() {}
int		setgroups(n, g) int *g; { return (0); }
void		sethostent(s) {}
int		sethostname(n, l) char *n; int l; { return (0) ;}
int		setitimer(w, v, ov) struct itimerval *v, *ov; { return (0); }
int		setjmp(e) jmp_buf e; { return (0); }
int		_setjmp(e) jmp_buf e; { return (0); }
void		setkey(k) char *k; {}
void		setlinebuf(f) FILE *f; {}
char		*setlocale(category, locale) char *locale; {return (locale);}
int		setlogmask(m) { return (0); }
FILE		*setmntent(f, t) char *f, *t; { return (0); }
void		setnetent(s) {}
void		setnetgrent(g) char *g; {}
int		setpgid(p, g) pid_t p, g; { return (0); }
int		setpgrp() { return (0); }
int		setpriority(w, who, pri) { return (0); }
void		setprotoent(s) {}
void		setpwent() {}
void		setpwaent() {}
void		setpwfile(file) char *file; {}
int		setregid(r, e) { return (0); }
int		setreuid(r, e) { return (0); }
int		setrgid(g) int g; { return (0); }
int		setrlimit(res, rip) struct rlimit *rip; { return (0); }
void		setrpcent(f) {}
int		setruid(u) int u; { return (0); }
void		setservent(s) {}
pid_t		setsid() { static pid_t p; return (p); }
int		setsockopt(s, level, opt, buf, len) char *buf; { return (0); }
char		*setstate(st) char *st; { return st; }
int		settimeofday(t, z) struct timeval *t; struct timezone *z; { return (0);}
void		setttyent() {}
int		setuid(u) uid_t u; { return (0); }
void		setupcolldef() {}
int		setuseraudit(u, s) audit_state_t *s; { return (0); }
void		setusershell() {}
int		setvbuf(f, b, t, s) FILE *f; char *b; size_t s; { return (t); }
char		*sfconvert(value, ndigit, decpt, sign, buf) single *value; int ndigit, *decpt, *sign; char *buf; { return (buf); }
char		*sgconvert(value, ndigit, trailing, buf) single *value; int ndigit; int trailing; char *buf; { return (buf); }
long		sgetl(b) char *b; { return (0L); }
char		*shmat(i, a, f) char *a; { return (a); }
int		shmctl(s, c, b) struct shmid_ds *b; { return (s); }
int		shmdt(a) char *a; { return (0); }
int		shmget(k, s, f) key_t k; { return (s); }
int		shutdown( s, h ){ return 0;}
int		sigaction(s, a, o) struct sigaction *a, *o; { return (0); }
int		sigaddset(s, i) sigset_t *s; { return (0); }
int		sigblock(m) { return (m); }
int		sigdelset(s, i) sigset_t *s; { return (0); }
int		sigemptyset(s) sigset_t *s; { return (0); }
int		sigfillset(s) sigset_t *s; { return (0); }
sigfpe_handler_type	sigfpe(code, hdl) sigfpe_code_type code; sigfpe_handler_type hdl; { return ((sigfpe_handler_type)0); }
int		sighold(s) { return (0); }
int		sigignore(s) { return (0); }
int		sigrelse(s) { return (0); }
void		(*sigset(s,f))() void (*f)(); { return (f); }
void		single_to_decimal(px, pm, pd, ps) single *px ; decimal_mode *pm; decimal_record *pd; fp_exception_field_type *ps; {}
int		siginterrupt(sig, flag) { return 0; }
int		sigismember(s, i) sigset_t *s; { return (1); }
void		siglongjmp(e, v) sigjmp_buf e; {}
void		(*signal(s, a))() void (*a)(); { return (a); }
int		sigpause(m) { return (0); }
int		sigpending(s) sigset_t *s; { return (0); }
int		sigprocmask(h, s, o) sigset_t *s, *o; { return (0); }
int		sigsetjmp(e, s) sigjmp_buf e; { return (0); }
int		sigsetmask(m) { return (m); }
int		sigstack(ss, oss) struct sigstack *ss, *oss; { return (0); }
int		sigsuspend(s) sigset_t *s; { return (0); }
int		sigvec(sig, vec, ovec) int sig; struct sigvec *vec, *ovec; { return (0); }
unsigned	sleep(n) unsigned n; { return (0); }
int		socket(a, t, p) { return (0); }
int		socketpair(d, t, p, s ) int s[2]; { return (0); }
		/*VARARGS2 PRINTFLIKE2*/
int		sprintf(p, s) char *p, *s; { return (0); }
void		sputl(l, b) char *b; {}
void		srand(s) unsigned s; {}
void		srand48(s) long s; {}
void		srandom(s) int s; {}
		/*VARARGS2 SCANFLIKE2*/
int		sscanf(p, s) char *p, *s; { return (0); }
int		(*ssignal(s, a))() int (*a)(); { return (a); }
int		stat(s, b) char *s; struct stat *b; { return (0); }
int		statfs(s, b) char *s; struct statfs *b; { return (0); }
int		stime(t) long *t; { return (0); }
int		strcasecmp(s1, s2) char *s1, *s2; { return (0); }
int		strcoll(s1, s2) char *s1, *s2; { return (0); }
char		*strcat(a, b) char *a, *b; { return (a); }
char		*strchr(a, b) char *a; { return (a); }
int		strcmp(a, b) char *a, *b; { return (0); }
char		*strcpy(a, b) char *a, *b; { return (a); }
size_t		strcspn(a, b) char *a, *b; { return (0); }
char		*strdup(a) char *a; { return (a); }
size_t		strftime(buf, maxsize, format, tm) char *buf, *format; size_t maxsize; struct tm *tm; {return (maxsize);}
void		string_to_decimal(pc,nmax,fortran_conventions,pd,pform,pechar) char **pc; int nmax; int fortran_conventions; decimal_record *pd; enum decimal_string_form *pform; char **pechar; {}
size_t		strlen(s) char *s; { return (0); }
int		strncasecmp(s1, s2, n) char *s1, *s2; { return (0); }
char		*strncat(a, b, n) char *a, *b; size_t n; { return (a); }
int		strncmp(a, b, n) char *a, *b; size_t n; { return (0); }
char		*strncpy(a, b, n) char *a, *b; size_t n; { return (a); }
char		*strpbrk(a, b) char *a, *b; { return (a); }
char		*strptime(buf,format,tm) char *buf, *format; struct tm *tm; {return ("");}
char		*strrchr(a, b) char *a; { return (a); }
size_t		strspn(a, b) char *a, *b; { return (0); }
char		*strstr(a,b) char *a, *b; { return (a); }
double		strtod(s, t) char *s, **t; { return (0.0); }
char		*strtok(a, b) char *a, *b; { return (a); }
long		strtol(s, t, b) char *s, **t; { return (0L); }
int		strxfrm(s1, s2, n) char *s1, *s2; { return (0); }
int		stty(fd, buf) struct sgttyb *buf; { return (0); }
void		svc_getreq(rdfds) int rdfds; {}
void		svc_getreqset(readfds) fd_set *readfds; {}
bool_t		svc_register(xprt, prog, vers, dispatch, prot) SVCXPRT *xprt; u_long prog, vers; void (*dispatch)(); int prot; { return (0); }
void		svc_run() {}
bool_t		svc_sendreply(xprt, xdr_results, xdr_location) SVCXPRT *xprt; xdrproc_t xdr_results; caddr_t xdr_location; { return (0); }
void		svc_unregister(prog, vers) u_long prog, vers; {}
void		svc_versquiet(x) SVCXPRT *x; {}
void		svcerr_auth(xprt, why) SVCXPRT *xprt; enum auth_stat why; {}
void		svcerr_decode(xprt) SVCXPRT *xprt; {}
void		svcerr_noproc(xprt) SVCXPRT *xprt; {}
void		svcerr_noprog(xprt) SVCXPRT *xprt; {}
void		svcerr_progvers(xprt, low_vers, high_vers) SVCXPRT *xprt; u_long low_vers, high_vers; {}
void		svcerr_systemerr(xprt) SVCXPRT *xprt; {}
void		svcerr_weakauth(xprt) SVCXPRT *xprt; {}
SVCXPRT		*svcfd_create(fd, sendsize, recvsize) int fd; u_int sendsize, recvsize; { return ((SVCXPRT *)0); }
SVCXPRT		*svcraw_create() { return ((SVCXPRT *)0); }
SVCXPRT		*svctcp_create(sock, sendsize, recvsize) int sock; u_int sendsize, recvsize; { return ((SVCXPRT *)0); }
SVCXPRT		*svcudp_bufcreate(sock, sendsz, recvsz) int sock; u_int sendsz, recvsz; { return ((SVCXPRT *)0); }
SVCXPRT		*svcudp_create(sock) int sock; { return ((SVCXPRT *)0); }
int		svcudp_enablecache(t, s) SVCXPRT *t; u_long s; { return (0); }
void		swab(f, t, n) char *f, *t; {}
int		swapon(s) char *s; { return (0); }
int		symlink(t, f) char *t, *f; { return (0); }
void		sync() {}
		/*VARARGS3*/
int		syscall(n, r, s, a) { return (n); }
long		sysconf(n) { static long x; return (x); }
		/*VARARGS2 PRINTFLIKE2*/
int		syslog(l, f) char *f; {}
int		system(s) char *s; { return (0); }
int		tcdrain(f) { return (0); }
int		tcflow(f, a) { return (0); }
int		tcflush(f, q) { return (0); }
int		tcgetattr(f, t) struct termios *t; { return (0); }
pid_t		tcgetpgrp(f) { static pid_t p; return (p); }
int		tcsendbreak(f, d) { return (0); }
int		tcsetattr(f, o, t) struct termios *t; { return (0); }
int		tcsetpgrp(f, p) pid_t p; { return (0); }
char		*tdelete(k, r, c) char *k, **r; int (*c)(); { return (k); }
long		tell(f) { return (0L); }
long		telldir(d) DIR *d; { return 0L; }
char		*tempnam(d, s) char *d, *s; { return (d); }
char		*tfind(k, r, c) char *k, **r; int (*c)(); { return (k); }
time_t		time(t) time_t *t; { return (*t);}
time_t		timegm(t) struct tm *t; { return (0); }
time_t		timelocal(t) struct tm *t; { return (0); }
time_t		timeoff(t, o) struct tm *t; long o; { return (0); }
clock_t		times(b) struct tms *b; { static clock_t x; return (x); }
FILE		*tmpfile() { return (stdin); }
char		*tmpnam(s) char *s; { return (s); }
int		toascii(i) { return (i); }
int		tolower(i) { return (i); }
int		_tolower(i) { return (i); }
int		toupper(i) { return (i); }
int		_toupper(i) { return (i); }
int		truncate(p, l) char *p; off_t l; { return (0); }
char		*tsearch(k, r, c) char *k, **r; int (*c)(); { return (k); }
char		*ttyname(f) { return (""); }
int		ttyslot() { return (0); }
void		twalk(r, f) char *r; void (*f)(); {}
void		tzset() {}
void		tzsetwall() {}
unsigned	ualarm(value, interval) unsigned value, interval; { return 0; }
daddr_t		ulimit(c, n) daddr_t n; { return (n); }
mode_t		umask(c) mode_t c; { return (c); }
int		umount(s) char *s; { return (0); }
int		unadvfs(s) char *s; { return (0); }
int		uname(n) struct utsname *n; { return (0); }
int		ungetc(c, f) FILE *f; { return (c); }
int		unlink(s) char *s; { return (0); }
int		unmount(s) char *s; { return (0); }
int		user2netname(netname, uid, domain) char *netname; int uid; char *domain; { return (0); }
void		usleep(useconds) unsigned useconds; { ; }
int		ustat(d, b) struct ustat *b; { return (d); }
int		utime(f, t) char *f; struct utimbuf *t; { return (0); }
int		utimes( f, t ) char *f; struct timeval *t; { return 0 ;}
char		*valloc(s) unsigned s; { return (""); }
int		vadvise(p) { return (p); }
int		vfork() { return (0); }
int		vfprintf(f, s, v) FILE *f; char *s; va_list v; { return (0); }
void		vhangup() {}
int		vprintf(s, v) char *s; va_list v; { return (0); }
int		vsprintf(p, s, v) char *p, *s; va_list v; { return (0); }
int		vsyslog(l, f, v) char *f; va_list v; {}
pid_t		wait(s) int *s; { static pid_t p; return (p); }
int		wait3(s, o, r) union wait *s; struct rusage *r; { return (1); }
int		wait4(pid, s, o, r) union wait *s; struct rusage *r; { return (1); }
pid_t		waitpid(p, s, o) pid_t p; int *s; { return (p); }
size_t		wcstombs(s, p, n) char *s; wchar_t *p; size_t n; { return (n); }
int		wctomb(s, pwc, n) char *s; wchar_t *pwc; size_t n; { return (0); }
int		write(f, b, n) char *b; unsigned n; { return (f); }
int		writev(f, v, l) struct iovec *v; {return (f); }
bool_t		xdr_accepted_reply(xdrs, ar) XDR *xdrs; struct accepted_reply *ar; { return (0); }
bool_t		xdr_array(xdrs, addrp, sizep, maxsize, elsize, elproc) XDR *xdrs; caddr_t *addrp; u_int *sizep, maxsize, elsize; xdrproc_t elproc; { return (0); }
bool_t		xdr_authdes_cred(xdrs, cred) XDR *xdrs; struct authdes_cred *cred;{ return (0); }
bool_t		xdr_authdes_verf(xdrs, verf) XDR *xdrs; struct authdes_verf *verf; { return (0); }
bool_t		xdr_authunix_parms(xdrs, p) XDR *xdrs; struct authunix_parms *p; { return (0); }
bool_t		xdr_bool(xdrs, bp) XDR *xdrs; bool_t *bp; { return (0); }
bool_t		xdr_bytes(xdrs, cpp, sizep, maxsize) XDR *xdrs; char **cpp; u_int *sizep, maxsize; { return (0); }
bool_t		xdr_callhdr(xdrs, cmsg) XDR *xdrs; struct rpc_msg *cmsg; { return (0); }
bool_t		xdr_callmsg(xdrs, cmsg) XDR *xdrs; struct rpc_msg *cmsg; { return (0); }
bool_t		xdr_char(xdrs, cp) XDR *xdrs; char *cp; { return (0); }
bool_t		xdr_cryptkeyarg(xdrs, objp) XDR *xdrs; cryptkeyarg *objp; { return (0); }
bool_t		xdr_cryptkeyres(xdrs, objp) XDR *xdrs; cryptkeyres *objp; { return (0); }
bool		xdr_datum(xdrs, p) XDR * xdrs; datum * p; { return (0); }
bool_t		xdr_des_block(xdrs, blkp) XDR *xdrs; des_block *blkp; { return (0); }
bool_t		xdr_double(xdrs, dp) XDR *xdrs; double *dp; { return (0); }
bool_t		xdr_enum(xdrs, ep) XDR *xdrs; enum_t *ep; { return (0); }
bool_t		xdr_float(xdrs, fp) XDR *xdrs; float *fp; { return (0); }
void		xdr_free(proc, objp) xdrproc_t proc; char *objp; {}
bool_t		xdr_getcredres(xdrs, objp) XDR *xdrs; getcredres *objp; { return (0); }
bool_t		xdr_int(xdrs, ip) XDR *xdrs; int *ip; { return (0); }
bool_t		xdr_keybuf(xdrs, objp) XDR *xdrs; keybuf objp; { return (0); }
bool_t		xdr_keystatus(xdrs, objp) XDR *xdrs; keystatus *objp; { return (0); }
bool_t		xdr_long(xdrs, lp) XDR *xdrs; long *lp; { return (0); }
bool_t		xdr_netnamestr(xdrs, objp) XDR *xdrs; netnamestr *objp; { return (0); }
bool_t		xdr_netobj(xdrs, np) XDR *xdrs; struct netobj *np; { return (0); }
bool_t		xdr_opaque(xdrs, cp, cnt) XDR *xdrs; caddr_t cp; u_int cnt; { return (0); }
bool_t		xdr_opaque_auth(xdrs, ap) XDR *xdrs; struct opaque_auth *ap; { return (0); }
bool_t		xdr_pmap(xdrs, regs) XDR *xdrs; struct pmap *regs; { return (0); }
bool_t		xdr_pmaplist(xdrs, rp) XDR *xdrs; struct pmaplist **rp; { return (0); }
bool_t		xdr_pointer(xdrs,objpp,obj_size,xdr_obj) XDR *xdrs; char **objpp; u_int obj_size; xdrproc_t xdr_obj; { return (0); }
bool_t		xdr_pwdnm(xdrs,objp) XDR *xdrs; pwdnm *objp; { return (0); }
bool_t		xdr_reference(xdrs, pp, size, proc) XDR *xdrs; caddr_t *pp; u_int size; xdrproc_t proc; { return (0); }
bool_t		xdr_rejected_reply(xdrs, rr) XDR *xdrs; struct rejected_reply *rr; { return (0); }
bool_t		xdr_replymsg(xdrs, rmsg) XDR *xdrs; struct rpc_msg *rmsg; { return (0); }
bool_t		xdr_rmtcall_args(xdrs, cap) XDR *xdrs; struct rmtcallargs *cap; { return (0); }
int		xdr_rmtcallres(xdrs, crp) XDR *xdrs; struct rmtcallres *crp; { return (0); }
bool_t		xdr_short(xdrs, sp) XDR *xdrs; short *sp; { return (0); }
bool_t		xdr_string(xdrs, cpp, maxsize) XDR *xdrs; char **cpp; u_int maxsize; { return (0); }
bool_t		xdr_u_char(xdrs, cp) XDR *xdrs; char *cp; { return (0); }
bool_t		xdr_u_int(xdrs, up) XDR *xdrs; u_int *up; { return (0); }
bool_t		xdr_u_long(xdrs, ulp) XDR *xdrs; u_long *ulp; { return (0); }
bool_t		xdr_u_short(xdrs, usp) XDR *xdrs; u_short *usp; { return (0); }
bool_t		xdr_union(xdrs, dscmp, unp, choices, dfault) XDR *xdrs; enum_t *dscmp; char *unp; struct xdr_discrim *choices; xdrproc_t dfault; { return (0); }
bool_t		xdr_unixcred(xdrs, objp) XDR *xdrs; unixcred *objp; { return (0); }
bool_t		xdr_vector(xdrs, basep, nelem, elemsize, xdr_elem) XDR *xdrs; char *basep; u_int nelem, elemsize; xdrproc_t xdr_elem; { return (0); }
bool_t		xdr_void() { return (0); }
bool_t		xdr_wrapstring(xdrs, cpp) XDR *xdrs; char **cpp; { return (0); }
bool		xdr_ypall(xdrs, c) XDR * xdrs; struct ypall_callback *c; { return (0); }
bool_t		xdr_yp_buf(x,o) XDR *x; /*yp_buf*/ char *o; { return (0); }
bool		xdr_yp_binding(xdrs, ps) XDR * xdrs; struct ypbind_binding *ps; { return (0); }
bool		xdr_yp_inaddr(xdrs, ps) XDR * xdrs; struct in_addr *ps; { return (0); }
bool		xdr_ypbind_resp(xdrs, ps) XDR * xdrs; struct ypbind_resp *ps; { return (0); }
bool		xdr_ypbind_setdom(xdrs, ps) XDR *xdrs; struct ypbind_setdom *ps; { return (0); }
bool		xdr_ypdomain_wrap_string(xdrs, ppstring) XDR * xdrs; char **ppstring; { return (0); }
bool		xdr_ypmaplist(xdrs, ps) XDR *xdrs; struct ypmaplist **ps; { return (0); }
bool		xdr_ypmaplist_wrap_string(xdrs, ps) XDR *xdrs; char *ps; { return (0); }
bool		xdr_ypmap_parms(xdrs, ps) XDR *xdrs; struct ypmap_parms *ps; { return (0); }
bool		xdr_ypmap_wrap_string(xdrs, ppstring) XDR * xdrs; char **ppstring;  { return (0); }
bool		xdr_ypowner_wrap_string(xdrs, ppstring) XDR * xdrs; char **ppstring; { return (0); }
bool		xdr_yppushresp_xfr(xdrs, ps) XDR * xdrs; struct yppushresp_xfr *ps; { return (0); }
bool		xdr_ypreq_key(xdrs, ps) XDR *xdrs; struct ypreq_key *ps; { return (0); }
bool		xdr_ypreq_nokey(xdrs, ps) XDR * xdrs; struct ypreq_nokey *ps; { return (0); }
bool		xdr_ypreq_xfr(xdrs, ps) XDR * xdrs; struct ypreq_xfr *ps; { return (0); }
bool		xdr_ypresp_key_val(xdrs, ps) XDR * xdrs; struct ypresp_key_val *ps; { return (0); }
bool		xdr_ypresp_maplist(xdrs, ps) XDR * xdrs; struct ypresp_maplist *ps; { return (0); }
bool		xdr_ypresp_master(xdrs, ps) XDR * xdrs; struct ypresp_master *ps; { return (0); }
bool		xdr_ypresp_order(xdrs, ps) XDR * xdrs; struct ypresp_order *ps; { return (0); }
bool		xdr_ypresp_val(xdrs, ps) XDR * xdrs; struct ypresp_val *ps; { return (0); }
void		xdrmem_create(xdrs, addr, size, op) XDR *xdrs; caddr_t addr; u_int size; enum xdr_op op; {}
void		xdrrec_create(xdrs, sendsize, recvsize, tcp_handle, readit, writeit) XDR *xdrs; u_int sendsize, recvsize; caddr_t tcp_handle; int (*readit)(); int (*writeit)(); {}
bool_t		xdrrec_endofrecord(xdrs, sendnow) XDR *xdrs; bool_t sendnow; { return (0); }
bool_t		xdrrec_eof(xdrs) XDR *xdrs; { return (0); }
int		xdrrec_readbytes(xdrs, addr, l) XDR *xdrs; caddr_t addr; u_int l; { return (0); }
bool_t		xdrrec_skiprecord(xdrs) XDR *xdrs; { return (0); }
void		xdrstdio_create(xdrs, file, op) XDR *xdrs; FILE *file; enum xdr_op op; {}
void		xprt_register(xprt) SVCXPRT *xprt; {}
void		xprt_unregister(xprt) SVCXPRT *xprt; {}
int		yp_all(d, m, c) char *d, *m; struct ypall_callback *c; { return (0); }
int		yp_bind(i) char *i; { return (0); }
int		yp_first(id, im, ok, okl, ov, ovl) char *id, *im; char **ok, **ov; int *okl, *ovl; { return (0); }
int		yp_get_default_domain(o) char **o; { return (0); }
int		yp_master(d, m, ms) char *d, *m, **ms; { return (0); }
int		yp_match(id, im, ik, ikl, ov, ovl) char *id, *im, *ik; char **ov; int *ovl; { return (0); }
int		yp_next(id, im, ik, ikl, ok, okl, ov, ovl) char *id, *im, *ik; char **ok, **ov; int *okl, *ovl; { return (0); }
int		yp_order(id, im, o) char *id, *im; int *o; { return (0); }
int		yp_softbind(d, t) char *d; { return (0); }
void		yp_unbind(i) char *i; {}
int		yp_update(dom, m, o, k, kl, d, dl) char *dom, *m, *k, *d; unsigned o; { return (0); }
char		*yperr_string(c) { return (""); }
int		ypprot_err(i) unsigned i; { return (0); }
