/*	@(#)llib-lc 1.1 86/09/25 SMI; from UCB 1.37 5/17/86	*/

/* LINTLIBRARY */

#include <sys/types.h>
#include <sys/time.h>

#include <sys/dir.h>
#include <sys/resource.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/timeb.h>
#include <sys/times.h>
#include <sys/uio.h>
#include <sys/vtimes.h>
#include <sys/wait.h>

#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/sem.h>
#include <sys/shm.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <fstab.h>
#include <grp.h>
#include <netdb.h>
#include <nlist.h>
#include <pwd.h>
#include <search.h>
#include <setjmp.h>
#include <sgtty.h>
#include <signal.h>
#include <stdio.h>
#include <mntent.h>

	/***	SECTION 2	***/
int	errno;

int	accept(s, a, l) struct sockaddr *a; int *l; { return s; }
int	access( p, m) char *p; { return 0; }
int	acct(f) char *f; { return 0;}
int	adjtime(delta, odelta) struct timeval *delta, *odelta; { return 0; }
int	bind(s, n, l) struct sockaddr *n; { return 0; }
char	*brk(a) char *a; { return(a); }
int	chdir(s) char *s; { return(0); }
int	chmod(s, m) char *s; { return(0); }
int	chown(s, u, g) char *s; { return(0); }
int	chroot( d ) char *d; { return 0; }
int	close(f) { return(0); }
int	connect( s, n, l) struct sockaddr *n; { return 0; }
int	dup(f) { return(f); }
int	dup2( o, n) { return o; }
	execve(s, v, e) char *s, *v[], *e[]; {;}
	_exit(s) {;}
int	fchmod(f, m) { return(0); }
int	fchown(f, u, g) { return(0); }
int	fcntl(f, c, a) { return (0); }
int	flock( f, o ) { return 0; }
int	fork() { return(0); }
int	fsync( f ) { return 0; }
int	fstat(f, b) struct stat *b; { return(0); }
int	ftruncate( d, l) off_t l; { 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 20 ; }
int	getegid() { return(1); }
int	geteuid() { return(1); }
int	getgid() { return(1); }
int	getgroups( n, g ) int n, *g; { return 0; }
long	gethostid() { return 1L; }
int	gethostname( n, l ) char *n; int l; { return 0 ;}
int	getitimer( w, v ) struct itimerval *v; { return 0; }
int	getpagesize() { return 1; }
int	getpeername(s, n, l) struct sockaddr *n; int *l; { return (0); }
int	getpgrp(p) { return 1; }
int	getpid() { return(1); }
int	getppid() { return(1); }
int	getpriority( w, who) { return 1;}
int	getrlimit( res, rip) struct rlimit *rip; { return 0;}
int	getrusage( res, rip) struct rusage *rip; { return 0;}
int	getsockname(s, name, namelen) struct sockaddr *name; int *namelen; { return(0); }
int	getsockopt( s, level, opt, buf, len ) char *buf; int *len; { return 0;}
int	gettimeofday( t, z ) struct timeval *t; struct timezone *z; { return 0;}
int	getuid() { return(1); }
	/* VARARGS2 */
int	ioctl( d, r, p) char *p; { return 0;}
int	kill(p, s) { return(0); }
int	killpg( pg, s) { return 0;}
int	link(a, b) char *a, *b; { return(0); }
int	listen( s, b ){ return 0; }
long	lseek(f, o, d) long o; { return(0); }
int	lstat(s, b) char *s; struct stat *b; { return(0); }
#ifdef notdef
int	madvise( a, l, b ) char * a; int l, b; { return 0;}
#endif
int	mmap( a, l, p, s, f, o ) char * a; off_t o; { return 0;}
#ifdef notdef
int	mincore( a, l, v ) char * a; int l; char *v; { return 0; }
#endif
int	mkdir( p, m ) char *p; { return 0; }
int	mknod(n, m, a) char *n; { return(0); }
int	mount(s, n, f) char *s, *n; { return(0); }
#ifdef notdef
int	mprotect( a, l, p) char * a; { return 0;}
int	mremap( a, l, p, s, f) char * a, f; { return 0;}
#endif
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	munmap( a, l) char * a; { return 0;}
	/* VARARGS2 */
int	open(f, m, stuff) char *f; { return(0); }
int	pipe(f) int f[2]; { return(0); }
	profil(b, s, o, i) char *b; {;}
int	ptrace(r, p, a, d) { return(0); }
int	read(f, b, l) char *b; { return(l); }
int	readv( d, v, l) struct iovec *v; { return l; }
int	readlink( p, b, s ) char *p, *b; { return 1; }
	reboot( h ) {;}
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 1; }
int	rename( f, t ) char *f, *t; { return 0;}
int	rmdir( p ) char *p; { return 0;}
char	*sbrk(i) { return((char *)0); }
int	select( n, r, w, e, t ) int *r, *w, *e; struct timeval *t; { return n; }
	/*VARARGS3*/
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	sendto( s, m, l, f, t, tl ) char *m; struct sockaddr *t; { return l; }
int	sendmsg( s, m, l) struct msghdr m[]; { return l; }
int	setdomainname(n, l) char *n; int l; { return (0) ;}
int	setgroups( n, g) int *g; { return 0; }
int	sethostname( n, l ) char *n; int l; { return 0 ;}
int	setitimer( w, v, ov ) struct itimerval *v, *ov; { return 0; }
int	setpgrp( g, pg) { return 0; }
int	setpriority( w, who, pri ) { return 1;}
int	setregid( r, e) int r, e; { return 0; }
int	setreuid( r, e) int r, e; { return 0; }
int	setrlimit( res, rip) struct rlimit *rip; { return 0;}
	/* VARARGS */
int	setsockopt( s, level, opt, buf, len ) char *buf; { return 0;}
int	settimeofday( t, z ) struct timeval *t; struct timezone *z; { return 0;}
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	(*signal(c, f))() int (*f)(); { return(f); }
int	sigvec(c, f, m) struct sigvec *f, *m; { return 0; }
int	sigblock(m) { return (m); }
int	sigsetmask(m) { return (m); }
	sigpause(m) { ; }
int	sigstack(ss, oss) struct sigstack *ss, *oss; { return 0 ; }
int	socket( a, t, p) {return 1;}
int	socketpair( d, t, p, s ) int s[2]; { return 0; }
int	stat(s, b) char *s; struct stat *b; { return(0); }
#ifdef notdef
char *	stk( a ) char * a; { return a; }
char *	sstk( a ) int a; { return (char *)0; }
#endif
int	swapon( s ) char *s; { return 0;}
int	symlink( t, f) char *t, *f; { return 0;}
	sync(){;}
int	truncate( p, l) char *p; off_t l; { return 0;}
int	umask( n ) { return n; }
int	unmount(s) char *s; { return (0); }
int	unlink(s) char *s; { return(0); }
int	utimes( f, t ) char *f; struct timeval t[2]; { return 0 ;}
int	vfork() { return(0); }
	vhangup() { ; }
int	wait(s) union wait *s; { return(1); }
int	wait3( s, o, r) union wait *s; struct rusage *r; { return 1;}
int	write(f, b, l) char *b; { return(l); }
int	writev( f, v, l) struct iovec *v; { return l; }


	/***	SECTION 3	***/

struct qelem {	/* this should really be defined in an include file */
	struct qelem	*q_forw;
	struct qelem	*q_back;
	char		data[1];
};
	/* antique system calls and unclassified */
	_longjmp( e, v) jmp_buf e; {;}
int	_setjmp(e) jmp_buf e; { return(0); }
long	a64l(s) char *s; { return (0L); }
char *	l64a(l) long l; { return (""); }
	abort() {;}
int	abs(i) int i; { return(i); }
int	addmntent(f, m) FILE *f; struct mntent *m; { return (0); }
int	alarm(s) unsigned s; { return(s); }
	alphasort( d1, d2) struct direct **d1, **d2; { return 0;}
char *	asctime(t) struct tm *t; { return(""); }
double	atof(s) char *s; { return(1.); }
int	atoi(s) char *s; { return 1;   }
long	atol(s) char *s; { return 1L;   }
int	bcmp(b1, b2, length) char *b1, *b2; { return 0; }
	bcopy(src, dst, length) char *src, *dst; { ; }
char *	bsearch(k, b, n, w, c) char *k, *b; unsigned n, w; int (*c)(); { return (k); }
	bzero(b, length) char *b; { ; }
char *	calloc(n,s) unsigned n, s; { static char c[1]; return(c); }
long	clock() { return (0L); }
void	closedir( p ) DIR *p; {}
	closelog() {}
int	creat(s, m) char *s; { return(0); }
char *	crypt(k,s) char *k, *s; { return(""); }
char *	ctermid(s) char *s; { return (s); }
char *	ctime(c) time_t *c;{ return(""); }
#undef isalpha
#undef isupper
#undef islower
#undef isdigit
#undef isxdigit
#undef isalnum
#undef isspace
#undef ispunct
#undef isprint
#undef isgraph
#undef iscntrl
#undef isascii
int	isalpha(c) { return (c); }
int	isupper(c) { return (c); }
int	islower(c) { return (c); }
int	isdigit(c) { return (c); }
int	isxdigit(c) { return (c); }
int	isalnum(c) { return (c); }
int	isspace(c) { return (c); }
int	ispunct(c) { return (c); }
int	isprint(c) { return (c); }
int	isgraph(c) { return (c); }
int	iscntrl(c) { return (c); }
int	isascii(c) { return (c); }
char	_ctype_[129];
#undef toupper
#undef tolower
#undef toascii
int	toupper(i) { return (i); }
int	tolower(i) { return (i); }
int	toascii(i) { return (i); }
char *	cuserid(s) char *s; { return (s); }
double	drand48() { return (0.0); }
char *	ecvt(v, n, d, s) double v; int *d, *s; { return(""); }
	encrypt(s, i) char *s; {}
int	end, etext, edata;
int	endfsent() { return 0; }
	endgrent() {}
	endhostent() { ; }
int	endmntent(f) FILE *f; { return (0); }
	endnetent() { ; }
	endnetgrent() {}
	endprotoent() { ; }
	endpwent() {}
	endservent() { ; }
char **	environ;
double	erand48(x) unsigned short x[3]; { return (0.0); }
	/* VARARGS2 */
	execl(f, a) char *f, *a; {;}
	/* VARARGS2 */
	execle(f, a) char *f, *a; {;}
	/* VARARGS2 */
	execlp(f, a) char *f, *a; {;}
	execv(s, v) char *s, *v[]; {;}
	execvp(s, v) char *s, *v[]; {;}
	exit(s) {;}
char *	fcvt(v, n, d, s) double v; int *d, *s; { return(""); }
int	ffs(i) { return i; }
struct group *	fgetgrent(f) FILE *f; { return (struct group *)NULL; }
struct passwd *	fgetpwent(f) FILE *f; { return (struct passwd *)NULL; }
	free(p) char *p; {;}
double	frexp( v, e) double v; int *e; { return v; }
	ftime(tp) struct timeb *tp; { ; }
key_t	ftok(s, i) char *s; { return ((key_t)0); }
int	ftw(p, f, d) char *p; int (*f)(); { return (d); }
char *	gcvt(v, n, b) double v; char *b; { return(""); }
char *	getenv( n ) char *n; { return n; }
struct fstab *	getfsent() { return (struct fstab *)NULL; }
struct fstab *	getfsspec( n ) char *n; { return (struct fstab *)NULL; }
struct fstab *	getfsfile( n ) char *n; { return (struct fstab *)NULL; }
struct fstab *	getfstype( t ) char *t; { return (struct fstab *)NULL; }
struct group *	getgrent() { return (struct group *)NULL; }
struct group *	getgrgid( n ) { return (struct group *)NULL; }
struct group *	getgrnam( n ) char *n; { return (struct group *)NULL; }
struct hostent *	gethostbyaddr(addr, len, type) char *addr; { return (struct hostent *) 0; }
struct hostent *	gethostbyname(name) char *name; { return (struct hostent *) 0; }
struct hostent *	gethostent() { return (struct hostent *) 0; }
char *	getlogin(){ return " "; }
struct mntent *getmntent(f) FILE *f; { return (struct mntent *)NULL; }
struct netent *	getnetbyaddr(net, type) { return (struct netent *) 0; }
struct netent *	getnetbyname(name) char *name; { return (struct netent *) 0; }
struct netent *	getnetent() { return (struct netent *) 0; }
int	getnetgrent(m, u, d) char **m, **u, **d; { return (0); }
int	getopt(argc, argv, optstr) char **argv, *optstr; { return EOF; }
char *	getpass( n ) char *n ; { return n; }
struct protoent *	getprotobyname(name) char *name; { return (struct protoent *) 0; }
struct protoent *	getprotobynumber(proto) { return (struct protoent *) 0; }
struct protoent *	getprotoent() { return (struct protoent *) 0; }
int	getpw( u, b) char *b;  { return 0; }
struct passwd *	getpwent() { return (struct passwd *)NULL; }
struct passwd *	getpwuid( n ) { return (struct passwd *)NULL; }
struct passwd *	getpwnam( n ) char *n; { return (struct passwd *)NULL; }
struct servent *	getservbyname(name, proto) char *name, *proto; { return (struct servent *) 0; }
struct servent *	getservbyport(port, proto) char *proto; { return (struct servent *) 0; }
struct servent *	getservent() { return (struct servent *) 0; }
char *	getwd(pathname) char *pathname; { return pathname; }
struct	tm *	gmtime(c) time_t *c; { return gmtime(c); }
int	gsignal(s) { return (s); }
int	gtty(f, b) struct sgttyb *b; { return(0); }
char *	hasmntopt(m, o) struct mntent *m; char *o; { return (0); }
int	hcreate(n) unsigned n; { return (0); }
void	hdestroy() {}
ENTRY *	hsearch(i, a) ENTRY i; ACTION a; { return (&i); }
#ifndef htonl
u_long	htonl(hostlong) u_long hostlong; { return hostlong; }
#endif htonl
#ifndef htons
u_short	htons(hostshort) u_short hostshort; { return hostshort; }
#endif htons
char *	index(s, c) char *s, c; { return s; }
u_long	inet_addr(cp) char *cp; { return 0L; }
int	inet_lnaof(in) struct in_addr in; { return 0; }
int	inet_netof(in) struct in_addr in; { return 0; }
struct in_addr	inet_makeaddr(net, host) { struct in_addr in; return in; }
u_long	inet_network(cp) char *cp; { return 0L; }
char *	inet_ntoa(in) struct in_addr in; { return (char *) 0; }
int	initgroups(uname, agroup) char *uname; { 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); }
	insque(elem, pred) struct qelem *elem, *pred; { ; }
int	isatty(f) { return 1; }
int	isinf(v) double v; { return (0); }
int	isnan(v) double v; { return (0); }
long	jrand48(x) unsigned short x[3]; { return (0L); }
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); }
	longjmp( e, v) jmp_buf e; {;}
struct	tm *localtime(c) time_t *c; { return localtime(c); }
long	lrand48() { return (0L); }
char *	lsearch(k, b, n, w, c) char *k, *b; unsigned *n, w; int (*c)(); { return (k); }
char *	malloc(n) unsigned n; {static char c; return(&c);}
char *	memalign(a, s) unsigned a, s; { return(""); }
char *	memccpy(t, f, c, n) char *t, *f; { return t; }
char *	memchr(s, c, n) char *s; { return s; }
int	memcmp(s1, s2, n) char *s1, *s2; { return 0; }
char *	memcpy(t, f, n) char *t, *f; { return t; }
char *	memset(s, c, n) char *s; { return s; }
char *	mktemp(p) char *p; { return(p);}
double	modf( v, p ) double v, *p; { return v; }
	moncontrol(mode) { ; }
	monitor(l, h, b, s, n) int (*l)(), (*h)(); short *b; {}
	monstartup( l, h) int (*l)(), (*h)(); {;}
long	mrand48() { return (0L); }
int	nice(incr) { return 0; }
int	nlist( f, n) char *f; struct nlist n[]; { return (0);}
long	nrand48(x) unsigned short x[3]; { return (0L); }
#ifndef ntohl
u_long	ntohl(netlong) u_long netlong; { return netlong; }
#endif ntohl
#ifndef ntohs
u_short	ntohs(netshort) u_short netshort; { return netshort; }
#endif ntohs
int	on_exit(p, a) int (*p)(); char *a; { return (0); }
DIR *	opendir( f ) char *f; { return (DIR *)NULL; }
	openlog(i, l) char *i; {}
char *	optarg;
int	optind;
int	opterr;
int	optopt; /* undocumented */
	pause() {;}
	perror(s) char *s; {}
	_perror(s) char *s; {}
	psignal(sig, s) unsigned sig; char *s; {}
	_psignal(sig, s) unsigned sig; char *s; {}
int	putenv(s) char *s; { return (0); }
int	putpwent(s, f) struct passwd *s; FILE *f; { return (0); }
	qsort( b, n, w, c ) char *b; int (*c)(); {;}
int	rand(){ return 1; }
long	random() { return 1L; }
int	rcmd(a, rp, lu, ru, c, f) char **a, *lu, *ru, *c; u_short rp; int *f; { return 0; }
char *	re_comp(s) char *s ; { return s; }
int	re_exec(s) char *s ; { return 1; }
struct direct *	readdir( p ) DIR *p; { return (struct direct *)NULL; }
char *	realloc(p, n) char *p; unsigned n; { static char c[1]; return(c);}
	remque(elem) struct qelem *elem; { ; }
int	rexec(a, rp, n, p, c, f) char **a, *n, *p, *c; u_short rp; int *f; { return 0; }
char *	rindex(s, c) char *s, c; { return s; }
int	rresvport(p) int *p; { return 0; }
int	ruserok(rh, su, ru, lu) char *rh, *ru, *lu; { return 0; }
int	scandir(d, n, s, c) char *d; struct direct *(*n[]); int (*s)(),(*c)();
		{ return 1; }
unsigned short *	seed48(s) unsigned short s[3]; { return (s); }
void	seekdir( p, l) DIR *p; long l; {}
int	setegid(egid) int egid; { return 0; }
int	seteuid(euid) int euid; { return 0; }
int	setfsent() { return 0; }
int	setgrent() { return 0; }
int	setgid(g) { return(0); }
	sethostent(stayopen) { ; }
int	setjmp(e) jmp_buf e; { return(0); }
	setkey(k) char *k; {}
FILE *	setmntent(f, t) char *f, *t; { return (0); }
	setnetent(stayopen) { ; }
	setnetgrent(g) char *g; {}
	setprotoent(stayopen) { ; }
int	setpwent() { return 0; }
int	setrgid(rgid) int rgid; { return 0; }
int	setruid(ruid) int ruid; { return 0; }
	setservent(stayopen) { ; }
char *	setstate( st ) char *st; { return st; }
int	setuid(u) { return(0); }
	sleep(i) unsigned i; {}
int	srand(s){ return s; }
void	srand48(s) long s; {}
	srandom(s) int s; {}
int (*	ssignal(s, a))() int (*a)(); { return (a); }
char *	strcat(a, b) char *a, *b; { return a; }
char *	strchr(s, c) char *s, c; { return s; }
int	strcmp(a, b) char *a, *b; { return(1); }
char *	strcpy(a, b) char *a, *b; { return a; }
int	strcspn(s, set) char *s, *set; { return(0); }
int	strlen(s) char *s; { return(1); }
char *	strncat(a, b, n) char *a, *b; { return a;}
int	strncmp(a, b, n) char *a, *b; { return(1); }
char *	strncpy(a, b, n) char *a, *b; { return a; }
char *	strpbrk(s, brk) char *s, *brk; { return s; }
char *	strrchr(s, c) char *s, c; { return s; }
int	strspn(s, set) char *s, *set; { return(0); }
double	strtod(s, t) char *s, **t; { return (0.0); }
char *	strtok(s, sep) char *s, *sep; { return s; }
long	strtol(s, t, b) char *s, **t; { return (0L); }
int	stty(f, b) struct sgttyb *b; { return(0); }
	swab( f, t, n) char *f, *t; {;}
	/* VARARGS2 */
	syslog(l, f) char *f; {}
char *	sys_errlist[];
char *	sys_siglist[];
int	sys_nerr;
int	system(s) char *s; { return(0); }
long	tell(f) { return((long)0); }
long	telldir( p ) DIR *p; { return 1L; }
char *	tdelete(k, r, c) char *k, **r; int (*c)(); { return (k); }
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( 0 );}
int	times(tmsp) struct tms *tmsp; { return 0; }
char *	timezone( z, d ){ return (char *)0; }
FILE *	tmpfile() { return (stdin); }
char *	tmpnam(s) char *s; { return s; }
char *	tsearch(k, r, c) char *k, **r; int (*c)(); { return (k); }
char *	ttyname(f) { return " "; }
int	ttyslot() { return 1; }
void	twalk(r, f) char *r; void (*f)(); {}
unsigned	ualarm(value, interval) unsigned value, interval; { return 0; }
	usleep(useconds) unsigned useconds; { ; }
int	utime(name, timep) char *name; time_t *timep; { return 0; }
char *	valloc(s) unsigned s; { return malloc(s); }
int	vlimit(limit, value) { return 0; }
int	vtimes(par, ch) struct vtimes *par, *ch; { return 0; }

	/* standard I/O library */

int	fclose(f) FILE *f; {return(0);}
FILE *	fdopen(fd, m) char *m; { return(stdin);}
int	fflush(f) FILE *f; {return(0);}
int	fgetc(f)  FILE *f; {return 0; }
char *	fgets( s, l, f ) char *s; FILE *f; { return(s); }
int	_filbuf( f ) FILE *f; { return 0; }
int	_flsbuf( c, f ) unsigned char c; FILE *f; { return 0; }
FILE *	fopen(s,m) char *s, *m; { return(stdin); }
	/* VARARGS2 */
int	fprintf( f, s ) FILE *f; char *s; {return 1;}
int	fputc(c, f) char c; FILE *f; {return 0; }
	fputs(s,f) char *s; FILE *f; {;}
int	fread( p, s, n, f ) char *p; FILE *f; {return(1);}
FILE *	freopen(s, m, f) char *s, *m; FILE *f; { return(stdin); }
	/* VARARGS2 */
	fscanf( f, s ) FILE *f; char *s; {return(1);}
int	fseek(f, o, p) FILE *f; long o; { return(0); }
long	ftell(f) FILE *f; { return(0L); }
int	fwrite( p, s, n, f ) char *p; FILE *f; {return(0);}
#ifndef getc
int	getc(f) FILE *f; { return EOF; }
#endif getc
int	getw(f) FILE *f; { return 0;}
char *	gets( s ) char *s; { return(s); }
struct _iobuf _iob[];
int	pclose( f ) FILE *f; { return 0; }
FILE *	popen( c, t ) char *c, *t; { return(stdin); }
	/* VARARGS1 */
int	printf( s ) char *s; {return 1;}
	puts(s) char *s;{;}
#ifndef putc
int	putc(c, f) char c; FILE *f; { return 0; }
#endif putc
int	putw(w, f) FILE *f; { return 0;}
	rewind(f) FILE *f; {;}
	/* VARARGS1 */
	scanf( f ) char *f; {return(1); }
	setbuf( f, b ) FILE *f; char *b; {;}
	setbuffer( f, b, s ) FILE *f; char *b; {;}
	setlinebuf( f ) FILE *f; {;}
	/* VARARGS2 */
char *	sprintf( s, f ) char *s, *f; { return(s);}
	/* VARARGS2 */
	sscanf( s, f ) char *s, *f; { return(1); }
	ungetc( c, f ) FILE *f; {  return(c); }

	/* Yellow pages */
#include <rpcsvc/ypclnt.h>
int	yp_bind(i) char *i; { return (0); }
int	yp_get_default_domain(o) char **o; { return (0); }
void	yp_unbind(i) char *i; {}
int	yp_match(id, im, ik, ikl, ov, ovl) char *id, *im, *ik; char **ov; int *ovl;
		{ return (0); }
int	yp_first(id, im, ok, okl, ov, ovl) char *id, *im; char **ok, **ov; int *okl, *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); }
char *	yperr_string(c) { return (""); }
