/* @(#) $Revision: 78.6.1.1 $       */
/*LINTLIBRARY*/

/*
 * Note that tabs are carefully placed before procedure names so it's
 * easy to extract them for consistency checking.
 */

/* The new-style definitions here assume __STDC__ */
#include <sys/stdsyms.h>
#ifndef __STDC__
#define __STDC__
#endif

/* First come the ANSI-C standard routines (X3J11/88-159) */
#ifdef _INCLUDE__STDC__
#include <errno.h>
int	errno;
#include <float.h>
#include <limits.h>
#include <stddef.h>
#include <assert.h>


/* 4.3 CHARACTER HANDLING */
#include <ctype.h>
int __nl_char_size;
/* CTYPE(3C) */
#undef isalnum
#undef isalpha
#undef iscntrl
#undef isdigit
#undef isgraph
#undef islower
#undef isprint
#undef ispunct
#undef isspace
#undef isupper
#undef isxdigit
int	isalnum(int c) { 
 return (c); }			/* ANSI 4.3.1.1 */

int	isalpha(int c) { 
 return (c); }			/* ANSI 4.3.1.2 */

int	iscntrl(int c) { 
 return (c); }			/* ANSI 4.3.1.3 */

int	isdigit(int c) { 
 return (c); }			/* ANSI 4.3.1.4 */

int	isgraph(int c) { 
 return (c); }			/* ANSI 4.3.1.5 */

int	islower(int c) { 
 return (c); }			/* ANSI 4.3.1.6 */

int	isprint(int c) { 
 return (c); }			/* ANSI 4.3.1.7 */

int	ispunct(int c) { 
 return (c); }			/* ANSI 4.3.1.8 */

int	isspace(int c) { 
 return (c); }			/* ANSI 4.3.1.9 */

int	isupper(int c) { 
 return (c); }			/* ANSI 4.3.1.10 */

int	isxdigit(int c) { 
 return (c); }			/* ANSI 4.3.1.11 */

/* CONV(3C) */
int	tolower(int i) { 
 return (i); }			/* ANSI 4.3.2.1 */

int	toupper(int i) { 
 return (i); }			/* ANSI 4.3.2.2 */


/* 4.4 LOCALIZATION */
#include <locale.h>
/* SETLOCALE(3C) */
char *	setlocale(int i, const char *c ) 		/* ANSI 4.4.1.1 */
	{ 
 char *x=NULL; return (x); }  

/* LOCALECONV(3C) */
struct lconv *	localeconv(void) { 
 return NULL; } 			 		/* ANSI 4.4.2.1 */


/* 4.5 MATHEMATICS (in libm) */

/* 4.6 NON-LOCAL JUMPS */
#include <setjmp.h>
/* SETJMP(3C) */
int	setjmp(jmp_buf e ) { 
 return (0); }  		/* ANSI 4.6.1.1 */

void	longjmp(jmp_buf e, int v) { 
}  			/* ANSI 4.6.2.1 */


/* 4.7 SIGNAL HANDLING */
#include <signal.h>

/* Additions made 7/12/95 */
int killpg(pid_t a, int b)
        { return(0); }
int sigaltstack(const stack_t *a, stack_t *b)
        { return(0); }
int siginterrupt(int a, int b)
        { return(0); }

void (*bsd_signal(int a, void(*func)(int)))(int)
  	{ return (void (*)())0; }

/* SIGNAL(2) */
void (*	signal(int sig, void (*func)(int)))(int){ 
 return (void (*)())0; }

							/* ANSI 4.7.1.1 */
/* KILL(2) */
int	raise(int i ) { 
 return (i); }			/* ANSI 4.7.2.1 */


/* 4.8 VARIABLE ARGUMENTS */
#include <stdarg.h>

/* 4.9 INPUT/OUTPUT */
#include <stdio.h>
/* STDIO(3S) */
FILE	__iob[8];
FILE   *___fno_iop;
unsigned char *	__bufendtab[8];
/* REMOVE(3) */
int	remove(const char *c ) { 
 return(0); }		/* ANSI 4.9.4.1 */

/* RENAME(2) */
int	rename(const char *s, const char *t ) 		/* ANSI 4.9.4.2 */
	{ 
 return (0); }  

/* TMPFILE(3S) */
FILE *	tmpfile(void) { 
 return (stdin); }		/* ANSI 4.9.4.3 */

FILE *	tmpfile64(void) { 
 return (stdin); }		/* ANSI 4.9.4.3 */

/* TMPNAM(3S) */
char *	tmpnam(char *s ) { 
 return (s); }		/* ANSI 4.9.4.4 */

/* FCLOSE(3S) */
int	fclose(FILE *f ) { 
 return (0); }		/* ANSI 4.9.5.1 */

int	fflush(FILE *f ) { 
 return (0); }		/* ANSI 4.9.5.2 */

/* FOPEN(3S) */
FILE *	fopen(const char *f, const char *t ) 		/* ANSI 4.9.5.3 */
	{ 
 return (stdin); }  

FILE *	fopen64(const char *f, const char *t )
	{ 
 return (stdin); }  

FILE *	freopen(const char *f, const char *t, FILE *s )	/* ANSI 4.9.5.4 */
	{ 
 return (s); }

FILE *	freopen64(const char *f, const char *t, FILE *s )
	{ 
 return (s); }

/* SETBUF(3S) */
void	setbuf(FILE *f, char *b ) { 
}			/* ANSI 4.9.5.5 */

int	setvbuf(FILE *f, char *b, int t, size_t s )   	/* ANSI 4.9.5.6 */
	{ 
 return (t); }

/* PRINTF(3S) */
/* VARARGS2 */
int	fprintf(FILE *f, const char *s, ... ) 		/* ANSI 4.9.6.1 */
	{ 
 return (0); }	

/* SCANF(3S) */
/* VARARGS2 */
int	fscanf(FILE *f, const char *s, ... ) 		/* ANSI 4.9.6.2 */
	{ 
 return (0); }

/* PRINTF(3S) */
/* VARARGS1 */
int	printf(const char *s, ... ) { 
 return (0); }	/* ANSI 4.9.6.3 */

/* SCANF(3S) */
/* VARARGS1 */
int	scanf(const char *s, ... ) { 
 return (0); }	/* ANSI 4.9.6.4 */

/* PRINTF(3S) */
/* VARARGS2 */
int	sprintf(char *p, const char *s, ... ) 		/* ANSI 4.9.6.5 */
	{ 
 return (0); }

/* SCANF(3S) */
/* VARARGS2 */
int	sscanf(const char *p, const char *s, ... )	/* ANSI 4.9.6.6 */
	{ 
 return (0); } 


/* VPRINTF(3S) */
int	vfprintf(FILE *f, const char *s, __va_list v ) 	/* ANSI 4.9.6.7 */
	{ 
 return (0); }

int	vprintf(const char *s, __va_list v ) 		/* ANSI 4.9.6.8 */
	{ 
 return (0); }

int	vsprintf(char *p, const char *s, __va_list v ) 	/* ANSI 4.9.6.9 */
	{ 
 return (0); }


/* GETC(3S) */
int	fgetc(FILE *f ) { 
 return (0); }			/* ANSI 4.9.7.1 */

/* GETS(3S) */
char *	fgets(char *s, int n, FILE *f ) { 
 return (s); }	/* ANSI 4.9.7.2 */

/* PUTC(3S) */
int	fputc(int c, FILE *f ) { 
 return (c); }		/* ANSI 4.9.7.3 */

/* PUTS(3S) */
int	fputs(const char *s, FILE *f ) { 
 return (0); }	/* ANSI 4.9.7.4 */

/* GETC(3S) */
#undef getc
int	getc(FILE *f ) { 
 return (0); }			/* ANSI 4.9.7.5 */

#undef getchar
int	getchar(void) { 
 return (0); }			/* ANSI 4.9.7.6 */

/* GETS(3S) */
char *	gets(char *s ) { 
 return (s); }			/* ANSI 4.9.7.7 */

/* PUTC(3S) */
#undef putc
int	putc(int c, FILE *f ) { 
 return (c); }		/* ANSI 4.9.7.8 */

#undef putchar
int	putchar(int c) { 
 return (c); }			/* ANSI 4.9.7.9 */

/* PUTS(3S) */
int	puts(const char *s ) { 
 return (0); }		/* ANSI 4.9.7.10 */

/* UNGETC(3S) */
int	ungetc(int c, FILE *f ) { 
 return (c); }		/* ANSI 4.9.7.11 */

/* FREAD(3S) */
#ifdef _CLASSIC_ANSI_TYPES
int	fread(char *b, int s, int n, FILE *f ) { 
 return (n); }

int	fwrite(char *b, int s, int n, FILE *f ) { 
 return (n); }

#else
size_t	fread(void *b, size_t s, size_t n, FILE *f ) 	/* ANSI 4.9.8.1 */
	{ 
 return (n); }

size_t	fwrite(const void *b, size_t s, size_t n, FILE *f ) /* ANSI 4.9.8.2 */
	{ 
 return (n); }

#endif
/* FGETPOS(3S) */
int	fgetpos(FILE *f, fpos_t *p ) { 
 return (0); }	/* ANSI 4.9.9.1 */

int	fgetpos64(FILE *f, fpos64_t *p ) { 
 return (0); }

/* FSEEK(3S) */
int	fseek(FILE *f, long o, int p) { 
 return (p); }	/* ANSI 4.9.9.2 */

int	fseeko(FILE *f, off_t o, int p) { 
 return (p); }	

int	fseeko64(FILE *f, off64_t o, int p) { 
 return (p); }	

/* FGETPOS(3S) */
int	fsetpos(FILE *f, const fpos_t *p ) 		/* ANSI 4.9.9.3 */
	{ 
 return (0); } 

int	fsetpos64(FILE *f, const fpos64_t *p ) 		/* ANSI 4.9.9.3 */
	{ 
 return (0); } 

/* FSEEK(3S) */
long	ftell(FILE *f ) { 
 return (0L); }		/* ANSI 4.9.9.4 */

off_t	ftello(FILE *f ) { 
 return ((off_t)0); }		

off64_t	ftello64(FILE *f ) { 
 return ((off64_t)0); }		

void	rewind(FILE *f ) { 
}				/* ANSI 4.9.9.5 */

/* FERROR(3S) */
#undef clearerr
void	clearerr(FILE *f ) { 
}				/* ANSI 4.9.10.1 */

#undef feof
int	feof(FILE *f ) { 
 return (0); }			/* ANSI 4.9.10.2 */

#undef ferror
int	ferror(FILE *f ) { 
 return (0); }		/* ANSI 4.9.10.3 */

/* PERROR(3C) */
void	perror(const char *s ) { 
}			/* ANSI 4.9.10.4 */


/* 4.10 GENERAL UTILITIES */
#include <stdlib.h>

/* Additions made 7/12/95 */
char *realpath(const char *a, char *b)
        { return(a); }
int grantpt(int a)
        { return(0); }
int unlockpt(int a)
        { return(0); }


/* STRTOD(3C) */
double	atof(const char *s ) { 
 return (0.0); } 		/* ANSI 4.10.1.1 */

/* STRTOL(3C) */
int	atoi(const char *s ) { 
 return (0); }		/* ANSI 4.10.1.2 */

long	atol(const char *s ) { 
 return (0L); }		/* ANSI 4.10.1.3 */

/* STRTOD(3C) */
double	strtod(const char *s, char **t ) 		/* ANSI 4.10.1.4 */
	{ 
 return (0.0); } 

/* STRTOL(3C) */
long	strtol(const char *s, char **t, int b) 		/* ANSI 4.10.1.5 */
	{ 
 return (0L); } 

unsigned long int	strtoul(const char *c, char **cp, int i ) 
	{ 
 return((unsigned long)0); }			/* ANSI 4.10.1.6 */


/* RAND(3C) */
int	rand(void) { 
 return (0); }			/* ANSI 4.10.2.1 */

void	srand(unsigned s ) { 
}				/* ANSI 4.10.2.2 */


/* MALLOC(3C), MALLOC(3X) */
void	free(void *s ) { 
}	  			/* ANSI 4.10.3.2 */

#ifdef _CLASSIC_ANSI_TYPES
char *	calloc(unsigned n, unsigned e ) { 
 return (""); }

char *	malloc(unsigned s ) { 
 return (""); }

char *	realloc(char *s, unsigned n ) { 
 return (s); }

#else
void *	calloc(size_t n, size_t e ) { 
 return (NULL); }  /* ANSI 4.10.3.1 */

void *	malloc(size_t s ) { 
 return (NULL); }	  	/* ANSI 4.10.3.3 */

void *	realloc(void *s, size_t n ) { 
 return (s); }	/* ANSI 4.10.3.4 */

#endif

/* ABORT(3C) */
#ifdef _CLASSIC_ANSI_TYPES
int	abort(void) { 
 return (0); }

#else
void	abort(void) { 
}					/* ANSI 4.10.4.1 */

#endif
/* ATEXIT(2) */
int	atexit(void (*f)() ) { 
 return(0); }		/* ANSI 4.10.4.2 */

/* EXIT(2) */
void	exit(int s) { 
}					/* ANSI 4.10.4.3 */

/* GETENV(3C) */
char *	getenv(const char *n ) { 
 char *x=NULL; return (x); }	/* ANSI 4.10.4.4 */

/* SYSTEM(3S) */
int	system(const char *s ) { 
 return (0); }		/* ANSI 4.10.4.5 */


/* BSEARCH(3C) */
#ifdef _CLASSIC_ANSI_TYPES
char *	bsearch(char *k, char *b, unsigned n, unsigned w, int (*c)() ) 	
	{ 
 return (k); }

#else
void *	bsearch(const void *k, const void *b, size_t n, size_t w, 
		int (*c)(const void *, const void*) ) 	/* ANSI 4.10.5.1 */
	{ 
 void *x=NULL; return (x);}

#endif
/* QSORT(3C) */
void	qsort(void *b, size_t n, size_t w, int (*c)() ) { 
} /* ANSI 4.10.5.2 */


/* ABS(3C) */
int	abs(int i) { 
 return (i); }			/* ANSI 4.10.6.1 */

/* DIV(3C) */
div_t	div(int i, int j ) { 
 div_t d={0,0}; return(d); }	/* ANSI 4.10.6.2 */

/* ABS(3C) */
long	labs(long l ) { 
 return(l); }			/* ANSI 4.10.6.3 */

/* DIV(3C) */
ldiv_t	ldiv(long l, long m ) { 
 ldiv_t ld={0,0}; return(ld); }/* ANSI 4.10.6.4 */


/* MULTIBYTE(3C) */
int	mblen(const char *c, size_t s ) 		/* ANSI 4.10.7.1 */
	{ 
 return(0); }	

int	mbtowc(wchar_t *w, const char *c, size_t s ) 	/* ANSI 4.10.7.2 */
	{ 
 return(0); }

int	wctomb(char *c, wchar_t w ) { 
 return(0); }	/* ANSI 4.10.7.3 */

size_t	mbstowcs(wchar_t *w, const char *c, size_t s ) 	/* ANSI 4.10.8.1 */
	{ 
 return(s); }

size_t	wcstombs(char *c, const wchar_t *w, size_t s ) 	/* ANSI 4.10.8.2 */
	{ 
 return(s); }


/* 4.11 STRING HANDLING */
#include <string.h>
/* MEMORY(3C) */
#ifdef _CLASSIC_ANSI_TYPES
char *	memcpy(char *a, char *b, int n) { 
 return (a); }

#else
void *	memcpy(void *a, const void *b, size_t n ) 	/* ANSI 4.11.2.1 */
	{ 
 return (a); }

#endif
void *	memmove(void *v, const void *x, size_t s ) 	/* ANSI 4.11.2.2 */
	{ 
 return(v); }

/* STRING(3C) */
char *	strcpy(char *a, const char *b ) { 
 return (a); }	/* ANSI 4.11.2.3 */

char *	strncpy(char *a, const char *b, size_t n ) 	/* ANSI 4.11.2.4 */
	{ 
 return (a); }

char *	strcat(char *a, const char *b ) { 
 return (a); }	/* ANSI 4.11.3.1 */

char *	strncat(char *a, const char *b, size_t n ) 	/* ANSI 4.11.3.2 */
	{ 
 return (a); }

/* MEMORY(3C) */
int	memcmp(const void *a, const void *b, size_t n ) /* ANSI 4.11.4.1 */
	{ 
 return (0); }

/* STRING(3C) */
int	strcmp(const char *a, const char *b ) 		/* ANSI 4.11.4.2 */
	{ 
 return (0); }

int	strcoll(const char *c1, const char *c2 ) 	/* ANSI 4.11.4.3 */
	{ 
 return(0); }

int	strncmp(const char *a, const char *b, size_t n )/* ANSI 4.11.4.4 */
	{ 
 return (0); }

size_t	strxfrm(char *c1, const char *c2, size_t s ) 	/* ANSI 4.11.4.5 */
	{ 
 return(s); }


/* MEMORY(3C) */
#ifdef _CLASSIC_ANSI_TYPES
char *	memchr(char *s, int c, int n) { 
 return (s); }

#else
void *	memchr(const void *s, int c, size_t n ) 	/* ANSI 4.11.5.1 */
	{ 
 void *x=NULL; return (x); }

#endif
/* STRING(3C) */
char *	strchr(const char *a, int b ) { 
 char *x=NULL; return (x); }	/* ANSI 4.11.5.2 */

#ifdef _CLASSIC_ANSI_TYPES
int	strcspn(char *a, char *b ) { 
 return (0); }

int	strspn(char *a, char *b ) { 
 return (0); }

#else
size_t	strcspn(const char *a, const char *b ) 		/* ANSI 4.11.5.3 */
	{ 
 return ((size_t)0); }

size_t	strspn(const char *a, const char *b ) 		/* ANSI 4.11.5.6 */
	{ 
 return (0); }

#endif
char *	strpbrk(const char *a, const char *b ) 		/* ANSI 4.11.5.4 */
	{ 
 char *x=NULL; return (x); }

char *	strrchr(const char *a, int b ) { 
 char *x=NULL; return (x); }	/* ANSI 4.11.5.5 */

char *	strstr(const char *c1, const char *c2 ) 	/* ANSI 4.11.5.7 */
	{ 
 char *x=NULL; return(x); }

char *	strtok(char *a, const char *b ) { 
 return (a); }	/* ANSI 4.11.5.8 */


/* MEMORY(3C) */
#ifdef _CLASSIC_ANSI_TYPES
char * memset(char *s, int c, int n) { 
 return (s); }

#else
void *	memset(void *s, int c, size_t n ) 		/* ANSI 4.11.6.1 */
	{ 
 return (s); }

#endif
/* PERROR(3C) */
char *	strerror(int i ) { 
 char c; return(&c); }	/* ANSI 4.11.6.2 */

#ifdef _CLASSIC_ANSI_TYPES
int	strlen(char *s ) { 
 return (0); }

#else
size_t	strlen(const char *s ) { 
 return ((size_t)0); }	/* ANSI 4.11.6.3 */

#endif


/* 4.12 DATE AND TIME */
#include <time.h>

/* Additions made 7/12/95 */

int utimes(const char *path, const struct timeval amtimes[2])
        { return(0); }

/* CLOCK(3C) */
#ifdef _CLASSIC_ANSI_TYPES
clock_t	clock(void) { 
 return (0L); }

#else
clock_t	clock(void) { 
 return ((clock_t)0); }		/* ANSI 4.12.2.1 */

#endif
/* CTIME(3C) */
char *	tzname[2];
double	difftime(time_t t1, time_t t2 ) { 
 return(t1); } /* ANSI 4.12.2.2 */

time_t	mktime(struct tm *s ) { 
 return((time_t)0); } 	/* ANSI 4.12.2.3 */

/* TIME(2) */
time_t	time(time_t *t ) { 
 return (*t); }		/* ANSI 4.12.2.4 */


/* CTIME(3C) */
char *	asctime(const struct tm *t ) { 
 return (""); }	/* ANSI 4.12.3.1 */

char *	ctime(const time_t *t ) { 
 return (""); }	/* ANSI 4.12.3.2 */

struct tm *	gmtime(const time_t *c ) 		/* ANSI 4.12.3.3 */
	{ 
 return (struct tm *)0; }

struct tm *	localtime(const time_t *c ) 		/* ANSI 4.12.3.4 */
	{ 
 return (struct tm *)0; }

/* STRFTIME(3C) */
size_t	strftime(char *c1, size_t s, const char *c2, const struct tm *t ) 
	{ 
 return(s); }					/* ANSI 4.12.3.5 */


#ifdef _REENTRANT
int 	asctime_r(const struct tm *t, char *c, int i) {
 return(0); }

int 	ctime_r(const time_t *t, char *c, int i) {
 return(0); }

int 	gmtime_r(const time_t *t, struct tm *s) {
 return(0); }

int 	localtime_r(const time_t *t, struct tm *s) {
 return(0); }

int 	setlocale_r(int i, const char *cc, char *c, int j) {
 return(0); }

int 	strerror_r(int i, char *c, int j) {
 return(0); }

char 	*strtok_r(char *c, const char *cc, char **cp) {
 return((char *) 0); }

#undef getc_unlocked
int	getc_unlocked(FILE *f ) { 
 return (0); }			

#undef getchar_unlocked
int	getchar_unlocked(FILE *f) {
 return(0); }

#undef putc_unlocked
int	putc_unlocked(int c, FILE *f) {
 return (c); }

#undef putchar_unlocked
int	putchar_unlocked(int c) {
 return (c); }

#undef clearerr_unlocked
void	clearerr_unlocked(FILE *f) {
 return; }

#undef feof_unlocked
int	feof_unlocked(FILE *f) {
 return (0); }

#undef ferror_unlocked
int	ferror_unlocked(FILE *f) {
 return (0); }

#endif /* _REENTRANT */

#endif /* _INCLUDE__STDC__ */


/* Next come those routines in POSIX 1003.1, but not in ANSI-C */
/* =====================   POSIX  ============================ */
#ifdef _INCLUDE_POSIX_SOURCE
#include <sys/types.h>
#include <pwd.h>
#include <unistd.h>

/* Additions made 7/12/95 */
int getdtablesize(void)
        { return(0); }
long gethostid(void)
        { return(0); }
int getpagesize(void)
        { return(0); }
int setreuid(uid_t a, uid_t b)
        { return(0); }
int setregid(gid_t a, gid_t b)
        { return(0); }
int usleep(unsigned int a)
        { return(0); }
pid_t getpgid(pid_t a)
        { return(a); }

unsigned int ualarm(unsigned int a, unsigned int b)
        { return(a); }
char *getcdf(const char *a , char *b , size_t c)
        { return(b); }
int set_userthreadid(int a)
        { return(0); }

/* 3. Process Primitives */
/* FORK(2) */ 						/* POSIX 3.1.1 */
#ifdef _CLASSIC_POSIX_TYPES
int   fork(void) { 
 return (0); }

#else
pid_t	fork(void) { 
 return ((pid_t)0); }		

#endif
/* EXEC(2) */						/* POSIX 3.1.2 */
char **	environ;
/*VARARGS2*/
int	execl(const char *f, const char *a, ... ) { 
 return (0); }

int	execv(const char *s, char * const *v ) { 
 return (0); }

/*VARARGS2*/
int	execle(const char *f, const char *a, ...) { 
 return (0); }

int	execve(const char *f, char * const *a, char * const *e ) { 
 return (0); }

/*VARARGS2*/
int	execlp(const char *f, const char *a, ... ) { 
 return (0); }

int	execvp(const char *s, char * const *v ) { 
 return (0); }

#include <sys/wait.h>

/* Additions made 7/12/95 */
int waitid(idtype_t a, id_t b, siginfo_t *c, int d)
        { return(0); }


/* WAIT(2) */						/* POSIX 3.2.1 */
#ifdef _CLASSIC_POSIX_TYPES
int	wait(int *s ) { 
 return (0); }

int	waitpid(int p, int *m, int i ) { 
 return(p); }

#else
pid_t	wait(int *s ) { 
 return ((pid_t)0); }

pid_t	waitpid(pid_t p, int *m, int i ) { 
 return((pid_t)0); }

#endif
/* EXIT(2) */						/* POSIX 3.2.2 */
void	_exit(int s) { 
}

/* KILL(2) */						/* POSIX 3.3.2 */
int	kill(pid_t i, int s ) { 
 return (s); }

/* SIGSETOPS(3C) */					/* POSIX 3.3.3 */
int	sigemptyset(sigset_t *s ) { 
 return(0); }

int	sigfillset(sigset_t *s ) { 
 return(0); }

int	sigaddset(sigset_t *s, int i ) { 
 return(i); }

int	sigdelset(sigset_t *s, int i ) { 
 return(i); }

int	sigismember(const sigset_t *s, int i ) { 
 return(i); }

/* SIGACTION(2) */					/* POSIX 3.3.4 */
int	sigaction(int i, const struct sigaction *s1, struct sigaction *s2 ) 
	{ 
 return(i); }

/* SIGPROCMASK(2) */					/* POSIX 3.3.5 */
int	sigprocmask(int i, const sigset_t *s1, sigset_t *s2 ) { 
 return(i); }

/* SIGPENDING(2) */					/* POSIX 3.3.6 */
int	sigpending(sigset_t *s ) { 
 return(0); }

/* SIGSUSPEND(2) */					/* POSIX 3.3.7 */
int	sigsuspend(const sigset_t *s ) { 
 return(0); }

/* ALARM(2) */						/* POSIX 3.4.1 */
#ifdef _CLASSIC_POSIX_TYPES
unsigned long   alarm(unsigned long s) { 
 return (s); }

#else
unsigned int	alarm(unsigned int s ) { 
 return (s); }

#endif
/* PAUSE(2) */						/* POSIX 3.4.2 */
int	pause(void) { 
 return (0); }

/* SLEEP(3C) */						/* POSIX 3.4.3 */
unsigned int	sleep(unsigned int n ) { 
 return (n); }


/* 4. Process Environment */
/* GETPID(2) */						/* POSIX 4.1.1 */
#ifdef _CLASSIC_POSIX_TYPES
int   getpid(void) { 
 return (0); }

int   getppid(void) { 
 return (0); }

#else
pid_t	getpid(void) { 
 return ((pid_t)0); }

pid_t	getppid(void) { 
 return ((pid_t)0); }

#endif
/* GETUID(2) */						/* POSIX 4.2.1 */
#ifdef _CLASSIC_POSIX_TYPES
unsigned short getuid(void) { 
 return ((unsigned short)0); }

unsigned short geteuid(void) { 
 return ((unsigned short)0); }

unsigned short getgid(void) { 
 return ((unsigned short)0); }

unsigned short getegid(void) { 
 return ((unsigned short)0); }

#else
uid_t	getuid(void) { 
 return ((uid_t)0); }

uid_t	geteuid(void) { 
 return ((uid_t)0); }

gid_t	getgid(void) { 
 return ((gid_t)0); }

gid_t	getegid(void) { 
 return ((gid_t)0); }

#endif
/* SETUID(2) */						/* POSIX 4.2.2 */
int	setuid(uid_t u ) { 
 return (u); }

int	setgid(gid_t g ) { 
 return (g); }

/* GETGROUPS(2) */					/* POSIX 4.2.3 */
int	getgroups(int n, gid_t *g ) { 
 return (0); }

/* GETLOGIN(3C) */					/* POSIX 4.2.4 */
char *	getlogin(void) { 
 return (""); }

/* CUSERID(3S) */					/* POSIX 4.2.4 */
char *	cuserid(char *s ) { 
 return (s); }

/* GETPID(2) */						/* POSIX 4.3.1 */
#ifdef _CLASSIC_POSIX_TYPES
int   getpgrp(void) { 
 return (0); }

#else
pid_t	getpgrp(void) { 
 return ((pid_t)0); }

#endif
/* SETSID(2) */						/* POSIX 4.3.2 */
pid_t	setsid(void) { 
 return((pid_t)0); }

/* SETPGID(2) */					/* POSIX 4.3.3 */
int	setpgid(pid_t p1, pid_t p2 ) { 
 return(0); }

/* UNAME(2) */						/* POSIX 4.4.1 */
#include <sys/utsname.h>
struct utsname utsname;
int	uname(struct utsname *n ) { 
 return (0); }
int	_utssys(struct utsname *name, int a, int b) {
 return 0; }

/* TIMES(2) */						/* POSIX 4.5.2 */
#include <sys/times.h>
#ifdef _CLASSIC_POSIX_TYPES
long  times(struct tms *b ) { 
 return (0L); }

#else
clock_t	times(struct tms *b ) { 
 return ((clock_t)0); }

#endif
/* CTERMID(3S) */					/* POSIX 4.7.1 */
char *	ctermid(char *s ) { 
 return (s); }

/* TTYNAME(3C) */					/* POSIX 4.7.2 */
char *	ttyname(int f) { 
 return (""); }

int	isatty(int f) { 
 return (f); }

/* SYSCONF(2) */					/* POSIX 4.8.1 */
long	sysconf(int i ) { 
 return(0L); }



/* 4. Files and Directories */
#include <dirent.h>
/* DIRECTORY(3C) */					/* POSIX 5.1.2 */
DIR *	opendir(const char *f ) { 
 return (0); }

struct dirent *	readdir(DIR *d ) { 
 return (0); }

#undef rewinddir
void	rewinddir(DIR *d ) { 
}

int	closedir(DIR *d ) { 
 return (0); }

/* CHDIR(2) */						/* POSIX 5.2.1 */
int	chdir(const char *s ) { 
 return (0); }

/* GETCWD(3C) */					/* POSIX 5.2.2 */
#if defined(_XPG3) || defined(_POSIX1_1988)
char *	getcwd(char *b, int s) { 
 return (b); }

#else /* not (_XPG3 || _POSIX1_1988) */
char *	getcwd(char *b, size_t s) { 
 return (b); }

#endif /* not (_XPG3 || _POSIX1_1988) */
/* OPEN(2) */						/* POSIX 5.3.1 */
#include <sys/stat.h>
#include <fcntl.h>
/*VARARGS2*/
int	open(const char *f, int o, ...) { 
 return (o); }

int	open64(const char *f, int o, ...) { 
 return (o); }

/* CREAT(2) */						/* POSIX 5.3.2 */
int	creat(const char *s, mode_t m ) { 
 return (0); }

int	creat64(const char *s, mode_t m ) { 
 return (0); }

/* UMASK(2) */
#ifdef _CLASSIC_POSIX_TYPES
int   umask(int c) { 
 return (c); }

#else
mode_t	umask(mode_t c) { 
 return ((mode_t)0); }		/* POSIX 5.3.3 */

#endif
/* LINK(2) */						/* POSIX 5.3.4 */
int	link(const char *a, const char *b ) { 
 return (0); }

/* MKDIR(2) */						/* POSIX 5.4.1 */
int	mkdir(const char *p, mode_t m ) { 
 return (0); }

/* MKFIFO(3C) */					/* POSIX 5.4.2 */
int	mkfifo(const char *c, mode_t m ) { 
 return(0); }

/* UNLINK(2) */						/* POSIX 5.5.1 */
int	unlink(const char *s ) { 
 return (0); }

/* RMDIR(2) */						/* POSIX 5.5.2 */
int	rmdir(const char *p ) { 
 return (0); }

/* STAT(2) */						/* POSIX 5.6.2 */
int	stat(const char *s, struct stat *b ) { 
 return (0); }

int	stat64(const char *s, struct stat64 *b ) { 
 return (0); }

int	fstat(int f, struct stat *b ) { 
 return (f); }

int	fstat64(int f, struct stat64 *b ) { 
 return (f); }

/* ACCESS(2) */						/* POSIX 5.6.3 */
int	access(const char *f, int m) { 
 return (m); }

/* CHMOD(2) */						/* POSIX 5.6.4 */
int	chmod(const char *s, mode_t m ) { 
 return (0); }

/* CHOWN(2) */						/* POSIX 5.6.5 */
int	chown(const char *s, uid_t o, gid_t g ) { 
 return (0); }

#include <utime.h>
/* UTIME(2) */						/* POSIX 5.6.6 */
int	utime(const char *f, const struct utimbuf *t ) { 
 return (0); }

/* PATHCONF(2) */					/* POSIX 5.7.1 */
long	pathconf(const char *c, int i ) { 
 return(0L); }

long	fpathconf(int i1, int i2 ) { 
 return(0L); }


/* 6. Input and Output Primitives */
/* PIPE(2) */						/* POSIX 6.1.1 */
int	pipe(int f[2] ) { 
 return (0); }

/* DUP(2) */						/* POSIX 6.2.1 */
int	dup(int f) { 
 return (f); }

/* DUP2(2) */						/* POSIX 6.2.1 */
int	dup2(int f, int f2) { 
 return(0); }

/* CLOSE(2) */						/* POSIX 6.3.1 */
int	close(int f) { 
 return (f); }


/* READ(2) */						/* POSIX 6.4.1 */
#if defined(_XPG3) || defined(_POSIX1_1988)
int	read(int f, char *b, unsigned n ) { 
 return (f); }

#else /* not (_XPG3 || _POSIX1_1988) */
ssize_t	read(int a, void *b, size_t c ) { 
 return 0; }

#endif /* not (_XPG3 || _POSIX1_1988) */

/* WRITE(2) */						/* POSIX 6.4.2 */
#if defined(_XPG3) || defined(_POSIX1_1988)
int	write(int f, const char *b, unsigned n ) { 
 return (f); }

#else /* not (_XPG3 || _POSIX1_1988) */
ssize_t	write(int f, const void *b, size_t n ) { 
 return (f); }

#endif /* not (_XPG3 || _POSIX1_1988) */
/* FCNTL(2) */						/* POSIX 6.5.2 */
/*VARARGS2*/
int	fcntl(int f, int c, ...) { 
 return (f); }


/* LSEEK(2) */						/* POSIX 6.5.3 */
off_t	lseek(int f, off_t o, int w ) { 
 return (o); }

off64_t	lseek64(int f, off64_t o, int w ) { 
 return (o); }

/* 7. Device- and Class-Specific Functions */
#include <termios.h>
/* CFSPEED(3C) */					/* POSIX 7.1.2.7 */
speed_t	cfgetospeed(const struct termios *t ) { 
 return((speed_t)0); }

int	cfsetospeed(struct termios *t, speed_t s ) { 
 return(0); }

speed_t	cfgetispeed(const struct termios *t ) { 
 return((speed_t)0); }

int	cfsetispeed(struct termios *t, speed_t s ) { 
 return(0); }

/* TCATTRIBUTE(3C) */					/* POSIX 7.2.1 */
int	tcgetattr(int i, struct termios *t ) { 
 return(0); }

int	tcsetattr(int i, int j, const struct termios *t ) { 
 return(0); }

/* TCCONTROL(3C) */					/* POSIX 7.2.2 */
int	tcsendbreak(int i1, int i2 ) { 
 return(i1); }

int	tcdrain(int i ) { 
 return(i); }

int	tcflush(int i1, int i2 ) { 
 return(i1); }

int	tcflow(int i1, int i2 ) { 
 return(i1); }

/* TCGETPGRP(3C) */					/* POSIX 7.2.3 */
pid_t	tcgetpgrp(int i ) { 
 return((pid_t)0); }

/* TCSETPGRP(3C) */					/* POSIX 7.2.4 */
int	tcsetpgrp(int i, pid_t p ) { 
 return(i); }


/* 8. Language-Specific Services for the C Programming Language */
/* FILENO(3S) */					/* POSIX 8.2.1 */
#undef fileno
int	fileno(FILE *f ) { 
 return (0); }

/* FOPEN(3S) */
FILE *	fdopen(int f, const char *t ) { 
return (stdin);}	/* POSIX 8.2.2 */

/* SETJMP(3C) */					/* POSIX 8.3.1 */
int	sigsetjmp(sigjmp_buf s, int i ) { 
 return(i); }

void	siglongjmp(sigjmp_buf s, int i ) { 
 return; }

/* CTIME(3C) */						/* POSIX 8.3.2 */
void	tzset(void) { 
}


/* 9. System Databases */
#include <grp.h>
/* GETGRENT(3C) */					/* POSIX 9.2.1 */
struct group *	getgrgid(gid_t g ) { 
 return (struct group *)0; }

struct group *	getgrnam(const char *n ) { 
 return (struct group *)0; }

/* GETPWENT(3C) */					/* POSIX 9.2.2 */
struct passwd *	getpwuid(uid_t u ) { 
 return (struct passwd *)0; }

struct passwd *	getpwnam(const char *n ) { 
 return (struct passwd *)0; }


#ifdef _REENTRANT

int 	getgrgid_r(gid_t gt, struct group *g, char *c, int i) {
 return(0); }

int 	getgrnam_r(const char *cc, struct group *g, char *c, int i) {
 return(0); }

int 	getlogin_r(char *c, int i) {
 return(0); }

int 	getpwnam_r(const char *cc, struct passwd *p, char *c, int i) {;
 return(0); }

int 	getpwuid_r(uid_t u, struct passwd *p, char *c, int i) {
 return(0); }

int 	readdir_r(DIR *d, struct dirent *e) {
 return(0); }

int 	ttyname_r(int i, char *c, int j){
 return(0);}

#endif /* _REENTRANT */

# endif  /* POSIX */

/*  POSIX.2 functions not in POSIX.1  */
/* ======================= POSIX.2 ============================= */
#ifdef _INCLUDE_POSIX2_SOURCE

int	fnmatch(const char *p, const char *s, int f) { 
 return (f); }


#include <regex.h>
int	regcomp(regex_t *preg, const char *pattern, int cflags) { 
 return (0); }

int	regexec(const regex_t *preg, const char *string,
		size_t nmatch, regmatch_t *pmatch,
		int eflags) { 
 return (0); }

void	regfree(regex_t *preg) { 
 return; }

size_t	regerror(int a, const regex_t *b, char *c, size_t d) { 
 return(d); }


#include <glob.h>
int	glob(const char *pattern, int flags, int (*errfunc)(),
	     glob_t *pglob) { 
 return (0); }

void	globfree(glob_t *pglob) { 
 return; }


size_t	confstr(int name, char *buf, size_t len) { 
 return (0); }

 
#endif  /* POSIX.2*/


/* X/Open Portability Guide, Issue 3 */
/* ======================= XOPEN =============================== */
#ifdef _INCLUDE_XOPEN_SOURCE


#include <nl_types.h>
/* _nl_fn */
nl_catd	_nl_fn;
/* CATOPEN(3C) NLS */
int	catclose(nl_catd d ) { 
 return(0); }

/* CATGETS(3C) NLS */
char *	catgets(nl_catd c, int s, int m, const char *d ) { 
 char *x=NULL; return(x); }

/* CATOPEN(3C) NLS */
nl_catd	catopen(const char *n, int o) { 
 return((nl_catd)0); }

/* CHROOT(2) */
int	chroot(const char *p ) { 
 return (0); }

/* CRYPT(3C) */
char *	crypt(const char *k, const char *s ) 
	{ 
 char *x=NULL; return (x); }

/* CTIME(3C) */
int	daylight;
/* DRAND48(3C) */
double	drand48(void) { 
 return (0.0); }

double	erand48(unsigned short x[3] ) { 
 return (0.0); }

long	jrand48(unsigned short x[3] ) { 
 return (0L); }

void	lcong48(unsigned short p[7] ) { 
}

long	lrand48(void) { 
 return (0L); }

long	mrand48(void) { 
 return (0L); }

long	nrand48(unsigned short x[3] ) { 
 return (0L); }

unsigned short *	seed48(unsigned short s[3] ) { 
 return (s); }

void	srand48(long s) { 
}

/* CRYPT(3C) */
void	encrypt(char *b, int e) { 
}

/* FSYNC(2) */
int	fsync(int f) { 
 return(f); }

/* FTW(3C) */
#include <ftw.h>
int	ftw(const char *p, int (*f)(const char *, const struct stat *,
	    int), int d) { 
 return (d); }

/* FTW64(3C) */
#include <ftw.h>
int	ftw64(const char *p, int (*f)(const char *, const struct stat64 *,
	    int), int d) { 
 return (d); }


/* GETOPT(3C) */
int	getopt(int c, char * const *v, const char *o ) { 
 return (c); }

char *	optarg;
int	optind;
int	opterr;
/* GETC(3S) */
int	getw(FILE *f ) { 
 return (0); }

/* HSEARCH(3C) */
#include <search.h>
int	hcreate(unsigned n ) { 
 return (0); }

void	hdestroy(void) { 
}

ENTRY *	hsearch(ENTRY i, ACTION a ) { 
 return (&i); }

/* CTYPE(3C) */
#undef isascii
int	isascii(int c) { 
 return (c); }

/* LSEARCH(3C) */
#ifdef _CLASSIC_XOPEN_TYPES
char *	lsearch(char *k, char *b, unsigned *n, unsigned w, int (*c)() ) 
	{ 
 return (k); }

char *	lfind(char *k, char *b, unsigned *n, unsigned w, int (*c)() ) 
	{ 
 return (k); }

#else
void *	lsearch(const void *k, void *b, size_t *n, size_t w,
		int (*c)(const void *, const void *)) 
	{ 
int i; return((void *)&i); }

void *	lfind(const void *k, const void *b, size_t *n, size_t w,
	      int (*c)(const void *, const void *)) 
	{ 
int i; return((void *)&i); }

#endif
/* MEMORY(3C) */
#include <sys/ipc.h>
#include <sys/msg.h>
#ifdef _CLASSIC_XOPEN_TYPES
char *	memccpy(char *a, char *b, int c, int n) { 
 return (a); }

#else
void *	memccpy(void *a, const void *b, int c, size_t n ) { 
 return (a); }

#endif /* _CLASSIC_XOPEN_TYPES */
/* MSGCTL(2) */
int	msgctl(int m, int c, struct msqid_ds *b ) { 
 return (m); }

/* MSGGET(2) */
int	msgget(key_t k, int m) { 
 return (m); }

/* MSGOP(2) */
int	msgrcv(int q, void *p, size_t s, long t, int f) { 
 return (q); }

int	msgsnd(int q, const void *p, size_t s, int f) { 
 return (q); }

/* NICE(2) */
int	nice(int i) { 
 return (i); }

/* NL_LANGINFO(3C) NLS */
#include <langinfo.h>
char *	nl_langinfo(nl_item i ) { 
 return (""); }

/* POPEN(3S) */
int	pclose(FILE *f ) { 
 return (0); }

FILE *	popen(const char *c, const char *t ) { 
 return (stdin); }

/* PUTENV(3C) */
int	putenv(const char *s ) { 
 return (0); }

/* PUTC(3S) */
int	putw(int w, FILE *f ) { 
 return (w); }

/* DIRECTORY(3C) */
void	seekdir(DIR *d, long l ) { 
}

/* SEMGET(2) */
int	semget(key_t k, int n, int s) { 
 return (n); }

/* SEMOP(2) */
union semun { int val; struct semid_ds *buf; unsigned short *array; };

#include <sys/sem.h>
int	semop(int i, struct sembuf *o, unsigned int n) { 
 return (i); }

/* CRYPT(3C) */
void	setkey(const char *k ) { 
}

/* SHMOP(2) */
#include <sys/shm.h>
void *	shmat(int i, const void *a, int f) { 
 void *x=NULL; return (x); }

/* SHMCTL(2) */
int	shmctl(int s, int c, struct shmid_ds *b ) { 
 return (s); }

/* SHMOP(2) */
int	shmdt(const void *a ) { 
 return (0); }

/* SHMGET(2) */
int	shmget(key_t k, size_t s, int f) { 
 return (s); }

/* SWAB(3C) */
void	swab(const void *f, void *t, ssize_t n) { 
}

/* DIRECTORY(3C) */
long	telldir(DIR *d ) { 
 return (0L); }

/* TMPNAM(3S) */
char *	tempnam(const char *d, const char *s ) { 
 char *x=NULL; return (x); }

/* CTIME(3C) */
long	timezone;
/* CONV(3C) */
#undef _toupper
#undef _tolower
#undef toascii
int	_toupper(int i) { 
 return (i); }

int	_tolower(int i) { 
 return (i); }

int	toascii(int i) { 
 return (i); }

/* TSEARCH(3C) */
#ifdef _CLASSIC_XOPEN_TYPES
char *	tsearch(char *k, char **r, int (*c)() ) { 
 return (k); }

char *	tfind(char *k, char **r, int (*c)() ) { 
 return (k); }

char *	tdelete(char *k, char **r, int (*c)() ) { 
 return (k); }

void	twalk(const void  *r, void (*f)(const void *,VISIT,int)) ) { 
}

#else
void *	tsearch(const void *k, void **r, int (*c)(const void *, const void *))
	{ 
 int i; return((void *)&i);}

void *	tfind(const void *k, void * const *r, int (*c)(const void *, 
	const void *))
	{ 
int i; return((void *)&i); }

void *	tdelete(const void *k, void **r, int (*c)(const void *, const void *))
	{ 
int i; return((void *)&i); }

void	twalk(const void *r, void (*f)(const void *, VISIT, int)) { 
}

#endif
/* ULIMIT(2) */
#include <ulimit.h>
/*VARARGS1*/
long	ulimit(int c, ...) { 
 return (c); }


#include <varargs.h>


/* X/Open Portability Guide, Issue 4 -- Worldwide Portability Interface */

#include <iconv.h>
int	iconv_close ( iconv_t c ) { 
 return 0; }

iconv_t	iconv_open ( const char *to, const char *from ) { 
 return 0; }


int	strfmon ( char *s, size_t m, char *fmt, ...) { 
 return 0; }

char	*strptime ( const char *b, const char *fmt, struct tm *tm) { 
 return 0; }

#include <wchar.h>

/* GETWC(3C) */
wint_t	getwc(FILE *stream) { 
 return (wint_t)0; }

wint_t getwchar(void) { 
 return (wint_t)0; }

wint_t fgetwc(FILE *stream) { 
 return (wint_t)0; }


/* FGETWS(3C) */
wchar_t *fgetws(wchar_t *ws, int n, FILE *stream) { 
 return (wchar_t)0; }



/* PUTWC(3C) */
wint_t putwc(wint_t wc, FILE *stream) { 
 return (wint_t)0; }

wint_t putwchar(wint_t wc) { 
 return (wint_t)0; }

wint_t fputwc(wint_t wc, FILE *stream) { 
 return (wint_t)0; }


/* FPUTWS(3C) */
int fputws(const wchar_t *ws, FILE *stream) { 
 return 0; }



/* UNGETWC(3C) */
wint_t ungetwc(wint_t wc, FILE *stream) { 
 return (wint_t)0; }


/* WCONV(3C) */
wint_t towupper(wint_t wc) { 
 return (wint_t)0; }

wint_t towlower(wint_t wc) { 
 return (wint_t)0; }


/* WCSFTIME(3C) */
size_t wcsftime(wchar_t *ws, size_t maxsize, const char *format, const struct tm *timeptr) { 
 return (size_t)0; }


/* WCSTOD(3C) */
double wcstod(const wchar_t *nptr, wchar_t **endptr) { 
 return (double)0; }


/* WCSTOL(3C) */
long int wcstol(const wchar_t *nptr, wchar_t **endptr, int base) { 
 return (long int)0; }

unsigned long int wcstoul(const wchar_t *nptr, wchar_t **endptr, int base) { 
 return (unsigned long int)0; }


/* WCTYPE(3C) */
wctype_t wctype(const char *charclass) { 
 return (wctype_t)0; }

int iswctype(wint_t wc, wctype_t prop) { 
 return 0; }

int iswalnum(wint_t wc) { 
 return 0; }

int iswalpha(wint_t wc) { 
 return 0; }

int iswcntrl(wint_t wc) { 
 return 0; }

int iswdigit(wint_t wc) { 
 return 0; }

int iswgraph(wint_t wc) { 
 return 0; }

int iswlower(wint_t wc) { 
 return 0; }

int iswprint(wint_t wc) { 
 return 0; }

int iswpunct(wint_t wc) { 
 return 0; }

int iswspace(wint_t wc) { 
 return 0; }

int iswupper(wint_t wc) { 
 return 0; }

int iswxdigit(wint_t wc) { 
 return 0; }


/* WCSTRING(3C) */
wchar_t *wcscat(wchar_t *ws1, const wchar_t *ws2) { 
 return (wchar_t *)0; }

wchar_t *wcsncat(wchar_t *ws1, const wchar_t *ws2, size_t n) { 
 return (wchar_t *)0; }

int wcscmp(const wchar_t *ws1, const wchar_t *ws2) { 
 return 0; }

int wcsncmp(const wchar_t *ws1, const wchar_t *ws2, size_t n) { 
 return 0; }

wchar_t *wcscpy(wchar_t *ws1, const wchar_t *ws2) { 
 return (wchar_t *)0; }

wchar_t *wcsncpy(wchar_t *ws1, const wchar_t *ws2, size_t n) { 
 return (wchar_t *)0; }

size_t wcslen(const wchar_t *ws) { 
 return (size_t)0; }

wchar_t *wcschr(const wchar_t *ws, wchar_t wc) { 
 return (wchar_t *)0; }

wchar_t *wcsrchr(const wchar_t *ws, wchar_t wc) { 
 return (wchar_t *)0; }

wchar_t *wcspbrk(const wchar_t *ws1, const wchar_t *ws2) { 
 return (wchar_t *)0; }

size_t wcsspn(const wchar_t *ws1, const wchar_t *ws2) { 
 return (size_t)0; }

size_t wcscspn(const wchar_t *ws1, const wchar_t *ws2) { 
 return (size_t)0; }

wchar_t *wcswcs(const wchar_t *ws1, const wchar_t *ws2) { 
 return (wchar_t *)0; }

wchar_t *wcstok(wchar_t *ws1, const wchar_t *ws2) { 
 return (wchar_t *)0; }

int wcscoll(const wchar_t *ws1, const wchar_t *ws2) { 
 return 0; }

size_t wcsxfrm(wchar_t *ws1, const wchar_t *ws2, size_t n) { 
 return (size_t)0; }

int wcwidth(const wchar_t wc) { 
 return 0; }

int wcswidth(const wchar_t *ws, size_t n) { 
 return 0; }


#endif  /* _INCLUDE_XOPEN_SOURCE */


/* SVID-3 entry points */
/* =========================  SVID-3 ============================= */

/* PFMT(3) */
int addsev(int a, const char *b) {
 return 0; }

int fmtmsg(long a, const char *b, int c, const char *d, const char *e, const char *f) {
 return 0; }

char *gettxt(const char *a, const char *b) {
 return NULL; }

int pfmt(FILE *a, long b, const char *c, ... ) {
 return 0; }

const char *setcat(const char *a) {
 return NULL; }

int setlabel(const char *a) {
 return 0; }

int vpfmt(FILE *a, long b, const char *c, ...) {
 return 0; }

pid_t getsid(pid_t pid) {
 return (pid_t)0; }

#include <sys/procset.h>
int sigsend(idtype_t a, id_t b, int c) {
 return 0; }

int sigsendset(const procset_t a, int b) {
 return 0; }

pid_t tcgetsid(int filedes) {
 return (pid_t)0; }

/* COSE SPEC1170 entry points */
/* =========================  COSE SPEC1170  ========================= */
#include <libgen.h>

char *basename(const char *path) {
 return NULL; }

char *dirname(const char *path) {
 return NULL; }

char *initstate(unsigned int a, char *b, size_t c) {
 return NULL; }

char *setstate(char *a) {
 return NULL; }

void srandom(unsigned int a) {
 return; }

long random(void) {
 return 0L; }

void insque(void *element, void *pred) {
 return; }

void remque(void *element) {
 return; }

char * getwd(char *pathname) {
 return NULL; }

/* REGCMP(3X) (libPW, COSE) */
char *regcmp(const char *string1, ...) {
 return NULL; }

char *regex(const char *re1, const char *subject, ...) {
 return NULL; }

char *re_comp(char *sp) {
 return NULL; }

int re_exec(char *p1) {
 return 0; }

void *valloc(size_t size) {
 return; }

/* HP-UX entry points */
/* =========================  HPUX ============================= */
#ifdef _INCLUDE_HPUX_SOURCE

#undef AUDIT
#define AUDIT
#undef ACLS
#define ACLS

#include <nl_ctype.h>
int	__nl_failid;
int	__status_tab[3][4];
#include <ustat.h>
#include <sys/resource.h>
#include <dial.h>
#include <utmp.h>
#include <sys/timeb.h>
#include <sys/vfs.h>
#include <sys/statvfs.h>


#include <sys/privgrp.h>
#include <sys/uio.h>
#include <mon.h>
#include <a.out.h>
#include <disktab.h>
#include <strings.h>

/* Additions made 7/12/95 */
int getrusage(int a, struct rusage *b )
        { return(0); }

#if defined(DUX) || defined(DISKLESS)
#    include <cluster.h>
#endif /* DUX/DISKLESS */

#ifdef ACLS
#    include <sys/acl.h>
#    include <acllib.h>
#endif

#ifdef AUDIT
#    include <sys/audit.h>
#endif

#include <sys/time.h>
int adjtime ( struct timeval *delta, struct timeval *olddelta ) {
return(0); }

int getbootinfo(int type, caddr_t *buf, int len) {
return(0); }


int setbootinfo(int type, caddr_t *buf, int len) {
return(0); }

/* Shared library routines.  These are physically in libdld. They are
   included here for to avoid creating a llib-ldld file. */
#include <dl.h>
shl_t shl_load( const char *p, int flags, long a ) { 
 shl_t x=(shl_t)0; return(x); }

int shl_findsym( shl_t *h, const char *s, short t, void *v) { 
 return(0); }


int shl_definesym( const char *a, short b, long c, int d ) { 
 return(d); }

int shl_getsymbols( shl_t a, short b, int c, void *(*e)(), 
	struct shl_symbol **f ) { 
 return(c); } 


int shl_unload( shl_t handle ) { 
 return(0); }

int shl_get( int index, struct shl_descriptor **des) { 
 return(0); }

int shl_gethandle( shl_t a, struct shl_descriptor **b ) { 
 return(0); }



#include <mntent.h>

/* ACCT(2) */
int	acct(char *f ) { 
 return (0); }


#ifdef AUDIT
/* AUDCTL(2) */
int	audctl (int c, char *cp, char *np, mode_t m) { 
 return (c); }

/* AUDSWITCH(2) */
int	audswitch (int a) { 
 return (a); }

/* AUDWRITE(2) */
int	audwrite (const struct self_audit_rec *audrec_p) { 
 return (0); }

#endif /* AUDIT */



/* BRK(2) */
int	brk(const void *e ) { 
 return (0); }

#ifdef _CLASSIC_XOPEN_TYPES
char *	sbrk(int i) { 
 return (""); }

#else /* not _CLASSIC_XOPEN_TYPES */
void *	sbrk(int i) { 
 return ((void *) ""); }

#endif /* not _CLASSIC_XOPEN_TYPES */
/* CHMOD(2) */
int	fchmod(int f, mode_t m) { 
 return (m); }

/* CHOWN(2) */
int	fchown(int f, uid_t o, gid_t g) { 
 return (o); }

/* CLEARENV(3C) */
int	clearenv(void) { 
 return (0); }

/* CTYPE(3C) */
char	_ctype[129];
char	_ctype2[129];

#undef isblank
int	isblank(int c) { 
 return (c); }

#undef isctype
int	isctype(int c, unsigned int m) {
 return 0; }

int iswblank(wint_t wc) { 
 return 0; }


#if defined(DUX) || defined(DISKLESS)
/* CNODEID(2) */
cnode_t	cnodeid(void) { 
return((cnode_t)0); }

/* CNODES(2) */
int	cnodes(cnode_t *b ) { 
 return(0); }

#endif /* DUX/DISKLESS */

/* FCHDIR(2) */
int     fchdir(int f) { 
 return (f); }


/* FSCTL(2) */
int fsctl(int fildes, int c, char *outbuf, int len) { 
return 0;}


/* FTIME(2) */
int	ftime(struct timeb *tp ) { 
 return(0); }


#ifdef ACLS
/* GETACCESS(2) */
int	getaccess (char *p, int u, int n, int g[], void *l, void *pr) 
	{ 
 return (u); }

/* GETACL(2) */
int	getacl (const char *p, int n, struct acl_entry a[]) { 
 return (n); }

int	fgetacl (int f, int n, struct acl_entry a[]) { 
 return (n); }

#endif /* ACLS */

#ifdef AUDIT
/* GETAUDID(2) */
int	getaudid(void) { 
 return (0); }

/* GETAUDPROC(2) */
int	getaudproc(void) { 
 return (0); }

#endif /* AUDIT */

#ifdef AES
/* GETCLOCK(3C) */
#include <sys/timers.h>
int	getclock(int c, struct timespec *tp) { 
 return (0); }
#endif /* AES */


/* GETDATE(3C) */
struct tm *	getdate(const char *s) { 
 return (struct tm *)0; }

int	getdate_err;
#if defined(DUX) || defined(DISKLESS)
/* GETCONTEXT(2) */
int	getcontext(char *c, size_t l) { 
 return(0); }

#endif /* DUX/DISKLESS */

/* GETDIRENTRIES(2) */
int	getdirentries(int f, char *b, int n, long *p ) { 
 return(0); }


#ifdef AUDIT
/* GETEVENT(2) */
int	getevent (struct aud_type *as, struct aud_event_tbl *ae	) 
	{ 
 return (0); }

#endif /* AUDIT */

/* GETHOSTNAME(2) */
int	gethostname(char h[], unsigned s ) { 
 return (0); }

/* GETITIMER(2) */
int	getitimer(int w, struct itimerval *v ) { 
 return (w); }

int	setitimer(int w, const struct itimerval *v, struct itimerval *o ) 
	{ 
 return (w); }

/* GETMNTENT(3X) */
int	addmntent(FILE *f, struct mntent *m) { 
 return 0; }

/* GETOPT(3C) */
int	optopt; /* SVID 3 */
/* GETSUBOPT(3C) */
int	getsubopt(char **o, char *t[], char **v ) { 
 return (0); }

/* GETPID(2) */
int	getpgrp2(pid_t p ) { 
 return (0); }

/* GETPRIORITY(2) */
int	getpriority(int which, id_t who) { 
 return 0; }

int	setpriority(int which, id_t who, int priority) { 
 return 0; }

/* GETPRIVGRP(2) */
int	getprivgrp(struct privgrp_map g[] ) { 
 return (0); }

int	setprivgrp(gid_t g, const int *m ) { 
 return (0); }

/* GETTIMEOFDAY(2) */
int	gettimeofday(struct timeval *t, void *z ) { 
 return (0); }

int	settimeofday(const struct timeval *t, const struct timezone *z )
		{ 
 return (0); }

#ifdef AES
/* GETTIMER(3C) */
int	gettimer(timer_t a, struct itimerspec *b) { 
 return (0); }
#endif /* AES */

/* ICONV(3C) */
int	iconvsize(const char *t, const char *f) { 
return 0;}

/* IOCTL(2) */
	/*VARARGS2*/
int	ioctl(int f, int r, ...) { 
 return (f); }

/* LCHMOD(2) */
int	lchmod(const char *s, mode_t m ) { 
 return (0); }

/* LCHOWN(2) */
int	lchown(const char *s, uid_t o, gid_t g ) { 
 return (0); }

/* LCKPWDF(3) */
int lckpwdf(void) {
 return 0; }

int ulckpwdf(void) {
 return 0; }

/* LDCVT(3C) */
char *	_ldecvt(long_double v, int n, int *d, int *s) { 
return "";}

char *	_ldfcvt(long_double v, int n, int *d, int *s) { 
return "";}

char *	_ldgcvt(long_double v, int n, char *b) { 
return "";}

/* LOCKF(2) */
int	lockf(int f, int u, off_t s ) { 
 return (f); }

int	lockf64(int f, int u, off64_t s ) { 
 return (f); }

/* LOGNAME(3C) */
char *	logname(void) { 
return "";}

/* MEMORYMAP(3C) */
void	memorymap(int a) { 
 return; }

/* MKNOD(2) */
int	mknod(const char *n, mode_t m, dev_t d ) { 
 return (d); }

int	mkrnod(const char *n, mode_t m, dev_t d, cnode_t c ) { 
 return (d); }

#ifdef AES
/* MKTIMER(3C) */
timer_t	mktimer(int clock_type, int notify_type, void *itimercbp) { 
 return (0); }
#endif /* AES */

/* MMAP(2) */
#include <sys/mman.h>
void *	mmap(void * a, size_t b, int c, int d, int e, off_t f) 
	{ 
 caddr_t x=(caddr_t)0; return(x);}

void *	mmap64(void * a, size_t b, int c, int d, int e, off64_t f) 
	{ 
 caddr_t x=(caddr_t)0; return(x);}

int	munmap(void * addr, size_t len) { 
return len;}

int	madvise(const caddr_t addr, size_t len, int behav) { 
 return 0; }

int	msem_remove(msemaphore *a) { 
 return 0; }

msemaphore *msem_init(msemaphore *a, int b) { 
 msemaphore *x=NULL; return(x); }

int	msem_lock(msemaphore *a, int b) { 
 return 0; }

int	msem_unlock(msemaphore *a, int b) { 
 return 0; }

int	mprotect(void * a, size_t b, int c) { 
 return 0; }

int	msync(void * a, size_t b, int c) { 
 return 0; }

int	cachectl(int a, char *b, int c) { 
return a;}

/* MOUNT(2) */
int	mount(char *s, char *d, int r) { 
 return (r); }

/* PLOCK(2) */
int	plock(int o) { 
 return (o); }

/* POLL(2) */
#include <poll.h>
int	poll(struct pollfd fds[], nfds_t nfds, int timeout) { 
 return 0; }

/* PREALLOC(2) */
int	prealloc(int f, off_t s ) { 
 return (f); }

int	prealloc64(int f, off64_t s ) { 
 return (f); }

/* PROFIL(2) */
void	profil(const void *b, size_t s, size_t o, int i) { 
}

/* PTRACE(2) */
int	ptrace(int r, ...) { 
 return (r); }

/* PTSNAME(3) */
char *	ptsname(int fdm) { 
 return (""); }

/* READ(2) */
ssize_t	readv(int f, const struct iovec *i, int v) { 
 return (f); }

/* READLINK(2) */
#include <symlink.h>
#ifdef _INCLUDE_HPUX_SOURCE
int	readlink(const char *p, char *b, size_t s) { 
 return (0); }

#else /* ! _INCLUDE_HPUX_SOURCE */
int	readlink(const char *p, char *b, int s) { 
 return (0); }

#endif /* _INCLUDE_HPUX_SOURCE */
/* Undocumented sgetl() and sputl() declared in <sys/unistd.h> */
long	sgetl(const char *p) { 
 return ((long)0); }

void	sputl(long i, char *p) { 
 }

/* Undocumented hidecdf() declared in <sys/unistd.h> */
char *	hidecdf(const char *a, char *c, size_t s) { 
 return(c); }

/* REBOOT(2) */
	/*VARARGS1*/
int	reboot(int h, ...) { 
return (0); }

#ifdef AES
/* RELTIMER */
int	reltimer(timer_t a, struct itimerspec *b, struct itimerspec *c) { 
 return (0); }

/* RMTIMER(3C) */
int	rmtimer(timer_t a) { 
 return (0); }
#endif /* AES */

/* RTPRIO(2) */
int	rtprio(pid_t p, int r) { 
 return (0); }

/* SELECT(2) */
int	select(int n, fd_set *r, fd_set *w, fd_set *e, const struct timeval *t )
		{ 
 return (0);}

#ifdef AES
/* SETCLOCK(3C) */
int	setclock(int a, struct timespec *b) { 
 return (0); }
#endif /* AES */

/* SEMCTL(2) */
	/*VARARGS3*/
int	semctl(int i, int n, int c, ... ) { 
 return (i); }


#ifdef ACLS
/* SETACL(2) */
int	setacl (const char *p, size_t n, const struct acl_entry a[] )
		{ 
 return (n); }

int	fsetacl (int f, size_t n, const struct acl_entry a[] ) { 
 return (n); }

#endif /* ACLS */

#ifdef AUDIT
/* SETAUDID(2) */
int	setaudid (aid_t a ) { 
 return (0); }

/* SETAUDPROC(2) */
int	setaudproc(int aflag) { 
 return (0); }

/* SETEVENT(2) */
int	setevent (const struct aud_type *as, const struct aud_event_tbl *ae)
		{ 
 return (0);}

#endif /* AUDIT */

/* SETGROUPS(2) */
int	setgroups(int n, gid_t g[]  ) { 
 return (n); }

/* SETHOSTNAME(2) */
int	sethostname(const char *n, size_t l) { 
 return (0); }

/* SETLOCALE(3C) */
struct locale_data * getlocale(int type ) { 
 struct locale_data l; return(&l); }

/* SETPGRP(2) */
int	setpgrp2(pid_t p1, pid_t p2 ) { 
 return (0); }

/* SETRESUID(2) */
int	setresuid (uid_t r, uid_t e, uid_t s) { 
 return (0); }

int	setresgid (gid_t r, gid_t e, gid_t s) { 
 return (0); }

/* SETSID(2) */
pid_t	setpgrp(void) { 
 return (0); }
pid_t	setpgrp3(void) { 
 return (0); }

/* SIGBLOCK(2) */
long	sigblock(long m ) { 
 return (m); }

/* SIGPAUSE(2) */
int	sigpause(int s ) { 
 return (s); }

/* SIGSET(2V) */
void    (*sigset(int sig, void (*func)(int)))(int) { 
return (void (*)())0;}

int	sighold(int sig) { 
return sig;}

int	sigrelse(int sig) { 
return sig;}

int	sigignore(int sig) { 
return sig;}

/* SIGSETMASK(2) */
long	sigsetmask(long m ) { 
 return (m); }

/* SIGSPACE(2) */
ssize_t	sigspace(size_t s ) { 
 return ((ssize_t) 0); }

/* SIGSTACK(2) */
int	sigstack(const struct sigstack *ss, struct sigstack *oss) { 
 return 0; }

/* SIGVECTOR(2) */
int	sigvector(int s, const struct sigvec *v, struct sigvec *o )
		{ 
 return (s); }

/* STAT(2) */
int	lstat(const char *p, struct stat *b ) { 
 return (0); }

int	lstat64(const char *p, struct stat64 *b ) { 
 return (0); }

/* STATFS(2) */
int	statfs(const char *s, struct statfs *b ) { 
 return (0); }

int	fstatfs(int f, struct statfs *b ) { 
 return (f); }

/* STATFSDEV(3C) */
int	statfsdev(const char *p, struct statfs *b) { 
return 0;}

int	statfsdev64(const char *p, struct statfs *b) { 
return 0;}

int	fstatfsdev(int f, struct statfs *b) { 
return 0;}

int	fstatfsdev64(int f, struct statfs *b) { 
return 0;}

/* statvfsdev(3C) */
int fstatvfsdev64(int a, struct statvfs64 *b){
return 0; }

int statvfsdev64(const char *a, struct statvfs64 *b){
return 0; }


/* STATVFS(2) */
int fstatvfs(int a, struct statvfs *b) {
 return 0; }

int fstatvfs64(int a, struct statvfs64 *b) {
 return 0; }

int statvfs(const char *a, struct statvfs *b) {
 return 0; }

int statvfs64(const char *a, struct statvfs64 *b) {
 return 0; }

/* STIME(2) */
int	stime(const time_t *t ) { 
 return (0); }

/* STREAMS(2) */
#include <sys/stropts.h>
int getmsg(int a, struct strbuf *b, struct strbuf *c, int *d) {
 return 0; }

int putmsg(int a, struct strbuf *b, struct strbuf *c, int d) {
 return 0; }

int getpmsg(int a, struct strbuf *b, struct strbuf *c, int *d, int *e) {
 return 0; }

int putpmsg(int a, struct strbuf *b, struct strbuf *c, int d, int e) {
 return 0; }

int isastream(int a) {
 return 0; }

int fattach(int a, const char *b) {
 return 0; }

int fdetach(const char *a) {
 return 0; }


/* STRTOLD(3C) */
long_double	strtold(const char *s, char **p) { 
 long_double x; return(x);}

/* STTY(2) */
/* in lieu of including <sgtty.h>, because of redefinition of B1200, etc. */
struct sgttyb {
	char	sg_ispeed;		/* input speed */
	char	sg_ospeed;		/* output speed */
	char	sg_erase;		/* erase character */
	char	sg_kill;		/* kill character */
	int	sg_flags;		/* mode flags */
};

int	stty(int f, const struct sgttyb *a ) { 
 return (0); }

int	gtty(int f, struct sgttyb *a ) { 
 return (0); }

/* SWAPON(2) */
int	swapon(const char *s, ... ) { 
 return (0); }
int	swapoff(const char *s, int num) {
 return (0); }

/* SYMLINK(2) */
int	symlink(const char *n1, const char *n2 ) { 
 return (0); }

/* SYNC(2) */
void	sync(void) { 
}

void	lsync(void) { 
}

/* SYSLOG(3C) */
/* VARARGS2 */
int	syslog(int p, char *m, ...) { 
return 0;}

void	openlog(char *id, int l, int f) { 
return;}

void	closelog(void) { 
return;}

int	setlogmask(int m) { 
return 0;}

/* TRUNCATE(2) */
int	truncate(const char *p, off_t l ) { 
 return (0); }

int	truncate64(const char *p, off64_t l ) { 
 return (0); }

int	ftruncate(int f, off_t l ) { 
 return (f); }

int	ftruncate64(int f, off64_t l ) { 
 return (f); }

/* UMOUNT(2) */
int	umount(char *s ) { 
 return (0); }

/* USTAT(2) */
int	ustat(dev_t d, struct ustat *b ) { 
 return (0); }

/* VFORK(2) */
#ifdef _CLASSIC_ID_TYPES
int	vfork(void) { 
 return (0); }

#else
pid_t	vfork(void) { 
 return ((pid_t) 0); }

#endif /* _CLASSIC_ID_TYPES */
/* VFSMOUNT(2) */
int	vfsmount(int t, char *d, int f, caddr_t c ) { 
 return (0); }

/* VHANGUP(2) */
int	vhangup(void) { 
 return(0); }

/* WAIT(2) */
pid_t	wait3(int *s, int o, struct rusage *r ) { 
 return (0); }

/* WORDEXP(3C) */
#include <wordexp.h>
int	wordexp ( const char *a, wordexp_t *b, int c) { 
 return (0); }

void	wordfree ( wordexp_t *a ) { 
 return; }

/* WRITE(2) */
ssize_t	writev(int f, const struct iovec *io, int iovcnt) { 
 return 0; }

/* A64L(3C) */
long	a64l(const char *s ) { 
 return (0L); }

char *	l64a(long l ) { 
 return (""); }


#ifdef ACLS
/* ACLTOSTR(3C) */
char *	acltostr (int n, struct acl_entry a[], int f	) { 
 return (""); }

#endif /* ACLS */

/* ASSERT(3X) */
void	__assert(char *a, char *f, int n) { 
}

/* CATGETMSG(3C) */
char *	catgetmsg(nl_catd c, int s, int m, char *b, int l) { 
 return(b); }

/* CATREAD(3C) NLS */
	/*VARARGS5*/
int	catread(int f, int s, int m, char *b, int l) { 
 return (f); }


#ifdef ACLS
/* CHOWNACL(3C) */
void	chownacl (int n, struct acl_entry a[], int ou, int og, int nu, int ng )
	{ 
}


/* CPACL(3C) */
int	cpacl (const char *f, const char *t, mode_t fm, uid_t fu, gid_t fg, 
		uid_t tu, gid_t tg	) 
	{ 
 return (fm); }

int	fcpacl (int f, int t, mode_t fm, uid_t fu, gid_t fg, uid_t tu, gid_t tg) 
	{ 
 return (fm); }

#endif /* ACLS */

/* CTIME(3C) */
char *	nl_cxtime(time_t *c, char *f ) { 
 return (""); }

char *	nl_ctime(time_t *c, char *f, int l) { 
 return (""); }

char *	nl_ascxtime(struct tm *t, char *f ) { 
 return (""); }

char *	nl_asctime(struct tm *t, char *f, int l) { 
 return (""); }

/* CVTNUM(3C) */
int	cvtnum(unsigned char *s, unsigned char *d, int t, int r,
       	   unsigned char **p, int *i ) 
	   { 
 return (0); }

/* DEVNM(3C) */
#include <devnm.h>
int 	devnm(ushort t, dev_t id, char *p, size_t l, int c) { 
 return (0); }

/* DATALOCK(3C) */
int	datalock(size_t d, size_t s) { 
 return (0); }

/* DIAL(3C) */
int	dial(CALL c ) { 
 return (0); }

void	undial(int f) { 
}

/* ECVT(3C) */
static char	fcvt_buf[1];
char *		ecvt(double v, int n, int *d, int *s ) { 
 return (""); }

const char *	fcvt(double v, int n, int *d, int *s ) 
	{ 
 return (fcvt_buf);}

char *		gcvt(double v, int n, char *b ) { 
 return (b); }

char *		nl_gcvt(double v, size_t n, char *b, int l) { 
 return (b); }

/* END(3C) */
int	end; 
int	etext; 
int	edata;
int 	_end;
int 	_etext;
int 	_edata;
/* GETSPWENT(3C) */
void	endspwent(void) { 
}

struct s_passwd *fgetspwent (FILE *f) { 
static struct s_passwd x; return (& x);}

/* FPTRAP(3X) */
/* FREXP(3C) */
double	frexp(double x, int *e ) { 
 return (x); }

double	ldexp(double v, int e) { 
 return (v); }

double	modf(double v, double *i ) { 
 return (v); }


/* FTW(3C) */
int	nftw(const char *p, int (*f)(const char *, const struct stat *,
	     int, struct FTW), int n, int m) { 
 return (n); }
int	nftw64(const char *p, int (*f)(const char *, const struct stat64 *,
	     int, struct FTW), int n, int m) { 
 return (n); }
int	nftw2(const char *p, int (*f)(const char *, const struct stat *,
	     int, struct FTW), int n, int m) { 
 return (n); }
int	nftw2_64(const char *p, int (*f)(const char *, const struct stat64 *,
	     int, struct FTW), int n, int m) { 
 return (n); }

#if defined(DUX) || defined(DISKLESS)
int	ftwh(const char *p, int (*f)(const char *, const struct stat *,
	    int), int d) { 
 return (d); }

int	nftwh(const char *p, int (*f)(const char *, const struct stat *,
	     int, struct FTW), int n, int m) { 
 return (n); }

/* GETCCENT(3C) */
struct cct_entry	*getccent(void) { 
struct cct_entry c; return(&c); }

struct cct_entry	*getcccid(cnode_t c ) { 
struct cct_entry e; return(&e);}

struct cct_entry	*getccnam(const char *n ) 
	{ 
struct cct_entry c; return(&c); }

void	setccent(void) { 
}

void	endccent(void) { 
}

struct cct_entry	*fgetccent(FILE *f ) { 
struct cct_entry c; return(&c);}

/* GETCDF(3C) */
char	*getcdf(const char *p, char *b, size_t s) { 
 char *x; return (x); }

/* GETDISKBYNAME(3C) */
struct disktab	*getdiskbyname(char *s) { 
 return((struct disktab *) 0); }

/* GETCWD(3C) */
char *	gethcwd(char *b, size_t s) { 
 return (b); }

#endif /* DUX/DISKLESS */
/* GETGRENT(3C) */
struct group *	getgrent(void) { 
 static struct group x; return (&x); }

void	setgrent(void) { 
}

void	endgrent(void) { 
}

struct group *	fgetgrent(FILE *f ) { 
 static struct group x; return (&x); }

/* GETMNTENT(3X) */
struct mntent *	getmntent(FILE *f ) { 
 struct mntent m; return (&m); }

char *	hasmntopt(struct mntent *m, const char *s) { 
 char *x=NULL; return(x); }

FILE *	setmntent(const char *s1, const char *s2) { 
 return(stdin); }

int	endmntent(FILE *f) { 
 return(0); }



/* GETPASS(3C) */
char *	getpass(const char *s ) { 
 char *x=NULL; return (x); }

/* GETPW(3C) */
int	getpw(int u, char *b ) { 
 return (u); }

/* GETPWENT(3C) */
struct passwd *	getpwent(void) { 
 static struct passwd x; return (&x); }

void	setpwent(void) { 
}

void	endpwent(void) { 
}

struct passwd *	fgetpwent(FILE *f ) { 
 static struct passwd x; return (&x); }


#ifdef ACLS
/* GETSPWENT(3C) */
struct s_passwd *getspwaid (int a) { 
 static struct s_passwd x; return (& x); }

struct s_passwd *getspwent (void) { 
 static struct s_passwd x; return (& x); }

struct s_passwd *getspwnam (char *n) { 
 static struct s_passwd x; return (& x);}

/* GETSPWUID(3C) */
struct s_passwd *getspwuid (int u) { 
 static struct s_passwd x; return (& x); }

#endif /* ACLS */

/* GETUSERSHELL(3C) */
char	*getusershell(void) { 
 return((char *) 0); }

void	setusershell(void) { 
}

void	endusershell(void) { 
}


/* GETUT(3C) */

/* Added utmpx versions on 7/12/95 */
#include <utmpx.h>
int getutxent_r(struct utmpx **utmp, struct utmpx_data *ud)
        { return(0); }
int pututxline_r(struct utmpx *entry, struct utmpx_data *ud)
        { return(0); }
struct utmpx *getutxent(void)
        { struct utmpx *a; return(a); }
struct utmpx *getutxid(const struct utmpx *a)
        { return(a); }
struct utmpx *getutxline(const struct utmpx *a)
        { return(a); }
struct utmpx *pututxline(const struct utmpx *a)
        { return(a); }
void endutxent(void)
        { return; }
void endutxent_r(struct utmpx_data *ud)
        { return; }
void setutxent(void)
        { return; }
void setutxent_r(struct utmpx_data *ud)
        { return; }


struct utmp *	getutent(void) { 
 static struct utmp x; return (&x); }

struct utmp *	getutid(struct utmp *i ) { 
 return (i); }

struct utmp *	getutline(struct utmp *l ) { 
 return (l); }

struct utmp *	_pututline(struct utmp *u ) { 
 return (u); }

void	pututline(struct utmp *u ) { 
}

void	setutent(void) { 
}

void	endutent(void) { 
}

void	utmpname(char *f ) { 
}

/* INITGROUPS(3C) */
int	initgroups(const char *n, gid_t b) { 
 return(0); }


/* L3TOL(3C) */
void	l3tol(long *l, const char *c, int n) { 
}

void	ltol3(char *c, const long *l, int n) { 
}

/* LTOSTR(3C) */
char *	ltostr(long l, int i ) { 
 char c; return(&c); }

char *	ultostr(unsigned long u, int i ) { 
 char c; return(&c); }

char *	ltoa(long l ) { 
 char c; return(&c); }

char *	ultoa(unsigned long u ) { 
 char c; return(&c); }

/* LANGINFO(3C) NLS */
char *	langinfo(int l, nl_item i ) { 
 return (""); }

int	langtoid(const char *l ) { 
 return (0); }

char *	idtolang(int l) { 
 return (""); }

int	currlangid(void) { 
 return (0); }

/* LD...(3X) libld -- shouldn't be documented in Section 3! */
/* LOGNAME(3X) libPW -- shouldn't be documented */
/* MALLOC(3X) (actually resides in malloc.a, but it's convenient to include
	malloc.h to declare malloc, etc, which declares these) */
#include <malloc.h>
int mallopt(int i, int j) { 
return i;}

struct mallinfo mallinfo(void) { 
struct mallinfo m; m.arena = 0; return m; }


/* MEMORY(3C) */
void	bcopy(const void *s1, void *s2, size_t n) { 
}

int	bcmp(const void *s1, const void *s2, size_t n) { 
 return(n); }

void	bzero(void *s, size_t n) { 
}

int	ffs(int i) { 
 return(i); }

/* MKTEMP(3C) */
char *	mktemp(char *t ) { 
 return (t); }

int	mkstemp(char *t) { 
 return (0); }

/* MONITOR(3C) */
void	monitor(void (*l)(), void ((*h)()), WORD *b, int s, int n) { 
}

/* NL_CONV(3C) NLS */
int	nl_toupper(int c, int l) { 
 return (c); }

int	nl_tolower(int c, int l) { 
 return (c); }

/* NL_CTYPE(3C) NLS */
#undef	nl_isalpha
#undef	nl_isupper
#undef	nl_islower
#undef	nl_isdigit
#undef	nl_isxdigit
#undef	nl_isalnum
#undef	nl_isspace
#undef	nl_ispunct
#undef	nl_isprint
#undef	nl_isgraph
#undef	nl_iscntrl
int	nl_isalpha(int c, int l) { 
 return (c); }

int	nl_isupper(int c, int l) { 
 return (c); }

int	nl_islower(int c, int l) { 
 return (c); }

int	nl_isdigit(int c, int l) { 
 return (c); }

int	nl_isxdigit(int c, int l) { 
 return (c); }

int	nl_isalnum(int c, int l) { 
 return (c); }

int	nl_isspace(int c, int l) { 
 return (c); }

int	nl_ispunct(int c, int l) { 
 return (c); }

int	nl_isprint(int c, int l) { 
 return (c); }

int	nl_isgraph(int c, int l) { 
 return (c); }

int	nl_iscntrl(int c, int l) { 
 return (c); }

/* NL_INIT(3C) NLS */
int	nl_init(char *s ) { 
 return(0); }

int	langinit(char *s ) { 
 return(0); }

/* NL_STRING(3C) NLS */
int	strcmp8(unsigned char *a, unsigned char *b, int l, int *s ) 
	{ 
 return (l); }

int	strncmp8(unsigned char *a, unsigned char *b, int n, int l, int *s ) 
	{ 
 return (l); }

int	strcmp16(unsigned char *a, unsigned char *b, unsigned char *f, int *s )
	{ 
 return (0); }

int	strncmp16(unsigned char *a, unsigned char *b, int n, unsigned char *f,
          	    int *s ) 
	{ 
 return (n); }

/* NL_TOOLS_16(3C) NLS */
#undef FIRSTof2
#undef SECof2
#undef BYTE_STATUS
#undef CHARAT
#undef ADVANCE
#undef CHARADV
#undef PCHAR
#undef PCHARADV
#undef WCHAR
#undef WCHARADV
#undef C_COLWIDTH
int	__nl_langid[1];
unsigned char *	__ctype;
unsigned char *	__ctype2;
unsigned char *	_upshift;
unsigned char *	_downshift;
unsigned char *	_1kanji;
unsigned char *	_2kanji;
#ifdef EUC
unsigned char *	__e_cset;
unsigned char *	__ein_csize;
unsigned char *	__eout_csize;
#endif /* EUC */
struct _era_data *	_nl_era[1];
int	_nl_radix;
int	_sh_low;
int	_sh_high;
#ifdef EUC
int	__nl_code_scheme;
int	__cs_SBYTE;
int	__cs_HP15;
int	__cs_EUC;
unsigned char	__in_csize[1];
unsigned char	__out_csize[1];
unsigned int	__euc_template[1];
#endif /* EUC */
nl_direct	_nl_direct;
int		_nl_context;
nl_order	_nl_order;
nl_mode		_nl_mode;
nl_outdgt	_nl_outdigit;
int		_nl_space_alt;
unsigned char *	_nl_dgt_alt;
unsigned char *	_nl_punct_alt;
unsigned char *	_nl_pascii;
unsigned char *	_nl_dascii;
int 		_nl_map21;
int 		_nl_onlyseq;
int 		_nl_collate_on;
int 		_nl_mb_collate;
unsigned char *	_seqtab;
unsigned char *	_pritab;
struct col_21tab *	_tab21;
struct col_12tab *	_tab12;
unsigned char *	__errptr;
struct lconv *	_lconv;
unsigned char *	__category_name[1];
unsigned char **__nl_info;
unsigned char *	__C_langinfo[1];
int	__sec_tab[4];
int	c_colwidth(int c) { 
 return c; }

int	firstof2(int c) { 
 return(c); }

int	secof2(int c) { 
 return(c); }

int	byte_status(int c, int s) { 
 return(c); }

int	FIRSTof2(int c) { 
 return(c); }

int	SECof2(int c) { 
 return(c); }

int	BYTE_STATUS(int c, int s) { 
 return(c); }

int	CHARAT(char *p ) { 
 return(0); }

int	ADVANCE(char *p ) { 
 return(0); }

int	CHARADV(char *p ) { 
 return(0); }

void	PCHAR(int c, char *p ) { 
}

void	PCHARADV(int c, char *p ) { 
}

int	WCHAR(int c, char *p) { 
return c;}

int	WCHARADV(int c, char *p) { 
return c;}

int C_COLWIDTH ( int c ) { 
 return c; }

/* EUC routines used in <nl_ctype.h> */
#ifdef EUC
unsigned char	__euc_cs( wchar_t w ) { 
 return (unsigned char) 0; }

wchar_t		__get_euc( const unsigned char *p ) { 
 return (wchar_t) 0; }

unsigned char *	__put_adv_euc( wchar_t w, unsigned char *p ) { 
 return p; }

wchar_t		__put_euc( wchar_t w, unsigned char *p ) { 
 return w; }

#endif /* EUC */
/* NLIST(3C) */
int	nlist(char *f, struct nlist *n ) { 
 return (0); }

/* PERROR(3C) */
char *	sys_errlist[1];
int	sys_nerr;

/* PLOT(3X) not in libc */
/* PRINTF(3S) */
int	nl_printf(const char *s, ... ) { 
 return (0); }

int	nl_fprintf(FILE *f, const char *s, ... ) { 
 return (0); }

	/*VARARGS2 PRINTFLIKE2*/
int	nl_sprintf(char *p, const char *s, ... ) { 
 return (0); }

/* PRINTMSG(3C) NLS */
	/*VARARGS1 PRINTMSGLIKE1*/
int	printmsg(const char *s ) { 
 return (0); }

	/*VARARGS2 PRINTMSGLIKE2*/
int	fprintmsg(FILE *f, const char *s ) { 
 return (0); }

	/*VARARGS2 PRINTMSGLIKE2*/
int	sprintmsg(char *p, const char *s ) { 
 return (0); }

/* PUTPWENT(3C) */
int	putpwent(struct passwd *s, FILE *f ) { 
 return (0); }

/* PUTSPWENT(3C) */
int	putspwent (struct s_passwd *p, FILE *f ) { 
 return (0); }

/* SCANDIR(3C) */
int	scandir(const char *dir, struct dirent ***n,
	int (*s)(const struct dirent *d), int (*c)(const struct dirent **d1,
	const struct dirent **d2)) { 
 return(0); }

int	alphasort(const struct dirent **d1, const struct dirent **d2)
		{ 
 return(0); }

/* SCANF(3S) */
	/* VARARGS1 */
int	nl_scanf(const char *s, ... ) { 
 return (0); }

	/* VARARGS2 */
int	nl_fscanf(FILE *f, const char *s, ... ) { 
 return (0); }

	/* VARARGS2 */
int	nl_sscanf(const char *p, const char *s, ... ) { 
 return (0); }

/* SETJMP(3C) */
int	_setjmp(jmp_buf e ) { 
 return (0); }

void	_longjmp(jmp_buf e, int v) { 
}

/* GETSPWENT(3C) */
void	setspwent(void) { 
}


#ifdef ACLS
/* SETACLENTRY(3C) */
int	setaclentry (const char *p, int u, int g, int m ) { 
 return (u); }

int	fsetaclentry (int f, int u, int g, int m ) { 
 return (u); }

#endif /* ACLS */

/* SETLOCALE (undocumented, but declared in locale.h) */
char *_errlocale(char *s){ 
return "";}


/* SSIGNAL(3C) */
int (*	ssignal(int s, int (*a) (int)))(int) { 
 }

int	gsignal(int s) { 
 return (s); }

/* STDIPC(3C) */
key_t	ftok(const char *s, int i ) { 
 return ((key_t)0); }

/* STRING(3C) */
int	strcasecmp(const char *s1, const char *s2) { 
 return(0); }

int	strncasecmp(const char *s1, const char *s2, size_t n) { 
 return(0); }

char *	strdup(const char *c ) { 
 char *x=NULL; return(x); }

int	nl_strcmp(const char *a, const char *b ) { 
 return (0); }

int	nl_strncmp(const char *a, const char *b, size_t n) { 
 return (n); }

char *	strrstr(const char *c1, const char *c2 ) 	{ 
 char *x=NULL; return(x); }

char	*index(const char *s, int c) { 
 return((char *) 0); }

char	*rindex(const char *s, int c) { 
 return((char *) 0); }


#ifdef ACLS
/* STRTOACL(3C) */
int	strtoacl (const char *s, int n, int m, struct acl_entry a[], int fu, int fg ) 
	{ 
 return (n); }

int	strtoaclpatt (const char *s, int m, struct acl_entry_patt a[]	) 
	{ 
 return (m); }

char *	aclentrystart[];
#endif /* ACLS */

/* STRORD(3C) */
char	*strord(char *s1, char *s2, nl_mode m ) { 
 return(s1); }

/* STRTOD(3C) */
double	nl_strtod(const char *s, char **t, int l) { 
 return (0.0); }

double	nl_atof(const char *s, int l) { 
 return (0.0); }

/* STRTOUL(3C) */

/* SYSFS(2) */
int sysfs(const int a, ...) {
 return 0; }

/* TTYSLOT(3C) */
int	ttyslot(void) { 
 return (0); }

/* VSCANF(3C) */
int	vscanf(const char *f, va_list ap) { 
return 0;}

int	vfscanf(FILE *s, const char *f, va_list ap) { 
return 0;}

int	vsscanf(char *s, const char *f, va_list ap) { 
return 0;}


/* UNDOCUMENTED (not for general use) */
	/*VARARGS1*/
/*VARARGS1*/
int	syscall(int n, ...) { 
 return (n); }

long	tell(int f) { 
 return (0L); }

int	_filbuf(FILE *f ) { 
 return (0); }

int	_flsbuf(unsigned char c, FILE *f ) { 
 return (0); }

/* The namespace clean versions (used in stdio macros) */
int	__filbuf(FILE *f ) { 
 return (0); }

int	__flsbuf(unsigned char c, FILE *f ) { 
 return (0); }


/* NETWORKING DECLARATIONS */
#ifdef _LANLINK
#include <netdb.h>
#undef hpux
#define hpux
#include <arpa/nameser.h>

/* _getlong() and _getshort().  These are not documented, but appear
   in the <arpa/nameser.h> header file. */
u_long		_getlong(u_char *m) { 
 return ((u_long) 0); }

u_short 	_getshort(u_char *m) { 
 return ((u_short) 0); }


/* GETHOSTENT(3C) */
struct hostent *	gethostbyname(const char *n )
		{ 
 struct hostent h; return(&h); }

struct hostent *	gethostbyaddr(const char *a, int l, int t ) 
		{ 
 struct hostent h; return(&h); }

int	sethostent(int s ) { 
 return(s); }

int	endhostent(void) { 
 return(0); }

struct hostent *	gethostent(void) { 
 struct hostent h; return(&h); }

int	sethostfile(char *n ) { 
 return(0); }

/* GETNETENT(3C) */
struct netent *	getnetbyaddr(int n, int t ) { 
 struct netent s; return(&s);}

struct netent *	getnetbyname(const char *name ) { 
 struct netent s; return(&s);}

int	setnetent(int f ) { 
 return(f); }

int	endnetent(void) { 
 return(0); }

struct netent *	getnetent(void) { 
 struct netent s; return(&s);}

/* GETSERVENT(3C) */
struct servent *	getservbyport(int p, const char *r )
		{ 
 struct servent s; return(&s); }

struct servent *	getservbyname(const char *n, const char *p)
		{ 
 struct servent s; return(&s);}

int	setservent(int f ) { 
 return(f); }

int	endservent(void) { 
 return(0); }

struct servent *	getservent(void) { 
 struct servent s; return(&s); }

/* GPROTOENT(3C) */
struct protoent *	getprotobynumber(int p ) { 
 struct protoent s; return(&s); }

struct protoent *	getprotobyname(const char *n )
		{ 
 struct protoent s; return(&s); }

int	setprotoent(int f ) { 
 return(f); }

int	endprotoent(void) { 
 return(0); }

struct protoent *	getprotoent(void) { 
 struct protoent s; return(&s); }


struct rpcent *	getrpcbyname(const char *n ) { 
 return(NULL); }

struct rpcent *	getrpcbynumber (int n ) { 
 return(NULL); }

struct rpcent *	getrpcent (void) { 
 return(NULL); }

int	setrpcent(int f ) { 
}

/* RES_INIT(3C) */
int	res_init(void) { 
 return(0); }

/* RES_MKQUERY(3C) */
int	res_mkquery(int o, char *d, int c, int t, char *da, int dl,
            	    struct rrec *n, char *b, int bl ) 
	{ 
 return(o); }

/* RES_QUERY(3C) */
int	res_query(char *n, int c, int t, u_char *a, int an ) { 
 return(c); }

int	res_search(char *n, int c, int t, u_char *a, int al ) { 
 return(c); }

int	res_querydomain(char *n, char *d, int c, int t, u_char *a, int al ) 
	{ 
 return(c); }

char *	hostalias(char *n ) { 
 return(n); }

/* RES_SEND(3C) */
int	res_send(char *b, int bl, char *a, int al ) { 
 return(bl); }

int	_res_close(void) { 
 return(0); }


#endif	/* _LANLINK fileset */

#ifdef _LANBLD
#include <netinet/in.h>

/* INET_ADDR(3C) */
u_long	inet_addr(char *c ) { 
 return((u_long)0); }

/* INET_ATON(3C) */
int inet_aton(const char *a, struct in_addr *b) {
 return 0; }

/* INET_LNAOF(3C) */
u_long	inet_lnaof(struct in_addr in ) { 
 return((u_long)0); }

/* INET_MAKEADDR(3C) */
struct in_addr	inet_makeaddr(int n, int h ) { 
 struct in_addr i; return(i); }

/* INET_NETOF(3C) */
u_long	inet_netof(struct in_addr in ) { 
 return((u_long)0); }

/* INET_NETWORK(3C) */
int	inet_network(char *cp ) { 
 return(0); }

/* INET_NTOA(3C) */
char *	inet_ntoa(struct in_addr in ) { 
 char c; return(&c); }


#endif  /* _LANBLD fileset */


/* RCMD(3C) */
int	rcmd(char **a, unsigned short p, const char *l,
			const char *r, const char *c, int *f ) { 
 return(p); }

int	rexec(char **ahost, int rport, const char *name,
			const char *pass, const char *cmd, int *fd2p ) 
	{ 
 return(0); }

int	rresvport(int *a ) { 
 return(0); }

int	ruserok(const char *h, int s, const char *r, const char *l )
		{ 
 return(s); }

/* RES_COMP(3C) */
int	dn_expand(u_char *m, u_char *e, u_char *c, u_char *x, int l ) 
	{ 
 return(l); }

int	dn_comp(u_char *x, u_char *c, int l, u_char **d, u_char **a ) 
	{ 
 return(l); }

int	dn_skipname(u_char *c, u_char *e ) { 
 return(0); }

nl_catd	_res_nls_catopen(void) { 
 return((nl_catd)0); }


/* HERROR(3C) */
int	herror(char *s ) { 
 return(0); }

/* RUSERPASS(3C) */
int	ruserpass(char *h, char **n, char **p ) { 
 return(0); }

/* YELLOWUP(3C) */
int	yellowup(int f, char *d ) { 
 return(f); }


/* NFS, YP, XDR and RPC */
#ifdef NFS

#include <sys/param.h>
#include <rpc/types.h>
#include <rpc/xdr.h>
#include <rpc/auth.h>
#include <rpc/clnt.h>
#include <rpc/key_prot.h>
#define	CALL	NFS_CALL
#include <rpc/rpc_msg.h>
#include <rpc/svc.h>
#include <nfs/export.h>
#include <nfs/nfs.h>
#include <rpcsvc/ypclnt.h>
#include <rpcsvc/yp_prot.h>
#include <rpcsvc/ypv1_prot.h>
#include <rpcsvc/mount.h>
#include <rpcsvc/rstat.h>
#include <rpc/auth_unix.h>
#include <rpc/pmap_prot.h>
typedef bool_t (*resultproc_t)();
fd_set	svc_fdset;
struct rpc_createerr	rpc_createerr;
int havedisk ( char *host ) { 
 return(0); }
#include <des_crypt.h>

int getnetname(char *a )
        { return (0); }
int host2netname(char *a, char *b, char *c)
        { return(0); }
int key_decryptsession(char *a, des_block *b)
	{ return(0); }

/* Additions made 7/12/95 */        

/* rpc/auth.h */
int key_encryptsession(char *a, des_block *b)
        { return(0); }
int key_gendes(des_block *a)
        { return(0); }
int key_setsecret(char *a)
        { return(0); }
int netname2host(char *a, char *b, int c)
        { return(0); }
int netname2user(char *a, int *b, int *c, int *d, int *e)
        { return(0); }
int user2netname(char *a, uid_t b, char *c)
        { return(0); }

/* rpc/xdr.h */
u_int  xdrrec_readbytes( XDR *xdrs,caddr_t addr, u_int nbytes ) /* reads bytes from an XDR */
        { return(0); }

#include <rpcsvc/ypupdate_prot.h>
bool_t xdr_yp_buf(XDR *a, yp_buf *b)
        { return(TRUE); }
bool_t xdr_ypdelete_args(XDR *a, ypdelete_args *b)
        { return(TRUE); }
bool_t xdr_ypupdate_args(XDR *a, ypupdate_args *b)
        { return(TRUE); }


int rstat ( char *host, struct statstime *statp ) { 
 return(0); }

int getrpcport( char *host, int prognum, int versnum, int proto )
    { 
return(0);}



void	endnetgrent(void) { 
}

void	getnetgrent(char **m, char **u, char *d ) { 
}

void	setnetgrent(char *g ) { 
}

void	uselocal(char *k, char **v, int *vn ) { 
}

void	innetgr(char *g, char *m, char *n, char *d ) { 
}

int	endrpcent(void) { 
}

bool_t	xdr_authunix_parms(register XDR *x, register struct authunix_parms *p )
	{ 
 return(TRUE); }

void	_seterr_reply(register struct rpc_msg *m, register struct rpc_err *e ) 
{ 
}

bool_t	xdr_accepted_reply(register XDR *x, register struct accepted_reply *a )
 
	{ 
 return(TRUE); }

bool_t xdr_callhdr(register XDR *x, register struct rpc_msg *c) 
	{ 
 return (TRUE); }

bool_t	xdr_callmsg(register XDR *x, register struct rpc_msg *c) 
	{ 
 return(TRUE); }

bool_t	xdr_deskey(register XDR *x, register union des_block *b) 
	{ 
 return(TRUE); }

bool_t	xdr_opaque_auth(register XDR *x, register struct opaque_auth *a) 
	{ 
 return(TRUE); }

bool_t	xdr_rejected_reply(register XDR *x, register struct rejected_reply *r)
	{ 
 return(TRUE); }

bool_t	xdr_replymsg(register XDR *x, register struct rpc_msg *r) 
	{ 
 return(TRUE); }

void	svc_getreq(int r ) { 
}

void	svc_getreqset(fd_set *r ) { 
}

bool_t	svc_register(SVCXPRT *x, u_long p, u_long v, void (*d)(), int pr) 
	{ 
 return(TRUE); }

void	svc_run(void) { 
}

bool_t	svc_sendreply(register SVCXPRT *x, xdrproc_t xd, caddr_t xdr) 
	{ 
 return(TRUE); }

void	svc_unregister(u_long p, u_long v ) { 
}

void	svcerr_auth(SVCXPRT *x, enum auth_stat w ) { 
}

void	svcerr_decode(register SVCXPRT *x ) { 
}

void	svcerr_noproc(register SVCXPRT *x ) { 
}

void	svcerr_noprog(register SVCXPRT *x ) { 
}

void	svcerr_progvers(register SVCXPRT *x, u_long l, u_long h ) { 
}

void	svcerr_systemerr(register SVCXPRT *x ) { 
}

void	svcerr_weakauth(SVCXPRT *x ) { 
}

void	svc_run_ms(long n) { 
}

void	svc_getreqset_ms(fd_set *r, long n) { 
}

void	xprt_register(SVCXPRT *x ) { 
}

void	xprt_unregister(SVCXPRT *x ) { 
}

enum auth_stat	_authenticate(register struct svc_req *r, struct rpc_msg *m) 
	{ 
 return(AUTH_REJECTEDCRED); }

enum auth_stat	_svcauth_short(struct svc_req *r, struct rpc_msg *m) 
	{ 
 return(AUTH_REJECTEDCRED); }

enum auth_stat	_svcauth_unix(register struct svc_req *r,
             	              register struct rpc_msg *m ) 
	{ 
 return(AUTH_REJECTEDCRED); }

bool_t	xdr_bool(register XDR *x, bool_t *b ) { 
 return(TRUE); }

bool_t	xdr_bytes(register XDR *x, char **c, register u_int *s,
          	      register u_int m) 
	{ 
 return(TRUE); }

bool_t	xdr_char(XDR *x, char *c ) { 
 return(TRUE); }

bool_t	xdr_enum(XDR *x, enum_t *e ) { 
 return(TRUE); }

void	xdr_free(xdrproc_t p, char *o ) { 
}

bool_t	xdr_int(XDR *x, int *i ) { 
 return(TRUE); }

bool_t	xdr_long(register XDR *x, long *l ) { 
 return(TRUE); }

bool_t	xdr_netobj(XDR *x, struct netobj *n ) { 
 return(TRUE); }

bool_t	xdr_opaque(register XDR *x, caddr_t c, register u_int cn) 
	{ 
 return(TRUE); }

bool_t	xdr_short(register XDR *x, short *s ) { 
 return(TRUE); }

bool_t	xdr_string(register XDR *x, char **c, u_int m ) { 
 return(TRUE); }

bool_t	xdr_u_char(XDR *x, char *c ) { 
 return(TRUE); }

bool_t	xdr_u_int(XDR *x, u_int *u ) { 
 return(TRUE); }

bool_t	xdr_u_long(register XDR *x, u_long *u ) { 
 return(TRUE); }

bool_t	xdr_u_short(register XDR *x, u_short *u ) { 
 return(TRUE); }

bool_t	xdr_union(register XDR *x, enum_t *ds, caddr_t u, 
			struct xdr_discrim *c, xdrproc_t df ) 
	{ 
 return(TRUE); }

bool_t	xdr_void(void) { 
 return(TRUE); }

bool_t	xdr_wrapstring(XDR *x, char **c ) { 
 return(TRUE); }

bool_t	xdr_array(register XDR *x, caddr_t *a, u_int *s, u_int m, u_int es,
          	      xdrproc_t ep ) 
	{ 
 return(TRUE); }

bool_t	xdr_vector(register XDR *x, register char *b, register u_int n,
           	      register u_int e, register xdrproc_t xe) 
	{ 
 return(TRUE); }

void	xdrmem_create(register XDR *x, caddr_t a, u_int s, enum xdr_op o ) { 
}

AUTH *	authnone_create(void) { 
 return(NULL); }

AUTH *	authunix_create(char *m, int u, int g, register int l, int *a) 
	{ 
 return(NULL); }

AUTH *	authunix_create_default(void) { 
 return(NULL); }

void	bindresvport(int sd, struct sockaddr_in *sn ) { 
}

CLIENT *clnt_create(char *h, u_long pg, u_long v, char *po) 
	{ 
 return(NULL); }

CLIENT * clnt_create_vers(char *a, unsigned b, unsigned *c, unsigned d,
					unsigned e, char *f) {
 return NULL; }

void	clnt_pcreateerror(char *s ) { 
}

void	clnt_perrno(enum clnt_stat n ) { 
}

void	clnt_perror(CLIENT *r, char *s ) { 
}

char *	clnt_spcreateerror(char *s ) { 
 return(NULL); }

char *	clnt_sperrno(enum clnt_stat n ) { 
 return(NULL); }

char *	clnt_sperror(CLIENT *r, char *s ) { 
 return(NULL); }

CLIENT *clntraw_create(u_long p, u_long v ) { 
 return(NULL); }

int	callrpc(char *h, int pg, int v, int pc, xdrproc_t ip, char *i,
        	    xdrproc_t op, char *o ) { 
 return(0); }

CLIENT *clnttcp_create(struct sockaddr_in *r, u_long p, u_long v, 
			register int *sk, u_int ss, u_int rs ) 
	{ 
 return(NULL); }

CLIENT *clntudp_bufcreate(struct sockaddr_in *r, u_long p, u_long v,
                          struct timeval w, register int *sk, u_int ss,
                          u_int rs) 
	{ 
 return(NULL); }

CLIENT *clntudp_create(struct sockaddr_in *r, u_long p, u_long v,
                       struct timeval w, register int *s ) 
	{ 
 return(NULL); }

void	get_myaddress(struct sockaddr_in *a ) { 
}

void	gettransient(int p, int v, int *s ) { 
}

bool_t	pmap_set(u_long pg, u_long v, u_long pcl, u_long pt ) { 
 return(TRUE); }

bool_t	pmap_unset(u_long pg, u_long v ) { 
 return(TRUE); }

struct pmaplist *	pmap_getmaps(struct sockaddr_in *a ) { 
 return(NULL); }

u_short	pmap_getport(struct sockaddr_in *a, u_long pg, u_long v, u_long pcl) 
	{ 
 return(0); }

bool_t	xdr_pmap(XDR *x, struct pmap *r ) { 
 return(TRUE); }

bool_t	xdr_pmaplist(register XDR *x, register struct pmaplist **r) 
	{ 
 return(TRUE); }

enum clnt_stat	clnt_broadcast(u_long pg, u_long v, u_long pc, xdrproc_t x,
               	              caddr_t a, xdrproc_t xr, caddr_t r,
               	              resultproc_t e) 
	{ 
 return(RPC_SUCCESS); }

enum clnt_stat	pmap_rmtcall(struct sockaddr_in *ad, u_long pg, u_long v,
             	              u_long pc, xdrproc_t x, caddr_t ar, xdrproc_t xd,
             	              caddr_t r, struct timeval t, u_long *pp 	) 
	{ 
 return(RPC_SUCCESS); }

SVCXPRT *svcraw_create(void) { 
 return(NULL); }

void	registerrpc(u_long pg, u_long v, u_long pc, char *(*pn)(), xdrproc_t ip,
            	    xdrproc_t op ) { 
}

SVCXPRT *svcfd_create(int f, u_int s, u_int r ) { 
 return(NULL); }

SVCXPRT *svctcp_create(register int sk, u_int ss, u_int rs ) { 
 return(NULL); }

SVCXPRT *svcudp_bufcreate(register int sk, u_int s, u_int r ) { 
 return(NULL); }

SVCXPRT *svcudp_create(int sk ) { 
 return(NULL); }

bool_t	xdr_double(register XDR *x, double *d ) { 
 return(TRUE); }

bool_t	xdr_float(register XDR *x, register float *f ) { 
 return(TRUE); }

void	xdrrec_create(register XDR *x, u_int ss, u_int rs, 
			caddr_t t, int (*r)(), int ((*w)())  )
	{ 
}

bool_t	xdrrec_endofrecord(XDR *x, bool_t s ) { 
 return(TRUE); }

bool_t	xdrrec_eof(XDR *x ) { 
 return(TRUE); }

bool_t	xdrrec_skiprecord(XDR *x ) { 
 return(TRUE); }

bool_t	xdr_pointer(register XDR *x, char **op, u_int os, xdrproc_t xo ) 
	{ 
 return(TRUE); }

bool_t	xdr_reference(register XDR *x, caddr_t *pp, u_int s, xdrproc_t pc ) 
	{ 
 return(TRUE); }

void	xdrstdio_create(register XDR *x, FILE *f, enum xdr_op o ) { 
}

nl_catd nfs_nls_catopen(void) { 
 return(0); }

void	_rpc_free(char *p ) { 
}

char *	_rpc_malloc(int s ) { 
 return(NULL); }

bool_t	xdr_fhandle(XDR *x, fhandle_t *f ) { 
 return(TRUE); }

bool_t	xdr_fhstatus(XDR *x, struct fhstatus *f ) { 
return(TRUE);}

bool_t	xdr_path(XDR *x, char **p ) { 
 return(TRUE); }

int	ypprot_err(unsigned int y ) { 
 return(0); }

int	yp_bind(char *d ) { 
 return(0); }

int	_yp_dobind(char *d, struct dom_binding **b ) { 
 return(0); }

int	yp_get_default_domain (char **d ) { 
 return(0); }

void	yp_unbind (char *d ) { 
}

char *	yperr_string(int c ) { 
 return(NULL); }

int	v1prot_dofirst (char *d, char *m, struct dom_binding *p,
	struct timeval t, char **k, int *kl, char **v, int *vl)
	{ 
 return(0); }

int	v1prot_donext (char *d, char *m, char *ik, int ikl,
	struct dom_binding *p, struct timeval t, char **ok, int *okl,
	char **v, int *vl ) { 
 return(0); }

int	yp_first (char *d, char *m, char **k, int *kl, char **v, int *vl ) 
	{ 
 return(0); }

int	yp_next (char *d, char *m, char *ik, int ikl, char **ok, int *okl,
         	   char **v, int *vl ) 
	{ 
 return(0); }

int	yp_match (char *d, char *m, char *k, int kl, char **v, int *vl) 
	{ 
 return(0); }

bool	xdr_datum(XDR *x, datum *p ) { 
 return(TRUE); }

bool	xdr_yp_binding(XDR *x, struct ypbind_binding *p ) { 
 return(TRUE); }

bool	xdr_yp_inaddr(XDR *x, struct in_addr *p ) { 
 return(TRUE); }

bool	xdr_ypall(XDR *x, struct ypall_callback *c ) { 
 return(TRUE); }

bool	xdr_ypbind_resp(XDR *x, struct ypbind_resp *p ) { 
 return(TRUE); }

bool	xdr_ypbind_setdom(XDR *x, struct ypbind_setdom *p ) { 
return(TRUE);}

bool	xdr_ypdomain_wrap_string(XDR *x, char **p ) { 
 return(TRUE); }

bool	xdr_ypmap_parms(XDR *x, struct ypmap_parms *p ) { 
 return(TRUE); }

bool	xdr_ypmap_wrap_string(XDR *x, char **p ) { 
 return(TRUE); }

bool	xdr_ypmaplist(XDR *x, struct ypmaplist **l ) { 
 return(TRUE); }

bool	xdr_ypmaplist_wrap_string(XDR *x, char *p ) { 
 return(TRUE); }

bool	xdr_ypowner_wrap_string(XDR *x, char **p ) { 
 return(TRUE); }

bool	xdr_yppushresp_xfr(XDR *x, struct yppushresp_xfr *p) 
	{ 
 return(TRUE); }

bool	xdr_ypreq_key(XDR *x, struct ypreq_key *p ) { 
 return(TRUE); }

bool	xdr_ypreq_nokey(XDR *x, struct ypreq_nokey *p ) { 
 return(TRUE); }

bool	xdr_ypreq_xfr(XDR *x, struct ypreq_xfr *p ) { 
 return(TRUE); }

bool	xdr_ypresp_key_val(XDR *x, struct ypresp_key_val *p) 
	{ 
 return(TRUE); }

bool	xdr_ypresp_maplist(XDR *x, struct ypresp_maplist *p) 
	{ 
 return(TRUE); }

bool	xdr_ypresp_master(XDR *x, struct ypresp_master *p ) { 
return(TRUE);}

bool	xdr_ypresp_order(XDR *x, struct ypresp_order *p ) { 
 return(TRUE); }

bool	xdr_ypresp_val(XDR *x, struct ypresp_val *p ) { 
 return(TRUE); }

int	yp_all (char *d, char *m, struct ypall_callback *c ) { 
 return(0); }

int	yp_master (char *d, char *mp, char **mr ) { 
 return(0); }

int	yp_order (char *d, char *m, unsigned long *o ) { 
 return(0); }

bool	_xdr_ypbind_oldsetdom(XDR *x, struct ypbind_setdom *p) { 
 return(TRUE); 
}

bool	_xdr_yprequest (XDR * x, struct yprequest *p ) { 
 return(TRUE); }

bool	_xdr_ypresponse (XDR * x, struct ypresponse *p ) { 
 return(TRUE); }

bool_t xdr_keystatus(XDR *a, keystatus*b) {
 return(TRUE); }

bool_t xdr_keybuf(XDR *a, keybuf b) {
 return(TRUE); }

bool_t xdr_netnamestr(XDR *a, netnamestr *b) {
 return(TRUE); }

bool_t xdr_cryptkeyarg(XDR *a, cryptkeyarg *b) {
 return(TRUE); }

bool_t xdr_cryptkeyres(XDR *a, cryptkeyres *b) {
 return(TRUE); }

bool_t xdr_unixcred(XDR *a, unixcred *b) {
 return(TRUE); }

bool_t xdr_getcredres(XDR *a, getcredres *b) {
 return(TRUE); }

bool_t xdr_des_block (XDR *a, des_block *b) {
 return(TRUE); }
/*
   This function is not visible in libc. 
void des_setparity(char *key) {
 return; }
*/
AUTH *authdes_create(char *a, u_int b, struct sockaddr_in c, des_block *d) {
 return NULL ; }

/* NFSSVC(2) */
int	nfssvc(int s) { 
 return s; }

void	async_daemon(void) { 
 }


/* EXPORTFS(2) */
int     exportfs(const char *a, const struct export *uex) { 
 return (0); }


/* GETFH(2) */
int     getfh(int a, const fhandle_t *h) { 
 return (0); }


#endif /* NFS */

/* USED TO BE LLIB-LBSDIPC, NOW MERGED HERE */
#include <sys/socket.h>

/* Berkeley IPC System Calls */

/* ACCEPT(2) */
int 	accept(int s, void *a, int *l) { 
 return(s); }

/* BIND(2) */
int 	bind(int s, const void *a, int l) { 
 return(s); }

/* CONNECT(2) */
int 	connect(int s, const void *a, int l) { 
 return(s); }

/* GETPEERNAME(2) */
int 	getpeername(int s, void *a, int *l) { 
 return(s); }

/* GETSOCKNAME(2) */
int 	getsockname(int s, void *a, int *l) { 
 return(s); }

/* GETSOCKOPT(2) */
int 	getsockopt(int s, int l, int o, void *v, int *n) { 
 return(s); }

/* SETSOCKOPT(2) */
int 	setsockopt(int s, int l, int o, const void *v, int n) { 
 return(s); }

/* LISTEN(2) */
int 	listen(int s, int b) { 
 return(s); }

/* RECV(2) */
int 	recv(int s, void *b, int l, int f) { 
 return(s); }

/* RECVFROM(2) */
int 	recvfrom(int s, void *b, int l, int f, void *r, int *n)
		{ 
 return(s); }

/* RECVMSG(2) */
int 	recvmsg(int s, struct msghdr *m, int f) { 
 return(s); }

/* SEND(2) */
int	send(int s, const void *m, int l, int f) { 
 return(s); }

/* SENDTO(2) */
int	sendto(int s, const void *m, int l, int f,
			const void *t, int n) { 
 return(s); }

/* SENDMSG(2) */
int 	sendmsg(int s, const struct msghdr *m, int f) { 
 return(s); }

/* SHUTDOWN(2) */
int 	shutdown(int s, int h) { 
 return(s); }

/* SOCKET(2) */
int socket(int a, int t, int p) { 
 return(a); }

/* SOCKETPAIR(2) */
int socketpair(int a, int t, int p, int r[2]) { 
 return(a); }


/* USED TO BE LLIB-LNSIPC, NOW MERGED HERE */
/* #include <sys/ns_ipc.h> 		*/

/* Netipc arrays */
short ns_error_mappings[256];
short ns_nerror_mappings[3];
short ns_uerror_mappings[3];
char *ipc_result_string(e) int e; { 
}


/* NetIPC System Calls */
#ifdef __OBSOLETE__
/* IPCCONNECT(2) */
void 	ipcconnect(ns_int_t c, ns_int_t d, ns_int_t *f, short int o[], 
		   ns_int_t *v, ns_int_t *r) { 
}

/* IPCCONTROL(2) */
void 	ipccontrol(ns_int_t d, ns_int_t q, const char *w, ns_int_t m, 
		   char *r, ns_int_t *n, ns_int_t *f, ns_int_t *s) { 
}

/* IPCCREATE(2) */
void 	ipccreate(ns_int_t s, ns_int_t p, ns_int_t *f, 
		  short int o[], ns_int_t *c, ns_int_t *r) { 
}

/* IPCDEST(2) */
void 	ipcdest(ns_int_t s, const char *m, ns_int_t n, ns_int_t p, short int *a,
		ns_int_t l, ns_int_t *f, short int o[], ns_int_t *d, 
		ns_int_t *r) { 
}

/* IPCGETNODENAME(2) */
void 	ipcgetnodename(char *n, ns_int_t *s, ns_int_t *r) { 
}

/* IPCLOOKUP(2) */
void 	ipclookup(const char *s, ns_int_t n, const char *m, ns_int_t l, 
		  ns_int_t *f, ns_int_t *d, ns_int_t *p, ns_int_t *k, 
		  ns_int_t *r) { 
}

/* IPCNAME(2) */
void 	ipcname(ns_int_t d, const char *s, ns_int_t n, ns_int_t *r) { 
}

/* IPCNAMERASE(2) */
void 	ipcnamerase(char *s, ns_int_t n, ns_int_t *r) { 
}

/* IPCRECV(2) */
void 	ipcrecv(ns_int_t v, void *d, ns_int_t *l, ns_int_t *f, 
		short int o[], ns_int_t *r) { 
}

/* IPCRECVCN(2) */
void 	ipcrecvcn(ns_int_t c, ns_int_t *v, ns_int_t *f, 
		  short int o[], ns_int_t *r) { 
}

/* IPCSELECT(2) */
void 	ipcselect(ns_int_t *s, int r[2], int w[2], int e[2], 
		  ns_int_t t, ns_int_t *u) { 
}

/* IPCSEND(2) */
void 	ipcsend(ns_int_t v, const void *d, ns_int_t l, ns_int_t *f, 
		short int o[], ns_int_t *r) { 
}

/* IPCSETNODENAME(2) */
void 	ipcsetnodename(const char *n, ns_int_t s, ns_int_t *r) { 
}

/* IPCSHUTDOWN(2) */
void 	ipcshutdown(ns_int_t d, ns_int_t *f, short int o[], 
		    ns_int_t *r) { 
}


/* NetIPC Library Routines */

/* ADDOPT(3) */
void	addopt(short int o[], short int a, short int c,
	       short int l, short int d[], short int *e) { 
}

/* INITOPT(3) */
void	initopt(short int o[], short int n, short int *e) { 
}

/* READOPT(3) */
void	readopt(short int o[], short int a, short int *c, short int *l,
		short int d[], short int *e) { 
}

/* OPTOVERHEAD(3) */
int	optoverhead(short int n, short int *e) { 
 return(0); }

/* IPCERRMSG(3) */
void	ipcerrmsg(int e, char *b, int *l, int *r) { 
}

/* IPCERRSTR(3) */
char *	ipcerrstr(ns_int_t e) { 
 return((char *) 0); }
#endif /* __OBSOLETE__ */

#include <netinet/in.h>   /* For <resolv.h> */
#include <arpa/nameser.h> /* For MAXDNAME define used in <resolv.h> */
#include <resolv.h>
/* RESOLVER routines and globals - See Man resolver(3N) */

char *	p_cdname(char *c, char *m, FILE *f) { 
 return(c); }

char *	p_rr(char *c, char *m, FILE *f) { 
 return(c); }

char *	p_type(int t) { 
 return((char *) 0); }

char *  p_time(u_long t) { 
 return((char *) 0); }

char *	p_class(int class) { 
 return((char *) 0); }


#include <checklist.h>
/* GETFSENT(3X) */
struct checklist *	getfsent(void) { 
 return (struct checklist *) 0; }

struct checklist *	getfsspec(const char *s)
			   { 
 return (struct checklist *) 0; }

struct checklist *	getfsfile(const char *f)
			   { 
 return (struct checklist *) 0; }

struct checklist *	getfstype(const char *t)
			   { 
 return (struct checklist *) 0; }

int	setfsent(void) { 
 return 0; }

int	endfsent(void) { 
 return 0; }


/* GETRLIMIT(2) */
int	getrlimit(int r, struct rlimit *b) { 
 return r; }

int	getrlimit64(int r, struct rlimit64 *b) { 
 return r; }

int	setrlimit(int r, const struct rlimit *b) { 
 return r; }

int	setrlimit64(int r, const struct rlimit64 *b) { 
 return r; }


/* GETDOMAINNAME(2) */
int	getdomainname(char *n, int l) { 
 return l; }

int	setdomainname(const char *n, int l) { 
 return l; }


char *net_aton( char *dstr, const char *sstr, int size) { 
 return dstr; }

char *net_ntoa( char *dstr, const char *sstr, int size) { 
 return dstr; }

int quotactl( int cmd, const char *special, uid_t uid, void *addr ) { 
return 0;}



/* EXPORTENT(3N) */
#include <exportent.h>
FILE *	setexportent(void) { 
 return (FILE *)0; }

struct exportent *	getexportent(FILE *fildep) { 
 return (struct exportent *)0; }

int	addexportent(FILE *filep, char *dirname, char *options) { 
 return 0; }

int	remexportent(FILE *filep, char *dirname) { 
 return 0; }

char *	getexportopt(struct exportent *xent, char *opt) { 
 return (char *)0; }

void	endexportent(FILE *filep) { 
 return; }


#include <sys/pstat.h>
/* PSTAT(2) */
int	pstat_getstatic(struct pst_static *bufp,
		size_t size, size_t entries, int offset) { 
 return 0; }

int	pstat_getdynamic(struct pst_dynamic *bufp,
		size_t size, size_t entries, int offset) { 
 return 0; }

int	pstat_getvminfo(struct pst_vminfo *bufp,
		size_t size, size_t entries, int offset) { 
 return 0; }

int	pstat_getproc(struct pst_status *bufp,
		size_t size, size_t entries, int offset) { 
 return 0; }

int	pstat_getdisk(struct pst_diskinfo *bufp,
		size_t size, size_t entries, int offset) { 
 return 0; }

int	pstat_getprocessor(struct pst_processor *bufp,
		size_t size, size_t entries, int offset) { 
 return 0; }

int	pstat_getlv(struct pst_lvinfo *bufp,
		size_t size, size_t entries, int offset) { 
 return 0; }

int	pstat_getswap(struct pst_swapinfo *bufp,
		size_t size, size_t entries, int offset) { 
 return 0; }

int	pstat_getfile(struct pst_fileinfo *bufp,
		size_t size, size_t entries, int offset) {
 return 0; }

int	pstat_getsem(struct pst_seminfo *bufp,
		size_t size, size_t entries, int offset) {
 return 0; }

int	pstat_getmsg(struct pst_msginfo *bufp,
		size_t size, size_t entries, int offset) {
 return 0; }

int	pstat_getshm(struct pst_shminfo *bufp,
		size_t size, size_t entries, int offset) {
 return 0; }

int	pstat_getipc(struct pst_ipcinfo *bufp,
		size_t size, size_t entries, int offset) {
 return 0; }

#ifdef __hp9000s800
#include <sys/blmodeio.h>
/* BLMODE(3C) S800-only */
int	blopen(int f) { 
 return f; }

int	blclose(int f) { 
 return f; }

int	blget(int f, struct blmodeio *a) { 
 return f; }

int	blset(int f, struct blmodeio *a) { 
 return f; }

int	blread(int b, char *s, int c) { 
 return b; }

#endif /* __hp9000s800 */

/* The following are implemented as macros on hpux, fn()s on osf */
#undef htonl
#undef ntohl
#undef htons
#undef ntohs
unsigned long htonl ( unsigned long i) { 
 return (i); } 

unsigned long ntohl ( unsigned long i) { 
 return (i); }

unsigned htons ( unsigned i) { 
 return 0; }

unsigned ntohs ( unsigned i) { 
 return 0; }

int 	getdate_r(const char *c, struct tm *t, int *i) {
 return(0); }

#ifdef _REENTRANT
int	fclose_unlocked(FILE *f ) { 
 return (0); }		

int	fflush_unlocked(FILE *f ) { 
 return (0); }		

int	setvbuf_unlocked(FILE *f, char *b, int t, size_t s )   	
	{ 
 return (t); }

int	ungetc_unlocked(int c, FILE *f ) { 
 return (c); }		

int	fseek_unlocked(FILE *f, long o, int p) { 
 return (p); }	

long	ftell_unlocked(FILE *f ) { 
 return (0L); }		

void	rewind_unlocked(FILE *f ) { 
}				

size_t	fread_unlocked(void *b, size_t s, size_t n, FILE *f ) 	
	{ 
 return (n); }

size_t	fwrite_unlocked(const void *b, size_t s, size_t n, FILE *f ) 
	{ 
 return (n); }

char	*fgets_unlocked(char *p, int s, FILE *f) {
 return((char *) 0); }

int	fputs_unlocked(char *p, FILE *f) {
 return(0); }

int	puts_unlocked(char *p) {
 return(0); }

wint_t 	fgetwc_unlocked(FILE *f) {
 return((wint_t) 0); }

wchar_t	*fgetws_unlocked(wchar_t *s, int n, FILE *f) {
 return((wchar_t) 0); }

wint_t	fputwc_unlocked(wint_t c, FILE *f) {
 return((wint_t) 0); }

int	fputws_unlocked(const wchar_t *s, FILE *f) {
 return(0); }

int	putws_unlocked(const wchar_t *s) {
 return(0); }

wint_t 	getwc_unlocked(FILE *f) {
 return((wint_t) 0); }

wint_t 	getwchar_unlocked(void) {
 return((wint_t) 0); }

wint_t 	putwc_unlocked(wint_t wc, FILE *f) {
 return((wint_t) 0); }

wint_t 	putwchar_unlocked(wint_t wc) {
 return((wint_t) 0); }

wint_t 	ungetwc_unlocked(wint_t wc, FILE *f) {
 return((wint_t) 0); }

int	fileno_unlocked(FILE *f ) { 
 return (0); }

int	getw_unlocked(FILE *f ) { 
 return (0); }

int	putw_unlocked(int w, FILE *f ) { 
 return (w); }

void 	endusershell_r(char **p) {
 return; }

char 	*getusershell_r(char **p) {
 return((char *) 0); }

void 	setusershell_r(char **p){
 return; }

int 	endhostent_r(struct hostent_data *d) {
 return(0); }

int 	gethostbyaddr_r(const char *c, int i, int j, struct hostent *h, 
		struct hostent_data *d) {
 return(0); }

int 	gethostbyname_r(const char *c, struct hostent *h, 
		struct hostent_data *d) {
 return(0); }

int 	gethostent_r(struct hostent *h, struct hostent_data *d) {
 return(0); }

int 	sethostent_r(int i, struct hostent_data *d) {
 return(0); }

int 	endnetent_r(struct netent_data *d) {
 return(0); }

int 	getnetbyaddr_r(int i, int j, struct netent *n, struct netent_data *d) {
 return(0); }

int 	getnetbyname_r(const char *c, struct netent *n, 
		struct netent_data *d) {
 return(0); }

int 	getnetent_r(struct netent *n, struct netent_data *d) {
 return(0); }

int 	setnetent_r(int i, struct netent_data *d) {
 return(0); }

int 	endservent_r(struct servent_data *d) {
 return(0); }

int 	getservbyname_r(const char *c, const char *cc, struct servent *s, 
		struct servent_data *d) {
 return(0); }

int 	getservbyport_r(int i, const char *c, struct servent *s, 
		struct servent_data *d) {
 return(0); }

int 	getservent_r(struct servent *s, struct servent_data *d) {
 return(0); }

int 	setservent_r(int i, struct servent_data *d) {
 return(0); }

int 	endprotoent_r(struct protoent_data *d) {
 return(0); }

int 	getprotobyname_r(const char *c, struct protoent *p, 
		struct protoent_data *d) {
 return(0); }

int 	getprotobynumber_r(int i, struct protoent *p, struct protoent_data *d) {
 return(0); }

int 	getprotoent_r(struct protoent *p, struct protoent_data *d) {
 return(0); }

int 	setprotoent_r(int i, struct protoent_data *d) {
 return(0); }

int 	inet_ntoa_r(struct in_addr a, char *c, int i) {
 return(0); }

int 	ecvt_r(double d, int s, int *i, int *j, char *c, int k) {
 return(0); }

int 	fcvt_r(double d, int s, int *i, int *j, char *c, int k) {
 return(0); }

int 	getmntent_r(FILE *f, struct mntent *m, char *c, int i) {
 return(0); }

int 	acltostr_r(int n, const struct acl_entry a[], int f, char *s, int l) {
 return(0); }

int 	rand_r(long *l, int *i) {
 return(0); }

int 	getdiskbyname_r(char *c, struct disktab *d, char *cc, int i) {
 return(0); }

void 	endgrent_r(FILE **f) {
 return; }

int 	fgetgrent_r(FILE *f, struct group *g, char *c, int i) {
 return(0); }

int 	getgrent_r(struct group *g, char *c, int i, FILE **f) {
 return(0); }

void 	setgrent_r(FILE **f) {
 return; }

int 	getlocale_r(int i, struct locale_data *d) {
 return(0); }

void 	endpwent_r(FILE **f) {
 return; }

int 	fgetpwent_r(FILE *f, struct passwd *p, char *c, int i) {
 return(0); }

int 	getpwent_r(struct passwd *p, char *c, int i, FILE **f) {
 return(0); }

void 	setpwent_r(FILE **f) {
 return; }

int 	l64a_r(long l, char *c, int i) {
 return(0); }

int 	ltoa_r(long l, char *c, int i) {
 return(0); }

int 	ltostr_r(long l, int i, char *c, int j) {
 return(0); }

int 	strtoacl_r(const char *c, int i, int j, struct acl_entry *a, int k, 
		int l, char *ca[]) {
 return(0); }

int 	strtoaclpatt_r(const char *c, int i, struct acl_entry_patt *a, 
		char *ca[]) {
 return(0); }

int 	ultoa_r(unsigned long l, char *c, int i) {
 return(0); }

int 	ultostr_r(unsigned long l, int i, char *c, int j) {
 return(0); }

int 	endrpcent_r(struct rpcent_data *d) {
 return(0); }

int 	getrpcbyname_r(const char *c, struct rpcent *r, struct rpcent_data *d) {
 return(0); }

int 	getrpcbynumber_r(int i, struct rpcent *r, struct rpcent_data *d) {
 return(0); }

int 	getrpcent_r(struct rpcent *r, struct rpcent_data *d) {
 return(0); }

int 	setrpcent_r(int i, struct rpcent_data *d) {
 return(0); }

#endif /* _REENTRANT */

#endif /* _INCLUDE_HPUX_SOURCE */

/* =====================  _REENTRANT ========================= */
#ifdef _REENTRANT

#include <crypt.h>
char	*crypt_r(char *c, char *cc, CRYPTD *d) {
 return ((char *) 0); }

void	encrypt_r(char *c, int i, CRYPTD *d) {
 return; }

void	setkey_r(char *c, CRYPTD *d) {
 return; }

int 	drand48_r (struct drand48_data *dd, double *d) {
 return(0); }

int 	erand48_r (unsigned short s[],struct drand48_data *dd,double *d) {
 return(0); }

int 	jrand48_r (unsigned short s[], struct drand48_data *d, long *l) {
 return(0); }

int 	lcong48_r (unsigned short s[], struct drand48_data *d) {
 return(0); }

int 	lrand48_r (struct drand48_data *d, long *l) {
 return(0); }

int 	mrand48_r (struct drand48_data *d, long *l) {
 return(0); }

int 	nrand48_r (unsigned short s[], struct drand48_data *d, long *l) {
 return(0); }

int 	seed48_r (unsigned short s[], struct drand48_data *d) {
 return(0); }

int 	srand48_r (long l, struct drand48_data *d) {
 return(0); }

void 	endutent_r(struct utmp_data *d) {
 return; }

int 	getutent_r(struct utmp **u, struct utmp_data *d) {
 return(0); }

int 	getutid_r(struct utmp *e, struct utmp **u, struct utmp_data *d) {
 return(0); }

int 	getutline_r(struct utmp *e, struct utmp **u, struct utmp_data *d) {
 return(0); }

int 	pututline_r(struct utmp *e, struct utmp_data *d) {
 return(0); }

void 	setutent_r(struct utmp_data *d) {
 return; }

void 	flockfile(FILE *f) {
 return; }

void 	funlockfile(FILE *f) {
 return; }

wchar_t		*wcstok_r(wchar_t *wc, const wchar_t *c, wchar_t **p) {
 return((wchar_t *) 0); }

int	ptsname_r(int fdm, char *buffer, int buflen) {
 return 0; }

int	utmpname_r(char *f ) {
 return 0; }

/* Secure password routines: */
void	endspwent_r(FILE **fp) {
 return; }

int getspwent_r(struct s_passwd *s, char *c, int i, FILE **fp) {
 return 0; }

int getspwuid_r(int i, struct s_passwd *s, char *c, int ii) {
 return 0; }

int getspwaid_r(int i, struct s_passwd *s, char *c, int ii) {
 return 0; }

int getspwnam_r(char *c, struct s_passwd *s, char *cc, int i) {
 return 0; }

int fgetspwent_r(FILE *f, struct s_passwd *s, char *c, int i) {
 return 0; }

void	setspwent_r(FILE **fp) {
 return; }

#endif /* _REENTRANT */


/*  POSIX.1B functions */
/* ======================= POSIX.1B ============================= */

#include <aio.h>
#include <mqueue.h>
#include <semaphore.h>
#include <siginfo.h>

int
aio_read(struct aiocb *aiocbp)				/* 6.7.2.1 */
{ return 0; }

int
aio_read64(struct aiocb *aiocbp)				/* 6.7.2.1 */
{ return 0; }

int
aio_write(struct aiocb *aiocbp)				/* 6.7.3.1 */
{ return 0; }

int
aio_write64(struct aiocb *aiocbp)				/* 6.7.3.1 */
{ return 0; }

int
lio_listio(int mode, struct aiocb * const list[],
	   int nent, struct sigevent *sig)		/* 6.7.4.1 */
{ return 0; }

int
lio_listio64(int mode, struct aiocb * const list[],
	   int nent, struct sigevent *sig)		/* 6.7.4.1 */
{ return 0; }

int
aio_error(const struct aiocb *aiocbp)			/* 6.7.5.1 */
{ return 0; }

ssize_t
aio_return(struct aiocb *aiocbp)			/* 6.7.6.1 */
{ return (ssize_t)0; }

int
aio_cancel(int fildes, struct aiocb *aiocbp)		/* 6.7.7.1 */
{ return 0; }

int
aio_suspend(const struct aiocb *const list[],
            int nent, const struct timespec *timeout)	/* 6.7.8.1 */
{ return 0; }

int
aio_fsync(int op, struct aiocb *aiocbp)			/* 6.7.9.1 */
{ return 0; }

mqd_t
mq_open(const char *name, int oflag, ...)		/* 15.2.1.1 */
{ return (mqd_t)0; }

int
mq_close(mqd_t mqdes)					/* 15.2.2.1 */
{ return 0; }

int
mq_unlink(const char *name)				/* 15.2.3.1 */
{ return 0; }

int
mq_send(mqd_t mqdes, const char *msg_ptr,
	size_t msg_len, unsigned int msg_prio)		/* 15.2.4.1 */
{ return 0; }

int
mq_receive(mqd_t mqdes, char *msg_ptr,
  	   size_t msg_len, unsigned int msg_prio)	/* 15.2.5.1 */
{ return 0; }

int
mq_notify(mqd_t mqdes, const struct sigevent *notification)	/* 15.2.6.1 */
{ return 0; }

int
mq_setattr(mqd_t mqdes, const struct mq_attr * mqstat,
	   struct mq_attr *omqstat)			/* 15.2.7.1 */
{ return 0; }

int
mq_getattr(mqd_t mqdes, struct mq_attr *mqstat)		/* 15.2.8.1 */
{ return 0; }

int
sem_init(sem_t *sem, int pshared, unsigned int value)	/* 11.2.1.1 */
{ return 0; }

int
sem_destroy(sem_t *sem)					/* 11.2.2.1 */
{ return 0; }

sem_t
*sem_open(const char *name, int oflag, ...)		/* 11.2.3.1 */
{ return (sem_t *)NULL; }

int
sem_close(sem_t *sem)					/* 11.2.4.1 */
{ return 0; }

int
sem_unlink(const char *name)				/* 11.2.5.1 */
{ return 0; }

int
sem_wait(sem_t *sem)					/* 11.2.6.1 */
{ return 0; }

int
sem_trywait(sem_t *sem)					/* 11.2.6.1 */
{ return 0; }

int
sem_post(sem_t *sem)					/* 11.2.7.1 */
{ return 0; }

int
sem_getvalue(sem_t *sem, int *sval)			/* 11.2.8.1 */
{ return 0; }

int
mlockall(int flags)					/* 12.1.1.2 */
{ return 0; }

int
munlockall(void)					/* 12.1.1.1 */
{ return 0; }

int
mlock(const void *addr, size_t len)			/* 12.1.1.1 */
{ return 0; }

int
munlock(const void *addr, size_t len)			/* 12.1.1.1 */
{ return 0; }

int
shm_open(const char *name, int oflag, mode_t mode)	/* 12.3.1.1 */
{ return 0; }

int
shm_unlink(const char *name)				/* 12.3.2.1 */
{ return 0; }

int
sigwaitinfo(const sigset_t *set, siginfo_t *info)	/* 3.3.8.1 */
{ return 0; }

int
sigtimedwait(const sigset_t *set, siginfo_t *info,
	     const struct timespec *timeout)		/* 3.3.8.1 */
{ return 0; }

int
sigqueue(pid_t pid, int signo, const union sigval value)	/* 3.3.9.1 */
{ return 0; }


/*  POSIX.4 functions */
/* ======================= POSIX.4 ============================= */

int clock_settime(clockid_t a, const struct timespec *b) {
 return 0; }

int clock_gettime(clockid_t a, struct timespec *b) {
 return 0; }

int clock_getres(clockid_t a, struct timespec *b) {
 return 0; }

int timer_create(clockid_t a, struct sigevent *b, timer_t *c) {
 return 0; }

int timer_delete(timer_t a) {
 return 0; }

int timer_settime(timer_t a, int b, const struct itimerspec *c,
		  struct itimerspec *d) {
 return 0; }

int timer_gettime(timer_t a, struct itimerspec *b) {
 return 0; }

int timer_getoverrun(timer_t a) {
 return 0; }

int nanosleep(const struct timespec *a, struct timespec *b) {
 return 0; }


#include <sys/sched.h>
int sched_setparam(pid_t a, const struct sched_param *b) {
 return 0; }

int sched_getparam(pid_t a, struct sched_param *b) {
 return 0; }

int sched_setscheduler(pid_t a, int b, const struct sched_param *c) {
 return 0; }

int sched_getscheduler(pid_t a) {
 return 0; }

int sched_yield(void) {
 return 0; }

int sched_get_priority_max(int a) {
 return 0; }

int sched_get_priority_min(int a) {
 return 0; }

int sched_rr_get_interval(pid_t a, struct timespec *b) {
 return 0; }

/* ============== ndbm entry points ============== */
#include <dbm.h>
#include <ndbm.h>

/* DBM(3X) */
int	dbmclose (void) { 
 return 0; }

int	dbminit (char *f) { 
 return 0; }

int	delete (datum k) { 
 return 0; }

datum	fetch (datum d) { 
 return d; }

datum	firstkey (void) { 
 datum d={(char *)0,0}; return d; }

datum	nextkey (datum d) { 
 return d; }

int	store (datum k, datum c) { 
 return 0; }

/* NDBM(3X) */
#undef dbm_error
#undef dbm_clearerr

void	dbm_close (DBM *d) { 
 return; }

int	dbm_clearerr (DBM *d) { 
 return 0; }

int	dbm_delete (DBM *d, datum k) { 
 return 0; }

int	dbm_error (DBM *d) { 
 return 0; }

datum	dbm_fetch (DBM *d, datum k) { 
 return k; }

datum	dbm_firstkey (DBM *d) { 
 datum k={(char *)0,0}; return k; }

long	dbm_forder (DBM *d, datum k) { 
 long l=0l; return l; }

datum	dbm_nextkey (DBM *d) { 
datum k={(char *)0,0}; return k; }

DBM *	dbm_open (const char *c, int n, mode_t m) { 
 DBM d; return &d; }

int	dbm_store (DBM *d, datum j, datum k, int r) { 
 return 0; }

/* Prototypes for sys/ucontext.h */
/* The ucontext calls are added as of 10.WC */
#include <sys/ucontext.h>

/* Additions made on 7/12/95 */

int getcontext(ucontext_t *a)
        { return(0); }
int setcontext(const ucontext_t *a)
        { return(0); }
int swapcontext(ucontext_t *a,const ucontext_t *b)
        { return(0); }

void makecontext(ucontext_t *a , void (*fn)(), int b , ... )
        { return; }


