# 1 "malloc.c"

static char *malloc_rcsid = "$Header: /usr/user/auis-7.2/overhead/malloc/RCS/malloc.c,v 2.5 1991/09/12 17:16:50 bobg R6tape $";

# 1 "malloc.ci" 1

static char rcsid[] = "$Header: /usr/user/auis-7.2/overhead/malloc/RCS/malloc.ci,v 2.34 1994/08/19 00:27:03 rr2b Exp $ ";

# 1 "/usr/chs/ams/include/andrewos.h" 1

# 1 "/usr/chs/ams/include/system.h" 1

# 1 "/usr/chs/ams/include/presite.h" 1
# 58 "/usr/chs/ams/include/system.h" 2

# 1 "/usr/chs/ams/include/allsys.h" 1

# 1 "/usr/chs/ams/include/aconcat.h" 1

# 42 "/usr/chs/ams/include/allsys.h" 2

typedef int boolean;
typedef void *pointer;
typedef int (*procedure)();

# 60 "/usr/chs/ams/include/system.h" 2

# 1 "/usr/chs/ams/include/atkproto.h" 1

# 128 "/usr/chs/ams/include/system.h" 2

# 1 "/usr/include/sys/types.h" 1 3

# 1 "/usr/include/standards.h" 1 3

# 155 "/usr/include/standards.h" 3

# 77 "/usr/include/sys/types.h" 2 3

typedef signed long     ptrdiff_t;

    typedef unsigned int  wchar_t;

typedef unsigned int wctype_t;

typedef long            fpos_t;

typedef int            time_t;

typedef int             clock_t;

typedef unsigned long   size_t;

typedef long                    ssize_t;  

typedef	unsigned char	uchar_t;
typedef	unsigned short	ushort_t;
typedef	unsigned int	uint_t;
typedef unsigned long	ulong_t;
typedef	volatile unsigned char	vuchar_t;
typedef	volatile unsigned short	vushort_t;
typedef	volatile unsigned int	vuint_t;
typedef volatile unsigned long	vulong_t;

# 194 "/usr/include/sys/types.h" 3

typedef	struct	{ long r[1]; } *physadr_t;

typedef	struct	label_t	{
	long	val[10];
} label_t;

typedef int		level_t;
typedef	int		daddr_t;	 
typedef	char *		caddr_t;	 
typedef long *		qaddr_t;         
typedef char *          addr_t;
typedef	uint_t		ino_t;		 
typedef short		cnt_t;
typedef int		dev_t;		 
typedef	int		chan_t;		 

typedef long    off_t;			 

typedef unsigned long	rlim_t;		 
typedef	int		paddr_t;
typedef	ushort_t	nlink_t;

typedef int    		key_t;		 

typedef	uint_t		mode_t;		 

typedef uint_t		uid_t;		 

typedef uint_t		gid_t;		 

typedef	void *		mid_t;		 

typedef	int		pid_t;		 

typedef char		slab_t[12];	 

typedef pid_t		id_t;		 

typedef ulong_t		shmatt_t;	 
typedef ulong_t		msgqnum_t;	 
typedef ulong_t		msglen_t;	 

        typedef unsigned int wint_t;          

typedef unsigned long	sigset_t;

typedef long            timer_t;         

typedef void (*sig_t)();

typedef uint_t	major_t;       
typedef uint_t	minor_t;       
typedef uint_t	devs_t;        
typedef uint_t	unit_t;        

# 1 "/usr/include/mach/machine/vm_types.h" 1 3

typedef	unsigned long	vm_offset_t;
typedef	unsigned long	vm_size_t;

# 343 "/usr/include/sys/types.h" 2 3

typedef	uchar_t		uchar;
typedef	ushort_t	ushort;
typedef	uint_t		uint;
typedef ulong_t		ulong;

typedef	physadr_t	physadr;

typedef	uchar_t		u_char;
typedef	ushort_t 	u_short;
typedef	uint_t		u_int;
typedef	ulong_t		u_long;
typedef	vuchar_t	vu_char;
typedef	vushort_t 	vu_short;
typedef	vuint_t		vu_int;
typedef	vulong_t	vu_long;

typedef struct  _quad { int val[2]; } quad;

typedef	long	swblk_t;
typedef u_long	fixpt_t;

typedef int	fd_mask;

typedef	struct fd_set {
	fd_mask	fds_bits[((( 4096   )+((  (sizeof(fd_mask) * 8 )  )-1))/(  (sizeof(fd_mask) * 8 )  )) ];
} fd_set;

# 148 "/usr/chs/ams/include/system.h" 2

# 1 "/usr/include/sys/stat.h" 1 3

# 1 "/usr/include/sys/mode.h" 1 3

# 57 "/usr/include/sys/stat.h" 2 3

struct  stat
{
	dev_t	st_dev;			 

	ino_t	st_ino;			 
	mode_t	st_mode;		 
	nlink_t	st_nlink;		 
	uid_t	st_uid;			 
	gid_t	st_gid;			 
	dev_t	st_rdev;		 

	off_t	st_size;		 
	time_t	st_atime;		 
	int	st_spare1;
	time_t	st_mtime;		 
	int	st_spare2;
	time_t	st_ctime;		 
	int	st_spare3;

	uint_t	st_blksize;		 
        int    st_blocks;               
        uint_t  st_flags;                
        uint_t  st_gen;                  

};

	extern int	mkdir(const char *, mode_t ); 
	extern mode_t	umask(mode_t ); 
	extern int	stat(const char *, struct stat *);
	extern int	fstat(int , struct stat *);
	extern int	chmod(const char *, mode_t );
	extern int	mkfifo(const char *, mode_t );

	extern int 	lstat(const char *, struct stat *);

# 198 "/usr/chs/ams/include/system.h" 2

# 1 "/usr/include/stdlib.h" 1 3

# 93 "/usr/include/stdlib.h" 3

typedef struct div_t  {			 
	int quot;			 
	int rem; } div_t;			 

typedef struct ldiv_t  {		 
	long int quot;			 
	long int rem; } ldiv_t;		 

extern int __getmbcurmax  (void)  ;

extern int	mblen  (const char *, size_t)  ;
extern size_t	mbstowcs  (wchar_t *, const char *, size_t)  ;
extern int	mbtowc  (wchar_t *, const char *, size_t)  ;
extern size_t	wcstombs  (char *, const wchar_t *, size_t)  ;
extern int	wctomb  (char *, wchar_t)  ;

extern int	rpmatch  (const char *)  ;
extern void 	*valloc  (register size_t )  ;

extern double 	atof  (const char *)  ;
extern int 	atoi  (const char *)  ;
extern long int atol  (const char *)  ;
extern double 	strtod  (const char *, char **)  ;
extern long int strtol  (const char *, char **, int )  ;
extern unsigned long int strtoul  (const char *, char **, int )  ;
extern int 	rand  (void)  ;
extern void	srand  (unsigned int )  ;
extern void 	*calloc  (size_t , size_t )  ;
extern void	free  (void *)  ;
extern void	*malloc  (size_t )  ;
extern void 	*realloc  (void *, size_t )  ;
extern void	abort  (void)  ;
extern int	atexit  (void (*)(void))  ;
extern void	exit  (int )  ;
extern char	*getenv  (const char *)  ;
extern int 	system  (const char *)  ;
extern void 	*bsearch  (const void *, const void *, size_t , size_t , int(*)(const void *, const void *))  ;
extern void 	qsort  (void *, size_t , size_t ,int(*)(const void *, const void *))  ;
extern int 	abs  (int )  ;
extern struct div_t	div  (int , int )  ;
extern long int	labs  (long int )  ;
extern struct ldiv_t 	ldiv  (long int , long int )  ;

# 192 "/usr/include/stdlib.h" 3

extern double	drand48  (void)  ;
extern double	erand48  (unsigned short [])  ;
extern long	jrand48  (unsigned short [])  ;
extern void	lcong48  (unsigned short [])  ;
extern long	lrand48  (void)  ;
extern long	mrand48  (void)  ;
extern long	nrand48  (unsigned short [])  ;
extern unsigned short *seed48  (unsigned short [])  ;
extern void	srand48  (long)  ;
extern int 	putenv  (const char *)  ;
extern void	setkey  (const char *)  ;

# 220 "/usr/include/stdlib.h" 3

extern int	srandom  (unsigned int)  ;
extern char	*initstate  (unsigned int, char *, int)  ;
extern char	*setstate  (char *)  ;
extern int	random  (void)  ;

# 276 "/usr/include/stdlib.h" 3

# 1 "/usr/include/getopt.h" 1 3

extern int getopt  (int, char * const [], const char *)  ;

extern char *optarg;
extern int optind;
extern int optopt;
extern int opterr;

# 283 "/usr/include/stdlib.h" 2 3

extern int 	clearenv  ()  ;
extern char 	*getpass  (const char *)  ;

     float    atoff();
char	*ecvt  (double, int, int *, int *)  ;
char	*fcvt  (double, int, int *, int *)  ;
char	*gcvt  (double, int, char *)  ;

     float    strtof();
     void     imul_dbl();
     void     umul_dbl();

# 229 "/usr/chs/ams/include/system.h" 2

# 1 "/usr/include/string.h" 1 3

# 95 "/usr/include/string.h" 3

extern void	*memchr(const void *, int , size_t );
extern void	*memcpy(void *, const void *, size_t );
extern void	*memset(void *, int , size_t );
extern size_t 	strcspn(const char *, const char *);
extern size_t	strlen(const char *);
extern size_t	strspn(const char *, const char *);

# 130 "/usr/include/string.h" 3

extern void 	*memmove(void *, const void *, size_t );
extern char 	*strcpy(char *, const char *);
extern char 	*strncpy(char *, const char *, size_t );
extern char 	*strcat(char *, const char *);
extern char	*strncat(char *, const char *, size_t );
extern int 	memcmp(const void *, const void *,size_t );
extern int	strcmp(const char *, const char *);
extern int	strcoll(const char *, const char *);
extern int	strncmp(const char *,const char *,size_t );
extern size_t 	strxfrm(char *, const char *, size_t );
extern char	*strchr(const char *, int );
extern char	*strpbrk(const char *, const char *);
extern char	*strrchr(const char *, int );
extern char	*strstr(const char *, const char *);
extern char 	*strtok(char *, const char *);
extern char 	*strerror(int);

extern void	*memccpy(void *, const void *, int , size_t );

extern void	swab(const void *, void *, ssize_t);

# 213 "/usr/include/string.h" 3

extern int  ffs(long);
extern void  bzero(char *, int);
extern int  bcmp(const char *, const char *, int);
extern void bcopy(const char *, char *, int);
extern char *strdup(const char *);
extern int  strcasecmp(const char *, const char *);
extern int  strncasecmp(const char *, const char *, size_t );
extern char *index(const char*, char);
extern char *rindex(const char*, char);
extern char *basename(char *);
extern char *dirname(char *);

# 253 "/usr/chs/ams/include/system.h" 2

# 1 "/usr/include/unistd.h" 1 3

# 1 "/usr/include/sys/access.h" 1 3

# 60 "/usr/include/unistd.h" 2 3

# 1 "/usr/include/sys/seek.h" 1 3

# 72 "/usr/include/unistd.h" 2 3

extern char **environ;           

# 140 "/usr/include/unistd.h" 3

extern int access(const char *, int );
extern unsigned int alarm(unsigned int );
extern int chdir(const char *);
extern int chown(const char *, uid_t , gid_t );
extern int chroot(const char *);
extern int close(int );
extern size_t confstr(int, char *, size_t);

extern int dup(int );
extern int dup2(int , int );

extern int execl(const char *, const char *, ...);
extern int execv(const char *, char *const[]);
extern int execle(const char *, const char *, ...); 
extern int execve(const char *, char *const[], char *const[]);
extern int execlp(const char *, const char *, ...); 
extern int execvp(const char *, char *const[]);

extern void _exit(int );
extern pid_t fork(void);
extern long fpathconf(int , int );
extern int fsync(int);
extern char *getcwd(char *, size_t );
extern gid_t getegid(void);
extern uid_t geteuid(void);
extern gid_t getgid(void);

extern int getgroups(int , gid_t []);

extern char *getlogin(void);
extern pid_t getpgrp(void);
extern pid_t getpid(void);
extern pid_t getppid(void);
extern uid_t getuid(void);
extern int isatty(int );
extern int link(const char *, const char *);
extern off_t lseek(int , off_t , int );
extern long pathconf(const char *, int );
extern int pause(void);

extern int pipe(int []);

extern ssize_t read(int , void *, size_t);
extern int rmdir(const char *);
extern int setgid(gid_t );
extern int setpgid(pid_t , pid_t );
extern pid_t setsid(void);
extern int setuid(uid_t );
extern unsigned int sleep(unsigned int );
extern long sysconf(int );
extern pid_t tcgetpgrp(int );
extern int tcsetpgrp(int , pid_t );
extern char *ttyname(int );
extern int unlink(const char *);
extern ssize_t write(int , const void *, size_t); 

extern void swab(const void *, void *, ssize_t);

# 428 "/usr/include/unistd.h" 3

extern int  fchown(int, uid_t, gid_t);
extern int  ftruncate(int, off_t);
extern int  readlink(const char *, char *, int);
extern int  setgroups(int, gid_t []);
extern int  symlink(const char *, const char *);
extern int  truncate(const char *, off_t);

# 452 "/usr/include/unistd.h" 3

extern char *crypt(const char *, const char *);
extern char *cuserid(char *);
extern char *ctermid(char *);
extern void encrypt(char [], int);
extern char *getpass(const char *);
extern int  nice(int);

# 496 "/usr/include/unistd.h" 3

extern char *getenv(const char *);
extern int rename(const char *, const char *);

extern int  brk(char *);
extern char *sbrk(ssize_t);
extern int  getpagesize(void);
extern pid_t getsid(pid_t);
extern char *getwd(char *);
extern int  seteuid(uid_t);
extern int  setegid(gid_t);
extern int  setlogin(char *);
extern pid_t setpgrp(void);
extern int  setregid(gid_t, gid_t);
extern int  setreuid(uid_t, uid_t);
extern int  setrgid(gid_t);
extern int  setruid(uid_t);
extern unsigned int ualarm(unsigned int, unsigned int);

# 262 "/usr/chs/ams/include/system.h" 2

# 1 "/usr/include/stdarg.h" 1 3

# 1 "/usr/include/va_list.h" 1 3

typedef struct {
	char	*_a0;		 
	int	_offset;		 
} va_list;

# 84 "/usr/include/va_list.h" 3

# 36 "/usr/include/stdarg.h" 2 3

# 271 "/usr/chs/ams/include/system.h" 2

# 1 "/usr/include/stdio.h" 1 3

typedef struct {
	int	_cnt;
	unsigned char	*_ptr;
	unsigned char	*_base;
	int	_bufsiz;
	short	_flag;
	short	_file;

	char	*__newbase;
	void	*_lock;			 
	unsigned char	*_bufendp;
} FILE;

extern FILE	_iob[];

extern size_t	fread  (void *, size_t, size_t, FILE *)  ;
extern size_t	fwrite  (const void *, size_t, size_t, FILE *)  ;

extern int	_flsbuf  (int, FILE *)  ;
extern int	_filbuf  (FILE *)  ;
extern int 	ferror  (FILE *)  ;
extern int 	feof  (FILE *)  ;
extern void 	clearerr  (FILE *)  ;
extern int 	putchar  (int)  ;
extern int 	getchar  (void)  ;
extern int 	putc  (int, FILE *)  ;
extern int 	getc  (FILE *)  ;
extern int	remove  (const char *)  ;
extern int	rename  (const char *, const char *)  ;
extern FILE 	*tmpfile  (void)  ;
extern char 	*tmpnam  (char *)  ;
extern int 	fclose  (FILE *)  ;
extern int 	fflush  (FILE *)  ;
extern FILE	*fopen  (const char *, const char *)  ;
extern FILE 	*freopen  (const char *, const char *, FILE *)  ;
extern void 	setbuf  (FILE *, char *)  ;
extern int 	setvbuf  (FILE *, char *, int, size_t)  ;
extern int	fprintf  (FILE *, const char *, ...)  ;
extern int	fscanf  (FILE *, const char *, ...)  ;
extern int	printf  (const char *, ...)  ;
extern int	scanf  (const char *, ...)  ;
extern int	sprintf  (char *, const char *, ...)  ;
extern int	sscanf  (const char *, const char *, ...)  ;

extern int  vfprintf  (FILE *, const char *, va_list)  ;
extern int  vprintf  (const char *, va_list)  ;
extern int  vsprintf  (char *, const char *, va_list)  ;
# 201 "/usr/include/stdio.h" 3

extern int 	fgetc  (FILE *)  ;
extern char 	*fgets  (char *, int, FILE *)  ;
extern int 	fputc  (int, FILE *)  ;
extern int 	fputs  (const char *, FILE *)  ;
extern char 	*gets  (char *)  ;
extern int 	puts  (const char *)  ;
extern int	ungetc  (int, FILE *)  ;
extern int	fgetpos  (FILE *, fpos_t *)  ;
extern int 	fseek  (FILE *, long, int)  ;
extern int	fsetpos  (FILE *, const fpos_t *)  ;
extern long	ftell  (FILE *)  ;
extern void	rewind  (FILE *)  ;
extern void 	perror  (const char *)  ;

# 293 "/usr/include/stdio.h" 3

extern int 	fileno  (FILE *)  ;
extern FILE 	*fdopen  (int, const char *)  ;

extern char *cuserid  (char *)  ;

extern char	*ctermid  (char *)  ;
extern int 	getw  (FILE *)  ;
extern int 	pclose  (FILE *)  ;
extern int 	putw  (int, FILE*)  ;
extern FILE 	*popen  (const char *, const char *)  ;
extern char 	*tempnam  (const char*, const char*)  ;

# 1 "/usr/include/sys/limits.h" 1 3

# 1 "/usr/include/machine/machlimits.h" 1 3

# 80 "/usr/include/sys/limits.h" 2 3

# 1 "/usr/include/sys/syslimits.h" 1 3

# 142 "/usr/include/sys/limits.h" 2 3

# 1 "/usr/include/machine/machtime.h" 1 3

# 219 "/usr/include/sys/limits.h" 2 3

# 1 "/usr/include/sys/rt_limits.h" 1 3

# 233 "/usr/include/sys/limits.h" 2 3

# 364 "/usr/include/stdio.h" 2 3

extern void 	setbuffer  (FILE *, char*, int)  ;
extern void 	setlinebuf  (FILE *)  ;

# 441 "/usr/include/stdio.h" 3

# 313 "/usr/chs/ams/include/system.h" 2

# 1 "/usr/include/dirent.h" 1 3

struct  dirent {
        ino_t    d_ino;                
        ushort_t d_reclen;             
        ushort_t d_namlen;             
        char    d_name[256];		 

};

typedef struct {
        int     __dd_fd;         
        long    __dd_loc;        
        long    __dd_size;       
        char    *__dd_buf;       
	int	__dd_bufsiz;
        int     __dd_len;        
        long    __dd_seek;       
	void	*__dd_lock;	 

} DIR;

extern  DIR *opendir  (const char *)  ;
extern  struct dirent *readdir  (DIR *)  ;

extern  int closedir  (DIR *)  ;
extern  void rewinddir  (DIR *)  ;

extern int seekdir  (DIR *, long)  ;

extern long telldir  (DIR *)  ;

# 181 "/usr/include/dirent.h" 3

extern int scandir  (const char *, struct dirent ***,
			int (*)(struct dirent *),  
			int (*)(struct dirent **, struct dirent **))  ;
extern int alphasort  (struct dirent **, struct dirent **)  ;

# 326 "/usr/chs/ams/include/system.h" 2

# 1 "/usr/include/sys/wait.h" 1 3

extern pid_t wait(int *);

extern pid_t waitpid(pid_t , int *, int );

# 1 "/usr/include/sys/param.h" 1 3

# 1 "/usr/include/machine/machparam.h" 1 3

# 1 "/usr/include/machine/endian.h" 1 3

unsigned short	ntohs(unsigned short), htons(unsigned short);
unsigned int	ntohl(unsigned int), htonl(unsigned int);

# 63 "/usr/include/machine/machparam.h" 2 3

typedef long pt_entry_t;

struct kernel_parameters {
	struct vm_parameters {
		long nbpg;
		long pgofset;
		long pgshift;
		long address_mask;
		pt_entry_t * selfmap;
		pt_entry_t * othermap;
		long unity_base;
		long seg1_base;
	} vm;
};

# 154 "/usr/include/machine/machparam.h" 3

# 84 "/usr/include/sys/param.h" 2 3

# 1 "/usr/include/sys/signal.h" 1 3

extern void (*signal(int, void (*)(int)))(int);

extern int raise( int );

typedef int sig_atomic_t;  

# 171 "/usr/include/sys/signal.h" 3

struct sigaction {

	void	(*sa_handler)(int);	 

	sigset_t sa_mask;		 
	int	sa_flags;		 
};

typedef union sigval {
	int 	sival_int;
	void	*sival_ptr;
} sigval_t;

typedef struct sigevent {
	union sigval	sigev_value;	 
	int		sigev_signo;	 
} sigevent_t;

# 270 "/usr/include/sys/signal.h" 3

extern int kill(pid_t , int ); 
extern int sigaction(int , const struct sigaction *, struct sigaction *);
extern int sigprocmask(int , const sigset_t *, sigset_t *);
extern int sigsuspend(const sigset_t *);

extern int sigemptyset(sigset_t *);
extern int sigfillset(sigset_t *);
extern int sigaddset(sigset_t *, int );
extern int sigdelset(sigset_t *, int );
extern int sigismember(const sigset_t *, int );
extern int sigpending(sigset_t *);

extern int sigwait(sigset_t *);

# 312 "/usr/include/sys/signal.h" 3

struct	sigvec {

	void	(*sv_handler)(int);	 

	int     sv_mask;         
	int     sv_flags;    
};                           

extern int sigvec(int, struct sigvec *, struct sigvec *);

# 393 "/usr/include/sys/signal.h" 3

struct  sigstack {
	char	*ss_sp;                  
        int     ss_onstack;              
};

typedef struct  sigaltstack {
        caddr_t	ss_sp;			 
        int     ss_flags;		 
        size_t	ss_size;		 
} stack_t;

struct  sigcontext {

	long    sc_onstack;		 
	long    sc_mask;		 

# 487 "/usr/include/sys/signal.h" 3

# 509 "/usr/include/sys/signal.h" 3

# 538 "/usr/include/sys/signal.h" 3

	long	sc_pc;			 
	long	sc_ps;			 
	long	sc_regs[32];		 
	long	sc_ownedfp;		 
	long	sc_fpregs[32];		 
	unsigned long sc_fpcr;		 
	unsigned long sc_fp_control;	 

	long sc_reserved1;		 
	long sc_reserved2;		 

	size_t	sc_ssize;	 
	caddr_t	sc_sbase;	 
	unsigned long sc_traparg_a0;	 
	unsigned long sc_traparg_a1;	 
	unsigned long sc_traparg_a2;	 
	unsigned long sc_fp_trap_pc;	 
	unsigned long sc_fp_trigger_sum;  
	unsigned long sc_fp_trigger_inst;  

};

# 666 "/usr/include/sys/signal.h" 3

# 695 "/usr/include/sys/signal.h" 3

# 785 "/usr/include/sys/signal.h" 3

extern int sigblock(int);
extern int sigpause(int);
extern int sigreturn(struct sigcontext *);
extern int sigsetmask(int);
extern int sigstack(struct sigstack *, struct sigstack *);
extern int siginterrupt(int, int);

extern void (*sigset(int, void (*)(int)))(int);
extern int sighold(int);
extern int sigrelse(int);
extern int sigignore(int);
extern int sigaltstack(stack_t *, stack_t *);
# 1 "/usr/include/sys/procset.h" 1 3

typedef enum idop {
	POP_DIFF,	 

	POP_AND,	 

	POP_OR,		 

	POP_XOR		 

} idop_t;

typedef enum idtype {
	P_PID,	 
	P_PPID,	 
	P_PGID,	 
	P_SID,	 
	P_CID,	 
	P_UID,	 
	P_GID,	 
	P_ALL	 
} idtype_t;

typedef struct procset {
	idop_t p_op;		 

	idtype_t p_lidtype;	 
	id_t p_lid;		 

	idtype_t p_ridtype;	 
	id_t p_rid;		 
} procset_t;

# 803 "/usr/include/sys/signal.h" 2 3

extern int sigsendset(const procset_t *, int);
extern int sigsend(idtype_t, id_t, int);

# 147 "/usr/include/sys/param.h" 2 3

# 196 "/usr/include/sys/param.h" 3

# 159 "/usr/include/sys/wait.h" 2 3

# 290 "/usr/include/sys/wait.h" 3

# 1 "/usr/include/sys/siginfo.h" 1 3

struct k_siginfo {
	int si_signo;	 
	int si_errno;	 
	int si_code;	 

	union {

		struct {
			pid_t	_pid;			 
			union {

				struct {
					uid_t	_uid;	 
				} _kill;

				struct {
					int	_status;  
					clock_t _utime;
					clock_t _stime;
				} _sigchld;
			} _pinfo;
		} _sigproc;

		struct {
			caddr_t	_addr;	 
		} _sigfault;

		struct {
			long	_band;	 

			int	_fd;	 
		} _sigpoll;
	} _sifields;
};

typedef struct k_siginfo k_siginfo_t;

struct siginfo {
	int si_signo;	 
	int si_errno;	 
	int si_code;	 

	union {
		char _sipad[((128)  - (sizeof(k_siginfo_t) - (3*sizeof(int)))) ];  

		struct {
			pid_t	_pid;			 
			union {

				struct {
					uid_t	_uid;	 
				} _kill;

				struct {
					int	_status;  
					clock_t _utime;
					clock_t _stime;
				} _sigchld;
			} _pinfo;
		} _sigproc;

		struct {
			caddr_t	_addr;	 
		} _sigfault;

		struct {
			long	_band;	 

			int	_fd;	 
		} _sigpoll;
	} _sifields;
};

typedef struct siginfo siginfo_t;

# 329 "/usr/include/sys/siginfo.h" 3

# 293 "/usr/include/sys/wait.h" 2 3

extern int waitid(idtype_t, id_t, siginfo_t *, int);

# 337 "/usr/chs/ams/include/system.h" 2

# 1 "/usr/include/sys/time.h" 1 3

# 82 "/usr/include/sys/time.h" 3

# 1 "/usr/include/time.h" 1 3

struct	tm {			 
        int     tm_sec;          
        int     tm_min;          
        int     tm_hour;         
        int     tm_mday;         
        int     tm_mon;          
        int     tm_year;         
        int     tm_wday;         
        int     tm_yday;         
        int     tm_isdst;        
	long    __tm_gmtoff;
        char    *__tm_zone;
};

# 132 "/usr/include/time.h" 3

extern clock_t 	clock(void);
extern double 	difftime(time_t , time_t );
extern time_t 	mktime(struct tm *);
extern time_t 	time(time_t *);
extern char 	*asctime(const struct tm *);
extern char 	*ctime(const time_t *);
extern struct tm *gmtime(const time_t *);
extern struct tm *localtime(const time_t *);
extern size_t 	strftime(char *, size_t , const char *,const struct tm *);

# 1 "/usr/include/sys/timers.h" 1 3

# 1 "/usr/include/time.h" 1 3

# 268 "/usr/include/time.h" 3

# 45 "/usr/include/sys/timers.h" 2 3

typedef struct timespec {
        time_t  tv_sec;          
        long    tv_nsec;         
} timespec_t;

# 97 "/usr/include/sys/timers.h" 3

struct	itimerspec {
	struct		timespec it_interval;  
	struct		timespec it_value;  
};

# 177 "/usr/include/sys/timers.h" 3

int clock_gettime(int clock_id, struct timespec *tp);
int clock_settime(int clock_id, struct timespec *tp);
int clock_getdrift(int clock_id, int *oppb);
int clock_setdrift(int clock_id, const int ppb, int *oppb);
timer_t timer_create(int clock_id, struct sigevent *evp);
int timer_delete(timer_t timerid);
int timer_gettime(timer_t timerid, struct itimerspec *value);  
int timer_settime(timer_t timerid, int flags, struct itimerspec *value, 
                   struct itimerspec *ovalue); 
int timer_getoverrun(timer_t timerid);
int nanosleep(struct timespec *rqtp, struct timespec *rmtp);

int clock_getres(int clock_id,struct timespec *res);

# 187 "/usr/include/time.h" 2 3

extern char *tzname[];

extern void tzset(void);

extern long timezone;

extern int daylight;

extern char *strptime  (const char *, const char *, struct tm *)  ;

extern unsigned char *NLctime(long *);
extern unsigned char *NLasctime(struct tm *);
extern char *NLstrtime(char *, size_t , const char *, const struct tm *);

# 83 "/usr/include/sys/time.h" 2 3

struct timeval {
	int	tv_sec;		 
	int	tv_usec;	 
};

struct	itimerval {
	struct		timeval it_interval;  
	struct		timeval it_value;  
};

struct timezone {
	int	tz_minuteswest;	 
	int	tz_dsttime;	 
};

extern int adjtime(struct timeval *, struct timeval *);
extern int getitimer(int, struct itimerval *);
extern int setitimer(int, struct itimerval *, struct itimerval *);
extern int gettimeofday(struct timeval *, struct timezone *);
extern int settimeofday(struct timeval *, struct timezone *);
extern int utimes(const char *, struct timeval *);

# 195 "/usr/include/sys/time.h" 3

typedef struct psx4_timer_struct {
        long		psx4t_idx;       
	long		psx4t_tid;	 
	struct itimerval psx4t_timeval;	 
	unsigned int	psx4t_active:1;	 
	unsigned int	psx4t_type:1;    
	unsigned short	psx4t_overrun; 	 
	sigval_t     	psx4t_value;	 
	int		psx4t_signo;	 
	void     	*psx4t_p_proc;	 
} psx4_timer_t;

typedef struct psx4_tblock_struct {
	long		psx4tb_free;	 
	psx4_timer_t 	psx4_timers[32 ];
} psx4_tblock_t;

# 373 "/usr/chs/ams/include/system.h" 2

# 1 "/usr/include/sys/times.h" 1 3

struct tms {
	clock_t	tms_utime;		 
	clock_t	tms_stime;		 
	clock_t	tms_cutime;		 
	clock_t	tms_cstime;		 
};

extern clock_t times(struct tms *);

# 374 "/usr/chs/ams/include/system.h" 2

# 1 "/usr/include/syslog.h" 1 3

# 1 "/usr/include/sys/syslog_pri.h" 1 3

# 111 "/usr/include/sys/syslog_pri.h" 3

# 165 "/usr/include/sys/syslog_pri.h" 3

# 69 "/usr/include/syslog.h" 2 3

# 84 "/usr/include/syslog.h" 3

extern int	openlog  (const char *, int, int)  ;
extern int	syslog  (int, const char *, ...)  ;
extern void	closelog  (void)  ;
extern int	setlogmask  (int)  ;

# 393 "/usr/chs/ams/include/system.h" 2

extern int select(int numfds, fd_set *readset, fd_set *writeset, fd_set *exceptionset, struct timeval *timeout);

# 421 "/usr/chs/ams/include/system.h"

# 1 "/usr/include/signal.h" 1 3

# 815 "/usr/include/signal.h" 3

# 422 "/usr/chs/ams/include/system.h" 2

# 1 "/usr/include/ctype.h" 1 3

extern int	isalpha  (int)  ;
extern int	isalnum  (int)  ;
extern int	iscntrl  (int)  ;
extern int	isdigit  (int)  ;
extern int	isgraph  (int)  ;
extern int	islower  (int)  ;
extern int	isprint  (int)  ;
extern int	ispunct  (int)  ;
extern int	isspace  (int)  ;
extern int	isupper  (int)  ;
extern int	isxdigit  (int)  ;
extern int	toupper  (int)  ;
extern int	tolower  (int)  ;

extern int	isascii  (int)  ;
extern int	toascii  (int)  ;

extern int	(_toupper)  (int)  ;
extern int	(_tolower)  (int)  ;

# 1 "/usr/include/sys/localedef.h" 1 3

typedef struct _LC_charmap_t 	_LC_charmap_t;
typedef struct _LC_monetary_t 	_LC_monetary_t;
typedef struct _LC_numeric_t	_LC_numeric_t;
typedef struct _LC_resp_t	_LC_resp_t;
typedef struct _LC_time_t	_LC_time_t;
typedef struct _LC_collate_t	_LC_collate_t;
typedef struct _LC_ctype_t	_LC_ctype_t;
typedef struct _LC_locale_t	_LC_locale_t;

# 1 "/usr/include/sys/lc_core.h" 1 3

typedef enum __lc_type_id_t {
    _LC_CAR=1,
    _LC_LOCALE=2,
    _LC_CHARMAP=3,
    _LC_CTYPE=4,
    _LC_COLLATE=5,
    _LC_NUMERIC=6,
    _LC_MONETARY=7,
    _LC_TIME=8,
    _LC_RESP=9 } __lc_type_id_t;

typedef struct {

    __lc_type_id_t
	type_id;
    unsigned short
	magic;
    unsigned long
	version;

    unsigned long  size;

} _LC_object_t;

typedef struct {

    _LC_object_t  hdr;

    char     *(*nl_langinfo) ();

    unsigned long   (*mbtowc) ();
    unsigned long   (*mbstowcs) ();
    int      (*wctomb) ();
    unsigned long   (*wcstombs) ();

    int      (*mblen) ();

    unsigned long   (*wcswidth) ();
    unsigned long   (*wcwidth) ();

    int      (*__mbtopc) ();
    int      (*__mbstopcs) ();
    int      (*__pctomb) ();
    int      (*__pcstombs) ();

    _LC_charmap_t *(*init) ();
    void     *data;
} _LC_core_charmap_t;

typedef struct {

    _LC_object_t  hdr; 

    unsigned int  (*towupper) ();
    unsigned int  (*towlower) ();

    unsigned int    (*wctype) ();
    int      (*iswctype) ();

    _LC_ctype_t   *(*init) ();
    void     *data;
} _LC_core_ctype_t;

typedef struct {

    _LC_object_t  hdr;

    int      (*strcoll) ();
    unsigned long   (*strxfrm) ();

    int      (*wcscoll) ();
    unsigned long   (*wcsxfrm) ();

    int      (*fnmatch) ();

    int      (*regcomp) ();
    unsigned long   (*regerror) ();
    int      (*regexec) ();
    void     (*regfree) ();

    _LC_collate_t *(*init) ();
    void     *data;
} _LC_core_collate_t;

struct tm;
typedef struct {

    _LC_object_t  hdr;

    char     *(*nl_langinfo) ();

    unsigned long   (*strftime) ();
    char     *(*strptime) ();

    unsigned long   (*wcsftime) ();

    _LC_time_t    *(*init) ();
    void     *data;
} _LC_core_time_t;

typedef struct {

    _LC_object_t  hdr;

    char     *(*nl_langinfo) ();

    unsigned long   (*strfmon) ();

    _LC_monetary_t        *(*init) ();
    void     *data;
} _LC_core_monetary_t;

typedef struct {

    _LC_object_t  hdr;

    char     *(*nl_langinfo) ();

    _LC_numeric_t *(*init) ();
    void     *data;
} _LC_core_numeric_t;

typedef struct {

    _LC_object_t  hdr;

    char        *(*nl_langinfo) ();

    int		(*rpmatch) ();

    _LC_resp_t    *(*init) ();
    void        *data;
} _LC_core_resp_t;

typedef struct {

    _LC_object_t hdr;

    char         *(*nl_langinfo) ();
    struct lconv * (*localeconv) ();

    _LC_locale_t  *(*init) ();
    void         *data;
} _LC_core_locale_t;

# 79 "/usr/include/sys/localedef.h" 2 3

struct _LC_charmap_t {

    _LC_core_charmap_t core;

    char     *cm_csname;	 

    unsigned long   cm_mb_cur_max;  
    unsigned long   cm_mb_cur_min;  

    unsigned char
	     cm_max_disp_width;  

};

struct _LC_monetary_t {

    _LC_core_monetary_t   core;

    char *int_curr_symbol;	    
    char *currency_symbol;	    
    char *mon_decimal_point;	    
    char *mon_thousands_sep;	    
    char *mon_grouping;		    
    char *positive_sign;	    
    char *negative_sign;	    
    signed  char int_frac_digits;    
    signed  char frac_digits;	    
    signed  char p_cs_precedes;	    
    signed  char p_sep_by_space;	    
    signed  char n_cs_precedes;	    
    signed  char n_sep_by_space;	    
    signed  char p_sign_posn;	    
    signed  char n_sign_posn;	    
    char *debit_sign;		    
    char *credit_sign;		    
    char *left_parenthesis;	    
    char *right_parenthesis;	    

};

struct _LC_numeric_t {

    _LC_core_numeric_t core;

    char     *decimal_point;
    char     *thousands_sep;
    unsigned
	char *grouping;

};

struct _LC_resp_t  {

    _LC_core_resp_t core;

    char    *yesexpr;	      
    char    *noexpr;	      
    char    *yesstr;	      
    char    *nostr;	      

};

struct _LC_time_t {

    _LC_core_time_t core;

    char *d_fmt;  
    char *t_fmt;  
    char *d_t_fmt;
    char *t_fmt_ampm;
    char *abday[7];  
    char *day[7];    
    char *abmon[12];  
    char *mon[12];    
    char *am_pm[2];
    char **era;			 
    char *era_year;
    char *era_d_fmt;
    char *alt_digits;
    char *m_d_recent;		 
    char *m_d_old;		 
    char *era_d_t_fmt;
    char *era_t_fmt;
};

typedef union {
    unsigned int n[(sizeof(unsigned int *)/sizeof(unsigned int)) ];

    const  unsigned int       
	  *p;	        
} _LC_weight_t;    

typedef struct {

    const  char         *ce_sym;  
    _LC_weight_t ce_wgt;	 

} _LC_collel_t;

typedef struct {
    _LC_weight_t   ct_wgt;     

    const  _LC_collel_t   *ct_collel; 

} _LC_coltbl_t;

typedef struct {

    _LC_weight_t ss_act;	 

    const  char *ss_src;	 
    const  char *ss_tgt;	 

} _LC_subs_t;

struct _LC_collate_t {

    _LC_core_collate_t core;

    unsigned			             
	char    co_nord;	             

    _LC_weight_t co_sort;	             

    unsigned int     co_wc_min;		     
    unsigned int     co_wc_max;		     
    unsigned int     co_hbound;		     

    unsigned int     co_col_min;	     
    unsigned int     co_col_max;	     

    const  _LC_coltbl_t *co_coltbl; 	     

    unsigned
	char    co_nsubs;		     
    const  _LC_subs_t  *co_subs; 	     

};

typedef struct {

    char    *name;
    unsigned
	int mask;

} _LC_classnm_t;

struct _LC_ctype_t {

  _LC_core_ctype_t core;

  unsigned int      min_wc;
  unsigned int      max_wc;

  unsigned int      max_upper;	 
  unsigned int      max_lower;	 

  const  unsigned int      *_upper;	 
  const  unsigned int      *_lower;	 

  const  unsigned
      int      *_mask;        
  const  unsigned
      int      *qmask;	      
  const  unsigned
      char     *qidx;	      

  unsigned int	qidx_hbound;	 

  unsigned
      char     nclasses;
 const  _LC_classnm_t *classnms;

};

struct _LC_locale_t {

    _LC_core_locale_t core;
    char           *nl_info[55 ];     

    struct lconv   *nl_lconv;

    _LC_charmap_t  *lc_charmap;
    _LC_collate_t  *lc_collate;
    _LC_ctype_t    *lc_ctype;
    _LC_monetary_t *lc_monetary;
    _LC_numeric_t  *lc_numeric;
    _LC_resp_t     *lc_resp;
    _LC_time_t     *lc_time;
    char	   *nl_info2[61  - 55 ];
};

extern _LC_charmap_t  *__lc_charmap;
extern _LC_collate_t  *__lc_collate;
extern _LC_ctype_t    *__lc_ctype;
extern _LC_monetary_t *__lc_monetary;
extern _LC_numeric_t  *__lc_numeric;
extern _LC_resp_t     *__lc_resp;
extern _LC_time_t     *__lc_time;
extern _LC_locale_t   *__lc_locale;

# 114 "/usr/include/ctype.h" 2 3

# 435 "/usr/chs/ams/include/system.h" 2

# 1 "/usr/include/fcntl.h" 1 3

# 1 "/usr/include/sys/fcntl.h" 1 3

struct  flock   {
        short   l_type;
        short   l_whence;
        off_t   l_start;
        off_t   l_len;           
        pid_t   l_pid;
};

extern int open(const char *, int , ...);
extern int creat(const char *, mode_t );
extern int fcntl(int , int ,...);

# 164 "/usr/include/sys/fcntl.h" 3

struct eflock {
        short   l_type;          
        short   l_whence;        
        off_t   l_start;         
        off_t   l_len;           
        pid_t	l_pid;           
        pid_t	l_rpid;          
        int     l_rsys;          
	short   l_xxx;		 
        int     l_cb;            
};

# 42 "/usr/include/fcntl.h" 2 3

# 462 "/usr/chs/ams/include/system.h" 2

# 487 "/usr/chs/ams/include/system.h"

struct osi_Times {unsigned long int Secs; unsigned long int USecs;};

extern int osi_GetTimes(struct osi_Times *p);

extern char *getwd(char *pbuf);

# 1 "/usr/chs/ams/include/site.h" 1

# 572 "/usr/chs/ams/include/system.h" 2

# 72 "/usr/chs/ams/include/andrewos.h" 2

# 83 "malloc.ci" 2

# 1 "./amalloc.h" 1

# 114 "./amalloc.h"

# 85 "malloc.ci" 2

# 1 "./imalloc.h" 1

struct hdr {
	int padding[(8  - 4 %8 ) / 4 ]; 
	int Size;			 

};
struct freehdr {
	int padding[(8  - 4 %8 ) / 4 ]; 
	int Size;			 
	struct freehdr *Next, *Prev;  
};
struct freetrlr {
	struct freehdr *Front;	 
};
struct segtrlr {
	int padding[(8  - 4 %8 ) / 4 ]; 
	int Size;			 
	struct freehdr *Next, *Prev;  
	struct freehdr *Front;	 
};

# 167 "./imalloc.h"

# 86 "malloc.ci" 2

# 1 "./getcallr.h" 1

# 87 "malloc.ci" 2

# 1 "/usr/include/sys/resource.h" 1 3

struct	rusage {
	struct timeval ru_utime;	 
	struct timeval ru_stime;	 
	long	ru_maxrss;

	long	ru_ixrss;		 
	long	ru_idrss;		 
	long	ru_isrss;		 
	long	ru_minflt;		 
	long	ru_majflt;		 
	long	ru_nswap;		 
	long	ru_inblock;		 
	long	ru_oublock;		 
	long	ru_msgsnd;		 
	long	ru_msgrcv;		 
	long	ru_nsignals;		 
	long	ru_nvcsw;		 
	long	ru_nivcsw;		 

};

struct rlimit {
	rlim_t	rlim_cur;		 
	rlim_t	rlim_max;		 
};

struct rusage_dev {
	struct rusage ru_rusage;
	dev_t	      ru_dev;
};

extern int getpriority(int, int);
extern int setpriority(int, int, int);
extern int getrlimit(int, struct rlimit *);
extern int setrlimit(int, struct rlimit *);
extern int getrusage(int, struct rusage *);

# 88 "malloc.ci" 2

static char msgbuf[200];

static CheckLevel;

static int DefaultM0Handler();    
static FlushFree();    
static int TestFree();    
static int TestActive();    
static CheckSegment(); 
static printarena();

static int (*M0Handler)() = DefaultM0Handler;

    static int Nscans, Nrequests, Nsbrk, Ncombines, Nfrees;

static struct arenastate A = {0, 0, 0, 0, 0, 0, 0, 0};

extern char	*sbrk();

static struct freehdr *addarena ();

static
botch(s)
char *s;
{

	char *msg;
	msg = "Malloc arena corruption discovered  at - "; 
	if ((( (&_iob[1])  )->_base) ) fflush((&_iob[1]) );
	if ((( (&_iob[2])  )->_base) ) fflush((&_iob[2]) );
	write(2, msg, strlen(msg));
	if (s) write(2, s, strlen(s));
	write(2, "\n", 1);
	abort();
}

	static long
AllocateInitialArena()
{
	long newsize;
	A.allocp = addarena(1<<15);     
	if (A.allocp == 0) {
		newsize = M0Handler(1<<15);
		if (newsize == 0)  return 0;
		A.allocp = addarena(newsize);
		return (A.allocp == 0) ? 0 : 1;
	}
	return 1;
}

	char *

 malloc  (nbytes)
unsigned nbytes;
{
	register siz;	 
	register struct freehdr *p, *t;
	register struct freehdr *prep = 0;    

	char *return_address;
	{ register char **addrloc; addrloc = (((char **)& nbytes ) - (1) );   return_address  = *addrloc; } ;

	if (A.allocp==0 && AllocateInitialArena() == 0)
		return 0;

	if (A.InProgress++) {
		botch("Program error.  Tried 'malloc' while in malloc package.");
		A.InProgress--;
		p = prep;		 
		return 0;
	}
	while (A.NQueued) 
		FlushFree(A.QueuedToFree[--A.NQueued]);

Nrequests++;

	if (CheckLevel > 0) {
		if (CheckLevel>=3) CheckAllocs("in Malloc");
		else if(!(  TestFree(A.allocp) ))botch( "m0" );else ;
	}

	siz = (nbytes+sizeof(struct hdr)+(8 -1))/8 *8 ;
	if (siz<((sizeof(struct freehdr)+sizeof(struct freetrlr)+(8 -1))/8 *8 ) ) siz = ((sizeof(struct freehdr)+sizeof(struct freetrlr)+(8 -1))/8 *8 ) ;
	t = A.allocp->Prev;

	if (CheckLevel!=2)  for (p=A.allocp; 

Nscans++,

			p!=t && p->Size<siz; 
			prep = p, p = p->Next) {

	}
	else    for (p=A.allocp;       

Nscans++,

			p!=t && p->Size<siz; 
			prep = p, p = p->Next) {
		if ((( p->Size )&(~0x1 )&(~0x2 )) ) {
			if(!(  ! (( p->Size )&( 0x1  ))  ))botch( "m1" );else ;
			if(!(  p == ((((struct freetrlr *)( ((struct freehdr *)((int ) p +((  p ->Size )&(~0x1 )&(~0x2 )) ))  ))-1)->Front)  ))botch( "m2" );else ;
		}
		else 
			if(!(  (( p->Size )&(  0x1  ))  ))botch( "m3" );else ;
		if(!(  p->Next->Prev==p ))botch( "m4" );else ;
	}
	if (p->Size < siz) {
		p = addarena(siz);
		if (p == 0L ) {
			if (A.RecurringM0) {
				A.InProgress = 0;
				DefaultM0Handler(nbytes);
				return 0;
			}
			else {
				char *v;
				int (*h)() = M0Handler;
				int newsize;
				A.InProgress--;
				newsize = M0Handler(nbytes);

				if (h == M0Handler)
					A.RecurringM0 ++;
				if(newsize > 0)
					v = malloc(newsize);
				else
					v = 0L ;
				A.RecurringM0 = 0;

				return v;
			}
		}
	}

	if (CheckLevel > 0)  
		if(!(  TestFree(p) ))botch( "m10" );else ;

	if ((( p->Size )&(~0x1 )&(~0x2 )) -siz < ((sizeof(struct freehdr)+sizeof(struct freetrlr)+(8 -1))/8 *8 ) ) {

		A.allocp = p->Next;
		p->Next->Prev = p->Prev;
		p->Prev->Next = p->Next;
		p->Size |= 0x1 ;
	}
	else if (A.MallocStrategy & AllocFront) {

		register oldsize = p->Size;

		p->Size = (( siz )|(  0x1  | (( p->Size )&(  0x2  ))  )) ;

		t = ((struct freehdr *)((int ) p +((  p ->Size )&(~0x1 )&(~0x2 )) )) ;
		t->Size = oldsize - siz;	 
		t->Next = p->Next;
		t->Prev = p->Prev;
		((((struct freetrlr *)( ((struct freehdr *)((int ) t +((  t ->Size )&(~0x1 )&(~0x2 )) ))  ))-1)->Front)  = t;

		t->Next->Prev = t;
		t->Prev->Next = t;
		if ((A.MallocStrategy & (DelayAdvance | AdvanceKludge)) == 0)
			A.allocp = t->Next;
		else if (A.MallocStrategy & AdvanceKludge) 
			A.allocp = (t->Size < t->Next->Size) ? t->Next : t;
		else   
			A.allocp = t;
	}
	else {

		p->Size -= siz;    
		if ((A.MallocStrategy & (DelayAdvance | AdvanceKludge)) == 0)
			A.allocp = p->Next;
		else if (A.MallocStrategy & AdvanceKludge) 
			A.allocp = (p->Size < p->Next->Size) ? p->Next : p;
		else   
			A.allocp = p;
		t = ((struct freehdr *)((int ) p +((  p ->Size )&(~0x1 )&(~0x2 )) )) ;
		((((struct freetrlr *)( t ))-1)->Front)  = p;
		p = t;
		p->Size = siz | 0x1 ;
	}

	p->Next = 0;
	p->Prev = 0;
	t = ((struct freehdr *)((int ) p +((  p ->Size )&(~0x1 )&(~0x2 )) )) ;
	((((struct freetrlr *)( t ))-1)->Front)  = 0;

	t->Size |= 0x2 ;

	A.InProgress --;

	if (CheckLevel >=4) 
		{sprintf(msgbuf,  "malloc @ 0x%lx for %d bytes returns 0x%lx\n" ,  
			return_address ,   nbytes ,   ((char *)p) + sizeof(struct hdr) ); write(2, msgbuf, strlen(msgbuf));} ;

	return ((char *)p) + sizeof(struct hdr);
}

static
struct freehdr *
addarena (min) {
	register struct freehdr *new, *trlr;
	struct freehdr *t;
	int segbytes;
	int x;

	if (min < 1<<14) min = 1<<14;
	x = (A.arenaend - A.arenastart)>>3;
	if (A.allocp != 0 && min < x) min = x;

	segbytes = ((min+2*((sizeof(struct freehdr)+sizeof(struct freetrlr)+(8 -1))/8 *8 ) +(4096 -1)) 
			/ 4096 ) * 4096 ;

Nsbrk++;

	new = (struct freehdr *)sbrk(segbytes);
	if((int )new == -1) 
		return(0L );
	if ((x=(int )new % 8 )) {

		new = (struct freehdr *)((int )new+8 -x);
		sbrk(8 -x);
	}
	trlr = (struct freehdr *)((int )new+segbytes- ((sizeof(struct freehdr)+sizeof(struct freetrlr)+(8 -1))/8 *8 ) );
	new->Size = (( segbytes - ((sizeof(struct freehdr)+sizeof(struct freetrlr)+(8 -1))/8 *8 )  )|(  0x2  )) ;
	new->Next = trlr;
	trlr->Size = (( 0 )|(  0x1  )) ;
	trlr->Prev = new;
	((((struct freetrlr *)( trlr ))-1)->Front)  = new;

	((((struct freetrlr *)( ((char *)trlr)+((sizeof(struct freehdr)+sizeof(struct freetrlr)+(8 -1))/8 *8 )  ))-1)->Front)  = new;

	if (A.arenaend) {

		new->Prev = A.arenaend;
		trlr->Next = A.arenaend->Next;
		A.arenaend->Next->Prev = trlr;
		A.arenaend->Next = new;
	}
	else {
		A.arenastart = new;
		trlr->Next = new;
		new->Prev = trlr;
	}
	if (new == (struct freehdr *)(((char *)A.arenaend)+((sizeof(struct freehdr)+sizeof(struct freetrlr)+(8 -1))/8 *8 ) )) {

		((((struct freetrlr *)( ((char *)trlr)+((sizeof(struct freehdr)+sizeof(struct freetrlr)+(8 -1))/8 *8 )  ))-1)->Front)  =
			((((struct freetrlr *)( ((char *)A.arenaend)+((sizeof(struct freehdr)+sizeof(struct freetrlr)+(8 -1))/8 *8 )  ))-1)->Front) ;
		t = A.arenaend;
		t->Size = (( ((sizeof(struct freehdr)+sizeof(struct freetrlr)+(8 -1))/8 *8 )  )|(  
				(( t->Size )&(  0x2  )) 
				| 0x1  )) ;
		t->Next->Prev = t->Prev;
		t->Prev->Next = t->Next;
		if (A.allocp==t)
			A.allocp = t->Next;
		A.arenaend = trlr;
		FlushFree((char *)t+sizeof (struct hdr));
	}
	else
		A.arenaend = trlr;
	if (CheckLevel>=5) 
		printarena("addarena");
	return (((((struct freetrlr *)( A.arenaend ))-1)->Front) );
}

    void
 free  (ap)
	struct hdr *ap;
{
	register struct freehdr *f = (struct freehdr *)(((char *)ap) - sizeof(struct hdr));
	register struct freehdr *t;

	char *return_address;
	{ register char **addrloc; addrloc = (((char **)& ap ) - (1) );   return_address  = *addrloc; } ;

	if (A.allocp == 0 || ap == 0L  || f < A.arenastart) {
		if (CheckLevel >= 4) 
			{sprintf(msgbuf,  "free @ 0x%lx for NULL\n" ,   return_address ); write(2, msgbuf, strlen(msgbuf));} ;
		return;
	}

	if (CheckLevel >= 4) 
		{sprintf(msgbuf,  "free @ 0x%lx for block of %d bytes at 0x%lx enqueued\n" ,  
			return_address ,   (( f->Size )&(~0x1 )&(~0x2 ))  ,   ap ); write(2, msgbuf, strlen(msgbuf));} ;
	t = ((struct freehdr *)((int ) f +((  f ->Size )&(~0x1 )&(~0x2 )) )) ;
	if (t > A.arenaend) 	return;

		if(!(  (((long)f)&(8 -1)) == 0 ))botch( "fa" );else ;

		if(!(  (( f->Size )&(  0x1  ))  ))botch( "fr" );else ;
	if (A.InProgress++) {
		botch ("Program error.  Tried 'free' while in malloc package.");
	}

	if (A.NQueued == MAXQUEUE) {

		FlushFree(A.QueuedToFree[0]);

			{register i;
				for (i = 1; i < MAXQUEUE; i++)
					A.QueuedToFree[i-1] 
						= A.QueuedToFree[i];
			}

		A.QueuedToFree[MAXQUEUE - 1] = ap;
	}
	else 
		A.QueuedToFree[A.NQueued++] = ap;

	A.InProgress -- ;
}

static
FlushFree(ap)
struct hdr *ap;
{
	register struct freehdr *p = (struct freehdr *)(((char *)ap) - sizeof(struct hdr));
	register struct freehdr *t = ((struct freehdr *)((int ) p +((  p ->Size )&(~0x1 )&(~0x2 )) )) ;
	register int siz = (( p->Size )&(~0x1 )&(~0x2 )) ;   
	int preact = (( p->Size )&(  0x2  )) ;  

Nfrees++;

	if (CheckLevel > 0) {
		if(!(  TestActive(p) ))botch( "F0" );else ;
		if (CheckLevel >= 3) CheckAllocs("in free");
		else {
			register s = t->Size;
			if(!(  TestFree(A.allocp) ))botch( "F1" );else ;
			if ( 
					(!(( s )&(  0x1  )) )
					 || (( s )&(~0x1 )&(~0x2 ))  == 0) 
				if(!(  TestFree(t) ))botch( "F2" );else ;
			else if(!(  TestActive(t) ))botch( "F3" );else ;
			if (!preact) 
				if(!(  TestFree(((((struct freetrlr *)( p ))-1)->Front) ) ))botch( "F4" );else ;
		}
	}

	if (!(( t->Size )&(  0x1  )) ) {  

Ncombines++;

		t->Next->Prev = t->Prev;
		t->Prev->Next = t->Next;
		if (t==A.allocp) 
			A.allocp = t->Next;
		siz += (( t->Size )&(~0x1 )&(~0x2 )) ;
	}
	else 
		t->Size = (( t->Size )&~(  0x2  )) ;

	if (!preact) {

Ncombines++;

		t = ((((struct freetrlr *)( p ))-1)->Front) ;
		preact = (( t->Size )&(  0x2  )) ;
		siz += (( t->Size )&(~0x1 )&(~0x2 )) ;
		p->Size = 0;   
		p = t;
	}
	else {

		p->Prev = A.allocp->Prev;
		p->Next = A.allocp;
		p->Prev->Next = A.allocp->Prev = p;
	}

	p->Size = (( siz )|(  preact )) ;
	((((struct freetrlr *)( (char *)p + siz ))-1)->Front)  = p;
}

	char *

 realloc  (ap, nbytes)
struct hdr *ap;			 
unsigned nbytes;			 
{
	register struct freehdr *h;
	struct freehdr *f;
	unsigned siz;		 
	unsigned newsz;		 
	unsigned oldsz;		 
	char *msg;		 

	char *return_address;
	{ register char **addrloc; addrloc = (((char **)& ap ) - (1) );   return_address  = *addrloc; } ;

	if (ap == 0L ) {
		if (CheckLevel>=4) 
			{sprintf(msgbuf,  "realloc @ 0x%lx for NULL block . . .\n" ,   return_address ); write(2, msgbuf, strlen(msgbuf));} ;
		ap = (struct hdr *)malloc(nbytes);
		if (ap==0L )
			{msg = "rx0"; goto nope;}

		return((char *)ap);
	}

	h = (struct freehdr *)(((char *)ap) - sizeof(struct hdr));
	f = ((struct freehdr *)((int ) h +((  h ->Size )&(~0x1 )&(~0x2 )) )) ;

	if (A.InProgress++) {
		botch ("Program error.  Tried 'realloc' while in malloc package.");
		A.InProgress--;
		return 0;
	}
	if (CheckLevel>=4) 
		{sprintf(msgbuf,  "realloc @ 0x%lx changes size %d at 0x%lx . . .\n" ,  
			return_address ,   (( h->Size )&(~0x1 )&(~0x2 ))  ,   ap ); write(2, msgbuf, strlen(msgbuf));} ;
	{register struct hdr **fp = &A.QueuedToFree[A.NQueued-1];
		for ( ; fp >= A.QueuedToFree;  fp--)
			if (*fp != ap)
				FlushFree(*fp);
	}
	A.NQueued = 0;

	if (! TestActive(h)) {
		msg = "rx1";   goto nope;
	}
	if (CheckLevel > 0) {
		if (CheckLevel>=3) CheckAllocs("in realloc");
		if (!(( f->Size )&(  0x1  )) )
			if(!(  TestFree(f) ))botch( "r0" );else ;
		if(!(  TestFree(A.allocp) ))botch( "r1" );else ;
	}
	siz = (nbytes+sizeof(struct hdr)+(8 -1))/8 *8 ;
	if (siz<((sizeof(struct freehdr)+sizeof(struct freetrlr)+(8 -1))/8 *8 ) ) siz = ((sizeof(struct freehdr)+sizeof(struct freetrlr)+(8 -1))/8 *8 ) ;
	if (!(( f->Size )&(  0x1  ))  
			&& (( h->Size )&(~0x1 )&(~0x2 )) +(( f->Size )&(~0x1 )&(~0x2 ))  >= siz) {

		f->Next->Prev = f->Prev;
		f->Prev->Next = f->Next;
		if (f==A.allocp) 
			A.allocp = f->Next;
		h->Size += (( f->Size )&(~0x1 )&(~0x2 )) ;    
		f = ((struct freehdr *)((int ) h +((  h ->Size )&(~0x1 )&(~0x2 )) )) ;
		f->Size = (( f->Size )|(  0x2  )) ;
	}

	A.InProgress --;

	newsz = (siz - sizeof(struct hdr));
	oldsz = ((( h->Size )&(~0x1 )&(~0x2 )) -sizeof(struct hdr));
	if (newsz <= oldsz) {

		if (oldsz-newsz>((sizeof(struct freehdr)+sizeof(struct freetrlr)+(8 -1))/8 *8 ) ) {
			h->Size = (( siz )|(  
				0x1  | (( h->Size )&(  0x2  ))  )) ;
			f = ((struct freehdr *)((int ) h +((  h ->Size )&(~0x1 )&(~0x2 )) )) ;
			f->Size = (( oldsz-newsz )|(  0x1  | 0x2  )) ;
			A.QueuedToFree[A.NQueued++] = ((struct hdr *)f) + 1;
		}
	}
	else {

		struct hdr *oldap = ap;
		ap = (struct hdr *)malloc(nbytes);    
		if (ap==0L )
			{msg = "rx5"; goto nope;}
		A.QueuedToFree[A.NQueued++] = oldap;
		bcopy((char *)oldap, (char *)ap, oldsz);
	}
	if (CheckLevel >= 4) 
		{sprintf(msgbuf,  ". . . to size %d at 0x%lx\n" ,   nbytes ,   ap ); write(2, msgbuf, strlen(msgbuf));} ;

	return((char *)ap);

nope:	if (CheckLevel>=4)
		{sprintf(msgbuf,  ". . . fails at %s\n" ,   msg ); write(2, msgbuf, strlen(msgbuf));} ;
	A.InProgress--;
	return 0L ;
}

    static int
TestFree (f)
    register struct freehdr *f;
{
	if ((( f->Size )&( 0x1  )) ) {

		register struct freehdr *t 
			= ((((struct freetrlr *)( (struct hdr *)(((char *)f)+((sizeof(struct freehdr)+sizeof(struct freetrlr)+(8 -1))/8 *8 ) ) ))-1)->Front) ;
		return ((((long)f)&(8 -1)) == 0
			&& f->Next->Prev == f
			&& f->Prev->Next == f
			&& (( t->Size )&(  0x2  )) 
			&& (( f->Size )&(~0x1 )&(~0x2 ))  == 0
			&& t < f
			&& (A.arenahasbeenreset 
				|| (f <= A.arenaend && t >= A.arenastart)));
	}
	else {

		register struct freehdr *t = ((struct freehdr *)((int ) f +((  f ->Size )&(~0x1 )&(~0x2 )) )) ;
		return ((((long)f)&(8 -1)) == 0
			&& f->Next->Prev == f
			&& f->Prev->Next == f
			&& (( f->Size )&(  0x2  )) 
			&& f == ((((struct freetrlr *)( t ))-1)->Front) 
			&& ! (( t->Size )&(  0x2  )) 
			&& f->Size >= ((sizeof(struct freehdr)+sizeof(struct freetrlr)+(8 -1))/8 *8 ) 
			&& (A.arenahasbeenreset 
				|| (t <= A.arenaend && f >= A.arenastart)));
	}
}

    static int
TestActive (f) 
    register struct freehdr *f;
{
	register struct freehdr *t = ((struct freehdr *)((int ) f +((  f ->Size )&(~0x1 )&(~0x2 )) )) ;
	return    (((long)f)&(8 -1)) == 0
		&& (( f->Size )&(  0x1  )) 
		&& f->Size > ((sizeof(struct freehdr)+sizeof(struct freetrlr)+(8 -1))/8 *8 ) 
		&& (A.arenahasbeenreset 
			|| (f >= A.arenastart
				&& t <= A.arenaend 
				&& (( t->Size )&(  0x2  )) 
		)	);
}

    static
printarena (m)
    char *m;
{
	int *x;
	int i;
	{sprintf(msgbuf,  "%s:  arenastart %lx  arenaend %lx  allocp %lx\narena starts with" ,   
			m ,   A.arenastart ,   A.arenaend ,   A.allocp ); write(2, msgbuf, strlen(msgbuf));} ;
	for (x = (int *)A.arenastart, i=0; i < ((sizeof(struct freehdr)+sizeof(struct freetrlr)+(8 -1))/8 *8 ) /8 ; i++)
		{sprintf(msgbuf,  "   %lx" ,   *(x+i) ); write(2, msgbuf, strlen(msgbuf));} ;
	{sprintf(msgbuf,  "\nand ends with" ); write(2, msgbuf, strlen(msgbuf));} ;
	for (x = (int *)A.arenaend- ((sizeof(struct freehdr)+sizeof(struct freetrlr)+(8 -1))/8 *8 ) , i = 0; i < ((sizeof(struct freehdr)+sizeof(struct freetrlr)+(8 -1))/8 *8 ) /8 ; i++)
		{sprintf(msgbuf,  "   %lx" ,   *(x+i) ); write(2, msgbuf, strlen(msgbuf));} ;
	{sprintf(msgbuf,  "\n" ); write(2, msgbuf, strlen(msgbuf));} ;
}

static int Nactive, Nfree, Nsegs;
static long int TotActive, TotFree;
static DumpBlocks = 0;

	long
CheckAllocs(m) char *m;
{
	int nfree=0;
	register struct freehdr *t;
	if (A.allocp==0 && AllocateInitialArena() == 0)
		return 0;

	Nactive = Nfree = Nsegs = 0;
	TotActive = TotFree = 0;
	if (DumpBlocks) {
		register struct freehdr *a, *olda;
		printarena(m);

		{sprintf(msgbuf,  "\n     Front;        loc:       Size       Next      Prev\n" ); write(2, msgbuf, strlen(msgbuf));} ;

		for (a = A.arenastart, olda = 0; 
				a>olda && a < A.arenaend; 
				a = (struct freehdr *)((char *)(olda=a) + (( a->Size )&(~0x1 )&(~0x2 )) ) ) {
			{sprintf(msgbuf,  "%10lx; %10lx: %10lx " ,   
				(((struct freetrlr *)a)-1)->Front ,   a ,  a->Size ); write(2, msgbuf, strlen(msgbuf));} ;

			{sprintf(msgbuf,  "%10lx %10lx\n" ,   a->Next ,   a->Prev ); write(2, msgbuf, strlen(msgbuf));} ;
		}
		if (a<=olda) {sprintf(msgbuf,  "Illegal pointer %lx\n" ,   a ); write(2, msgbuf, strlen(msgbuf));} ;
	}

	t = A.allocp;
	do {
		nfree++;
		if(!(  t->Next->Prev==t ))botch( "c1" );else ;
		if ((( t->Size )&(  0x1  )) ) {

			struct hdr *nextblk
				= (struct hdr *)(((char *)t)+((sizeof(struct freehdr)+sizeof(struct freetrlr)+(8 -1))/8 *8 ) );
			if(!(  (( t->Size )&(~0x1 )&(~0x2 )) ==0 ))botch( "c2" );else ;

			if(!(  (((int )(nextblk))-(int )((((struct freetrlr *)( nextblk ))-1)->Front) )
						 % 4096  == 0 ))botch( "c3" );else ;
			nfree -= (CheckSegment(m, ((((struct freetrlr *)( nextblk ))-1)->Front) , t));
		}
		else 
			if(!(  t==((((struct freetrlr *)( ((struct freehdr *)((int ) t +((  t ->Size )&(~0x1 )&(~0x2 )) ))  ))-1)->Front)  ))botch( "c4" );else ;
		t = t->Next;
	} while (t!=A.allocp);
	if(!(  nfree==0 ))botch( "c5" );else ;

return(TotFree+1);    

}
static CheckSegment(m, f, t) 
char *m;  
register struct freehdr *f, *t; 
{
	register int nfree = 1;   
	register int wasactive = 0x2 ;   
	register struct freehdr *pref, *prepref=0;   

Nsegs++;

	pref = prepref;   
	for (; f<t; prepref = pref, pref = f, 
			f = (struct freehdr *)((char *)f 
				+ (( f->Size )&(~0x1 )&(~0x2 )) )) {
		if(!(  (( f->Size )&(~0x1 )&(~0x2 )) >0 ))botch( "s1" );else ;
		if(!(  wasactive==(( f->Size )&(  0x2  ))  ))botch( "s2" );else ;
		if (!(( f->Size )&(  0x1  )) ) 
			nfree++, wasactive=0;
		else 
			wasactive = 0x2 ;

		if (!(( f->Size )&(  0x1  )) ) {
			Nfree++;
			TotFree += (( f->Size )&(~0x1 )&(~0x2 )) ;
		}
		else {
			Nactive++;
			TotActive += (( f->Size )&(~0x1 )&(~0x2 )) ;
		}

	}
	if(!(  f==t ))botch( "s3" );else ;
	return nfree;
}

	void
mstats (m) char *m; 
{
    MallocStats(m, (&_iob[2]) );
}
	void
MallocStats(m, f) char *m; FILE *f;
{
	double TotSpace;
	long int TotHdrs;
	int ActHdrs;
	int fd = ((  f  )->_file)  ;

	fflush(f);
	{sprintf(msgbuf,  "\nmstats - %s\n" ,   m ,   0 ,   0 ,   0 ); write(fd, msgbuf, strlen(msgbuf));} ;

	if (CheckLevel>=5) DumpBlocks=1;
	CheckAllocs("");   
	DumpBlocks = 0;
	TotSpace = TotActive + TotFree + Nsegs*((sizeof(struct freehdr)+sizeof(struct freetrlr)+(8 -1))/8 *8 ) ;
	ActHdrs = Nactive*sizeof(struct hdr);
	TotActive -= ActHdrs;
	TotHdrs = ActHdrs + Nsegs*((sizeof(struct freehdr)+sizeof(struct freetrlr)+(8 -1))/8 *8 ) ;

	{sprintf(msgbuf,  "%-10s%10s%10s%10s\n" ,   "" ,   "Active" ,   "Free" ,   "Segments" ); write(fd, msgbuf, strlen(msgbuf));} ;
	{sprintf(msgbuf,  "%-10s%10d%10d%10d\n" ,   "requests" ,   Nrequests ,   Nfrees ,   Nsbrk ); write(fd, msgbuf, strlen(msgbuf));} ;
	{sprintf(msgbuf,  "%-10s%10d%10d%10d\n" ,   "current" ,   Nactive ,   Nfree ,   Nsegs ); write(fd, msgbuf, strlen(msgbuf));} ;
	{sprintf(msgbuf,  "%-10s%10d%10d%10d\n" ,  
		"avg size" ,   (Nactive ? TotActive/Nactive : 0) ,   
		(Nfree ? TotFree/Nfree : 0) ,   
		(int)(TotSpace/Nsegs)  ); write(fd, msgbuf, strlen(msgbuf));} ;
	{sprintf(msgbuf,  "%-10s%10.1f%10.3f\n" ,  
		"avg ops" ,   
		(Nrequests ? ((float)Nscans)/Nrequests : 0) ,  
		(Nfrees ? ((float)Ncombines)/Nfrees : 0) ,   0 ); write(fd, msgbuf, strlen(msgbuf));} ; 
	{sprintf(msgbuf,  "%-10s%9.1f%%%9.1f%%\n" ,  
		"% space" ,   
		100.0*TotActive/TotSpace ,  
		100.0*TotFree/TotSpace ,   0 ); write(fd, msgbuf, strlen(msgbuf));} ;
	{sprintf(msgbuf,  "%s %d   %s%5.1f%%\n\n" ,  
		"total space" ,   (int)TotSpace ,   
		"headers" ,   100.0*TotHdrs/TotSpace ); write(fd, msgbuf, strlen(msgbuf));} ;

}
	void
resetmstats() {
    Nscans = Nrequests = Nsbrk = Ncombines = Nfrees = 0;
}

int  (*
SetM0Handler (p))() int (*p)(); {
    int (*t)() = M0Handler;
    M0Handler = (p==0) ? DefaultM0Handler : p;
    return t;
}

static 	void AbortFullMessage (unsigned int nbytes);

static int DefaultM0Handler (size) {
	AbortFullMessage(size);
	return (0);
}

SetMallocCheckLevel (level) int level; {
	int old = CheckLevel;
	CheckLevel = level;
	return old;
}

	void
NewMallocArena() {
	A.arenastart = A.arenaend = A.allocp = 0;
	A.NQueued = 0;
	A.InProgress = A.RecurringM0 = 0;
	A.arenahasbeenreset++;

}

    struct arenastate *
GetMallocArena () 
{
	return (&A);
}

    int
MallocStrategy(new)
    int new;
{
	char ret = A.MallocStrategy;
	A.MallocStrategy = new;
	return ret;
}

static 	void
AbortFullMessage (nbytes) register unsigned int nbytes; {
	register siz, segbytes;
	char buf[200];

	siz = (nbytes+sizeof(struct hdr)+(8 -1))/8 *8 ;
	if (siz<((sizeof(struct freehdr)+sizeof(struct freetrlr)+(8 -1))/8 *8 ) ) siz = ((sizeof(struct freehdr)+sizeof(struct freetrlr)+(8 -1))/8 *8 ) ;
	segbytes = ((siz+2*((sizeof(struct freehdr)+sizeof(struct freetrlr)+(8 -1))/8 *8 ) +(4096 -1)) 
			/ 4096 ) * 4096 ;

	sprintf(buf, "Malloc abort.  Attempt to allocate %d bytes would cause arena (now having %d bytes) to exceed the currently available swap space.\n",
			nbytes, (A.arenaend - A.arenastart + 1) * sizeof(*A.arenaend));
	if ((( (&_iob[1])  )->_base) ) fflush((&_iob[1]) );
	if ((( (&_iob[2])  )->_base) ) fflush((&_iob[2]) );
	write(2, buf, strlen(buf));
}

int realloc_srchlen = 0;
void morecore() {}

	struct mallinfo __mallinfo = {
		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,			 
		0 ,  100 ,  8  ,   
		0, 0, 0
	};
	char	*_root = 0L ;		 
	char	*_lbound = 0L ;		 
	char	*_ubound = 0L ;	 

    char *
_malloc_at_addr(addr, nbytes)
	char *addr;
	unsigned nbytes;
{
	return(0L );
}

# 1186 "malloc.ci"

# 7 "malloc.c" 2
