# 1 "error.c"
static const char FN[] = "error.c";

# 1 "lic.h" 1


 
 























































# 1 "c:/djgpp/include/malloc.h" 1 3
 













# 1 "c:/djgpp/include/stdlib.h" 1 3
 
 
 









# 1 "c:/djgpp/include/sys/djtypes.h" 1 3
 
 
 

















 






# 13 "c:/djgpp/include/stdlib.h" 2 3

  
 








extern int __dj_mb_cur_max;

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

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

typedef long unsigned int size_t; 


typedef unsigned short wchar_t; 



void	abort(void) __attribute__((noreturn));
int	abs(int _i);
int	atexit(void (*_func)(void));
double	atof(const char *_s);
int	atoi(const char *_s);
long	atol(const char *_s);
void *	bsearch(const void *_key, const void *_base, size_t _nelem,
		size_t _size, int (*_cmp)(const void *_ck, const void *_ce));
void *	calloc(size_t _nelem, size_t _size);
div_t	div(int _numer, int _denom);
void	exit(int _status) __attribute__((noreturn));
void	free(void *_ptr);
char *	getenv(const char *_name);
long	labs(long _i);
ldiv_t	ldiv(long _numer, long _denom);
void *	malloc(size_t _size);
int	mblen(const char *_s, size_t _n);
size_t	mbstowcs(wchar_t *_wcs, const char *_s, size_t _n);
int	mbtowc(wchar_t *_pwc, const char *_s, size_t _n);
void	qsort(void *_base, size_t _nelem, size_t _size,
	      int (*_cmp)(const void *_e1, const void *_e2));
int	rand(void);
void *	realloc(void *_ptr, size_t _size);
void	srand(unsigned _seed);
double	strtod(const char *_s, char **_endptr);
long	strtol(const char *_s, char **_endptr, int _base);
unsigned long	strtoul(const char *_s, char **_endptr, int _base);
int	system(const char *_s);
size_t	wcstombs(char *_s, const wchar_t *_wcs, size_t _n);
int	wctomb(char *_s, wchar_t _wchar);





typedef struct {
  long long quot;
  long long rem;
} lldiv_t;

void *		alloca(size_t _size);
long double	_atold(const char *_s);
long long	atoll(const char *_s);
void		cfree(void *_ptr);
double          drand48(void);
char *		ecvtbuf(double _val, int _nd, int *_dp, int *_sn, char *_bf);
char *		ecvt(double _val, int _nd, int *_dp, int *_sn);
double          erand48(unsigned short state[3]);
char *		fcvtbuf(double _val, int _nd, int *_dp, int *_sn, char *_bf);
char *		fcvt(double _val, int _nd, int *_dp, int *_sn);
char *		gcvt(double _val, int _nd, char *_buf);
char *		getpass(const char *_prompt);
int		getlongpass(const char *_prompt, char *_buffer, int _max_len);
char *		itoa(int value, char *buffer, int radix);
long            jrand48(unsigned short state[3]);
long long	llabs(long long _i);
lldiv_t		lldiv(long long _numer, long long _denom);
void            lcong48(unsigned short param[7]);
unsigned long   lrand48(void);
long            mrand48(void);
unsigned long   nrand48(unsigned short state[3]);
int		putenv(const char *_val);
unsigned short *seed48(unsigned short state_seed[3]);
int		setenv(const char *_var, const char *_val, int _replace);
void            srand48(long seedval);
int		stackavail(void);
long double	_strtold(const char *_s, char **_endptr);
long long	strtoll(const char *_s, char **_endptr, int _base);
unsigned long long strtoull(const char *_s, char **_endptr, int _base);
void		swab(const void *from, void *to, int nbytes);





 
char  *	initstate (unsigned _seed, char *_arg_state, int _n);
char  *	setstate(char *_arg_state);
long	random(void);
int	srandom(int _seed);

 















extern int __system_flags;













# 15 "c:/djgpp/include/malloc.h" 2 3














# 60 "lic.h" 2

# 1 "c:/djgpp/include/unistd.h" 1 3
 
 
 











# 1 "c:/djgpp/include/sys/types.h" 1 3
 
 
 












  
typedef int		dev_t;
typedef int		ino_t;
typedef int		mode_t;
typedef int		nlink_t;

typedef int gid_t; 


typedef int off_t; 


typedef int pid_t; 


 


typedef int ssize_t; 


typedef int uid_t; 





 




typedef struct fd_set {
  unsigned char fd_bits [((256 ) + 7) / 8];
} fd_set;






typedef unsigned int time_t; 















# 15 "c:/djgpp/include/unistd.h" 2 3






  
 








































 
 


 



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

void		__exit(int _status) __attribute__((noreturn));
void		_exit(int _status) __attribute__((noreturn));
int		access(const char *_path, int _amode);
unsigned int	alarm(unsigned int _seconds);
int		chdir(const char *_path);
int		chown(const char *_path, uid_t _owner, gid_t _group);
int		close(int _fildes);
char *		ctermid(char *_s);
int		dup(int _fildes);
int		dup2(int _fildes, int _fildes2);
int		execl(const char *_path, const char *_arg, ...);
int		execle(const char *_path, const char *_arg, ...);
int		execlp(const char *_file, const char *_arg, ...);
int		execv(const char *_path, char *const _argv[]);
int		execve(const char *_path, char *const _argv[], char *const _envp[]);
int		execvp(const char *_file, char *const _argv[]);
pid_t		fork(void);
long		fpathconf(int _fildes, int _name);
char *		getcwd(char *_buf, size_t _size);
gid_t		getegid(void);
uid_t		geteuid(void);
gid_t		getgid(void);
int		getgroups(int _gidsetsize, gid_t *_grouplist);
char *		getlogin(void);
int		getopt(int _argc, char *const _argv[], const char *_optstring);
pid_t		getpgrp(void);
pid_t		getpid(void);
pid_t		getppid(void);
uid_t		getuid(void);
int		isatty(int _fildes);
int		link(const char *_existing, const char *_new);
off_t		lseek(int _fildes, off_t _offset, int _whence);
long		pathconf(const char *_path, int _name);
int		pause(void);
int		pipe(int _fildes[2]);
ssize_t		read(int _fildes, void *_buf, size_t _nbyte);
int		rmdir(const char *_path);
int		setgid(gid_t _gid);
int		setpgid(pid_t _pid, pid_t _pgid);
pid_t		setsid(void);
int		setuid(uid_t uid);
unsigned int	sleep(unsigned int _seconds);
long		sysconf(int _name);
pid_t		tcgetpgrp(int _fildes);
int		tcsetpgrp(int _fildes, pid_t _pgrp_id);
char *		ttyname(int _fildes);
int		unlink(const char *_path);
ssize_t		write(int _fildes, const void *_buf, size_t _nbyte);



 


char *		basename(const char *_fn);
int		brk(void *_heaptop);
char *		dirname(const char *_fn);
int		__file_exists(const char *_fn);
int		fsync(int _fd);
int		ftruncate(int, off_t);
int		getdtablesize(void);
int		gethostname(char *buf, int size);
int		getpagesize(void);
char *		getwd(char *__buffer);
int		nice(int _increment);
void *		sbrk(int _delta);
int		symlink (const char *, const char *);
int		sync(void);
int		truncate(const char*, off_t);
unsigned int	usleep(unsigned int _useconds);

pid_t		vfork(void);














# 61 "lic.h" 2






# 1 "c:/djgpp/include/stdio.h" 1 3
 
 










# 1 "c:/djgpp/include/sys/version.h" 1 3
 
 

















# 13 "c:/djgpp/include/stdio.h" 2 3


  




 














typedef void *va_list; 


 



 


   
typedef struct {
  int   _cnt;
  char *_ptr;
  char *_base;
  int   _bufsiz;
  int   _flag;
  int   _file;
  char *_name_to_remove;
  int   _fillsize;
} FILE;

typedef unsigned long		fpos_t;

extern FILE __dj_stdin, __dj_stdout, __dj_stderr;




void	clearerr(FILE *_stream);
int	fclose(FILE *_stream);
int	feof(FILE *_stream);
int	ferror(FILE *_stream);
int	fflush(FILE *_stream);
int	fgetc(FILE *_stream);
int	fgetpos(FILE *_stream, fpos_t *_pos);
char *	fgets(char *_s, int _n, FILE *_stream);
FILE *	fopen(const char *_filename, const char *_mode);
int	fprintf(FILE *_stream, const char *_format, ...);
int	fputc(int _c, FILE *_stream);
int	fputs(const char *_s, FILE *_stream);
size_t	fread(void *_ptr, size_t _size, size_t _nelem, FILE *_stream);
FILE *	freopen(const char *_filename, const char *_mode, FILE *_stream);
int	fscanf(FILE *_stream, const char *_format, ...);
int	fseek(FILE *_stream, long _offset, int _mode);
int	fsetpos(FILE *_stream, const fpos_t *_pos);
long	ftell(FILE *_stream);
size_t	fwrite(const void *_ptr, size_t _size, size_t _nelem, FILE *_stream);
int	getc(FILE *_stream);
int	getchar(void);
char *	gets(char *_s);
void	perror(const char *_s);
int	printf(const char *_format, ...);
int	putc(int _c, FILE *_stream);
int	putchar(int _c);
int	puts(const char *_s);
int	remove(const char *_filename);
int	rename(const char *_old, const char *_new);
void	rewind(FILE *_stream);
int	scanf(const char *_format, ...);
void	setbuf(FILE *_stream, char *_buf);
int	setvbuf(FILE *_stream, char *_buf, int _mode, size_t _size);
int	sprintf(char *_s, const char *_format, ...);
int	sscanf(const char *_s, const char *_format, ...);
FILE *	tmpfile(void);
char *	tmpnam(char *_s);
int	ungetc(int _c, FILE *_stream);
int	vfprintf(FILE *_stream, const char *_format, va_list _ap);
int	vprintf(const char *_format, va_list _ap);
int	vsprintf(char *_s, const char *_format, va_list _ap);





 

int	fileno(FILE *_stream);
FILE *	fdopen(int _fildes, const char *_type);
int	pclose(FILE *_pf);
FILE *	popen(const char *_command, const char *_mode);



extern FILE __dj_stdprn, __dj_stdaux;





void	_djstat_describe_lossage(FILE *_to_where);
int	_doprnt(const char *_fmt, va_list _args, FILE *_f);
int	_doscan(FILE *_f, const char *_fmt, void **_argp);
int	_doscan_low(FILE *, int (*)(FILE *_get), int (*_unget)(int, FILE *), const char *_fmt, void **_argp);
int	fpurge(FILE *_f);
int	getw(FILE *_f);
int	mkstemp(char *_template);
char *	mktemp(char *_template);
int	putw(int _v, FILE *_f);
void	setbuffer(FILE *_f, void *_buf, int _size);
void	setlinebuf(FILE *_f);
char *	tempnam(const char *_dir, const char *_prefix);
int	_rename(const char *_old, const char *_new);	 
int	vfscanf(FILE *_stream, const char *_format, va_list _ap);
int	vscanf(const char *_format, va_list _ap);
int	vsscanf(const char *_s, const char *_format, va_list _ap);













# 67 "lic.h" 2

# 1 "c:/djgpp/include/setjmp.h" 1 3
 
 









typedef struct __jmp_buf {
  unsigned long __eax, __ebx, __ecx, __edx, __esi;
  unsigned long __edi, __ebp, __esp, __eip, __eflags;
  unsigned short __cs, __ds, __es, __fs, __gs, __ss;
  unsigned long __sigmask;  
  unsigned long __signum;  
  unsigned long __exception_ptr;  
  unsigned char __fpu_state[108];  
} jmp_buf[1];

void	longjmp(jmp_buf env, int val);
int	setjmp(jmp_buf env);



typedef jmp_buf sigjmp_buf;

int	sigsetjmp(sigjmp_buf env, int savemask);
int	siglongjmp(sigjmp_buf env, int val);















# 68 "lic.h" 2

# 1 "c:/djgpp/include/stdarg.h" 1 3
 
 















 


  











  
















# 69 "lic.h" 2

# 1 "c:/djgpp/include/string.h" 1 3
 
 










    
 



 



void *	memchr(const void *_s, int _c, size_t _n);
int	memcmp(const void *_s1, const void *_s2, size_t _n);
void *	memcpy(void *_dest, const void *_src, size_t _n);
void *	memmove(void *_s1, const void *_s2, size_t _n);
void *	memset(void *_s, int _c, size_t _n);
char *	strcat(char *_s1, const char *_s2);
char *	strchr(const char *_s, int _c);
int	strcmp(const char *_s1, const char *_s2);
int	strcoll(const char *_s1, const char *_s2);
char *	strcpy(char *_s1, const char *_s2);
size_t	strcspn(const char *_s1, const char *_s2);
char *	strerror(int _errcode);
size_t	strlen(const char *_s);
char *	strncat(char *_s1, const char *_s2, size_t _n);
int	strncmp(const char *_s1, const char *_s2, size_t _n);
char *	strncpy(char *_s1, const char *_s2, size_t _n);
char *	strpbrk(const char *_s1, const char *_s2);
char *	strrchr(const char *_s, int _c);
size_t	strspn(const char *_s1, const char *_s2);
char *	strstr(const char *_s1, const char *_s2);
char *	strtok(char *_s1, const char *_s2);
size_t	strxfrm(char *_s1, const char *_s2, size_t _n);





# 1 "c:/djgpp/include/sys/movedata.h" 1 3
 
 















 



 



 
void dosmemget(unsigned long _offset, size_t _length, void *_buffer);
void dosmemput(const void *_buffer, size_t _length, unsigned long _offset);

 
void _dosmemgetb(unsigned long _offset, size_t _xfers, void *_buffer);
void _dosmemgetw(unsigned long _offset, size_t _xfers, void *_buffer);
void _dosmemgetl(unsigned long _offset, size_t _xfers, void *_buffer);
void _dosmemputb(const void *_buffer, size_t _xfers, unsigned long _offset);
void _dosmemputw(const void *_buffer, size_t _xfers, unsigned long _offset);
void _dosmemputl(const void *_buffer, size_t _xfers, unsigned long _offset);


 
void movedata(unsigned _source_selector, unsigned _source_offset,
	       unsigned _dest_selector, unsigned _dest_offset,
	       size_t _length);

 
void _movedatab(unsigned, unsigned, unsigned, unsigned, size_t);
void _movedataw(unsigned, unsigned, unsigned, unsigned, size_t);
void _movedatal(unsigned, unsigned, unsigned, unsigned, size_t);
  












# 49 "c:/djgpp/include/string.h" 2 3


int	bcmp(const void *_ptr1, const void *_ptr2, int _length);
void *	bcopy(const void *_a, void *_b, size_t _len);
void *	bzero(void *ptr, size_t _len);
int	ffs(int _mask);
char *  index(const char *_string, int _c);
void *	memccpy(void *_to, const void *_from, int c, size_t n);
int	memicmp(const void *_s1, const void *_s2, size_t _n);
char *  rindex(const char *_string, int _c);
char *	stpcpy(char *_dest, const char *_src);
char *	strdup(const char *_s);
char *	strlwr(char *_s);
int	strcasecmp(const char *_s1, const char *_s2);
int	stricmp(const char *_s1, const char *_s2);
int	strncasecmp(const char *_s1, const char *_s2, size_t _n);
int	strnicmp(const char *_s1, const char *_s2, size_t _n);
char *	strsep(char **_stringp, const char *_delim);
char *	strupr(char *_s);













# 70 "lic.h" 2


# 1 "c:/djgpp/include/ctype.h" 1 3
 









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


# 1 "c:/djgpp/include/inlines/ctype.ha" 1 3















extern unsigned short __dj_ctype_flags[];
extern unsigned char __dj_ctype_toupper[];
extern unsigned char __dj_ctype_tolower[];

















# 26 "c:/djgpp/include/ctype.h" 2 3


  




int	isascii(int c);
int	toascii(int c);


# 1 "c:/djgpp/include/inlines/ctype.hd" 1 3







# 37 "c:/djgpp/include/ctype.h" 2 3












# 72 "lic.h" 2

# 1 "c:/djgpp/include/limits.h" 1 3
 
 
















































 

 
 













 



 
















# 73 "lic.h" 2

# 1 "c:/djgpp/include/conio.h" 1 3
 
 














extern int directvideo;  
extern int _wscroll;





struct text_info {
    unsigned char winleft;
    unsigned char wintop;
    unsigned char winright;
    unsigned char winbottom;
    unsigned char attribute;
    unsigned char normattr;
    unsigned char currmode;
    unsigned char screenheight;
    unsigned char screenwidth;
    unsigned char curx;
    unsigned char cury;
};

enum text_modes { LASTMODE=-1, BW40=0, C40, BW80, C80, MONO=7, C4350=64 };

enum COLORS {
     
    BLACK,          
    BLUE,
    GREEN,
    CYAN,
    RED,
    MAGENTA,
    BROWN,
    LIGHTGRAY,
     
    DARKGRAY,  
    LIGHTBLUE,
    LIGHTGREEN,
    LIGHTCYAN,
    LIGHTRED,
    LIGHTMAGENTA,
    YELLOW,
    WHITE
};



void    blinkvideo(void);
char *  cgets(char *_str); 
void    clreol(void);
void    clrscr(void);
int     _conio_kbhit(void);  
int     cprintf(const char *_format, ...) __attribute__((format(printf,1,2)));
int     cputs(const char *_str);
int     cscanf(const char *_format, ...) __attribute__((format(scanf,1,2)));
void    delline(void);
int     getch(void);
int     getche(void);
int     gettext(int _left, int _top, int _right, int _bottom, void *_destin);
void    gettextinfo(struct text_info *_r);
void    gotoxy(int _x, int _y);
void    gppconio_init(void);
void    highvideo(void);
void    insline(void);
void	intensevideo(void);
void    lowvideo(void);
int     movetext(int _left, int _top, int _right, int _bottom, int _destleft, int _desttop);
void    normvideo(void);
int     putch(int _c);
int     puttext(int _left, int _top, int _right, int _bottom, void *_source);
void    _setcursortype(int _type);
void    _set_screen_lines(int _nlines);
void    textattr(int _attr);
void    textbackground(int _color);
void    textcolor(int _color);
void    textmode(int _mode);
int     ungetch(int); 
int     wherex(void);
int     wherey(void);
void    window(int _left, int _top, int _right, int _bottom);

















# 74 "lic.h" 2


























extern  int nheaps, objects_per_heap;




     typedef struct LOBJ *LPTR;






# 148 "lic.h"


extern  LPTR   *   * sp; 
extern  LPTR   *arg_base,   * arg_top;

extern  LPTR NULL_LPTR;
extern  LPTR   *   * stack_bot;
extern  LPTR   *   * sp_max;
extern  LPTR   *arg_bot;
extern  LPTR   *ap_max;
extern  int environments_allocated;



extern  int stack_size, a_stack_size;
























   typedef long INTEGER;






  typedef double FLOAT;


 





typedef LPTR   *pLPTR;


 


 



 


 
typedef short unsigned int lisp_type;

enum {
    unused_t,
 
    character_t,
 
    hash_table_t, package_t, pathname_t, random_state_t, readtable_t,
    stream_t, structure_t, symbol_t,
 
    compiled_function_t, compiled_mv_function_t,
    macro_closure_t, compiled_macro_function_t,
    lexical_closure_t, special_form_t,
 

    bignum_t, complex_t, double_float_t, float_t, integer_t, long_float_t,
    rational_t, short_float_t,

 
    cons_t, array_t, bit_vector_t,

 
 
    string_t,

 
    blkbnd_t, environment_t,

     
    list_t,			 
    applicable_form_t,		 
    lambda_list_t,		 
    natural_number_t,		 
    number_t,			 
    atom_t,			 
    list_or_symbol_t,		 
    sequence_t,			 
    vector_t			 
};



typedef short int BOOLEAN;



typedef char *STRING;

typedef struct environment {
    LPTR env_var, env_func, env_block;
 



} environment;

typedef struct lexical_closure {
    LPTR closure_func;
    LPTR closure_env;
} lexical_closure;

typedef enum {
    whitespace, constituent,
    terminating_macro,
    non_terminating_macro,
    single_escape,
    multiple_escape
} char_syntaxes;

typedef struct readtable {
    char_syntaxes chsyn[(127 - (-128) +1) ];
    LPTR char_macros[(127 - (-128) +1) ];
    LPTR readtable_case;
} readtable;

extern  LPTR character_macros[(127 - (-128) +1) ];
extern  char_syntaxes cl_chsyn[(127 - (-128) +1) ];

typedef struct character_object {
    char character;
    unsigned int control:1, alt:1, meta:1, function:1;
    unsigned int shift:1, escape:1, numeric:1;
} character_object;




typedef struct rational_number {
    INTEGER rn_n;
    INTEGER rn_d;
} rational_number;



typedef long random_state;

typedef struct package {
    int pkg_ht_size;		 
    LPTR *internal_ht;		 
    LPTR *external_ht;		 
    LPTR nicknames;		 
    LPTR uses;			 
    LPTR used_by;		 
    LPTR shadowings;		 
    STRING package_name;	 
} package;

extern  LPTR CL_p, USER_p, KEYWORD_p, SYSTEM_p, PACKAGES_p   ;
extern  LPTR s_package, all_packages;



typedef struct complex_number {
    FLOAT re;
    FLOAT im;
} complex_number;


typedef enum {
    sym_constant,		 
    sym_special,		 
    sym_regular			 
} symtype;

typedef struct symbol_property {
    LPTR a_def;			 
    LPTR a_val;			 
    LPTR a_plist;		 
    LPTR a_package_cell;	 
    STRING a_pname;		 
    symtype a_stype;		 
} symbol_property;

typedef struct name_table {
    LPTR *object_p;
    const char *name;
    symtype stype;
} name_table;



typedef struct array {
    unsigned short int rank;	 
    BOOLEAN row_major;		 
    int nelements[7 ];	 
    LPTR   *elements;	 



} array;

typedef struct lstream {
    union {
	struct {
	    FILE *stream_file;
	    char *stream_filename;
	    long stream_character;	 
	    long stream_line;	 
	} s_fp;
	struct {
	    char *stream_buffer, *stream_buffer_where;
	    int stream_buffer_nchar;
	} s_cp;
    } u_str;
    unsigned is_stream_input:1;	 
    unsigned is_stream_output:1;	 
    unsigned is_stream_char:1;	 
    unsigned short stream_column:8;	 
} stream;

typedef void (*fMV) (void);
typedef LPTR(*fLPTR) (void);
typedef void (*fSPECIAL) (LPTR);

typedef struct function_entry {	 
    LPTR function_name;
    fLPTR function_definition;
    short int min_args:8;
    short int max_args:8;
} function_entry;

typedef struct mv_function_entry {	 

    LPTR function_name;
    fMV function_definition;
    short int min_args:8;
    short int max_args:8;
} mv_function_entry;

typedef struct special_function_entry {		 
    LPTR function_name;
    fSPECIAL function_definition;
    short int min_args:8;
    short int max_args:8;
} special_function_entry;

typedef struct f_entry {
    const char *fn;
    fLPTR fd;
    short int min_args:8;
    short int max_args:8;
} f_entry;

typedef struct s_entry {
    const char *fn;
    fSPECIAL fd;
} s_entry;

typedef struct mv_entry {
    const char *fn;
    fMV fd;
} mv_entry;


typedef struct structure {
    LPTR struct_name;		 

    LPTR slot_names;		 

    LPTR *slot_values;
    int nslots;
} structure;

typedef struct list_cell {
    LPTR o_car;
    LPTR o_cdr;
} list_cell;





typedef struct LOBJ {



    unsigned short o_type:6 __attribute__((packed));



    unsigned int o_marked:2 __attribute__((packed));



    unsigned int o_traced:1 __attribute__((packed));
    union u_lo {
	list_cell o_lc;



	INTEGER o_int;		 

	short unsigned int o_bit;
	struct symbol_property *o_symbol;	 
	rational_number *o_rn;	 
	STRING o_str;		 

	struct complex_number *o_cn;


	FLOAT o_real;		 

	struct mv_function_entry *o_MVcf;	 


	struct function_entry *o_cf;	 

	special_function_entry *o_special_form;		 
	special_function_entry *o_cm;	 
	special_function_entry *o_mf;	 

	lexical_closure o_lexical_closure;
	lexical_closure o_macro_closure;
	character_object o_char;	 
	package *o_package;	 
	struct lstream *o_stream;	 
	struct array *o_array;	 
	structure *o_structure;	 
	struct hash_table *o_ht;	 
	struct readtable *o_readtable;	 
	struct context *block_binding;	 
	random_state o_random_state;

	LPTR o_environment;



    } u_lo;
} LOBJ;






extern  LOBJ   *workspace;


# 532 "lic.h"








extern  int Initialized;

LPTR O  (LPTR s, const char *fn, int line, char *funcname)  ;
 
























 
 













typedef struct context {
    struct context   *ccp;	 
    LPTR cname;			 
    unsigned char cflags;	 
    jmp_buf cjb;		 

    pLPTR cap;			 
    pLPTR cab;			 
    pLPTR   *csp;	 
    LPTR cenvir;		 
     

    struct environment   *clexenv;	 
    LPTR cbody;			 
    int ctl;			 
    int ctrind;			 
    long cunique;		 

 

    long cblock_level;		 
    unsigned long context_marker;	 

} context;



extern  context   *cp;
extern  long context_index;

typedef struct trace_record {
    LPTR tr_form;
    environment *e;
    LPTR dynenv;
} trace_record;

extern  jmp_buf eval_jump_buffer;

extern  struct trace_record   *trace_stack;
extern  int trace_stack_size, trace_ind;

struct hash_table {
    int ht_size;
    int ht_nentries;
    LPTR ht_keytest;		 
    LPTR   *ht_entries;
};

typedef struct packnode {
    char *packname;
    LPTR pack;
    struct packnode *left;
    struct packnode *right;
} packnode;

extern  LPTR all_chars[(127 - (-128) +1) ];	 























































extern  LPTR s_macro, nil, t, s_lambda, s_dlambda, s_macroargs;
extern  LPTR s_quote, s_funct, s_prog, s_block, s_comma;
extern  LPTR s_comma_atsign, s_comma_dot, s_backquote, s_declare;
extern  LPTR k_start, k_end, k_from_end, k_key, k_test, k_test_not;
extern  LPTR k_count, k_initial_value;


extern  int system_flags[20 ];	 
enum flags {
    displace_flag = 0,
    old_backquote_flag
};

enum {
    IS_NOTTHERE, IS_INTERNAL, IS_EXTERNAL, IS_INHERITED, IS_SHADOWED
};

 

extern  environment   *lexical_environment;
extern  environment   *env_stack;
extern  struct environment nil_env;

extern  int env_stack_size;

extern  LPTR envir;		 




















 

extern  LPTR stdin_stream, stdout_stream, stderr_stream;
extern  LPTR s_stdin_stream, s_stdout_stream, s_stderr_stream;
extern  LPTR conscar, conscdr, evalhook, applyhook, macroexpand_hook;




extern  int tracelevel;

extern  unsigned long nleft, wksiz, cells_allocated;
extern  LPTR freep;
extern  LPTR main_readtable, s_readtable, delimiter   ;

 
extern  LPTR n_one, n_zero, n_negone   ;

 


extern  LPTR equal_fn, eql_fn, eq_fn, equalp_fn, identity_fn;































































































 
LPTR type_of  (LPTR s)  ;
int coerce_to_int  (LPTR x)  ;
FLOAT coerce_to_float  (LPTR x)  ;
LPTR coerce_to_vector  (LPTR s)  ;
LPTR coerce_to_stream  (LPTR s)  ;
void init_typespec  (void)  ;


 
LPTR new_vector  (int n)  ;
LPTR coerce_list_vector  (LPTR s)  ;
LPTR l_vector  (void)  ;
LPTR l_make_array  (void)  ;
LPTR l_aref  (void)  ;
pLPTR paref  (LPTR array, int nindices, int *indices)  ;
void init_array  (void)  ;


 
void new_special_binding  (LPTR name, LPTR value)  ;
LPTR let_do_bind  (LPTR body, BOOLEAN sequential, BOOLEAN in_do)  ;
void update_do_forms  (LPTR   * bts, LPTR   * bte,
			    BOOLEAN sequential)  ;
void parse_keys  (int nreq, LPTR * kv, LPTR * names)  ;
void parse_keys_1  (int nreq, LPTR * vals, LPTR name1)  ;
void get_1_key  (int nreq, LPTR n1, LPTR * v1, LPTR d1)  ;
void get_2_keys  (int nreq, LPTR n1, LPTR * v1, LPTR d1, LPTR n2, LPTR * v2, LPTR d2)  ;
void get_3_keys  (int nreq, LPTR n1, LPTR * v1, LPTR d1, LPTR n2, LPTR * v2, LPTR d2, LPTR n3, LPTR * v3, LPTR d3)  ;
void parse_keys_2  (int nreq, LPTR * vals, LPTR name1, LPTR name2)  ;
void parse_keys_3  (int nreq, LPTR * vals, LPTR name1, LPTR name2, LPTR name3)  ;
void parse_keys_4  (int nreq, LPTR * vals, LPTR name1, LPTR name2, LPTR name3, LPTR name4)  ;
void parse_keys_5  (int nreq, LPTR * vals, LPTR name1, LPTR name2, LPTR name3, LPTR name4, LPTR name5)  ;
void check_var  (LPTR x)  ;
BOOLEAN endp  (LPTR x)  ;
BOOLEAN keywordp  (LPTR x)  ;
LPTR lambda_bind  (LPTR body)  ;
void bind_var  (LPTR var, LPTR val, LPTR is_special)  ;
void init_bind  (void)  ;


 
void block_level_error  (void)  ;
void check_cp_message  (struct context * p)  ;
void check_cp  (struct context * p, struct context * cp)  ;
void block_init  (struct context * p, int flags, LPTR body, LPTR bname)  ;
void block_end  (void)  ;
void return_results_from_block  (LPTR block_name)  ;
void eval_tag_body  (  LPTR body)  ;
void prog_block  (LPTR args, BOOLEAN sequential)  ;
void progn  (LPTR args)  ;
void prog1  (LPTR args)  ;
void prog2  (LPTR args)  ;
void letcore  (LPTR args, BOOLEAN sequential)  ;
void err_too_few  (LPTR form)  ;
void err_too_many  (LPTR form)  ;
void return_results_from_continuation  (void)  ;
LPTR error_core  (const char *error_message, BOOLEAN continuable, LPTR list_of_args)  ;

 
LPTR error  (const char *error_message)  ;
LPTR error1  (const char *error_message, LPTR x)  ;
LPTR error2  (const char *error_message, LPTR x, LPTR y)  ;
LPTR error3  (const char *error_message, LPTR x, LPTR y, LPTR z)  ;
LPTR error4  (const char *error_message, LPTR w, LPTR x, LPTR y, LPTR z)  ;
LPTR warning  (const char *error_message)  ;
LPTR warning1  (const char *error_message, LPTR x)  ;
LPTR warning2  (const char *error_message, LPTR x, LPTR y)  ;
LPTR warning3  (const char *error_message, LPTR x, LPTR y, LPTR z)  ;
LPTR warning4  (const char *error_message, LPTR w, LPTR x, LPTR y, LPTR z)  ;
void init_cond  (void)  ;

 
LPTR parse_macro_definition  (LPTR form)  ;
LPTR macroexpand  (LPTR form)  ;
void set_macro_definition  (LPTR s, LPTR value)  ;
LPTR make_macro_definition  (LPTR form, environment * e)  ;
void init_macros  (void)  ;
 

void values  (void)  ;
void init_multival  (void)  ;
void init_block  (void)  ;


 
char_syntaxes current_character_syntax  (char c)  ;
LPTR l_set_macro_char  (void)  ;
LPTR l_get_dispatch_macro  (void)  ;
LPTR read_string  (LPTR f)  ;
void null_result  (void)  ;
LPTR readexpr  (LPTR input_stream, LPTR eof_error_p, LPTR eof_val, LPTR recursive_p)  ;
LPTR new_character  (const char *token)  ;
LPTR new_string  (const char *string)  ;
LPTR new_readtable  (void)  ;
void copy_readtable  (struct readtable * from_rt, struct readtable * to_rt)  ;
LPTR l_set_readtable_case  (void)  ;
LPTR l_copy_readtable  (void)  ;
void init_backq  (void)  ;
void init_read  (void)  ;
 
LPTR new_lexical_environment  (void)  ;
LPTR new_lexical_closure  (LPTR funct,
				struct environment   * e)  ;
void extract_closure  (LPTR clo)  ;
void init_env(void);
 
LPTR symbol_function  (LPTR s)  ;
void evbody  (LPTR body)  ;
void printenv  (LPTR strm)  ;
void evalargs  (LPTR args)  ;
LPTR symbol_value  (LPTR s)  ;
void trace_in  (LPTR expression)  ;
void trace_out  (void)  ;
void evaluate  (LPTR expression)  ;
LPTR eval_1  (LPTR form)  ;
void apply  (LPTR funct, LPTR args)  ;
void funcall  (void)  ;
LPTR funcall_1  (LPTR funct, LPTR arg)  ;
LPTR funcall_2  (LPTR funct, LPTR a1, LPTR a2)  ;
LPTR funcall_3  (LPTR funct, LPTR a1, LPTR a2, LPTR a3)  ;
LPTR apply_2  (LPTR funct, LPTR args)  ;

void chklistn  (LPTR s, int n)  ;
void chktyp  (LPTR s, lisp_type allowed_type)  ;
void chkargs  (int lower, int upper)  ;
void check_arglist  (LPTR arglist, int lower, int upper)  ;
void set_atom  (LPTR a, LPTR value)  ;
LPTR l_macro_function  (void)  ;
LPTR l_symbol_function  (void)  ;
LPTR trace  (LPTR x)  ;
LPTR untrace  (LPTR x)  ;
LPTR new_dynamic_closure  (LPTR f)  ;
void init_eval  (void)  ;


 
LPTR counter_to_object  (int s)  ;
void gc  (void)  ;
void mark  (LPTR s)  ;
void init_gc  (void)  ;


 
LPTR new_hash_table  (LPTR ht_size, LPTR test_function)  ;
LPTR *get_hash  (LPTR key, struct hash_table * ht)  ;
void set_hash  (LPTR key, LPTR val, struct hash_table * ht)  ;
void l_gethash  (void)  ;
void init_hash  (void)  ;


 
LPTR l_car  (void)  ;
LPTR l_cdr  (void)  ;
LPTR l_caar  (void)  ;
LPTR l_cdar  (void)  ;
LPTR l_cadr  (void)  ;
LPTR cons  (LPTR x, LPTR y)  ;
LPTR append_lists  (LPTR a1, LPTR a2)  ;
LPTR nconc  (LPTR x, LPTR y)  ;
LPTR copy_tree  (LPTR s)  ;
LPTR append1  (LPTR a1, LPTR a2)  ;
LPTR copy_list  (LPTR x)  ;
LPTR assoc  (LPTR k, LPTR a)  ;
LPTR memb  (LPTR s, LPTR l)  ;
LPTR member  (LPTR s, LPTR l)  ;
LPTR member_test  (LPTR s, LPTR l, LPTR test_func, LPTR key_func)  ;
void init_list  (void)  ;


 
LPTR new_float  (FLOAT f)  ;
LPTR new_complex  (FLOAT re, FLOAT im)  ;
 
void big_convert_to_string  (char *destination, LPTR s)  ;
LPTR decode_integer  (const char *str, int base)  ;
void big_convert_to_string  (char *destination, LPTR s)  ;
LPTR new_integer  (INTEGER n)  ;
LPTR new_rational  (INTEGER n1, INTEGER n2)  ;
LPTR rational_add  (LPTR addend1, LPTR addend2)  ;
LPTR rational_subtract  (LPTR n1, LPTR n2)  ;
int rational_compare  (LPTR n1, LPTR n2)  ;
LPTR rational_multiply  (LPTR n1, LPTR n2)  ;
LPTR rational_divide  (LPTR n1, LPTR n2)  ;
LPTR l_numerator  (void)  ;
LPTR l_denominator  (void)  ;
int integer_compare  (LPTR x, LPTR y)  ;
LPTR arithmetic  (char op)  ;
LPTR add_to  (LPTR s, INTEGER j)  ;
int signum  (LPTR s)  ;
 
BOOLEAN prime  (unsigned long i)  ;
void init_math  (void)  ;
double coerce_Rational_double(rational_number x);
double coerce_Integer_double(INTEGER x);


 

void FPE_catcher  (int sig, int signal_type, int *lp)  ;
void setup_signals  (void)  ;
void PROTECT_DEBUG  (LPTR * x, const char *fn, int ln)  ;
void UNPROTECT_DEBUG  (LPTR * x, const char *fn, int ln)  ;
void env_stack_overflow  (const char *fn, int ln)  ;
void PUSHARG_DEBUG  (LPTR x, const char *fn, int ln)  ;
LPTR ARG_DEBUG  (int n, const char *fn, int ln)  ;

void reset_values  (void)  ;
void enter_name_table  (struct name_table * p)  ;
LPTR enter_proc  (const char *name, fMV definition, lisp_type procedure_type)  ;
LPTR enter_mv_func  (const char *name, fMV definition)  ;
LPTR enter_func  (const char *name, fLPTR definition)  ;
LPTR enter_special  (const char *name, fSPECIAL definition)  ;
void enter_functions  (struct f_entry * p)  ;
void enter_specials  (struct s_entry * p)  ;
void enter_mvs  (struct mv_entry * p)  ;
LPTR new_keyword  (const char *keyname)  ;
void reset  (void)  ;
void initialize_lisp  (void)  ;


 
void look_at_cleared  (LPTR s, char *fn, int ln)  ;
void simple_print  (LPTR stream, LPTR s)  ;
void simple_backtrace  (void)  ;
void *DBALLOCATE_SPACE  (unsigned long nbytes, const char *fn, int line)  ;
void *Allocate_Space  (unsigned long nbytes)  ;
char *Allocate_Chars  (int nchar)  ;
char *DBALLOCATE_CHARS  (int nchar, const char *fn, int line)  ;
char *Allocate_String  (const char *str)  ;
char *DBALLOCATE_STRING  (const char *str, const char *fn, int line)  ;
void free_space  (void *ptr)  ;
LPTR new_lisp_object  (void)  ;
struct LOBJ *CHECK_MISER_OBJECT  (LPTR s, const char *fn, int ln,
				       char *funcname)  ;
struct LOBJ *CHECK_MISER_OBJECT  (LPTR s, const char *fn, int ln,
				       char *funcname)  ;
 

void initialize_workspace  (void)  ;
void initialize_workspace  (void)  ;
void check_ap  (const char *fn, const int line)  ;
void check_sp  (const char *fn, const int line)  ;



 
LPTR setup_package  (const char *name, const int size)  ;
void setup_packages  (void)  ;
char *SYMPNAME_DEBUG  (LPTR s, int ln, char *fn)  ;
LPTR coerce_to_package  (LPTR s)  ;
LPTR find_package  (const char *name)  ;
LPTR all_symbols  (LPTR p)  ;
int pkg_hash  (const char *x, LPTR p)  ;
LPTR new_symbol  (const char *name, const symtype st)  ;
void streq_error  (void)  ;
LPTR find_symbol  (const char *name, LPTR p, int *intern_flag)  ;
LPTR intern  (const char *st, LPTR p)  ;
LPTR exportp    (LPTR s, LPTR pack)  ;
LPTR new_package  (const char *packagename, LPTR nicknames, LPTR to_use, const int packagesize)  ;
void init_packages  (void)  ;
LPTR getprop  (LPTR sym, LPTR prop)  ;
LPTR getf  (LPTR plist, LPTR prop)  ;
BOOLEAN remf  (LPTR * p, LPTR i)  ;
void l_remf  (void)  ;
LPTR putprop  (LPTR a, LPTR p, LPTR v)  ;
LPTR l_getprop  (void)  ;
LPTR l_putprop  (void)  ;
LPTR l_plist  (void)  ;
void init_symbol  (void)  ;


 
BOOLEAN eq  (LPTR s1, LPTR s2)  ;
BOOLEAN eql  (LPTR s1, LPTR s2)  ;
BOOLEAN equal  (LPTR s1, LPTR s2)  ;
BOOLEAN equalp  (LPTR s1, LPTR s2)  ;
LPTR explode_atom  (LPTR s)  ;
LPTR predicate  (BOOLEAN s)  ;
void init_pred  (void)  ;


 
void check_for_break  (void)  ;
void stream_tocolumn  (LPTR s, int col)  ;
void backtrace  (void)  ;
int where_on_stream  (LPTR s)  ;
int room_on_stream  (LPTR s)  ;
BOOLEAN functioned  (LPTR s)  ;
BOOLEAN quoted  (LPTR s)  ;
char *atom_to_string  (LPTR s, BOOLEAN readably)  ;
void print_atom  (LPTR stream, LPTR s)  ;
void print_s  (  LPTR stream,   LPTR s)  ;
void levprint  (LPTR stream, LPTR x)  ;
void pretty  (  LPTR stream,   LPTR s,   int col)  ;
int int_length  (INTEGER num, int base)  ;
int display_size  (LPTR s, int max_length)  ;
LPTR l_backtrace  (void)  ;
LPTR l_prin1  (void)  ;
LPTR l_print  (void)  ;
LPTR l_princ  (void)  ;
char *fmt_process  (LPTR stream, char *str, BOOLEAN recursive)  ;
char *format_core  (LPTR stream, const char *str, LPTR arglist)  ;
void format1  (LPTR stream, STRING format_string, LPTR x)  ;
void format2  (LPTR stream, STRING format_string, LPTR x, LPTR y)  ;
void format3  (LPTR stream, STRING format_string, LPTR x, LPTR y, LPTR z)  ;
void format4  (LPTR stream, STRING fs, LPTR w, LPTR x, LPTR y, LPTR z)  ;
LPTR l_format  (void)  ;
void print_prompt  (char *prompt_string)  ;
LPTR l_grindef  (void)  ;
void init_print  (void)  ;


 



typedef struct seq_key {	 
    int start;
    int end;
    int count;
    BOOLEAN from_end;
    LPTR key;
    LPTR test;
    LPTR test_not;
} seq_key;

LPTR elt  (LPTR seq, int n)  ;
BOOLEAN sequence_test  (LPTR item_or_test, LPTR seq_item, struct seq_key * k, BOOLEAN testing, BOOLEAN ifnot)  ;
LPTR copy_string  (LPTR s)  ;
LPTR copy_vector  (LPTR s)  ;
LPTR listify_args  (void)  ;
LPTR l_nth  (void)  ;
int length  (LPTR s)  ;
LPTR reverse  (LPTR s)  ;
LPTR nreverse  (LPTR s)  ;
LPTR subseq  (LPTR seq, int start, int end)  ;
LPTR delete_core  (LPTR item, LPTR seq, struct seq_key * k, BOOLEAN testing, BOOLEAN ifnot)  ;
LPTR delete_from_list  (LPTR item, LPTR l)  ;
LPTR xsort  (void)  ;
void init_seq  (void)  ;


 
void set_generalized_variable  (LPTR genvar, LPTR value)  ;
void l_setq  (LPTR args)  ;
LPTR l_set  (void)  ;
void l_incf  (LPTR arguments)  ;
void l_decf  (LPTR arguments)  ;
void l_push  (LPTR arguments)  ;
void l_pop  (LPTR arguments)  ;
void l_defvar  (LPTR arguments)  ;
void l_defparameter  (LPTR arguments)  ;
void l_defconstant  (LPTR arguments)  ;
LPTR setf_aux  (LPTR place_form, LPTR value)  ;
void l_setf  (LPTR args)  ;
void init_setf  (void)  ;


 
FILE *stream_to_file  (LPTR strm)  ;
void check_stream  (LPTR s)  ;
void stream_putc  (char ch, LPTR s)  ;
int stream_puts  (const char *string_to_write, LPTR s)  ;
BOOLEAN stream_eof  (LPTR s)  ;
char stream_next  (LPTR strm)  ;
LPTR l_peek_char  (void)  ;
char stream_getc  (LPTR input_stream, BOOLEAN signal_eof)  ;
void stream_ungetc  (char c, LPTR input_stream)  ;
LPTR new_stream  (BOOLEAN is, BOOLEAN os, BOOLEAN cs, const char *fn, int nc)  ;
LPTR new_input_file_stream  (LPTR s)  ;
LPTR new_output_file_stream  (LPTR s)  ;
LPTR new_io_file_stream  (LPTR s)  ;
LPTR l_new_file_stream  (void)  ;
void stream_close  (LPTR strm)  ;
LPTR l_close  (void)  ;
FILE *current_input_file  (void)  ;
LPTR l_load  (void)  ;
LPTR l_open  (void)  ;
LPTR l_list_file  (void)  ;
void init_open  (void)  ;
void init_streams  (void)  ;
void beep  (void)  ;
void flush_line  (void)  ;
void lstream_print  (LPTR strm, char *fmt,...)  ;
void lsprintf  (char *fmt,...)  ;

 
STRING coerce_to_string  (LPTR name)  ;
int strcmpu  (const char *s1, const char *s2)  ;
int strcmps  (const char *s1, const char *s2)  ;
void make_all_chars  (void)  ;
LPTR get_character  (char ch)  ;
void init_string  (void)  ;


 
LPTR structure_ref  (void)  ;
int print_struct  (char *destination, LPTR s, LPTR str)  ;
void init_struct  (void)  ;


 
LPTR l_system  (void)  ;
LPTR l_clock  (void)  ;
void l_time  (LPTR args)  ;
LPTR l_address  (void)  ;
LPTR l_chdir  (void)  ;
LPTR l_pwd  (void)  ;
char sys_getche  (void)  ;
char sys_getch  (void)  ;
void init_system  (void)  ;

# 1298 "lic.h"



# 3 "error.c" 2



LPTR error_core(const char *error_message, BOOLEAN continuable,
		LPTR list_of_args)
{
    struct context error_context;
    LPTR form = nil, result = nil;
    char c;
printf("%s\n",error_message);
exit(0);
    block_init(&error_context, 16  | 2 , nil, nil);
    lstream_print(stderr_stream, "\nERROR: ");
    (void) format_core(stderr_stream, error_message, list_of_args);
    fputc('\n', (&__dj_stderr) );
    fflush((&__dj_stdout) );
    fflush((&__dj_stdin) );
    fflush((&__dj_stderr) );
    do{O( form ,FN,0,0 ); PROTECT_DEBUG(& form ,FN,21);} while(0) ;
    do{O( result ,FN,0,0 ); PROTECT_DEBUG(& result ,FN,22);} while(0) ;
    new_special_binding(s_readtable, main_readtable);
    for (;;) {
	switch (setjmp(error_context.cjb)) {
	case 0:
	    lstream_print(stdout_stream,
			  "([b]acktrace, [r]eset, [?/h]elp, [q]uit): ");
	    fflush((&__dj_stdout) );
	    c = sys_getche();
	    switch ((__dj_ctype_tolower[(int)( c )+1]) ) {
	    case '?':
	    case 'h':
		lsprintf("\n?\thelp\n");
		lsprintf("b\tbacktrace\n");
		lsprintf("r\treset\n");
		lsprintf("q\treturn to DOS\n");
		lsprintf("c\tContinue\n");
		lsprintf("anything else is evaluated\n");
		break;
	    case 'b':
		backtrace();
		break;
	    case 'r':
		reset();
		break;
	    case 'q':
		exit(1);
		break;
	    case 'c':
		if (continuable) {
		    block_end();
		    UNPROTECT_DEBUG(& result ,FN,53) ;
		    UNPROTECT_DEBUG(& form ,FN,54) ;
		    return nil;
		} else {
		    lsprintf("Not continuable\n");
		}
		break;
	    default:
		stream_ungetc(c, stdin_stream);
		form = readexpr(stdin_stream, t, nil, nil);
		result = eval_1(form);
		format1(stderr_stream, "~s\n", result);
		break;
	    }
	    break;
	case 8 :
	    {
		if (continuable) {
		    block_end();
		    UNPROTECT_DEBUG(& result ,FN,72) ;
		    UNPROTECT_DEBUG(& form ,FN,73) ;
		    return nil;
		} else {
		    lsprintf("Not continuable\n");
		}
	    }
	    break;
	default:
	    ;
	}
    }
}

LPTR error(const char *error_message)
{
    return error_core(error_message, 0 , nil);
}
LPTR error1(const char *error_message, LPTR x)
{
    LPTR result = nil;
    do{O( result ,FN,0,0 ); PROTECT_DEBUG(& result ,FN,93);} while(0) ;
    result = (cons( x ,nil)) ;
    result = error_core(error_message, 0 , result);
    UNPROTECT_DEBUG(& result ,FN,96) ;
    return result;
}
LPTR error2(const char *error_message, LPTR x, LPTR y)
{
    LPTR result = nil;
    do{O( result ,FN,0,0 ); PROTECT_DEBUG(& result ,FN,102);} while(0) ;
    result = cons(x, cons(y, nil));
    result = error_core(error_message, 0 , result);
    UNPROTECT_DEBUG(& result ,FN,105) ;
    return result;
}

LPTR error3(const char *error_message, LPTR x, LPTR y, LPTR z)
{
    LPTR result = nil;
    do{O( result ,FN,0,0 ); PROTECT_DEBUG(& result ,FN,112);} while(0) ;
    result = cons(x, cons(y, cons(z, nil)));
    result = error_core(error_message, 0 , result);
    UNPROTECT_DEBUG(& result ,FN,115) ;
    return result;
}
LPTR error4(const char *error_message, LPTR w, LPTR x, LPTR y, LPTR z)
{
    LPTR result = nil;
    do{O( result ,FN,0,0 ); PROTECT_DEBUG(& result ,FN,121);} while(0) ;
    result = cons(w, cons(x, cons(y, cons(z, nil))));
    result = error_core(error_message, 0 , result);
    UNPROTECT_DEBUG(& result ,FN,124) ;
    return result;
}

LPTR warning(const char *error_message)
{
    return error_core(error_message, 1 , nil);
}
LPTR warning1(const char *error_message, LPTR x)
{
    LPTR result = nil;
    do{O( result ,FN,0,0 ); PROTECT_DEBUG(& result ,FN,135);} while(0) ;
    result = (cons( x ,nil)) ;
    result = error_core(error_message, 1 , result);
    UNPROTECT_DEBUG(& result ,FN,138) ;
    return result;
}
LPTR warning2(const char *error_message, LPTR x, LPTR y)
{
    LPTR result = nil;
    do{O( result ,FN,0,0 ); PROTECT_DEBUG(& result ,FN,144);} while(0) ;
    result = cons(x, cons(y, nil));
    result = error_core(error_message, 1 , result);
    UNPROTECT_DEBUG(& result ,FN,147) ;
    return result;
}

LPTR warning3(const char *error_message, LPTR x, LPTR y, LPTR z)
{
    LPTR result = nil;
    do{O( result ,FN,0,0 ); PROTECT_DEBUG(& result ,FN,154);} while(0) ;
    result = cons(x, cons(y, cons(z, nil)));
    result = error_core(error_message, 1 , result);
    UNPROTECT_DEBUG(& result ,FN,157) ;
    return result;
}
LPTR warning4(const char *error_message, LPTR w, LPTR x, LPTR y, LPTR z)
{
    LPTR result = nil;
    do{O( result ,FN,0,0 ); PROTECT_DEBUG(& result ,FN,163);} while(0) ;
    result = cons(w, cons(x, cons(y, cons(z, nil))));
    result = error_core(error_message, 1 , result);
    UNPROTECT_DEBUG(& result ,FN,166) ;
    return result;
}