gcl 2.6.12-1 / usr / lib / gcl-2.6.12-prof / h / cmpinclude.h

#define char_code(x) ((object)x)->ch.ch_code
#define code_char(x) (object)((character_table1+128)+((unsigned char)(x)))
#define endp(x) (({register object _z=(object)(x); (!(((ufixnum)(_z))>=0x8000000000000000) && (!(_z)->d.e || (((ufixnum)((*(object *)(_z))))>=0x8000000000000000)) && _z!=((object)&Cnil_body));}) ? 0 : ((x)==((object)&Cnil_body) ? 1 : endp_error(x)))
#define eql(x,y) ({register object _a=(x);register object _b=(y);_a==_b || (!((((ufixnum)(_a))>=0x8000000000000000)||_a==((object)&Cnil_body))&&!((((ufixnum)(_b))>=0x8000000000000000)||_b==((object)&Cnil_body))&&eql1(_a,_b));})
#define equal(x,y) ({register object _a=(x);register object _b=(y);_a==_b || (!((((ufixnum)(_a))>=0x8000000000000000)||_a==((object)&Cnil_body))&&!((((ufixnum)(_b))>=0x8000000000000000)||_b==((object)&Cnil_body))&&equal1(_a,_b));})
#define equalp(x,y) ({register object _a=(x);register object _b=(y);_a==_b || (_a!=((object)&Cnil_body)&&_b!=((object)&Cnil_body)&&equalp1(_a,_b));})
#define fix(x) ({register object _q2=(x);register fixnum _q3; _q3=(((ufixnum)(_q2))>=0x8000000000000000) ? (((fixnum)(_q2))-(0x8000000000000000 +(0x4000000000000000>>1))) : (_q2)->FIX.FIXVAL;_q3;})
#define lf(x) (x)->LF.LFVAL
#define make_fixnum(x) ({register fixnum _q1=(x);register object _q4; _q4=(!(((_q1)+(0x4000000000000000>>1))&-0x4000000000000000)) ? ((object)((_q1)+(0x8000000000000000 +(0x4000000000000000>>1)))) : make_fixnum1(_q1);_q4;})
#define CMPmake_fixnum(x) ({register fixnum _q1=(x);register object _q4; _q4=(!(((_q1)+(0x4000000000000000>>1))&-0x4000000000000000)) ? ((object)((_q1)+(0x8000000000000000 +(0x4000000000000000>>1)))) : make_fixnum1(_q1);_q4;})
#define small_fixnum(x) ({register fixnum _q1=(x);register object _q4; _q4=(!(((_q1)+(0x4000000000000000>>1))&-0x4000000000000000)) ? ((object)((_q1)+(0x8000000000000000 +(0x4000000000000000>>1)))) : make_fixnum1(_q1);_q4;})
#define type_of(x) ({register object _z=(object)(x); ((((ufixnum)(_z))>=0x8000000000000000) ? t_fixnum : ((!(_z)->d.e || (((ufixnum)((*(object *)(_z))))>=0x8000000000000000)) ? (_z==((object)&Cnil_body) ? t_symbol : t_cons) : _z->d.t));})
#define STREF(a,b,c) (*((a *)(((char *)((b)->str.str_self))+(c))))
#define STSET(a,b,c,val) do{(b)->d.e=1;(*((a *)(((char *)((b)->str.str_self))+(c)))) = (val);} while(0)
#define immnum_bool(a,b,c) immnum_boole(fixint(a),b,c)
#define immnum_ior(x,y) immnum_boole(07,x,y)
#define immnum_and(x,y) immnum_boole(01,x,y)
#define immnum_xor(x,y) immnum_boole(06,x,y)
#define immnum_not(x) immnum_boole(014,x,x)
#define immnum_nand(x,y) immnum_boole(016,x,y)
#define immnum_nor(x,y) immnum_boole(010,x,y)
#define immnum_eqv(x,y) immnum_boole(011,x,y)
#define immnum_andc1(x,y) immnum_boole(04,x,y)
#define immnum_andc2(x,y) immnum_boole(02,x,y)
#define immnum_orc1(x,y) immnum_boole(015,x,y)
#define immnum_orc2(x,y) immnum_boole(013,x,y)
#define listp(x) ({register object _z=(object)(x); (!(((ufixnum)(_z))>=0x8000000000000000) && (!(_z)->d.e || (((ufixnum)((*(object *)(_z))))>=0x8000000000000000)));})
#define sf(x) (x)->SF.SFVAL
#define atom(x) ({register object _z=(object)(x); ((((ufixnum)(_z))>=0x8000000000000000) || !(!(_z)->d.e || (((ufixnum)((*(object *)(_z))))>=0x8000000000000000)) || _z==((object)&Cnil_body));})
#define consp(x) ({register object _z=(object)(x); (!(((ufixnum)(_z))>=0x8000000000000000) && (!(_z)->d.e || (((ufixnum)((*(object *)(_z))))>=0x8000000000000000)) && _z!=((object)&Cnil_body));})
#define OBJNULL ((void *)0)
#define Cnil ((object)&Cnil_body)
#define Ct ((object)&Ct_body)
#define bds_check if (bds_top >= bds_limit) bds_overflow()
#define bds_unwind1 ((bds_top->bds_sym)->s.s_dbind = bds_top->bds_val, --bds_top)
#define bds_bind(a,b) ({object _sym=(a),_val=(b);bds_ptr _b=++bds_top;(_b)->bds_sym=_sym;(_b)->bds_val=_sym->s.s_dbind;_sym->s.s_dbind=_val;})
#define va_arg(a,b) __builtin_va_arg(a,b)
#define va_start(a,b) __builtin_va_start(a,b)
#define va_end(a) __builtin_va_end(a)
#define ON_STACK_CONS(x,y) (alloca_val=__builtin_alloca (sizeof(struct cons)), on_stack_cons(x,y))
#define frs_pop() frs_top--
#define frs_push(a,b) do { frame_ptr _frs_top = frs_top +1; if (_frs_top >= frs_limit) frs_overflow(); _frs_top->frs_lex = lex_env; _frs_top->frs_bds_top = bds_top; _frs_top->frs_class = (a); _frs_top->frs_in_signal_handler = in_signal_handler; _frs_top->frs_val = (b); _frs_top->frs_ihs = ihs_top; frs_top=_frs_top; _setjmp ((void *)_frs_top->frs_jmpbuf); } while (0)
#define vs_push(x) (*vs_top++ = (x))
#define vs_reserve(x) if(vs_base+(x) >= vs_limit) vs_overflow();
#define vs_head vs_top[-1]
#define vs_pop (*--vs_top)
#define vs_check if (vs_top >= vs_limit) vs_overflow()
#define ihs_check if (ihs_top >= ihs_limit) ihs_overflow()
#define alloc_frame_id() alloc_object(t_spice)
#define complex _Complex
#define I (__extension__ 1.0iF)
#define NOT_SPECIAL ((void (*)())((object)&Cnil_body))
#define VOL volatile
#define compiled_functionp(x) ({enum type _t=({register object _z=(object)(x); ((((ufixnum)(_z))>=0x8000000000000000) ? t_fixnum : ((!(_z)->d.e || (((ufixnum)((*(object *)(_z))))>=0x8000000000000000)) ? (_z==((object)&Cnil_body) ? t_symbol : t_cons) : _z->d.t));});_t>=t_cfun && _t<=t_closure;})
#define mpz_even_p(x) (! (((x)->_mp_size != 0) & ((int) ((x)->_mp_d[0]))))
#define mpz_odd_p(x) (((x)->_mp_size != 0) & ((int) ((x)->_mp_d[0])))
#define mpz_sgn(x) ((x)->_mp_size < 0 ? -1 : (x)->_mp_size > 0)
#define NULL ((void *)0)
#define FALSE 0
#define TRUE 1
#define is_imm_fixnum(x) (((ufixnum)(x))>=0x8000000000000000)
#define aref1 fLrow_major_aref
#define VFUN_NARGS fcall.argd
#define KEYTYPE void *
#define S_DATA(x) ((struct s_data *)((x)->str.str_self))
#define MMcons(x,y) make_cons((x),(y))
#define MMcar(x) (x)->c.c_car
#define MMcdr(x) (x)->c.c_cdr
#define fcalln ((object (*)())fcalln1)
#define CMPcar(x) (x)->c.c_car
#define CMPcdr(x) (x)->c.c_cdr
#define CMPcaar(x) (x)->c.c_car->c.c_car
#define CMPcadr(x) (x)->c.c_cdr->c.c_car
#define CMPcdar(x) (x)->c.c_car->c.c_cdr
#define CMPcddr(x) (x)->c.c_cdr->c.c_cdr
#define CMPcaaar(x) (x)->c.c_car->c.c_car->c.c_car
#define CMPcaadr(x) (x)->c.c_cdr->c.c_car->c.c_car
#define CMPcadar(x) (x)->c.c_car->c.c_cdr->c.c_car
#define CMPcaddr(x) (x)->c.c_cdr->c.c_cdr->c.c_car
#define CMPcdaar(x) (x)->c.c_car->c.c_car->c.c_cdr
#define CMPcdadr(x) (x)->c.c_cdr->c.c_car->c.c_cdr
#define CMPcddar(x) (x)->c.c_car->c.c_cdr->c.c_cdr
#define CMPcdddr(x) (x)->c.c_cdr->c.c_cdr->c.c_cdr
#define CMPcaaaar(x) (x)->c.c_car->c.c_car->c.c_car->c.c_car
#define CMPcaaadr(x) (x)->c.c_cdr->c.c_car->c.c_car->c.c_car
#define CMPcaadar(x) (x)->c.c_car->c.c_cdr->c.c_car->c.c_car
#define CMPcaaddr(x) (x)->c.c_cdr->c.c_cdr->c.c_car->c.c_car
#define CMPcadaar(x) (x)->c.c_car->c.c_car->c.c_cdr->c.c_car
#define CMPcadadr(x) (x)->c.c_cdr->c.c_car->c.c_cdr->c.c_car
#define CMPcaddar(x) (x)->c.c_car->c.c_cdr->c.c_cdr->c.c_car
#define CMPcadddr(x) (x)->c.c_cdr->c.c_cdr->c.c_cdr->c.c_car
#define CMPcdaaar(x) (x)->c.c_car->c.c_car->c.c_car->c.c_cdr
#define CMPcdaadr(x) (x)->c.c_cdr->c.c_car->c.c_car->c.c_cdr
#define CMPcdadar(x) (x)->c.c_car->c.c_cdr->c.c_car->c.c_cdr
#define CMPcdaddr(x) (x)->c.c_cdr->c.c_cdr->c.c_car->c.c_cdr
#define CMPcddaar(x) (x)->c.c_car->c.c_car->c.c_cdr->c.c_cdr
#define CMPcddadr(x) (x)->c.c_cdr->c.c_car->c.c_cdr->c.c_cdr
#define CMPcdddar(x) (x)->c.c_car->c.c_cdr->c.c_cdr->c.c_cdr
#define CMPcddddr(x) (x)->c.c_cdr->c.c_cdr->c.c_cdr->c.c_cdr
#define ALLOCA_CONS(x) (alloca_val=__builtin_alloca ((x)*sizeof(struct cons)))
#define check_arg(x) if (vs_top - vs_base != (x)) check_arg_failed(x)
#define endp_prop(x) (({register object _z=(object)(x); (!(((ufixnum)(_z))>=0x8000000000000000) && (!(_z)->d.e || (((ufixnum)((*(object *)(_z))))>=0x8000000000000000)) && _z!=((object)&Cnil_body));}) ? 0 : ((x)==((object)&Cnil_body) ? 1 : endp_error(x)))
#define fix_imm_fixnum(x) (((fixnum)(x))-(0x8000000000000000 +(0x4000000000000000>>1)))
#define make_imm_fixnum(x) ((object)((x)+(0x8000000000000000 +(0x4000000000000000>>1))))
#define gethash_with_check(x,y) ({object _b=(y);while (({register object _z=(object)(_b); ((((ufixnum)(_z))>=0x8000000000000000) ? t_fixnum : ((!(_z)->d.e || (((ufixnum)((*(object *)(_z))))>=0x8000000000000000)) ? (_z==((object)&Cnil_body) ? t_symbol : t_cons) : _z->d.t));})!=t_hashtable) _b=wrong_type_argument(sLhash_table,_b);gethash(x,_b);})
#define sethash_with_check(x,y,z) ({object _b=(y);while (({register object _z=(object)(_b); ((((ufixnum)(_z))>=0x8000000000000000) ? t_fixnum : ((!(_z)->d.e || (((ufixnum)((*(object *)(_z))))>=0x8000000000000000)) ? (_z==((object)&Cnil_body) ? t_symbol : t_cons) : _z->d.t));})!=t_hashtable) _b=wrong_type_argument(sLhash_table,_b);sethash(x,_b,z);})
#define ON_STACK_LIST_VECTOR_NEW on_stack_list_vector_new
#define ON_STACK_MAKE_LIST on_stack_make_list
#define SAFE_CDR(x) x
#define Scons sLcons
#define EQ(x,y) ((x)==(y))
#define aset aset1
#define stp_ordinary 0
#define SIGNED_CHAR(x) (((char ) -1) < (char )0 ? (char) x : (x >= (1<<(8 -1)) ? x - (((int)(1<<(8 -1))) << 1) : (char ) x))
#define FEerror(x,y...) Icall_gen_error_handler(((object)&Cnil_body),null_string,sLerror,null_string,4,sKformat_control,make_simple_string(x),sKformat_arguments,list(y))
#define FEwrong_type_argument(x,y) Icall_gen_error_handler(((object)&Cnil_body),null_string,sLtype_error,null_string,4,sKdatum,(y),sKexpected_type,(x))
typedef __builtin_va_list __gnuc_va_list;
typedef __gnuc_va_list va_list;
enum type {
  t_cons,
  t_start = 0,
  t_fixnum,
  t_bignum,
  t_ratio,
  t_shortfloat,
  t_longfloat,
  t_complex,
  t_pathname,
  t_string,
  t_bitvector,
  t_vector,
  t_array,
  t_hashtable,
  t_structure,
  t_character,
  t_symbol,
  t_package,
  t_stream,
  t_random,
  t_readtable,
  t_cfun,
  t_cclosure,
  t_sfun,
  t_gfun,
  t_vfun,
  t_afun,
  t_closure,
  t_cfdata,
  t_spice,
  t_contiguous,
  t_end=t_contiguous,
  t_relocatable,
  t_other
};
typedef unsigned long int mp_limb_t;
typedef mp_limb_t * mp_ptr;
typedef struct
{
  int _mp_alloc;
  int _mp_size;
  mp_limb_t *_mp_d;
} __mpz_struct;
typedef __mpz_struct MP_INT;
typedef __mpz_struct * mpz_t;
typedef enum
{
  GMP_RAND_ALG_DEFAULT = 0,
  GMP_RAND_ALG_LC = GMP_RAND_ALG_DEFAULT
} gmp_randalg_t;
typedef struct {
  mpz_t _mp_a;
  unsigned long int _mp_c;
  mpz_t _mp_m;
  unsigned long int _mp_m2exp;
} __gmp_randata_lc;
typedef struct
{
  mpz_t _mp_seed;
  gmp_randalg_t _mp_alg;
  union {
    __gmp_randata_lc *_mp_lc;
  } _mp_algdata;
} __gmp_randstate_struct;
typedef __gmp_randstate_struct gmp_randstate_t[1];
typedef int bool;
typedef long long lfixnum;
typedef unsigned long long ulfixnum;
typedef long fixnum;
typedef unsigned long ufixnum;
typedef float shortfloat;
typedef double longfloat;
typedef union lispunion *object;
struct fixnum_struct {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  fixnum FIXVAL;
};
struct shortfloat_struct {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  shortfloat SFVAL;
};
struct longfloat_struct {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  longfloat LFVAL;
  ;
};
struct bignum {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  __mpz_struct big_mpz_t;
};
struct ratio {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  object rat_den;
  object rat_num;
  ;
};
struct ocomplex {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  object cmp_real;
  object cmp_imag;
  ;
};
struct character {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  unsigned short ch_code;
  unsigned char ch_font;
  unsigned char ch_bits;
};
struct symbol {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  object s_dbind;
  void (*s_sfdef) ();
  char *s_self;
  int s_fillp;
  object s_gfdef;
  object s_plist;
  object s_hpack;
  short s_stype;
  short s_mflag;
  ;
};
struct package {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  object p_name;
  object p_nicknames;
  object p_shadowings;
  object p_uselist;
  object p_usedbylist;
  object *p_internal;
  object *p_external;
  int p_internal_size;
  int p_external_size;
  int p_internal_fp;
  int p_external_fp;
  struct package *p_link;
  ;
};
struct cons {
  object c_cdr;
  object c_car;
};
struct htent {
  object hte_key;
  object hte_value;
};
struct hashtable {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  struct htent *ht_self;
  object ht_rhsize;
  object ht_rhthresh;
  int ht_nent;
  int ht_size;
  short ht_test;
  ;
};
struct array {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  object a_displaced;
  short a_rank;
  short a_elttype;
  object *a_self;
  short a_adjustable;
  short a_offset;
  int a_dim;
  int *a_dims;
  ;
};
struct vector {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  object v_displaced;
  short v_hasfillp;
  short v_elttype;
  object *v_self;
  int v_fillp;
  int v_dim;
  short v_adjustable;
  short v_offset;
  ;
};
struct string {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  object st_displaced;
  short st_hasfillp;
  short st_adjustable;
  char *st_self;
  int st_fillp;
  int st_dim;
};
struct ustring {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  object ust_displaced;
  short ust_hasfillp;
  short ust_adjustable;
  unsigned char *ust_self;
  int ust_fillp;
  int ust_dim;
};
struct bitvector {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  object bv_displaced;
  short bv_hasfillp;
  short bv_elttype;
  char *bv_self;
  int bv_fillp;
  int bv_dim;
  short bv_adjustable;
  short bv_offset;
  ;
};
struct fixarray {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  object fixa_displaced;
  short fixa_rank;
  short fixa_elttype;
  fixnum *fixa_self;
  short fixa_adjustable;
  short fixa_offset;
  int fixa_dim;
  int *fixa_dims;
  ;
};
struct sfarray {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  object sfa_displaced;
  short sfa_rank;
  short sfa_elttype;
  shortfloat *sfa_self;
  short sfa_adjustable;
  short sfa_offset;
  int sfa_dim;
  int *sfa_dims;
  ;
};
struct lfarray {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  object lfa_displaced;
  short lfa_rank;
  short lfa_elttype;
  longfloat *lfa_self;
  short lfa_adjustable;
  short lfa_offset;
  int lfa_dim;
  int *lfa_dims;
  ;
};
struct s_data {
  object name;
  fixnum length;
  object raw;
  object included;
  object includes;
  object staticp;
  object print_function;
  object slot_descriptions;
  object slot_position;
  fixnum size;
  object has_holes;
};
struct structure {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  object str_def;
  object *str_self;
  ;
};
struct stream {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  void *sm_fp;
  object sm_object0;
  object sm_object1;
  int sm_int0;
  int sm_int1;
  char *sm_buffer;
  char sm_mode;
  unsigned char sm_flags;
  short sm_fd;
};
struct random {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  __gmp_randstate_struct rnd_state;
};
struct readtable {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  struct rtent *rt_self;
};
struct pathname {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  object pn_host;
  object pn_device;
  object pn_directory;
  object pn_name;
  object pn_type;
  object pn_version;
  ;
};
struct cfun {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  object cf_name;
  void (*cf_self) ();
  object cf_data;
};
struct cclosure {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  object cc_name;
  void (*cc_self) ();
  object cc_env;
  object cc_data;
  int cc_envdim;
  object *cc_turbo;
  ;
};
struct closure {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  object cl_name;
  object (*cl_self) ();
  object cl_data;
  int cl_argd;
  int cl_envdim;
  object *cl_env;
};
struct sfun {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  object sfn_name;
  object (*sfn_self) ();
  object sfn_data;
  int sfn_argd;
  ;
};
struct vfun {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  object vfn_name;
  object (*vfn_self) ();
  object vfn_data;
  unsigned short vfn_minargs;
  unsigned short vfn_maxargs;
  ;
};
struct cfdata {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  char *cfd_start;
  int cfd_size;
  int cfd_fillp;
  object *cfd_self;
  ;
};
struct spice {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
  int spc_dummy;
};
struct dummy {
  ufixnum e:1,m:1,f:1,s:1,tt:4,t:5,st:3,w:48;
};
struct ff {
  ufixnum ff;
};
struct fstpw {
  ufixnum emfs:4, tp:9, st:3,w:48;
};
union fstp
{
  ufixnum ff;
  struct fstpw t;
};
struct mark {
  ufixnum e:1, mf:2,s:1,tt:4,t:5,x:51;
};
struct typew {
  ufixnum emf:3, s:1,tt:4,t:5,x:51;
};
struct sgcm {
  ufixnum e:1,mfs:3, tt:4,t:5,x:51;
};
union lispunion {
  struct fixnum_struct FIX;
  struct bignum big;
  struct ratio rat;
  struct shortfloat_struct SF;
  struct longfloat_struct LF;
  struct ocomplex cmp;
  struct character ch;
  struct symbol s;
  struct package p;
  struct cons c;
  struct hashtable ht;
  struct array a;
  struct vector v;
  struct string st;
  struct ustring ust;
  struct bitvector bv;
  struct structure str;
  struct stream sm;
  struct random rnd;
  struct readtable rt;
  struct pathname pn;
  struct cfun cf;
  struct cclosure cc;
  struct closure cl;
  struct sfun sfn;
  struct vfun vfn;
  struct cfdata cfd;
  struct spice spc;
  struct dummy d;
  struct fstpw fstp;
  struct ff ff;
  struct mark md;
  struct sgcm smd;
  struct typew td;
  fixnum fw;
  void *vw;
  struct fixarray fixa;
  struct sfarray sfa;
  struct lfarray lfa;
};
extern union lispunion Cnil_body __attribute__ ((aligned (8)));
extern union lispunion Ct_body __attribute__ ((aligned (8)));
struct call_data {
  object fun;
  int argd;
  int nvalues;
  object values[50];
  double double_return;
};
extern struct call_data fcall;
extern union lispunion character_table1[256+128] __attribute__ ((aligned (8)));
extern object Cstd_key_defaults[15];
extern char *alloca_val;
extern object keyword_package;
extern object sLlist;
extern object sLstring;
extern object sLcons;
extern object sLhash_table;
extern object sLerror;
extern object sKformat_control;
extern object sKformat_arguments;
extern object sLtype_error;
extern object sKdatum;
extern object sKexpected_type;
extern object MVloc[10];
extern object null_string;
extern object *vs_org,*vs_limit;
extern object *vs_base;
extern object *vs_top;
struct bds_bd {
 object bds_sym;
 object bds_val;
};
typedef struct bds_bd *bds_ptr;
extern bds_ptr bds_org,bds_limit;
extern bds_ptr bds_top;
typedef struct invocation_history {
 object ihs_function;
 object *ihs_base;
} *ihs_ptr;
extern ihs_ptr ihs_org,ihs_limit;
extern ihs_ptr ihs_top;
enum fr_class {
 FRS_CATCH,
 FRS_CATCHALL,
 FRS_PROTECT
};
extern int in_signal_handler;
struct frame {
  char frs_jmpbuf[200] __attribute__ ((__aligned__ (8*2)));
  object *frs_lex;
  bds_ptr frs_bds_top;
  object frs_val;
  ihs_ptr frs_ihs;
  char frs_class;
  char frs_in_signal_handler;
};
typedef struct frame *frame_ptr;
extern frame_ptr frs_org,frs_limit;
extern frame_ptr frs_top;
extern bool nlj_active;
extern frame_ptr nlj_fr;
extern object nlj_tag;
extern object *lex_env;
bool eql1(object,object);
bool equal1(object,object);
bool equalp1(object,object);
bool file_exists(object);
bool integer_bitp(object,object);
double big_to_double(object);
frame_ptr frs_sch_catch(object);
frame_ptr frs_sch(object);
int length(object);
int number_compare(object,object);
int number_evenp(object);
int number_minusp(object);
int number_oddp(object);
int number_plusp(object);
int number_zerop(object);
long int fixint(object);
object alloc_object(enum type);
object call_proc_new(object,void **,int,object,va_list);
object coerce_to_string();
object elt(object,int);
object fixnum_big_shift(fixnum,fixnum);
object fixnum_times(fixnum,fixnum);
object fSsputprop(object,object,object);
object get(object,object,object);
object get_gcd(object,object);
object get_lcm(object,object);
object integer_count(object);
object integer_length(object);
object integer_shift(object,object);
object listA(int,...);
object list(int,...);
object log_op2(fixnum,object,object);
object make_cons(object,object);
object make_fixnum1(long);
object make_list(int);
object make_longfloat(longfloat);
object make_shortfloat(double);
object make_simple_string(const char *);
object number_abs(object);
object number_divide(object, object);
object number_dpb(object,object,object);
object number_dpf(object,object,object);
object number_ldb(object,object);
object number_ldbt(object,object);
object number_minus(object,object);
object number_negate(object);
object number_plus(object,object);
object number_signum(object);
object number_times(object,object);
object princ(object,object);
object read_char1(object,object);
object structure_ref(object,object,fixnum);
object structure_set(object,object,fixnum,object);
object symbol_function(object);
object symbol_name(object);
object symbol_value(object);
object terpri(object);
object vs_overflow(void);
void bds_overflow(void);
void bds_unwind(bds_ptr);
void do_init(object *);
void frs_overflow(void);
void intdivrem(object,object,fixnum,object *,object *);
void princ_char(int,object);
void princ_str(char *,object);
void princ_str(char *,object);
void sethash(object,object,object);
void setq(object,object);
void super_funcall_no_event(object);
void unwind(frame_ptr,object) __attribute__ ((noreturn));
int object_to_int(object);
fixnum object_to_fixnum(object);
char object_to_char(object);
void not_a_symbol(object);
object number_expt(object,object);
object fLrow_major_aref(object,fixnum);
object car(object);
object cdr(object);
object caar(object);
object cadr(object);
object cdar(object);
object cddr(object);
object caaar(object);
object caadr(object);
object cadar(object);
object caddr(object);
object cdaar(object);
object cdadr(object);
object cddar(object);
object cdddr(object);
object caaaar(object);
object caaadr(object);
object caadar(object);
object caaddr(object);
object cadaar(object);
object cadadr(object);
object caddar(object);
object cadddr(object);
object cdaaar(object);
object cdaadr(object);
object cdadar(object);
object cdaddr(object);
object cddaar(object);
object cddadr(object);
object cdddar(object);
object cddddr(object);
object fcalln1(object,...);
object append(object,object);
object aset1(object,fixnum,object);
void call_or_link(object,void **);
object call_proc0(object,void *);
object call_vproc_new(object,void *,object,va_list);
void check_arg_failed (int);
void check_other_key (object,int, ...);
object elt_set(object,int,object);
void funcall(object);
object getf(object,object,object);
struct htent * gethash(object,object);
void invalid_macro_call(void);
long labs(long);
object list_vector_new(int,object,va_list);
object make_cclosure_new(void (*)(),object,object,object);
object nconc(object,object);
object nreverse(object);
object one_plus(object);
object one_minus(object);
void parse_key(object *,bool,bool,int,...);
int parse_key_new_new();
int parse_key_rest_new();
object prin1(object,object);
object print(object,object);
object putprop(object,object,object);
object remprop(object,object);
object reverse(object);
object simple_symlispcall(object,object *,int);
object sputprop(object,object,object);
void symlispcall(object,object *,int);
void too_few_arguments(void);
void too_many_arguments(void);
object wrong_type_argument(object,object);
bool oeql(object,object);
void call_or_link_closure(object,void **,void **);
void check_alist(object);
void lispcall(object *,int);
object make_cclosure(void (*)(),object,object,object,char *,int);
object simple_lispcall(object *,int);
object sublis1(object,object,bool(*)());
void turbo_closure(object);
char * object_to_string(object);
object on_stack_cons(object,object);
object on_stack_list(int,...);
object on_stack_list_vector_new(int,object,va_list);
object on_stack_make_list(int);
object read_byte1(object,object);
int not_a_variable(object);
object cmod(object);
object ctimes(object,object);
object cdifference(object,object);
object cplus(object,object);
void funcall_with_catcher(object,object);
void check_type_symbol(object *);
void ck_larg_exactly(int, object);
double cos(double);
double sin(double);
double sqrt(double);
double tan(double);
int gcl_feof(void *);
int gcl_getc(void *);
int gcl_putc(int,void *);
int setjmp();
int _setjmp();
void vfun_wrong_number_of_args(object);
void ihs_overflow (void);
double object_to_double(object);
void gcl_init_or_load1(void (*)(void),const char *);
char *gcl_gets(char *,int);
int gcl_puts(const char *);
int endp_error(object);
object Icall_gen_error_handler(object,object,object,object,ufixnum,...);
extern inline fixnum
lnabs(fixnum x) {return x<0 ? ~x : x;}
extern inline char
clz(ufixnum x) {
  return x ? __builtin_clzl(x) : sizeof(x)*8;
}
extern inline char
ctz(ufixnum x) {
  return __builtin_ctzl(x);
}
extern inline char
fixnum_length(fixnum x) {return sizeof(x)*8-clz(lnabs(x));}
extern inline object
immnum_length(object x) {return is_imm_fixnum(x) ? make_imm_fixnum(fixnum_length(fix_imm_fixnum(x))) : integer_length(x);}
extern inline char
fixnum_popcount(ufixnum x) {
  x-=0x5555555555555555UL&(x>>1);
  x=(x&0x3333333333333333UL)+((x>>2)&0x3333333333333333UL);
  x=0x0F0F0F0F0F0F0F0FUL&(x+(x>>4));
  x+=x>>8;
  x+=x>>16;
  x+=x>>32;
  return x&0x7F;
}
extern inline char
fixnum_count(fixnum x) {return fixnum_popcount(lnabs(x));}
extern inline object
immnum_count(object x) {return is_imm_fixnum(x) ? make_imm_fixnum(fixnum_count(fix_imm_fixnum(x))) : integer_count(x);}
extern inline bool
fixnum_mul_safe_abs(fixnum x,fixnum y) {return clz(x)+clz(y)>sizeof(x)*8+1;}
extern inline object
safe_mul_abs(fixnum x,fixnum y) {return fixnum_mul_safe_abs(x,y) ? make_fixnum(x*y) : fixnum_times(x,y);}
extern inline bool
fixnum_mul_safe(fixnum x,fixnum y) {return fixnum_mul_safe_abs(labs(x),labs(y));}
extern inline object
safe_mul(fixnum x,fixnum y) {return fixnum_mul_safe(x,y) ? make_fixnum(x*y) : fixnum_times(x,y);}
extern inline object
immnum_times(object x,object y) {return is_imm_fixnum(((ufixnum)x)&((ufixnum)y)) ? safe_mul(fix_imm_fixnum(x),fix_imm_fixnum(y)) : number_times(x,y);}
extern inline object
immnum_plus(object x,object y) {return is_imm_fixnum(((ufixnum)x)&((ufixnum)y)) ? make_fixnum(fix_imm_fixnum(x)+fix_imm_fixnum(y)) : number_plus(x,y);}
extern inline object
immnum_minus(object x,object y) {return is_imm_fixnum(((ufixnum)x)&((ufixnum)y)) ? make_fixnum(fix_imm_fixnum(x)-fix_imm_fixnum(y)) : number_minus(x,y);}
extern inline object
immnum_negate(object x) {return is_imm_fixnum(x) ? make_fixnum(-fix_imm_fixnum(x)) : number_negate(x);}
extern inline fixnum
fixnum_boole(fixnum op,fixnum x,fixnum y) {
  switch(op) {
  case 0: return 0;
  case 017: return -1;
  case 03: return x;
  case 05: return y;
  case 014: return ~x;
  case 012: return ~y;
  case 01: return x&y;
  case 07: return x|y;
  case 06: return x^y;
  case 011: return ~(x^y);
  case 016: return ~(x&y);
  case 010: return ~(x|y);
  case 04:return ~x&y;
  case 02:return x&~y;
  case 015: return ~x|y;
  case 013: return x|~y;
  }
  return 0;
}
extern inline object
immnum_boole(fixnum o,object x,object y) {return is_imm_fixnum(((ufixnum)x)&((ufixnum)y)) ? make_imm_fixnum(fixnum_boole(o,fix_imm_fixnum(x),fix_imm_fixnum(y))) : log_op2(o,x,y);}
extern inline fixnum
fixnum_div(fixnum x,fixnum y,fixnum d) {
  fixnum z=x/y;
  if (d && x!=y*z && (x*d>0 ? y>0 : y<0))
    z+=d;
  return z;
}
extern inline fixnum
fixnum_rem(fixnum x,fixnum y,fixnum d) {
  fixnum z=x%y;
  if (d && z && (x*d>0 ? y>0 : y<0))
    z+=y;
  return z;
}
extern inline object
immnum_truncate(object x,object y) {return is_imm_fixnum(((ufixnum)x)&((ufixnum)y))&&y!=make_fixnum(0) ? make_imm_fixnum(fixnum_div(fix_imm_fixnum(x),fix_imm_fixnum(y),0)) : (intdivrem(x,y,0,&x,NULL),x);}
extern inline object
immnum_floor(object x,object y) {return is_imm_fixnum(((ufixnum)x)&((ufixnum)y))&&y!=make_fixnum(0) ? make_imm_fixnum(fixnum_div(fix_imm_fixnum(x),fix_imm_fixnum(y),-1)) : (intdivrem(x,y,-1,&x,NULL),x);}
extern inline object
immnum_ceiling(object x,object y) {return is_imm_fixnum(((ufixnum)x)&((ufixnum)y))&&y!=make_fixnum(0) ? make_imm_fixnum(fixnum_div(fix_imm_fixnum(x),fix_imm_fixnum(y),1)) : (intdivrem(x,y,1,&x,NULL),x);}
extern inline object
immnum_mod(object x,object y) {return is_imm_fixnum(((ufixnum)x)&((ufixnum)y))&&y!=make_fixnum(0) ? make_imm_fixnum(fixnum_rem(fix_imm_fixnum(x),fix_imm_fixnum(y),-1)) : (intdivrem(x,y,-1,NULL,&y),y);}
extern inline object
immnum_rem(object x,object y) {return is_imm_fixnum(((ufixnum)x)&((ufixnum)y))&&y!=make_fixnum(0) ? make_imm_fixnum(fixnum_rem(fix_imm_fixnum(x),fix_imm_fixnum(y),0)) : (intdivrem(x,y,0,NULL,&y),y);}
extern inline fixnum
fixnum_rshft(fixnum x,fixnum y) {
  return y>=sizeof(x)*8 ? (x<0 ? -1 : 0) : x>>y;
}
extern inline object
fixnum_lshft(fixnum x,fixnum y) {
  return clz(labs(x))>y ? make_fixnum(x<<y) : (x ? fixnum_big_shift(x,y) : make_fixnum(0));
}
extern inline object
fixnum_shft(fixnum x,fixnum y) {
  return y<0 ? make_fixnum(fixnum_rshft(x,-y)) : fixnum_lshft(x,y);
}
extern inline object
immnum_shft(object x,object y) {return is_imm_fixnum(((ufixnum)x)&((ufixnum)y)) ? fixnum_shft(fix_imm_fixnum(x),fix_imm_fixnum(y)) : integer_shift(x,y);}
extern inline bool
fixnum_bitp(fixnum p,fixnum x) {return fixnum_rshft(x,p)&0x1;}
extern inline bool
immnum_bitp(object x,object y) {return is_imm_fixnum(((ufixnum)x)&((ufixnum)y)) ? fixnum_bitp(fix_imm_fixnum(x),fix_imm_fixnum(y)) : integer_bitp(x,y);}
extern inline bool
immnum_lt(object x,object y) {return is_imm_fixnum(((ufixnum)x)&((ufixnum)y)) ? (x < y) : (number_compare(x,y) < 0);}
extern inline bool
immnum_le(object x,object y) {return is_imm_fixnum(((ufixnum)x)&((ufixnum)y)) ? (x <= y) : (number_compare(x,y) <= 0);}
extern inline bool
immnum_eq(object x,object y) {return is_imm_fixnum(((ufixnum)x)&((ufixnum)y)) ? (x == y) : (number_compare(x,y) == 0);}
extern inline bool
immnum_ne(object x,object y) {return is_imm_fixnum(((ufixnum)x)&((ufixnum)y)) ? (x != y) : (number_compare(x,y) != 0);}
extern inline bool
immnum_gt(object x,object y) {return is_imm_fixnum(((ufixnum)x)&((ufixnum)y)) ? (x > y) : (number_compare(x,y) > 0);}
extern inline bool
immnum_ge(object x,object y) {return is_imm_fixnum(((ufixnum)x)&((ufixnum)y)) ? (x >= y) : (number_compare(x,y) >= 0);}
extern inline bool
immnum_minusp(object x) {return is_imm_fixnum(x) ? ((ufixnum)x)<((ufixnum)make_fixnum(0)) : number_minusp(x);}
extern inline bool
immnum_plusp(object x) {return is_imm_fixnum(x) ? ((ufixnum)x)>((ufixnum)make_fixnum(0)) : number_plusp(x);}
extern inline bool
immnum_zerop(object x) {return is_imm_fixnum(x) ? ((ufixnum)x)==((ufixnum)make_fixnum(0)) : number_zerop(x);}
extern inline bool
immnum_evenp(object x) {return is_imm_fixnum(x) ? !(((ufixnum)x)&0x1) : number_evenp(x);}
extern inline bool
immnum_oddp(object x) {return is_imm_fixnum(x) ? (((ufixnum)x)&0x1) : number_oddp(x);}
extern inline object
immnum_signum(object x) {
  ufixnum ux=(ufixnum)x,uz=((ufixnum)make_fixnum(0));
  return is_imm_fixnum(x) ? (ux<uz ? make_imm_fixnum(-1) : (ux==uz ? make_imm_fixnum(0) : make_imm_fixnum(1))) : number_signum(x);
}
extern inline object
immnum_abs(object x) {return is_imm_fixnum(x) ? make_fixnum(labs(fix_imm_fixnum(x))) : number_abs(x);}
extern inline fixnum
fixnum_ldb(fixnum s,fixnum p,fixnum i) {
  return ((1UL<<s)-1)&fixnum_rshft(i,p);
}
extern inline object
immnum_ldb(object x,object i) {
  if (is_imm_fixnum(i))
    if (({register object _z=(object)(x); (!is_imm_fixnum(_z) && (!(_z)->d.e || is_imm_fixnum((*(object *)(_z)))) && _z!=Cnil);})) {
      object s=x->c.c_car,p=x->c.c_cdr;
      if (is_imm_fixnum(((ufixnum)s)&((ufixnum)p))) {
 fixnum fs=fix_imm_fixnum(s),fp=fix_imm_fixnum(p);
 if (fs+fp<sizeof(fs)*8)
   return make_fixnum(fixnum_ldb(fs,fp,fix_imm_fixnum(i)));
      }
    }
  return number_ldb(x,i);
}
extern inline bool
immnum_ldbt(object x,object i) {
  if (is_imm_fixnum(i))
    if (({register object _z=(object)(x); (!is_imm_fixnum(_z) && (!(_z)->d.e || is_imm_fixnum((*(object *)(_z)))) && _z!=Cnil);})) {
      object s=x->c.c_car,p=x->c.c_cdr;
      if (is_imm_fixnum(((ufixnum)s)&((ufixnum)p))) {
 fixnum fs=fix_imm_fixnum(s),fp=fix_imm_fixnum(p);
 if (fs+fp<sizeof(fs)*8)
   return fixnum_ldb(fs,fp,fix_imm_fixnum(i));
      }
    }
  return number_ldbt(x,i)!=Cnil;
}
extern inline fixnum
fixnum_dpb(fixnum s,fixnum p,fixnum n,fixnum i) {
  fixnum z=(1UL<<s)-1;
  return (i&~(z<<p))|((n&z)<<p);
}
extern inline object
immnum_dpb(object n,object x,object i) {
  if (is_imm_fixnum(((ufixnum)n)&((ufixnum)i)))
    if (({register object _z=(object)(x); (!is_imm_fixnum(_z) && (!(_z)->d.e || is_imm_fixnum((*(object *)(_z)))) && _z!=Cnil);})) {
      object s=x->c.c_car,p=x->c.c_cdr;
      if (is_imm_fixnum(((ufixnum)s)&((ufixnum)p))) {
 fixnum fs=fix_imm_fixnum(s),fp=fix_imm_fixnum(p);
 if (fs+fp<sizeof(fs)*8)
   return make_fixnum(fixnum_dpb(fs,fp,fix_imm_fixnum(n),fix_imm_fixnum(i)));
      }
    }
  return number_dpb(n,x,i);
}
extern inline fixnum
fixnum_dpf(fixnum s,fixnum p,fixnum n,fixnum i) {
  fixnum z=((1UL<<s)-1)<<p;
  return (i&~z)|(n&z);
}
extern inline object
immnum_dpf(object n,object x,object i) {
  if (is_imm_fixnum(((ufixnum)n)&((ufixnum)i)))
    if (({register object _z=(object)(x); (!is_imm_fixnum(_z) && (!(_z)->d.e || is_imm_fixnum((*(object *)(_z)))) && _z!=Cnil);})) {
      object s=x->c.c_car,p=x->c.c_cdr;
      if (is_imm_fixnum(((ufixnum)s)&((ufixnum)p))) {
 fixnum fs=fix_imm_fixnum(s),fp=fix_imm_fixnum(p);
 if (fs+fp<sizeof(fs)*8)
   return make_fixnum(fixnum_dpf(fs,fp,fix_imm_fixnum(n),fix_imm_fixnum(i)));
      }
    }
  return number_dpf(n,x,i);
}
extern inline object
immnum_max(object x,object y) {return is_imm_fixnum(((ufixnum)x)&((ufixnum)y)) ? ((ufixnum)x>=(ufixnum)y ? x : y) : (number_compare(x,y)>=0?x:y);}
extern inline object
immnum_min(object x,object y) {return is_imm_fixnum(((ufixnum)x)&((ufixnum)y)) ? ((ufixnum)x<=(ufixnum)y ? x : y) : (number_compare(x,y)<=0?x:y);}
extern inline bool
immnum_logt(object x,object y) {return is_imm_fixnum(((ufixnum)x)&((ufixnum)y)) ? fixnum_boole(01,fix_imm_fixnum(x),fix_imm_fixnum(y))!=0 : !number_zerop(log_op2(01,x,y));}
extern inline fixnum
fixnum_gcd(fixnum x,fixnum y) {
  fixnum t;
  char tx,ty;
  if (!x) return y;
  if (!y) return x;
  tx=ctz(x);
  ty=ctz(y);
  tx=tx<ty ? tx : ty;
  x>>=tx;
  y>>=tx;
  t=x&0x1 ? -y : x>>1;
  do {
    t>>=ctz(t);
    if (t>0) x=t; else y=-t;
    t=x-y;
  } while (t);
  return x<<tx;
}
extern inline object
immnum_gcd(object x,object y) {return is_imm_fixnum(((ufixnum)x)&((ufixnum)y)) ? make_imm_fixnum(fixnum_gcd(labs(fix_imm_fixnum(x)),labs(fix_imm_fixnum(y)))) : get_gcd(x,y);}
extern inline object
fixnum_lcm(fixnum x,fixnum y) {
  fixnum g=fixnum_gcd(x,y);
  return g ? safe_mul_abs(x,fixnum_div(y,g,0)) : make_fixnum(0);
}
extern inline object
immnum_lcm(object x,object y) {return is_imm_fixnum(((ufixnum)x)&((ufixnum)y)) ? fixnum_lcm(labs(fix_imm_fixnum(x)),labs(fix_imm_fixnum(y))) : get_lcm(x,y);}