/*	@(#)llib-lc.c	13.2 (RC International) 91/02/19	*/

/* LINTLIBRARY */

#include <sys/types.h>
#include <sys/resource.h>
#include <sys/time.h>
#include <sys/file.h>
#include <sys/iovec.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/param.h>
#include <sys/pid.h>
#include <sys/run.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <sys/sysinfo.h>
#include <sys/trans.h>
#include <sys/volmgmtpars.h>
#include <sys/volsys.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/timeb.h>
#include <sys/times.h>
#include <sys/utsname.h>
#include <sys/wait.h>

#include <imc/imcrpu.h>

#include <netns/ns.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <dirent.h>
#include <disktab.h>
#include <fcntl.h>
#include <grp.h>
#include <langinfo.h>
#include <locale.h>
#include <ndbm.h>
#include <netdb.h>
#include <nl_types.h>
#include <pwd.h>

/* The following defines is to avoid syntax errors from regexp.h */
#define  INIT		char *sp = instring;
#define  GETC()		(*sp++)
#define  PEEKC()	(*sp)
#define  UNGETC(c)	(--sp)
#define  RETURN(c)	return;
#define  ERROR(c)	perror("")
#include <regexp.h>

#include <search.h>
#include <setjmp.h>
#include <sgtty.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <termios.h>
#include <time.h>
#include <unistd.h>
#include <ustat.h>
#include <utime.h>
#include <utmp.h>
#include <varargs.h>

	/***	SECTION 2	***/
int	daylight;
char **	environ;
int	errno;
char *	loc1;
char *	loc2;
char *	locs;
char *	optarg;
int	opterr;
int	optind;
char *	sys_errlist[];
char *	sys_siglist[];
char *	sys_nerr;
long	timezone;
char *	tzname[];

/* union semun: For semctl */
union semun {
	int val;
	struct semid_ds *buf;
	u_short array[1]; 
};

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	attach(f, m) { 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	chflags(s, f) char *s; { return 0; }
int	chmod(s, m) char *s; mode_t m; { return 0; }
int	chown(s, u, g) char *s; uid_t u; gid_t g; { return 0; }
int	chroot(d) char *d; { return 0; }
int	close(f) { return 0; }
int	closeutimes(f, t) struct timeval *t[]; { return 0; }
int	connect(s, n, l) struct sockaddr *n; { return 0; }
int	createfile(f, m, p) char *f; struct createfile_params *p; { return 0; }
int	detach(f) { return 0; }
int	dup(f) { return 0; }
int	dup2(o, n) { return o; }
int	execve(s, v, e) char *s, *v[], *e[]; { return 0; }
void	_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; }
pid_t	fork() { return (pid_t)0; }
int	fp_sigint(x) { return 0; }
int	fstat(f, b) struct stat *b; { return 0; }
int	fsync(f) { return 0; }
int	ftruncate(d, l) { return 0; }
int	getdtablesize() { return 1; }
gid_t  	getegid() { return 1; }
uid_t  	geteuid() { return 1; }
gid_t	getgid() { return 1; }
int	getgroups(n, g) gid_t *g; { return 0; }
int	gethostid() { return 1; }
int	gethostname(n, l ) char *n; int l; { return 0; }
int	getpagesize() { return 1; }
int	getpeername(s, n, l) struct sockaddr *n; int *l; { return 0; }
pid_t	getpgrp(p) { return 1; }
pid_t	getpid() { return 1; }
pid_t	getppid() { return 1; }
int	getpriority(w, who) { return 1;}
int	getpuid() { return 1; }
int	getpuname(p, n) char *p; { return 0; }
int	getrlimit(res, rip) struct rlimit *rip; { return 0; }
int	getrusage(res, rip) struct rusage *rip; { return 0; }
int	getsockname(s, name, namelen) char *name; int *namelen; { return 0; }
int	getsockopt(s, level, opt, buf, len ) char *buf; int *len; { return 0; }
uid_t	getuid() { return 1; }
UID_T	getuniqueid() { UID_T u; return u; }
char *	getwd(f) char *f; { return f; }
	/*VARARGS2*/
int	ioctl(f, r) { return 1; }
int	kill(p, s) pid_t p; { return 0; }
int	killpg(pg, s) { return 0; }
int	link(a, b) char *a, *b; { return 0; }
int	listen(s, b) { return 0; }
int	lockf(f, c, l) long l; { return 0; }
off_t	lseek(f, o, d) off_t o; { return((off_t) 1); }
int	lstat(s, b) char *s; struct stat *b; { return 0; }
int	mblock(f, o, n) { 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(p, m, d) char *p; { return 0; }
int	mkunod(n, m, x, u) char *n; UID_T u; { return 0; }
int	mount(s, n, f) char *s, *n; { return 0; }
	/* VARARGS2 */
int	open(f, m, stuff) char *f; { return 0; }
int	opentext(p) { return 0; }
int	pipe(f) int f[2]; { return 0; }
int	profil(b, s, o, i) char *b; { return 0; }
int	read(f, b, l) char *b; unsigned l; { return 1; }
int	readv(d, v, l) struct iovec *v; { return l; }
int	readlink(p, b, s) char *p, *b; { return 1; }
int	readrandom(f, o, b, l) char *b; { return l; }
int	readvrandom(f, o, i, l) struct iovec *i; { return l; }
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 1; }
int	remove(p) char *p; { return 0; }
int	rename(f, t) char *f, *t; { return 0;}
int	rmdir(p) char *p; { return 0; }
int	run(n, a, e, r) char *n, *a[], *e[]; struct runinfo *r; { return 0; }
char	*sbrk(i) { return((char *)0); }
int	select(n, r, w, e, t) int *r, *w, *e; struct timeval *t; { return n; }
int	semctl(i, n, c, a) union semun a; { return 1; }
int	semget(k, n, s) key_t k; { return 1; }
int	semop(i, o, n) struct sembuf (*o)[]; unsigned n; { return 0; }
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	setext(f, e) struct extent_descriptor *e; { return 0; }
int	setgroups(n, g) int *g; { return 0; }
int	sethostid(h) { return 0; }
int	sethostname(n, l) char *n; int l; { return 0; }
int	setpgid(p, g) pid_t p, g; { return 0; }
int	setpgrp() { return 1; }
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; }
pid_t	setsid() { return (pid_t)1; }
	/* VARARGS */
int	setsockopt(s, level, opt, buf, len) char *buf; { return 0; }
char *	shmat(i, a, f) char *a; { return a; }
int	shmctl(s, c, b) struct shmid_ds *b; { return 0; }
int	shmdt(s) char *s; { return 0; }
int	shmget(k, s, f) key_t k; { return 1; }
int	shutdown(s, h) { return 0; }

void	(*signal(c, f))() void (*f)(); { return(f); }

int	sigaction(s, a, o) struct sigaction *a, *o; { return 0; }
int	sigaddset(s, n) sigset_t *s; { return 0; }
int	sigdelset(s, n) sigset_t *s; { return 0; }
int	sigemptyset(s) sigset_t *s; { return 0; }
int	sigfillset(s) sigset_t *s; { return 0; }
int	sigismember(s, n) sigset_t *s; { return 0; }
void	siglongjmp(e, v) sigjmp_buf e; { ; }
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	sigsuspend(s) sigset_t *s; { return 0; }

void    (* sigset(s, a))() void (*a)(); { return a; }
int	sighold(s) { return 0; }
int	sigrelse(s) { return 0; }
int	sigignore(s) { return 0; }

int	sigvec(c, f, m) struct sigvec *f, *m; { return 0; }
int	sigblock(m) { return m; }
int	sigsetmask(m) { return m; }
int	sigsetmode(n, o) int *n, *o; { return 0; }
	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; }
int	stime(t) long *t; { return 0; }
int	symlink(t, f) char *t, *f; { return 0; }
void	sync() { ; }
int	syncfs(p) char *p; { return 0; }
	/* VARARGS1 */
int	syscall(n) { return 0; }
int	sysinfo(f, i, u, n, o) char *i, *u, *n; { return 1; }
int	trans(f, r) struct trans_ret *r; { return 0; }
int	truncate(p, l) char *p; { return 0; }
	/* VARARGS1 */
long	ulimit(c) { return 0L; }
mode_t	umask(m) mode_t m; { return m; }
int	umount(s) char *s; { return 0; }
int	uname(n) struct utsname *n; { return 0; }
int	unlink(s) char *s; { return 0; }
int	ustat(d, b) UID_T d; struct ustat *b; { return 0; }
int	utimes(f, t ) char *f; struct timeval t[2]; { return 0; }
int	vfork() { return 0; }
void	vhangup() { ; }
int	volsys(f, a) char *a; { return 0; }
pid_t	wait(s) int *s; { return (pid_t)1; }
pid_t	waitpid(p, s, o) pid_t p; int *s, *o; { return (pid_t)1; }
int	wait3(s, o, r) union wait *s; struct rusage *r; { return 1; }
int	write(f, b, l) char *b; unsigned l; { return 1; }
int	writev(f, v, l) struct iovec *v; { return l; }
int	writerandom(f, o, b, l) char *b; { return l; }
int	writevrandom(f, o, i, l) struct iovec *i; { 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];
};

void	_longjmp(e, v) jmp_buf e; { ; }	
int	_setjmp(e) jmp_buf e; { return 0; }
long	a64l(s) char *s; { return 1L; }
char *	l64a(l) long l; { return ""; }
void	abort() { ; }
int	abs(i) int i; { return i; }
unsigned int	alarm(s) unsigned int s; { return s; }
char *	asctime(t) struct tm *t; { return""; }
void	assert(e) int e; { ; }
double	atof(s) char *s; { return 1.0; }
int	atoi(s) char *s; { return 1; }
long	atol(s) char *s; { return 1L; }
int	bcmp(b1, b2, length) char *b1, *b2; { return 0; }
void	bcopy(src, dst, length) char *src, *dst; { ; }
void	bzero(b, length) char *b; { ; }
void *	bsearch(k, b, n, s, c) void *k, *b; size_t n, s; int (*c)(); { return k; }
void *	calloc(n,s) size_t n, s; { void *p=NULL; return p; }
int	catclose(c) nl_catd c; { return 0; }
char *	catgets(c, i, m, s) nl_catd c; int i, m; char *s; { return ""; }
nl_catd	catopen(n, o) char *n; int o; { return (nl_catd)1; }
speed_t cfgetispeed(t) struct termios *t; { return (speed_t)1; }
speed_t cfgetospeed(t) struct termios *t; { return (speed_t)1; }
int	cfsetispeed(t, s) struct termios *t; speed_t s; { return 0; }
int	cfsetospeed(t, s) struct termios *t; speed_t s; { return 0; }
clock_t clock() { return (clock_t)1; }
int	closedir(p) DIR *p; { ; }
void	closelog() { ; }
int	context_close() { return 0; }
int	context_exec(n) char *n; { return 0; }
int	context_open() { return 0; }
int	context_restore(i, l) struct iovec *i; { return 1; }
int	context_stat(f, n) int *f, *n; { return 0; }
int	context_trans(f, r, i, l) struct trans_ret *r; struct iovec *i; { return 0; }
int	creat(s, m) char *s; mode_t m; { return 0; }
char *	crypt(k,s) char *k, *s; { return ""; }
char *	ctime(c) time_t *c;{ return ""; }
char	_ctype_[];
DBM *	dbm_open(file, flags, mode) char *file; { return (DBM *) 0; }
void	dbm_close(db) DBM *db; { ; }
datum	dbm_fetch(db, key) DBM *db; datum key; { return key; }
int	dbm_store(db, key, cont, flags) DBM *db; datum key, cont; { return 0; }
int	dbm_delete(db, key) DBM *db; datum key; { return 0; }
datum	dbm_firstkey(db) DBM *db; { datum key; return key; }
datum	dbm_nextkey(db) DBM *db; { datum key; return key; }

double	drand48() { return 0.0; }
double	erand48(x) unsigned short x[3]; { return 0.0; }
long	lrand48() { return 0L; }
long	nrand48(x) unsigned short x[3]; { return 0L; }
long	mrand48() { return 0L; }
long	jrand48(x) unsigned short x[3]; { return 0L; }
void	srand48(s) long s; { ; }
unsigned short *	seed48(s) unsigned short s[3]; { return s; }
void	lcong48(p) unsigned short p[7]; { ; }

char *	ecvt(v, n, d, s) double v; int *d, *s; { return ""; }
void	encrypt(s, i) char *s; { ; }
void	endgrent() { ; }
void	endhostent() { ; }
void	endnetent() { ; }
void	endprotoent() { ; }
void	endpwent() { ; }
void	endservent() { ; }
void	endutent() { ; }
	/* VARARGS */
int	execl(f, a) char *f, *a; { return 0; }
	/* VARARGS */
int	execle(f, a) char *f, *a; { return 0; }
	/* VARARGS */
int	execlp(f, a) char *f, *a; { return 0; }
int	execv(s, v) char *s, *v[]; { return 0; }
int	execvp(s, v) char *s, *v[]; { return 0; }
void	exit(s) { ; }
int	extentsize(f, p, s) int *p, *s; { ; }
char *	fcvt(v, n, d, s) double v; int *d, *s; { return ""; }
int	ffs(i) { return i; }
long	fpathconf(f, n) { return (long)1; }
void	free(p) void *p; { ; }
double	frexp( v, e) double v; int *e; { return v; }
int	ftime(tp) struct timeb *tp; { return 0; }
key_t	ftok(p, i) char *p; char i; { return (key_t)1; }
int	ftw(p, f, n) char *p; int (*f)(); { return 1; }
char *	gcvt(v, n, b) double v; char *b; { return ""; }
char *	getcwd(b, s) char *b; { return ""; }
struct disktab *	getdiskbyname(name) char *name; { return (struct disktab *) 0; }
char *	getenv(n) char *n; { return n; }
struct group *	getgrent() { return (struct group *)NULL; }
struct group *	getgrgid(n) gid_t 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 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	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 *	getpwnam(n) char *n; { return (struct passwd *)NULL; }
struct passwd *	getpwuid(n) uid_t 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; }
struct utmp *getutent() { struct utmp *u=NULL; return u; }
struct utmp *getutid(i) struct utmp *i; { struct utmp *u=NULL; return u; }
struct utmp *getutline(l) struct utmp *l; { struct utmp *u=NULL; return u; }
struct tm * gmtime(c) time_t *c; { struct tm * g=NULL; return g; }
int	gsignal(s) { return s; }
int	gtty(f, b) struct sgttyb *b; { 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; }
unsigned long	inet_addr(cp) char *cp; { return 0; }
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; }
unsigned long	inet_network(cp) char *cp; { return 0; }
char *	inet_ntoa(in) struct in_addr in; { return (char *) 0; }
int	initgroups(un, agroup) char *un; { return 0; }
char *	initstate( s, st, n) unsigned s; char *st; { return st; }
void	insque(elem, pred) struct qelem *elem, pred; { ; }
int	isatty(f) { return 1; }
int	isnan(x) double x; { return 0; }

/* CTYPE */
#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[];

void	l3tol(l, c, n) long *l; char *c; { ; }
void	ltol3(c, l, n) char *c; long *l; { ; }
double	ldexp(v, e) double v; { return v; }
void	loadav(p, a) double a[3]; { ; }
	/* VARARGS1 */
int	log_error(n) { return 0; }
void	log_perror(n, s, m) char *s, *m; { ; }
void	longjmp(e, v) jmp_buf e; { ; }
struct	tm *localtime(c) time_t *c; { return localtime(c); }
int	lcmp(a, b, l) long *a, *b; long l; { return 0; }
int	lcopy(f, t, l) long *f, *t; long l; { ; }
void *	lsearch(k, b, n, s, c) void *k, *b; size_t *n, s; int (*c)(); { return k;}
void *	lfind(k, b, n, s, c) void *k, *b; size_t *n, s; int (*c)(); { return k;}
void	lzero(a, l) long *a; long l; { ; }
void *	malloc(n) size_t n; { void *p=NULL; return p; }
void *	memccpy(t, f, c, n) void *t, *f; size_t n; { return t; }
void *	memchr(s, c, n) void *s; size_t n; { return s; }
int	memcmp(s1, s2, n) void *s1, *s2; size_t n; { return 0; }
void *	memcpy(t, f, n) void *t, *f; size_t n; { return t; }
void *	memset(s, c, n) void *s; size_t n; { return s; }
char *	mktemp(p) char *p; { return p;}
time_t	mktime(t) struct tm *t; { return (time_t)1; }
double	modf(v, p) double v, *p; { return v; }
void	moncontrol(mode) { ; }
void	monitor(l, h, b, s, n) int (*l)(), (*h)(); short *b; { ; }
void	monstartup(l, h) int (*l)(), (*h)(); { ; }
int	msgctl(m, c, b) struct msqid_ds *b; { return 0; }
int	msgget(k, m) key_t k; { return 0; }
int	msgrvc(i, p, z, y, f) void *p; size_t z; long y; { return 1; }
int	msgsnd(i, p, z, f) void *p; size_t z; { return 0; }
int	nametopu(s) char *s; { return 1; }
int	nice(incr) { return 0; }
char *	nl_langinfo(i) nl_item i; { return ""; }
struct ns_addr	ns_addr(name) char *name; { struct ns_addr ns; return ns; }
char *	ns_ntoa(addr) struct ns_addr addr; { return (char *) 0; }
#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
DIR *	opendir(f) char *f; { return (DIR *)NULL; }
void	openlog(s, f) char *s; { ; }
long	pathconf(p, n) char *p; { return (long)1; }
int	pause() { ; }
void	perror(s) char *s; { ; }
int	pidfromstring(s) char *s; { return 1; }
char *	pidtostring(p) { return ""; }
void	psignal(sig, s) unsigned sig; char *s; { ; }
int	putenv(s) char *s; { return 0; }
void	putoname(p, s) char *s; { ; }
void	pututline(u) struct utmp *u; { ; }
void	qsort(b, n, w, c) void *b; size_t n, w; 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 dirent *	readdir(p) DIR *p; { return (struct dirent *)NULL; }
void *	realloc(p, n) void *p; size_t n; { return p;}
void	regerror(m) char *m; { ; }
void	remque(elem) struct qelem *elem; { ; }
void	rewinddir(d) DIR *d; { ; }
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; }
void	seekdir(p, l) DIR *p; long l; { ; }
int	setegid(egid) { return 0; }
int	setenv(n, v, o) char *n, *v; { return 0; }
int	seteuid(euid) { return 0; }
void	setgrent() { ; }
int	setgid(g) gid_t g; { return 0; }
void	sethostent(stayopen) { ; }
int	setjmp(e) jmp_buf e; { return 0; }
void	setkey(k) char *k; { ; }
char *	setlocale(c, l) char *l; { return ""; }
void	setnetent(stayopen) { ; }
void	setprotoent(stayopen) { ; }
void	setpwent() { ; }
int	setrgid(rgid) { return 0; }
int	setruid(ruid) { return 0; }
void	setservent(stayopen) { ; }
char *	setstate(st) char *st; { return st; }
int	setuid(u) uid_t u; { return 0; }
void	setutent() { ; }
int	siginterrupt(sig, flag) { return 0; }
unsigned sleep(i) unsigned i; { return 1; }
void	sputl(v, b) long v; char *b; { ; }
long	sgetl(b) char *b; { return 1L; }
void	srand(s) unsigned s; { ; }
void	srandom(s) { ; }
int	(*ssignal(s, a))() int (*a)(); { return a; }
char *	strcat(a, b) char *a, *b; { return a; }
char *	strcatn(a, b, n) char *a, *b; { return a; }
char *	strchr(s, c) char *s; { return s; }
int	strcmp(a, b) char *a, *b; { return 1; }
int	strcmpn(a, b, n) char *a, *b; { return 1; }
int	strcoll(a, b) char *a, *b; { return 1; }
char *	strcpy(a, b) char *a, *b; { return a; }
char *	strcpyn(a, b, n) char *a, *b; { return a; }
size_t	strcspn(s, set) char *s, *set; { return (size_t)1; }
char *	strerror(e) { return ""; }
size_t	strftime(s, m, f, t) char *s, *f; size_t m; struct tm *t; { size_t sz=(size_t)0; return sz; }
size_t	strlen(s) char *s; { size_t l=(size_t)0; return l; }
char *	strncat(a, b, n) char *a, *b; size_t n; { return ""; }
int	strncmp(a, b, n) char *a, *b; size_t n; { return 1; }
char *	strncpy(a, b, n) char *a, *b; size_t n; { return ""; }
char *	strpbrk(s, br) char *s, *br; { return ""; }
char *	strrchr(s, c) char *s; { return ""; }
size_t	strspn(s, set) char *s, *set; { return 0; }
char *	strstr(a, b) char *a, *b; { return ""; }
double	strtod(a, b) char *a, **b; { double d=0.0; return d; }
char *	strtok(s, sep) char *s, *sep; { return s; }
long	strtol(s, p, b) char *s, **p; { return (long)1; }
size_t	strxfrm(a, b, n) char *a, *b; size_t n; { size_t s=(size_t)0; return s; }
int	stty(f, b) struct sgttyb *b; { return 0; }
void	swab(f, t, n) char *f, *t; { ; }
long	sysconf(n) { long l=(long)0; return l; }
	/* VARARGS2 */
void	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) { return (pid_t)1; }
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; }
long	tell(f) { return((long)0); }
long	telldir(p) DIR *p; { return 1L; }
time_t	time(t) time_t *t; { return (time_t)0; }
clock_t	times(tmsp) struct tms *tmsp; { return (clock_t)0; }
char *	tempnam(d, p) char *d, *p; { static char c[1]; return c; }
char *	tmpnam(s) char *s; { return s; }

/* CONV */
#undef _toupper
#undef _tolower
#undef toascii
int	toupper(c) { return c; }
int	tolower(c) { return c; }
int	_toupper(c) { return c; }
int	_tolower(c) { return c; }
int	toascii(c) { return c; }

/* TSEARCH */
void *	tsearch(k, r, c) void *k, **r; int (*c)(); { return k; }
void *	tfind(k, r, c) void *k, **r; int (*c)(); { return k; }
void *	tdelete(k, r, c) void *k, **r; int (*c)(); { return k; }
void	twalk(r, f) void *r; void (*f)(); { ; }

char *	ttyname(f) { return ""; }
int	ttyslot() { return 1; }
void	tzset() { ; }
void	unsetenv(n) char *n; { ; }
UID_T	uidfromstring(s) char *s; { UID_T u; return u; }
char *	uidtostring(u) UID_T u; { return ""; }
int	utime(name, timep) char *name; struct utimbuf *timep; { return 0; }
void	utmpname(f) char *f; { ; }
char *	valloc(s) unsigned s; { return malloc(s); }
int	vlimit(limit, value) { return 0; }

	/* standard I/O library */

void	clearerr(f) FILE *f; { ; }
char *	ctermid(s) char *s; { return ""; }
char *	cuserid(s) char *s; { return ""; }
int	fclose(f) FILE *f; { return 0; }
FILE *	fdopen(fd, m) char *m; { FILE * f=NULL; return f; }
int	feof(f) FILE *f; { return 0; }
int	ferror(f) FILE *f; { return 1; }
int	fflush(f) FILE *f; { return 0; }
int	fgetc(f)  FILE *f; { return 0; }
struct group  *fgetgrent(f) FILE *f; { struct group *g=NULL; return g; }
struct passwd *fgetpwent(f) FILE *f; { struct passwd *g=NULL; return g; }
char *	fgets(s, l, f) char *s; FILE *f; { return s; }
int	fileno(f) FILE *f; { return 1; }
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; { FILE * f=NULL; return f; }
	/* VARARGS2 */
int	fprintf(f, s) FILE *f; char *s; { return 1; }
int	fputc(c, f) int c; FILE *f; { return 1; }
int	fputs(s, f) char *s; FILE *f; { return 0; }
size_t	fread(p, s, n, f) void *p; size_t s, n; FILE *f; { return 1; }
FILE *	freopen(s, m, f) char *s, *m; FILE *f; { FILE * ff=NULL; return ff; }
	/* VARARGS2 */
int	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; }
size_t	fwrite(p, s, n, f) void *p; size_t s, n; FILE *f; { return 0; }
#ifndef getc
int	getc(f) FILE *f; { return EOF; }
#endif getc
#ifndef getchar
int	getchar() { return EOF; }
#endif	getchar
int	getw(f) FILE *f; { return 0; }
char *	gets(s) char *s; { return s; }
int	pclose(f) FILE *f; { return 0; }
FILE *	popen(c, t) char *c, *t; { FILE *f=NULL; return f; }
	/* VARARGS1 */
int	printf(s) char *s; { ; }
int	puts(s) char *s; { ; }
#ifndef putc
int	putc(c, f) FILE *f; { return 0; }
#endif putc
#ifndef putchar
int	putchar(c) { return 1; }
#endif	putchar
int	putw(w, f) FILE *f; { return 0; }
void	rewind(f) FILE *f; { ; }
	/* VARARGS1 */
int	scanf(f) char *f; { return 1; }
void	setbuf(f, b) FILE *f; char *b; { ; }
	setbuffer(f, b, s) FILE *f; char *b; { ; }
	setlinebuf(f) FILE *f; { ; }
int	setvbuf(f, b, t, s) FILE *f; char *b; size_t s; { return 0; }
	/* VARARGS2 */
int	sprintf(s, f) char *s, *f; { return 1;}
	/* VARARGS2 */
int	sscanf(s, f) char *s, *f; { return 1; }
FILE *	tmpfile() { FILE *f=NULL; return f; }
int	ungetc(c, f) FILE *f; { return c; }
int	vprintf(s, a) char *s; va_list a; { return 1; }
int	vfprintf(f, s, a) FILE *f; char *s; va_list a; { return 1; }
int	vsprintf(s, f, a) char *s, *f; va_list a; { return 1; }