/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/lsp/defstruct.lsp                   */
#include <ecl/ecl-cmp.h>
#include "lsp/defstruct.eclh"
/* function definition for SLOT-ACCESS-FUNCTION                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L300slot_access_function(cl_object v1conc_name, cl_object v2slot_name)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (Null(v1conc_name)){
  goto L2;
 }
 T0 = si_base_string_concatenate(2, v1conc_name, v2slot_name);
 value0 = cl_intern(1, T0);
 return value0;
L2:;
 value0 = v2slot_name;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L300slot_access_function_va(cl_narg narg, cl_object v3conc_name, cl_object v4slot_name, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[0]);
 {
  return L300slot_access_function(v3conc_name, v4slot_name);
 }
}
/* function definition for MAKE-ATOMIC-ACCESSORS                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L301make_atomic_accessors(cl_object v1name, cl_object v2conc_name, cl_object v3type, cl_object v4slot_descriptions, cl_object v5removep)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (!(v3type==ECL_NIL)){
  goto L2;
 }
 {
  cl_object v6accessors;
  v6accessors = ECL_NIL;
  {
   cl_object v7;
   v7 = v4slot_descriptions;
   goto L8;
L7:;
   {
    cl_object v8slotd;
    v8slotd = ecl_car(v7);
    {
     cl_object v9;
     cl_object v10;
     cl_object v11;
     T0 = ecl_car(v8slotd);
     v9 = L300slot_access_function(v2conc_name, T0);
     v10 = ecl_cadddr(v8slotd);
     T0 = ecl_cddddr(v8slotd);
     v11 = ecl_car(T0);
     if (!(v10==ECL_NIL)){
      goto L16;
     }
     if (!(v5removep==ECL_NIL)){
      goto L16;
     }
     T0 = cl_list(2, ECL_SYM("QUOTE",682), v1name);
     T1 = cl_list(3, ECL_SYM("LIST",483), VV[9], T0);
     T2 = cl_list(2, ECL_SYM("QUOTE",682), v11);
     T3 = cl_listX(6, ECL_SYM("LIST",483), VV[7], VV[8], T1, T2, VV[10]);
     T4 = cl_list(2, ECL_SYM("QUOTE",682), v1name);
     T5 = cl_list(3, ECL_SYM("LIST",483), VV[9], T4);
     T6 = cl_list(2, ECL_SYM("QUOTE",682), v11);
     T7 = cl_list(5, ECL_SYM("LIST",483), VV[11], VV[8], T5, T6);
     T8 = cl_list(7, ECL_SYM("VALUES",899), ECL_NIL, ECL_NIL, VV[5], VV[6], T3, T7);
     T9 = cl_list(3, ECL_SYM("LET",479), VV[4], T8);
     T10 = cl_list(4, ECL_SYM("DEFINE-CAS-EXPANDER",1533), v9, VV[3], T9);
     v6accessors = CONS(T10,v6accessors);
     goto L12;
L16:;
     T0 = cl_list(2, ECL_SYM("QUOTE",682), v9);
     T1 = cl_list(2, ECL_SYM("REMCAS",1535), T0);
     v6accessors = CONS(T1,v6accessors);
    }
L12:;
   }
   v7 = ecl_cdr(v7);
L8:;
   if (Null(v7)){
    goto L23;
   }
   goto L7;
L23:;
   value0 = v6accessors;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L301make_atomic_accessors_va(cl_narg narg, cl_object v8name, cl_object v9conc_name, cl_object v10type, cl_object v11slot_descriptions, cl_object v12removep, ...)
{
 if (ecl_unlikely(narg!=5)) FEwrong_num_arguments(VV[2]);
 {
  return L301make_atomic_accessors(v8name, v9conc_name, v10type, v11slot_descriptions, v12removep);
 }
}
/* function definition for STRUCTURE-TYPE-ERROR                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_structure_type_error(cl_object v1value, cl_object v2slot_type, cl_object v3struct_name, cl_object v4slot_name)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 T0 = cl_list(3, v4slot_name, v3struct_name, v2slot_type);
 value0 = cl_error(9, ECL_SYM("SIMPLE-TYPE-ERROR",776), ECL_SYM("FORMAT-CONTROL",1272), VV[14], ECL_SYM("FORMAT-ARGUMENTS",1271), T0, ECL_SYM("DATUM",1245), v1value, ECL_SYM("EXPECTED-TYPE",1263), v2slot_type);
 return value0;
}
cl_object si_structure_type_error_va(cl_narg narg, cl_object v5value, cl_object v6slot_type, cl_object v7struct_name, cl_object v8slot_name, ...)
{
 if (ecl_unlikely(narg!=4)) FEwrong_num_arguments(VV[13]);
 {
  return si_structure_type_error(v5value, v6slot_type, v7struct_name, v8slot_name);
 }
}
/* function definition for MAKE-ACCESS-FUNCTION                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L304make_access_function(cl_object v1name, cl_object v2conc_name, cl_object v3type, cl_object v4named, cl_object v5slot_descr)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 cl_object CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 env0 = ECL_NIL;
 CLV0 = env0 = CONS(v1name,env0);                 /*  NAME                    */
 {
  cl_object v6slot_name;
  cl_object v7read_only;
  cl_object v8access_function;
  cl_object env1 = env0;
  v6slot_name = ecl_car(v5slot_descr);
  v7read_only = ecl_cadddr(v5slot_descr);
  T0 = ecl_cddddr(v5slot_descr);
  T1 = ecl_car(T0);
  CLV1 = env1 = CONS(T1,env1);                    /*  OFFSET                  */
  v8access_function = L300slot_access_function(v2conc_name, v6slot_name);
  T0 = ecl_cddddr(v5slot_descr);
  T1 = ecl_cadr(T0);
  if (!(ecl_eql(v8access_function,T1))){
   goto L5;
  }
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L5:;
  {
   cl_object v9;
   v9 = v8access_function;
   {
    cl_object v10;
    T1 = ecl_cddddr(v5slot_descr);
    v10 = ecl_cdr(T1);
    if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    T0 = v10;
   }
   (ECL_CONS_CAR(T0)=v9,T0);
  }
  if (!(v3type==ECL_NIL)){
   goto L13;
  }
  {
   cl_object v9;
   v9 = ecl_make_cclosure_va((cl_objectfn)LC302__lambda14,env1,Cblock,1);
   T0 = v9;
  }
  si_fset(2, v8access_function, T0);
  goto L12;
L13:;
  if (Null(cl_subtypep(2, v3type, VV[18]))){
   goto L16;
  }
  {
   cl_object v9;
   v9 = ecl_make_cclosure_va((cl_objectfn)LC303__lambda16,env1,Cblock,1);
   T0 = v9;
  }
  si_fset(2, v8access_function, T0);
  goto L12;
L16:;
  cl_error(2, VV[20], v3type);
L12:;
  if (Null(v7read_only)){
   goto L19;
  }
  T0 = cl_list(2, ECL_SYM("SETF",753), v8access_function);
  cl_fmakunbound(T0);
  value0 = si_set_documentation(v8access_function, ECL_SYM("SETF",753), ECL_NIL);
  return value0;
L19:;
  value0 = v3type;
  if (value0!=ECL_NIL) {
   goto L24;
  }
  T0 = ECL_CONS_CAR(CLV0);
  goto L22;
L24:;
  T0 = value0;
  goto L22;
L22:;
  value0 = L308do_setf_structure_method(v8access_function, T0, ECL_CONS_CAR(CLV1));
  return value0;
 }
}
/* function definition for DO-SETF-STRUCTURE-METHOD                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L308do_setf_structure_method(cl_object v1access_function, cl_object v2type, cl_object v3index)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 cl_object CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 env0 = ECL_NIL;
 CLV0 = env0 = CONS(v2type,env0);                 /*  TYPE                    */
 CLV1 = env0 = CONS(v3index,env0);                /*  INDEX                   */
 T0 = CONS(ECL_CONS_CAR(CLV0),ECL_CONS_CAR(CLV1));
 si_put_sysprop(v1access_function, VV[23], T0);
 if ((ECL_CONS_CAR(CLV0))==(ECL_SYM("LIST",483))) {
  goto L5;
 }
 if (!((ECL_CONS_CAR(CLV0))==(ECL_SYM("VECTOR",902)))){
  goto L3;
 }
 goto L4;
L5:;
L4:;
 {
  cl_object v4;
  v4 = ecl_make_cclosure_va((cl_objectfn)LC305__lambda19,env0,Cblock,2);
  T0 = v4;
  goto L2;
 }
L3:;
 if (!(ECL_CONSP(ECL_CONS_CAR(CLV0)))){
  goto L7;
 }
 {
  cl_object v5;
  v5 = ecl_make_cclosure_va((cl_objectfn)LC306__lambda21,env0,Cblock,2);
  T0 = v5;
  goto L2;
 }
L7:;
 {
  cl_object v6;
  v6 = ecl_make_cclosure_va((cl_objectfn)LC307__lambda23,env0,Cblock,2);
  T0 = v6;
 }
L2:;
 value0 = si_do_defsetf(2, v1access_function, T0);
 return value0;
}
/* function definition for PROCESS-BOA-LAMBDA-LIST                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L309process_boa_lambda_list(cl_object v1slot_names, cl_object v2slot_descriptions, cl_object v3boa_list, cl_object v4assertions)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v5mentioned_slots;
  cl_object v6aux;
  v5mentioned_slots = ECL_NIL;
  v6aux = ECL_NIL;
  v3boa_list = cl_copy_list(v3boa_list);
  si_process_lambda_list(v3boa_list, ECL_SYM("FUNCTION",398));
  {
   cl_object v7i;
   cl_object v8slot;
   cl_object v9modify;
   v7i = v3boa_list;
   v8slot = ecl_car(v7i);
   v9modify = ECL_NIL;
   goto L12;
L11:;
   if ((v8slot)==(ECL_SYM("&OPTIONAL",13))) {
    goto L17;
   }
   if (!((v8slot)==(ECL_SYM("&KEY",12)))){
    goto L15;
   }
   goto L16;
L17:;
L16:;
   v9modify = ECL_T;
   goto L14;
L15:;
   if (!((v8slot)==(ECL_SYM("&REST",14)))){
    goto L20;
   }
   v9modify = ECL_NIL;
   goto L14;
L20:;
   if (!((v8slot)==(ECL_SYM("&AUX",9)))){
    goto L23;
   }
   v6aux = ECL_T;
   v9modify = ECL_NIL;
   goto L14;
L23:;
   {
    cl_object v10;
    v10 = ecl_make_bool((v8slot)==(ECL_SYM("&ALLOW-OTHER-KEYS",8)));
    if (Null(v10)){
     goto L29;
    }
    goto L14;
L29:;
    if (!(ECL_ATOM(v8slot))){
     goto L31;
    }
    v5mentioned_slots = CONS(v8slot,v5mentioned_slots);
    if (Null(v9modify)){
     goto L35;
    }
    {
     cl_object v11;
     {
      cl_object v12;
      cl_object v13;
      v12 = v8slot;
      v13 = v2slot_descriptions;
      T0 = ecl_assql(v12,v13);
     }
     T1 = ecl_cadr(T0);
     v11 = cl_list(2, v8slot, T1);
     {
      cl_object v12;
      v12 = v7i;
      if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T0 = v12;
     }
     (ECL_CONS_CAR(T0)=v11,T0);
    }
L35:;
    if (Null(v6aux)){
     goto L14;
    }
    v4assertions = cl_delete(4, v8slot, v4assertions, ECL_SYM("KEY",1297), ECL_SYM("CADADR",175));
    goto L14;
L31:;
    {
     cl_object v11slot_name;
     v11slot_name = ecl_car(v8slot);
     if (!(ECL_CONSP(v11slot_name))){
      goto L48;
     }
     v11slot_name = ecl_cadr(v11slot_name);
L48:;
     v5mentioned_slots = CONS(v11slot_name,v5mentioned_slots);
     T0 = ecl_cdr(v8slot);
     if (!(ecl_endp(T0))){
      goto L14;
     }
     if (Null(v9modify)){
      goto L54;
     }
     {
      cl_object v12;
      {
       cl_object v13;
       cl_object v14;
       v13 = v11slot_name;
       v14 = v2slot_descriptions;
       T0 = ecl_assql(v13,v14);
      }
      T1 = ecl_cadr(T0);
      v12 = ecl_list1(T1);
      {
       cl_object v13;
       v13 = v8slot;
       if (ecl_unlikely(ECL_ATOM(v13))) FEtype_error_cons(v13);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T0 = v13;
      }
      (ECL_CONS_CDR(T0)=v12,T0);
     }
L54:;
     if (Null(v6aux)){
      goto L14;
     }
     v4assertions = cl_delete(4, v8slot, v4assertions, ECL_SYM("KEY",1297), ECL_SYM("CADADR",175));
    }
   }
L14:;
   v7i = ecl_cdr(v7i);
   v8slot = ecl_car(v7i);
L12:;
   if (ecl_endp(v7i)) {
    goto L70;
   }
   goto L11;
L70:;
  }
  {
   cl_object v7other_slots;
   T0 = (ECL_SYM("CONSP",254)->symbol.gfdef);
   T1 = cl_copy_list(v1slot_names);
   T2 = cl_delete_if(2, T0, T1);
   v7other_slots = cl_nset_difference(2, T2, v5mentioned_slots);
   {
    cl_object v8l;
    v8l = v7other_slots;
    goto L78;
L77:;
    {
     cl_object v9slot;
     cl_object v10slot_init;
     {
      cl_object v11;
      cl_object v12;
      cl_object v13;
      v11 = ecl_car(v8l);
      v12 = v11;
      v13 = v2slot_descriptions;
      v9slot = ecl_assql(v12,v13);
     }
     v10slot_init = ecl_cadr(v9slot);
     if (Null(v10slot_init)){
      goto L80;
     }
     {
      cl_object v11;
      T0 = ecl_car(v8l);
      v11 = cl_list(2, T0, v10slot_init);
      {
       cl_object v12;
       v12 = v8l;
       if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T0 = v12;
      }
      (ECL_CONS_CAR(T0)=v11,T0);
     }
    }
L80:;
    v8l = ecl_cdr(v8l);
L78:;
    if (ecl_endp(v8l)) {
     goto L94;
    }
    goto L77;
L94:;
   }
   if (Null(v7other_slots)){
    goto L96;
   }
   if (v6aux!=ECL_NIL) {
    goto L98;
   }
   v7other_slots = CONS(ECL_SYM("&AUX",9),v7other_slots);
L98:;
   v3boa_list = ecl_nconc(v3boa_list,v7other_slots);
L96:;
   cl_env_copy->nvalues = 2;
   cl_env_copy->values[1] = v4assertions;
   cl_env_copy->values[0] = v3boa_list;
   return cl_env_copy->values[0];
  }
 }
}
/* function definition for MAKE-CONSTRUCTOR                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L310make_constructor(cl_object v1name, cl_object v2constructor, cl_object v3type, cl_object v4named, cl_object v5slot_descriptions, cl_object v6env)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v7boa_constructor_p;
  cl_object v8keys;
  cl_object v9constructor_name;
  cl_object v10slot_names;
  cl_object v11assertions;
  v7boa_constructor_p = ecl_make_bool(ECL_CONSP(v2constructor));
  if (v7boa_constructor_p!=ECL_NIL) {
   goto L4;
  }
  v8keys = ecl_list1(ECL_SYM("&KEY",12));
  goto L3;
L4:;
  v8keys = ECL_NIL;
L3:;
  if (Null(v7boa_constructor_p)){
   goto L7;
  }
  v9constructor_name = ecl_car(v2constructor);
  goto L6;
L7:;
  v9constructor_name = v2constructor;
L6:;
  v10slot_names = ECL_NIL;
  v11assertions = ECL_NIL;
  {
   cl_object v12;
   v12 = v5slot_descriptions;
   goto L15;
L14:;
   {
    cl_object v13slot;
    v13slot = ecl_car(v12);
    if (!(v13slot==ECL_NIL)){
     goto L22;
    }
    T0 = ECL_NIL;
    goto L21;
L22:;
    T1 = ecl_car(v13slot);
    if (!((T1)==(VV[29]))){
     goto L24;
    }
    T1 = ecl_cadr(v13slot);
    T0 = cl_list(2, ECL_SYM("QUOTE",682), T1);
    goto L21;
L24:;
    {
     cl_object v14slot_name;
     cl_object v15slot_type;
     cl_object v16offset;
     cl_object v17init_form;
     cl_object v18var_name;
     v14slot_name = ecl_car(v13slot);
     v15slot_type = ecl_caddr(v13slot);
     T1 = ecl_cddddr(v13slot);
     v16offset = ecl_car(T1);
     v17init_form = ecl_cadr(v13slot);
     v18var_name = v14slot_name;
     if (v7boa_constructor_p!=ECL_NIL) {
      goto L31;
     }
     v18var_name = cl_copy_symbol(1, v14slot_name);
     if (Null(v17init_form)){
      goto L37;
     }
     T1 = cl_list(2, v18var_name, v17init_form);
     goto L36;
L37:;
     T1 = v18var_name;
L36:;
     v8keys = CONS(T1,v8keys);
L31:;
     if ((ECL_T)==(v15slot_type)) {
      goto L39;
     }
     T1 = (cl_env_copy->function=(VV[30]->symbol.gfdef))->cfun.entry(2, v15slot_type, v6env) /*  FLATTEN-FUNCTION-TYPES */;
     T2 = cl_list(2, ECL_SYM("QUOTE",682), T1);
     T3 = cl_list(3, ECL_SYM("TYPEP",878), v18var_name, T2);
     T4 = cl_list(2, ECL_SYM("QUOTE",682), v15slot_type);
     T5 = cl_list(2, ECL_SYM("QUOTE",682), v1name);
     T6 = cl_list(2, ECL_SYM("QUOTE",682), v14slot_name);
     T7 = cl_list(5, VV[13], v18var_name, T4, T5, T6);
     T8 = cl_list(3, ECL_SYM("UNLESS",886), T3, T7);
     v11assertions = CONS(T8,v11assertions);
L39:;
     T0 = v18var_name;
    }
L21:;
    v10slot_names = CONS(T0,v10slot_names);
   }
   v12 = ecl_cdr(v12);
L15:;
   if (Null(v12)){
    goto L44;
   }
   goto L14;
L44:;
   v10slot_names = cl_nreverse(v10slot_names);
   v8keys = cl_nreverse(v8keys);
  }
  if (Null(v7boa_constructor_p)){
   goto L49;
  }
  {
   cl_object v12;
   cl_object v13;
   T0 = ecl_cadr(v2constructor);
   value0 = L309process_boa_lambda_list(v10slot_names, v5slot_descriptions, T0, v11assertions);
   {
    const int v14 = cl_env_copy->nvalues;
    v12 = value0;
    cl_object v15;
    v15 = (v14<=1)? ECL_NIL : cl_env_copy->values[1];
    v13 = v15;
   }
   v8keys = v12;
   v11assertions = v13;
  }
L49:;
  if (!(v3type==ECL_NIL)){
   goto L56;
  }
  T0 = cl_listX(3, ECL_SYM("MAKE-STRUCTURE",1117), VV[31], v10slot_names);
  T1 = ecl_list1(T0);
  T2 = ecl_append(v11assertions,T1);
  value0 = cl_listX(4, ECL_SYM("DEFUN",291), v9constructor_name, v8keys, T2);
  return value0;
L56:;
  if (Null(cl_subtypep(2, v3type, VV[32]))){
   goto L58;
  }
  T0 = CONS(ECL_SYM("VECTOR",902),v10slot_names);
  value0 = cl_list(4, ECL_SYM("DEFUN",291), v9constructor_name, v8keys, T0);
  return value0;
L58:;
  if (Null(cl_subtypep(2, v3type, ECL_SYM("VECTOR",902)))){
   goto L60;
  }
  {
   cl_fixnum v12;
   v12 = ecl_length(v10slot_names);
   T0 = ecl_list1(ecl_make_fixnum(v12));
   T1 = cl_list(2, ECL_SYM("QUOTE",682), T0);
   T2 = (cl_env_copy->function=(VV[33]->symbol.gfdef))->cfun.entry(1, v3type) /*  CLOSEST-SEQUENCE-TYPE */;
   T3 = cl_list(2, ECL_SYM("QUOTE",682), T2);
   T4 = CONS(ECL_SYM("LIST",483),v10slot_names);
   T5 = cl_list(6, ECL_SYM("MAKE-ARRAY",524), T1, ECL_SYM("ELEMENT-TYPE",1255), T3, ECL_SYM("INITIAL-CONTENTS",1287), T4);
   value0 = cl_list(4, ECL_SYM("DEFUN",291), v9constructor_name, v8keys, T5);
   return value0;
  }
L60:;
  if (!((v3type)==(ECL_SYM("LIST",483)))){
   goto L62;
  }
  T0 = CONS(ECL_SYM("LIST",483),v10slot_names);
  value0 = cl_list(4, ECL_SYM("DEFUN",291), v9constructor_name, v8keys, T0);
  return value0;
L62:;
  {
   cl_object v12;
   v12 = cl_error(2, VV[34], v3type);
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* function definition for MAKE-PREDICATE                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L315make_predicate(cl_object v1name, cl_object v2type, cl_object v3named, cl_object v4name_offset)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 cl_object CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 env0 = ECL_NIL;
 CLV0 = env0 = CONS(v1name,env0);                 /*  NAME                    */
 CLV1 = env0 = CONS(v4name_offset,env0);          /*  NAME-OFFSET             */
 if (!(v2type==ECL_NIL)){
  goto L1;
 }
 {
  cl_object v5;
  v5 = ecl_make_cclosure_va((cl_objectfn)LC311__lambda87,env0,Cblock,1);
  value0 = v5;
  cl_env_copy->nvalues = 1;
  return value0;
 }
L1:;
 if ((v2type)==(ECL_SYM("VECTOR",902))) {
  goto L5;
 }
 if (!(ECL_CONSP(v2type))){
  goto L3;
 }
 T0 = ecl_car(v2type);
 if (!((T0)==(ECL_SYM("VECTOR",902)))){
  goto L3;
 }
 goto L4;
L5:;
L4:;
 if (v3named!=ECL_NIL) {
  goto L8;
 }
 cl_error(1, VV[37]);
L8:;
 {
  cl_object v6;
  v6 = ecl_make_cclosure_va((cl_objectfn)LC312__lambda89,env0,Cblock,1);
  value0 = v6;
  cl_env_copy->nvalues = 1;
  return value0;
 }
L3:;
 if (!((v2type)==(ECL_SYM("LIST",483)))){
  goto L10;
 }
 if (v3named!=ECL_NIL) {
  goto L12;
 }
 cl_error(1, VV[37]);
L12:;
 if (!(ecl_number_equalp(ECL_CONS_CAR(CLV1),ecl_make_int8_t(0)))){
  goto L14;
 }
 {
  cl_object v7;
  v7 = ecl_make_cclosure_va((cl_objectfn)LC313__lambda91,env0,Cblock,1);
  value0 = v7;
  cl_env_copy->nvalues = 1;
  return value0;
 }
L14:;
 {
  cl_object v8;
  v8 = ecl_make_cclosure_va((cl_objectfn)LC314__lambda93,env0,Cblock,1);
  value0 = v8;
  cl_env_copy->nvalues = 1;
  return value0;
 }
L10:;
 {
  cl_object v9;
  v9 = cl_error(1, VV[20]);
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for PARSE-SLOT-DESCRIPTION                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L316parse_slot_description(cl_narg narg, cl_object v1slot_description, cl_object v2offset, ...)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<2)) FEwrong_num_arguments(VV[41]);
 if (ecl_unlikely(narg>3)) FEwrong_num_arguments(VV[41]);
 {
  cl_object v3read_only;
  va_list args; va_start(args,v2offset);
  {
   int i = 2;
   if (i >= narg) {
    v3read_only = ECL_NIL;
   } else {
    i++;
    v3read_only = va_arg(args,cl_object);
   }
  }
  va_end(args);
  if (!(ECL_ATOM(v1slot_description))){
   goto L2;
  }
  value0 = cl_list(6, v1slot_description, ECL_NIL, ECL_T, v3read_only, v2offset, ECL_NIL);
  return value0;
L2:;
  {
   cl_object v4;
   cl_object v5;
   cl_object v6;
   cl_object v7slot_type;
   cl_object v8os;
   v4 = ecl_car(v1slot_description);
   v5 = ecl_cadr(v1slot_description);
   v6 = ecl_cddr(v1slot_description);
   v7slot_type = ECL_T;
   v8os = v6;
   goto L11;
L10:;
   T0 = ecl_cdr(v8os);
   if (!(ecl_endp(T0))){
    goto L13;
   }
   cl_error(2, VV[42], v8os);
L13:;
   {
    cl_object v9;
    cl_object v10;
    v9 = ecl_car(v8os);
    v10 = ecl_cadr(v8os);
    if (!((v9)==(ECL_SYM("TYPE",1356)))){
     goto L18;
    }
    v7slot_type = v10;
    goto L15;
L18:;
    if (!((v9)==(VV[43]))){
     goto L21;
    }
    v3read_only = v10;
    goto L15;
L21:;
    cl_error(2, VV[42], v8os);
   }
L15:;
   v8os = ecl_cddr(v8os);
L11:;
   if (ecl_endp(v8os)) {
    goto L26;
   }
   goto L10;
L26:;
   value0 = cl_list(6, v4, v5, v7slot_type, v3read_only, v2offset, ECL_NIL);
   return value0;
  }
 }
}
/* function definition for OVERWRITE-SLOT-DESCRIPTIONS                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L317overwrite_slot_descriptions(cl_object v1new_slots, cl_object v2old_slots)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3output;
  cl_object v4old_slots;
  v3output = ECL_NIL;
  v4old_slots = v2old_slots;
  goto L6;
L5:;
  {
   cl_object v5old_slot;
   cl_object v6slot_name;
   cl_object v7new_slot;
   v5old_slot = ecl_car(v4old_slots);
   v6slot_name = ecl_car(v5old_slot);
   {
    cl_object v8;
    v8 = (ECL_SYM("CAR",182)->symbol.gfdef);
    {
     cl_object v9;
     v9 = v1new_slots;
     goto L17;
L16:;
     {
      cl_object v10;
      cl_object v11;
      {
       cl_object v12;
       v12 = v9;
       if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v10 = v12;
      }
      v11 = ECL_CONS_CAR(v10);
      T1 = ecl_car(v11);
      if (!(ecl_eql(v6slot_name,T1))){
       goto L19;
      }
      T0 = v10;
      goto L12;
     }
L19:;
     v9 = ECL_CONS_CDR(v9);
L17:;
     if (v9==ECL_NIL) {
      goto L27;
     }
     goto L16;
L27:;
     T0 = ECL_NIL;
    }
   }
L12:;
   v7new_slot = ecl_car(T0);
   if (!(v7new_slot==ECL_NIL)){
    goto L30;
   }
   v7new_slot = v5old_slot;
   goto L29;
L30:;
   {
    cl_object v8old_read_only;
    cl_object v9new_read_only;
    v8old_read_only = ecl_cadddr(v5old_slot);
    v9new_read_only = ecl_cadddr(v7new_slot);
    if (!(v9new_read_only==ECL_NIL)){
     goto L36;
    }
    if (Null(v8old_read_only)){
     goto L36;
    }
    cl_error(2, VV[48], v6slot_name);
    goto L35;
L36:;
    if (!((v9new_read_only)==(VV[49]))){
     goto L35;
    }
    v9new_read_only = v8old_read_only;
L35:;
    v7new_slot = cl_copy_list(v7new_slot);
    {
     cl_object v10;
     v10 = v9new_read_only;
     {
      cl_object v11;
      v11 = ecl_cdddr(v7new_slot);
      if (ecl_unlikely(ECL_ATOM(v11))) FEtype_error_cons(v11);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T0 = v11;
     }
     (ECL_CONS_CAR(T0)=v10,T0);
    }
    {
     cl_object v10;
     T0 = ecl_cddddr(v5old_slot);
     v10 = ecl_car(T0);
     {
      cl_object v11;
      v11 = ecl_cddddr(v7new_slot);
      if (ecl_unlikely(ECL_ATOM(v11))) FEtype_error_cons(v11);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T0 = v11;
     }
     (ECL_CONS_CAR(T0)=v10,T0);
    }
    {
     cl_object v10;
     T0 = ecl_cddddr(v5old_slot);
     v10 = ecl_cadr(T0);
     {
      cl_object v11;
      T1 = ecl_cddddr(v7new_slot);
      v11 = ecl_cdr(T1);
      if (ecl_unlikely(ECL_ATOM(v11))) FEtype_error_cons(v11);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T0 = v11;
     }
     (ECL_CONS_CAR(T0)=v10,T0);
    }
   }
L29:;
   v3output = CONS(v7new_slot,v3output);
  }
  v4old_slots = ecl_cdr(v4old_slots);
L6:;
  if (v4old_slots==ECL_NIL) {
   goto L63;
  }
  goto L5;
L63:;
  value0 = cl_nreverse(v3output);
  return value0;
 }
}
/* function definition for %STRUCT-LAYOUT-COMPATIBLE-P                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L318_struct_layout_compatible_p(cl_object v1old_slot_descriptions, cl_object v2new_slot_descriptions)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3old_defs;
  cl_object v4new_defs;
  cl_object v5old_def;
  cl_object v6new_def;
  v3old_defs = v1old_slot_descriptions;
  v4new_defs = v2new_slot_descriptions;
  v5old_def = ecl_car(v3old_defs);
  v6new_def = ecl_car(v4new_defs);
  goto L8;
L7:;
  if (v5old_def==ECL_NIL) {
   goto L16;
  }
  if (!(v6new_def==ECL_NIL)){
   goto L14;
  }
  goto L15;
L16:;
L15:;
  value0 = ecl_make_bool(ecl_eql(v5old_def,v6new_def));
  goto L13;
L14:;
  T0 = ecl_car(v5old_def);
  if ((T0)==(VV[29])) {
   goto L20;
  }
  T0 = ecl_car(v6new_def);
  if (!((T0)==(VV[29]))){
   goto L18;
  }
  goto L19;
L20:;
L19:;
  T0 = ecl_cddr(v5old_def);
  if (!(T0==ECL_NIL)){
   goto L23;
  }
  value0 = ecl_make_bool(ecl_equal(v5old_def,v6new_def));
  goto L13;
L23:;
  value0 = ECL_NIL;
  goto L13;
L18:;
  {
   cl_object v7;
   cl_object v8old_slot_name;
   cl_object v9old_init;
   cl_object v10old_type;
   cl_object v11old_read_only;
   cl_object v12old_offset;
   cl_object v13old_ac;
   v7 = v5old_def;
   if (!(v7==ECL_NIL)){
    goto L27;
   }
   si_dm_too_few_arguments(v5old_def);
L27:;
   {
    cl_object v14;
    v14 = ecl_car(v7);
    v7 = ecl_cdr(v7);
    v8old_slot_name = v14;
   }
   if (!(v7==ECL_NIL)){
    goto L33;
   }
   si_dm_too_few_arguments(v5old_def);
L33:;
   {
    cl_object v14;
    v14 = ecl_car(v7);
    v7 = ecl_cdr(v7);
    v9old_init = v14;
   }
   if (!(v7==ECL_NIL)){
    goto L39;
   }
   si_dm_too_few_arguments(v5old_def);
L39:;
   {
    cl_object v14;
    v14 = ecl_car(v7);
    v7 = ecl_cdr(v7);
    v10old_type = v14;
   }
   if (!(v7==ECL_NIL)){
    goto L45;
   }
   si_dm_too_few_arguments(v5old_def);
L45:;
   {
    cl_object v14;
    v14 = ecl_car(v7);
    v7 = ecl_cdr(v7);
    v11old_read_only = v14;
   }
   if (!(v7==ECL_NIL)){
    goto L51;
   }
   si_dm_too_few_arguments(v5old_def);
L51:;
   {
    cl_object v14;
    v14 = ecl_car(v7);
    v7 = ecl_cdr(v7);
    v12old_offset = v14;
   }
   if (!(v7==ECL_NIL)){
    goto L57;
   }
   si_dm_too_few_arguments(v5old_def);
L57:;
   {
    cl_object v14;
    v14 = ecl_car(v7);
    v7 = ecl_cdr(v7);
    v13old_ac = v14;
   }
   if (Null(v7)){
    goto L62;
   }
   si_dm_too_many_arguments(v5old_def);
L62:;
   {
    cl_object v14;
    cl_object v15new_slot_name;
    cl_object v16new_init;
    cl_object v17new_type;
    cl_object v18new_read_only;
    cl_object v19new_offset;
    cl_object v20new_ac;
    v14 = v6new_def;
    if (!(v14==ECL_NIL)){
     goto L66;
    }
    si_dm_too_few_arguments(v6new_def);
L66:;
    {
     cl_object v21;
     v21 = ecl_car(v14);
     v14 = ecl_cdr(v14);
     v15new_slot_name = v21;
    }
    if (!(v14==ECL_NIL)){
     goto L72;
    }
    si_dm_too_few_arguments(v6new_def);
L72:;
    {
     cl_object v21;
     v21 = ecl_car(v14);
     v14 = ecl_cdr(v14);
     v16new_init = v21;
    }
    if (!(v14==ECL_NIL)){
     goto L78;
    }
    si_dm_too_few_arguments(v6new_def);
L78:;
    {
     cl_object v21;
     v21 = ecl_car(v14);
     v14 = ecl_cdr(v14);
     v17new_type = v21;
    }
    if (!(v14==ECL_NIL)){
     goto L84;
    }
    si_dm_too_few_arguments(v6new_def);
L84:;
    {
     cl_object v21;
     v21 = ecl_car(v14);
     v14 = ecl_cdr(v14);
     v18new_read_only = v21;
    }
    if (!(v14==ECL_NIL)){
     goto L90;
    }
    si_dm_too_few_arguments(v6new_def);
L90:;
    {
     cl_object v21;
     v21 = ecl_car(v14);
     v14 = ecl_cdr(v14);
     v19new_offset = v21;
    }
    if (!(v14==ECL_NIL)){
     goto L96;
    }
    si_dm_too_few_arguments(v6new_def);
L96:;
    {
     cl_object v21;
     v21 = ecl_car(v14);
     v14 = ecl_cdr(v14);
     v20new_ac = v21;
    }
    if (Null(v14)){
     goto L101;
    }
    si_dm_too_many_arguments(v6new_def);
L101:;
    if (Null(cl_stringE(2, v8old_slot_name, v15new_slot_name))){
     goto L104;
    }
    if (!(ecl_number_equalp(v12old_offset,v19new_offset))){
     goto L104;
    }
    {
     cl_object v21;                               /*  SUBTYPEP                */
     cl_object v22;                               /*  CERTAIN                 */
     value0 = cl_subtypep(2, v10old_type, v17new_type);
     {
      v21 = value0;
      v22 = cl_env_copy->values[1];
     }
     if (Null(v22)){
      goto L111;
     }
     if (Null(v21)){
      goto L108;
     }
     goto L109;
L111:;
    }
L109:;
    {
     cl_object v21;                               /*  SUBTYPEP                */
     cl_object v22;                               /*  CERTAIN                 */
     value0 = cl_subtypep(2, v17new_type, v10old_type);
     {
      v21 = value0;
      v22 = cl_env_copy->values[1];
     }
     value0 = Null(v22)?ECL_T:ECL_NIL;
     if (value0!=ECL_NIL) {
      goto L115;
     }
     value0 = v21;
     goto L13;
L115:;
     goto L13;
    }
L108:;
    value0 = ECL_NIL;
    goto L13;
L104:;
    value0 = ECL_NIL;
    goto L13;
   }
  }
L13:;
  if (value0!=ECL_NIL) {
   goto L12;
  }
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L12:;
  goto L10;
L10:;
  v3old_defs = ecl_cdr(v3old_defs);
  v4new_defs = ecl_cdr(v4new_defs);
L8:;
  if (v3old_defs==ECL_NIL) {
   goto L121;
  }
  if (v4new_defs==ECL_NIL) {
   goto L121;
  }
  goto L7;
L121:;
  if (!(v3old_defs==ECL_NIL)){
   goto L125;
  }
  value0 = ecl_make_bool(v4new_defs==ECL_NIL);
  cl_env_copy->nvalues = 1;
  return value0;
L125:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for DEFINE-STRUCTURE                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_define_structure(cl_object v1name, cl_object v2conc_name, cl_object v3type, cl_object v4named, cl_object v5slots, cl_object v6slot_descriptions, cl_object v7copier, cl_object v8include, cl_object v9print_function, cl_object v10print_object, cl_object v11constructors, cl_object v12offset, cl_object v13name_offset, cl_object v14documentation, cl_object v15predicate)
{
 cl_object T0, T1, T2, T3;
 cl_object env0 = ECL_NIL;
 cl_object CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 env0 = ECL_NIL;
 CLV0 = env0 = CONS(v9print_function,env0);       /*  PRINT-FUNCTION          */
 CLV1 = env0 = CONS(v10print_object,env0);        /*  PRINT-OBJECT            */
 {
  cl_object v16;
  {
   cl_object v17;
   v17 = ecl_make_cfun_va((cl_objectfn)LC319__lambda159_va,ECL_NIL,Cblock,1);
   v16 = v17;
  }
  {
   cl_object v17;
   {
    cl_object v18;
    v18 = v6slot_descriptions;
    if (ecl_unlikely(!ECL_LISTP(v18))) FEtype_error_list(v18);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v17 = v18;
   }
   {
    cl_object v18;
    v18 = v17;
L7:;
    if (!(ECL_ATOM(v18))){
     goto L9;
    }
    goto L8;
L9:;
    ecl_function_dispatch(cl_env_copy,v16)(1, v18);
    v18 = ECL_CONS_CDR(v18);
    goto L7;
L8:;
    goto L1;
   }
  }
 }
L1:;
 if (Null(si_get_sysprop(v1name, VV[58]))){
  goto L16;
 }
 {
  cl_object v16old_slot_descriptions;
  v16old_slot_descriptions = si_get_sysprop(v1name, ECL_SYM("STRUCTURE-SLOT-DESCRIPTIONS",1180));
  if (L318_struct_layout_compatible_p(v16old_slot_descriptions, v6slot_descriptions)!=ECL_NIL) {
   goto L16;
  }
  cl_error(2, VV[59], v1name);
 }
L16:;
 (cl_env_copy->function=(ECL_SYM("CREATE-TYPE-NAME",1661)->symbol.gfdef))->cfun.entry(1, v1name) /*  CREATE-TYPE-NAME */;
 v6slot_descriptions = cl_copy_tree(v6slot_descriptions);
 if (v3type!=ECL_NIL) {
  goto L23;
 }
 if (Null(v8include)){
  goto L27;
 }
 T0 = ecl_list1(v8include);
 goto L25;
L27:;
 T0 = ECL_NIL;
 goto L25;
L25:;
 {
  cl_object v16;
  {
   cl_object v17;
   v17 = ecl_make_cfun_va((cl_objectfn)LC320__lambda184_va,ECL_NIL,Cblock,1);
   v16 = v17;
  }
  {
   cl_object v17;
   cl_object v18;
   cl_object v19;
   {
    cl_object v20;
    v20 = v6slot_descriptions;
    if (ecl_unlikely(!ECL_LISTP(v20))) FEtype_error_list(v20);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v17 = v20;
   }
   v18 = ECL_NIL;
   v19 = v17;
   {
    cl_object v20;
    cl_object v21;
    v20 = ecl_list1(ECL_NIL);
    v21 = v20;
L38:;
    if (!(ecl_endp(v19))){
     goto L40;
    }
    goto L39;
L40:;
    v18 = ECL_CONS_CAR(v19);
    {
     cl_object v22;
     v22 = ECL_CONS_CDR(v19);
     if (ecl_unlikely(!ECL_LISTP(v22))) FEtype_error_list(v22);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v19 = v22;
    }
    {
     cl_object v22;
     v22 = v21;
     if (ecl_unlikely(ECL_ATOM(v22))) FEtype_error_cons(v22);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     T2 = v22;
    }
    T3 = ecl_function_dispatch(cl_env_copy,v16)(1, v18);
    v21 = ecl_list1(T3);
    (ECL_CONS_CDR(T2)=v21,T2);
    goto L38;
L39:;
    T1 = ecl_cdr(v20);
    goto L29;
   }
  }
 }
L29:;
 clos_ensure_class(7, v1name, ECL_SYM("DIRECT-SUPERCLASSES",995), T0, ECL_SYM("DIRECT-SLOTS",994), T1, ECL_SYM("METACLASS",1004), ECL_SYM("STRUCTURE-CLASS",981));
L23:;
 if (Null(ECL_CONS_CAR(CLV0))){
  goto L56;
 }
 T0 = cl_list(2, v1name, ECL_T);
 {
  cl_object v16;
  v16 = ecl_make_cclosure_va((cl_objectfn)LC321__lambda188,env0,Cblock,2);
  T1 = v16;
 }
 clos_install_method(5, ECL_SYM("PRINT-OBJECT",965), ECL_NIL, T0, VV[65], T1);
L56:;
 if (Null(ECL_CONS_CAR(CLV1))){
  goto L59;
 }
 T0 = cl_list(2, v1name, ECL_T);
 {
  cl_object v16;
  v16 = ecl_make_cclosure_va((cl_objectfn)LC322__lambda190,env0,Cblock,2);
  T1 = v16;
 }
 clos_install_method(5, ECL_SYM("PRINT-OBJECT",965), ECL_NIL, T0, VV[65], T1);
L59:;
 if (Null(v15predicate)){
  goto L62;
 }
 T0 = L315make_predicate(v1name, v3type, v4named, v13name_offset);
 si_fset(2, v15predicate, T0);
L62:;
 T0 = cl_listX(3, ECL_SYM("DEFSTRUCT",289), v1name, v5slots);
 si_put_sysprop(v1name, VV[68], T0);
 si_put_sysprop(v1name, VV[58], ECL_T);
 si_put_sysprop(v1name, ECL_SYM("STRUCTURE-SLOT-DESCRIPTIONS",1180), v6slot_descriptions);
 si_put_sysprop(v1name, VV[69], v8include);
 si_put_sysprop(v1name, ECL_SYM("STRUCTURE-PRINT-FUNCTION",1177), ECL_CONS_CAR(CLV0));
 si_put_sysprop(v1name, VV[70], v3type);
 si_put_sysprop(v1name, VV[71], v4named);
 si_put_sysprop(v1name, VV[72], v12offset);
 si_put_sysprop(v1name, VV[73], v11constructors);
 if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[74]))){
  goto L73;
 }
 si_set_documentation(v1name, ECL_SYM("STRUCTURE",829), v14documentation);
L73:;
 {
  cl_object v16;
  v16 = v6slot_descriptions;
  goto L79;
L78:;
  {
   cl_object v17x;
   v17x = ecl_car(v16);
   if (Null(v17x)){
    goto L85;
   }
   T0 = ecl_car(v17x);
   if ((T0)==(VV[29])) {
    goto L85;
   }
   L304make_access_function(v1name, v2conc_name, v3type, v4named, v17x);
   goto L83;
L85:;
   goto L83;
L83:;
  }
  v16 = ecl_cdr(v16);
L79:;
  if (Null(v16)){
   goto L90;
  }
  goto L78;
L90:;
 }
 if (Null(v7copier)){
  goto L92;
 }
 T0 = (ECL_SYM("COPY-STRUCTURE",263)->symbol.gfdef);
 si_fset(2, v7copier, T0);
L92:;
 if (v3type!=ECL_NIL) {
  goto L95;
 }
 value0 = cl_find_class(1, v1name);
 return value0;
L95:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
cl_object si_define_structure_va(cl_narg narg, cl_object v16name, cl_object v17conc_name, cl_object v18type, cl_object v19named, cl_object v20slots, cl_object v21slot_descriptions, cl_object v22copier, cl_object v23include, cl_object v24print_function, cl_object v25print_object, cl_object v26constructors, cl_object v27offset, cl_object v28name_offset, cl_object v29documentation, cl_object v30predicate, ...)
{
 if (ecl_unlikely(narg!=15)) FEwrong_num_arguments(VV[53]);
 {
  return si_define_structure(v16name, v17conc_name, v18type, v19named, v20slots, v21slot_descriptions, v22copier, v23include, v24print_function, v25print_object, v26constructors, v27offset, v28name_offset, v29documentation, v30predicate);
 }
}
/* local function DEFSTRUCT                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC325defstruct(cl_object v1, cl_object v2env)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13;
 cl_object env0 = ECL_NIL;
 cl_object CLV0, CLV1, CLV2, CLV3, CLV4;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 env0 = ECL_NIL;
 CLV0 = env0 = CONS(v2env,env0);                  /*  ENV                     */
 {
  cl_object v3;
  cl_object v4name_opts;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L3;
  }
  si_dm_too_few_arguments(v1);
L3:;
  {
   cl_object v5;
   v5 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4name_opts = v5;
  }
  {
   cl_object v5options;
   cl_object v6conc_name;
   cl_object v7default_constructor;
   cl_object v8copier;
   cl_object v9predicate;
   cl_object v10constructors;
   cl_object v11no_constructor;
   cl_object v12predicate_specified;
   cl_object v13include;
   cl_object v14print_function;
   cl_object v15print_object;
   cl_object v16initial_offset;
   cl_object v17offset;
   cl_object v18name_offset;
   cl_object v19documentation;
   cl_object v20atomic_accessors;
   cl_object env1 = env0;
   CLV1 = env1 = CONS(v3,env1);                   /*  SLOT-DESCRIPTIONS       */
   if (!(ECL_CONSP(v4name_opts))){
    goto L9;
   }
   T0 = ecl_car(v4name_opts);
   goto L8;
L9:;
   T0 = v4name_opts;
L8:;
   CLV2 = env1 = CONS(T0,env1);                   /*  NAME                    */
   if (!(ECL_CONSP(v4name_opts))){
    goto L12;
   }
   v5options = ecl_cdr(v4name_opts);
   goto L11;
L12:;
   v5options = ECL_NIL;
L11:;
   v6conc_name = si_base_string_concatenate(2, ECL_CONS_CAR(CLV2), VV[76]);
   T0 = si_base_string_concatenate(2, VV[77], ECL_CONS_CAR(CLV2));
   v7default_constructor = cl_intern(1, T0);
   T0 = si_base_string_concatenate(2, VV[78], ECL_CONS_CAR(CLV2));
   v8copier = cl_intern(1, T0);
   T0 = si_base_string_concatenate(2, ECL_CONS_CAR(CLV2), VV[79]);
   v9predicate = cl_intern(1, T0);
   v10constructors = ECL_NIL;
   v11no_constructor = ECL_NIL;
   v12predicate_specified = ECL_NIL;
   v13include = ECL_NIL;
   v14print_function = ECL_NIL;
   v15print_object = ECL_NIL;
   CLV3 = env1 = CONS(ECL_NIL,env1);              /*  TYPE                    */
   CLV4 = env1 = CONS(ECL_NIL,env1);              /*  NAMED                   */
   v16initial_offset = ECL_NIL;
   v17offset = ECL_NIL;
   v18name_offset = ECL_NIL;
   v19documentation = ECL_NIL;
   v20atomic_accessors = ECL_T;
   {
    cl_object v21os;
    cl_object v22o;
    cl_object v23v;
    v21os = v5options;
    v22o = ECL_NIL;
    v23v = ECL_NIL;
    goto L35;
L34:;
    T0 = ecl_car(v21os);
    if (!(ECL_CONSP(T0))){
     goto L38;
    }
    T0 = ecl_cdar(v21os);
    if (ecl_endp(T0)) {
     goto L38;
    }
    v22o = ecl_caar(v21os);
    v23v = ecl_cadar(v21os);
    if (!((v22o)==(ECL_SYM("CONC-NAME",1240)))){
     goto L45;
    }
    if (!(v23v==ECL_NIL)){
     goto L47;
    }
    v6conc_name = ECL_NIL;
    goto L37;
L47:;
    v6conc_name = v23v;
    goto L37;
L45:;
    if (!((v22o)==(ECL_SYM("CONSTRUCTOR",1241)))){
     goto L51;
    }
    if (!(v23v==ECL_NIL)){
     goto L53;
    }
    v11no_constructor = ECL_T;
    goto L37;
L53:;
    T0 = ecl_cddar(v21os);
    if (!(ecl_endp(T0))){
     goto L56;
    }
    v10constructors = CONS(v23v,v10constructors);
    goto L37;
L56:;
    T0 = ecl_cdar(v21os);
    v10constructors = CONS(T0,v10constructors);
    goto L37;
L51:;
    if (!((v22o)==(ECL_SYM("COPIER",1243)))){
     goto L60;
    }
    v8copier = v23v;
    goto L37;
L60:;
    if (!((v22o)==(ECL_SYM("PREDICATE",1324)))){
     goto L63;
    }
    v9predicate = v23v;
    v12predicate_specified = ECL_T;
    goto L37;
L63:;
    if (!((v22o)==(ECL_SYM("INCLUDE",1284)))){
     goto L68;
    }
    v13include = ecl_cdar(v21os);
    if (si_get_sysprop(v23v, VV[58])!=ECL_NIL) {
     goto L37;
    }
    cl_error(2, VV[80], v23v);
    goto L37;
L68:;
    if (!((v22o)==(ECL_SYM("PRINT-FUNCTION",1328)))){
     goto L73;
    }
    if (!(ECL_SYMBOLP(v23v))){
     goto L76;
    }
    v14print_function = cl_list(2, ECL_SYM("QUOTE",682), v23v);
    goto L75;
L76:;
    v14print_function = cl_list(2, ECL_SYM("FUNCTION",398), v23v);
L75:;
    goto L37;
L73:;
    if (!((v22o)==(ECL_SYM("PRINT-OBJECT",1329)))){
     goto L78;
    }
    if (!(ECL_SYMBOLP(v23v))){
     goto L81;
    }
    v15print_object = cl_list(2, ECL_SYM("QUOTE",682), v23v);
    goto L80;
L81:;
    v15print_object = cl_list(2, ECL_SYM("FUNCTION",398), v23v);
L80:;
    goto L37;
L78:;
    if (!((v22o)==(ECL_SYM("TYPE",1356)))){
     goto L83;
    }
    ECL_CONS_CAR(CLV3) = v23v;
    goto L37;
L83:;
    if (!((v22o)==(ECL_SYM("INITIAL-OFFSET",1288)))){
     goto L86;
    }
    v16initial_offset = v23v;
    goto L37;
L86:;
    if (!((v22o)==(VV[81]))){
     goto L89;
    }
    v20atomic_accessors = v23v;
    goto L37;
L89:;
    cl_error(2, VV[82], v22o);
    goto L37;
L38:;
    T0 = ecl_car(v21os);
    if (!(ECL_CONSP(T0))){
     goto L93;
    }
    v22o = ecl_caar(v21os);
    goto L92;
L93:;
    v22o = ecl_car(v21os);
L92:;
    if (!((v22o)==(ECL_SYM("CONSTRUCTOR",1241)))){
     goto L97;
    }
    v10constructors = CONS(v7default_constructor,v10constructors);
    goto L37;
L97:;
    if (!((v22o)==(ECL_SYM("CONC-NAME",1240)))){
     goto L100;
    }
    v6conc_name = ECL_NIL;
    goto L37;
L100:;
    {
     cl_object v24;
     cl_object v25;
     v24 = v22o;
     v25 = VV[83];
     if (ecl_memql(v24,v25)!=ECL_NIL) {
      goto L37;
     }
    }
    if (!((v22o)==(ECL_SYM("NAMED",1310)))){
     goto L106;
    }
    ECL_CONS_CAR(CLV4) = ECL_T;
    goto L37;
L106:;
    cl_error(2, VV[82], v22o);
L37:;
    v21os = ecl_cdr(v21os);
L35:;
    if (ecl_endp(v21os)) {
     goto L111;
    }
    goto L34;
L111:;
   }
   if (ecl_endp(ECL_CONS_CAR(CLV1))) {
    goto L113;
   }
   T0 = ecl_car(ECL_CONS_CAR(CLV1));
   if (!(ECL_STRINGP(T0))){
    goto L113;
   }
   v19documentation = ecl_car(ECL_CONS_CAR(CLV1));
   ECL_CONS_CAR(CLV1) = ecl_cdr(ECL_CONS_CAR(CLV1));
L113:;
   if (Null(v13include)){
    goto L119;
   }
   T0 = ecl_car(v13include);
   T1 = si_get_sysprop(T0, VV[70]);
   if (ecl_equal(ECL_CONS_CAR(CLV3),T1)) {
    goto L119;
   }
   T0 = ecl_car(v13include);
   cl_error(2, VV[84], T0);
L119:;
   if (Null(v13include)){
    goto L124;
   }
   T0 = ecl_car(v13include);
   v17offset = si_get_sysprop(T0, VV[72]);
   goto L123;
L124:;
   v17offset = ecl_make_int8_t(0);
L123:;
   if (Null(ECL_CONS_CAR(CLV3))){
    goto L126;
   }
   if (Null(v16initial_offset)){
    goto L126;
   }
   v17offset = ecl_plus(v17offset,v16initial_offset);
L126:;
   if (Null(ECL_CONS_CAR(CLV3))){
    goto L130;
   }
   if (Null(ECL_CONS_CAR(CLV4))){
    goto L130;
   }
   if (cl_subtypep(2, VV[85], ECL_CONS_CAR(CLV3))!=ECL_NIL) {
    goto L133;
   }
   if (cl_subtypep(2, ECL_CONS_CAR(CLV3), ECL_SYM("LIST",483))!=ECL_NIL) {
    goto L133;
   }
   cl_error(2, VV[86], ECL_CONS_CAR(CLV3));
L133:;
   v18name_offset = v17offset;
   v17offset = ecl_one_plus(v17offset);
L130:;
   {
    cl_object v21;
    cl_object v22ds;
    cl_object v23sds;
    v21 = ECL_CONS_CAR(CLV1);
    v22ds = v21;
    v23sds = ECL_NIL;
    goto L145;
L144:;
    T0 = ecl_car(v22ds);
    T1 = L316parse_slot_description(2, T0, v17offset);
    v23sds = CONS(T1,v23sds);
    v17offset = ecl_one_plus(v17offset);
    v22ds = ecl_cdr(v22ds);
L145:;
    if (ecl_endp(v22ds)) {
     goto L153;
    }
    goto L144;
L153:;
    ECL_CONS_CAR(CLV1) = cl_nreverse(v23sds);
   }
   if (Null(ECL_CONS_CAR(CLV3))){
    goto L156;
   }
   if (Null(ECL_CONS_CAR(CLV4))){
    goto L156;
   }
   T0 = cl_list(2, VV[29], ECL_CONS_CAR(CLV2));
   ECL_CONS_CAR(CLV1) = CONS(T0,ECL_CONS_CAR(CLV1));
L156:;
   if (Null(ECL_CONS_CAR(CLV3))){
    goto L160;
   }
   if (Null(v16initial_offset)){
    goto L160;
   }
   T0 = cl_make_list(1, v16initial_offset);
   ECL_CONS_CAR(CLV1) = ecl_append(T0,ECL_CONS_CAR(CLV1));
L160:;
   {
    cl_object v21;
    v21 = ecl_make_bool(v13include==ECL_NIL);
    if (Null(v21)){
     goto L166;
    }
    goto L164;
L166:;
    T0 = ecl_cdr(v13include);
    if (!(ecl_endp(T0))){
     goto L168;
    }
    T0 = ecl_car(v13include);
    T1 = si_get_sysprop(T0, ECL_SYM("STRUCTURE-SLOT-DESCRIPTIONS",1180));
    ECL_CONS_CAR(CLV1) = ecl_append(T1,ECL_CONS_CAR(CLV1));
    goto L164;
L168:;
    {
     cl_object v22;
     {
      cl_object v23;
      v23 = ecl_make_cfun_va((cl_objectfn)LC323__lambda237_va,ECL_NIL,Cblock,1);
      v22 = v23;
     }
     {
      cl_object v23;
      cl_object v24;
      cl_object v25;
      {
       cl_object v26;
       v26 = ecl_cdr(v13include);
       if (ecl_unlikely(!ECL_LISTP(v26))) FEtype_error_list(v26);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v23 = v26;
      }
      v24 = ECL_NIL;
      v25 = v23;
      {
       cl_object v26;
       cl_object v27;
       v26 = ecl_list1(ECL_NIL);
       v27 = v26;
L181:;
       if (!(ecl_endp(v25))){
        goto L183;
       }
       goto L182;
L183:;
       v24 = ECL_CONS_CAR(v25);
       {
        cl_object v28;
        v28 = ECL_CONS_CDR(v25);
        if (ecl_unlikely(!ECL_LISTP(v28))) FEtype_error_list(v28);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        v25 = v28;
       }
       {
        cl_object v28;
        v28 = v27;
        if (ecl_unlikely(ECL_ATOM(v28))) FEtype_error_cons(v28);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        T1 = v28;
       }
       T2 = ecl_function_dispatch(cl_env_copy,v22)(1, v24);
       v27 = ecl_list1(T2);
       (ECL_CONS_CDR(T1)=v27,T1);
       goto L181;
L182:;
       T0 = ecl_cdr(v26);
       goto L172;
      }
     }
    }
L172:;
    T1 = ecl_car(v13include);
    T2 = si_get_sysprop(T1, ECL_SYM("STRUCTURE-SLOT-DESCRIPTIONS",1180));
    T3 = L317overwrite_slot_descriptions(T0, T2);
    ECL_CONS_CAR(CLV1) = ecl_append(T3,ECL_CONS_CAR(CLV1));
   }
L164:;
   if (Null(v11no_constructor)){
    goto L200;
   }
   if (Null(v10constructors)){
    goto L199;
   }
   cl_error(1, VV[88]);
   goto L199;
L200:;
   if (!(v10constructors==ECL_NIL)){
    goto L199;
   }
   v10constructors = ecl_list1(v7default_constructor);
L199:;
   if (Null(ECL_CONS_CAR(CLV3))){
    goto L205;
   }
   if (ECL_CONS_CAR(CLV4)!=ECL_NIL) {
    goto L205;
   }
   if (Null(v12predicate_specified)){
    goto L208;
   }
   if (Null(v9predicate)){
    goto L208;
   }
   cl_error(2, VV[89], v9predicate);
L208:;
   v9predicate = ECL_NIL;
L205:;
   if (Null(v13include)){
    goto L212;
   }
   v13include = ecl_car(v13include);
L212:;
   if (Null(v14print_function)){
    goto L215;
   }
   if (Null(ECL_CONS_CAR(CLV3))){
    goto L215;
   }
   cl_error(1, VV[90]);
L215:;
   {
    cl_object v21;
    cl_object v22;
    T0 = cl_list(2, ECL_SYM("QUOTE",682), ECL_CONS_CAR(CLV2));
    T1 = cl_list(2, ECL_SYM("QUOTE",682), v6conc_name);
    T2 = cl_list(2, ECL_SYM("QUOTE",682), ECL_CONS_CAR(CLV3));
    T3 = cl_list(2, ECL_SYM("QUOTE",682), ECL_CONS_CAR(CLV4));
    T4 = cl_list(2, ECL_SYM("QUOTE",682), v3);
    T5 = cl_list(2, ECL_SYM("QUOTE",682), ECL_CONS_CAR(CLV1));
    T6 = cl_list(2, ECL_SYM("QUOTE",682), v8copier);
    T7 = cl_list(2, ECL_SYM("QUOTE",682), v13include);
    T8 = cl_list(2, ECL_SYM("QUOTE",682), v10constructors);
    T9 = cl_list(2, ECL_SYM("QUOTE",682), v17offset);
    T10 = cl_list(2, ECL_SYM("QUOTE",682), v18name_offset);
    T11 = cl_list(2, ECL_SYM("QUOTE",682), v19documentation);
    T12 = cl_list(2, ECL_SYM("QUOTE",682), v9predicate);
    v21 = cl_list(16, VV[53], T0, T1, T2, T3, T4, T5, T6, T7, v14print_function, v15print_object, T8, T9, T10, T11, T12);
    {
     cl_object v23;
     {
      cl_object v24;
      v24 = ecl_make_cclosure_va((cl_objectfn)LC324__lambda248,env1,Cblock,1);
      v23 = v24;
     }
     {
      cl_object v24;
      cl_object v25;
      cl_object v26;
      {
       cl_object v27;
       v27 = v10constructors;
       if (ecl_unlikely(!ECL_LISTP(v27))) FEtype_error_list(v27);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v24 = v27;
      }
      v25 = ECL_NIL;
      v26 = v24;
      {
       cl_object v27;
       cl_object v28;
       v27 = ecl_list1(ECL_NIL);
       v28 = v27;
L228:;
       if (!(ecl_endp(v26))){
        goto L230;
       }
       goto L229;
L230:;
       v25 = ECL_CONS_CAR(v26);
       {
        cl_object v29;
        v29 = ECL_CONS_CDR(v26);
        if (ecl_unlikely(!ECL_LISTP(v29))) FEtype_error_list(v29);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        v26 = v29;
       }
       {
        cl_object v29;
        v29 = v28;
        if (ecl_unlikely(ECL_ATOM(v29))) FEtype_error_cons(v29);
        value0 = ECL_NIL;
        cl_env_copy->nvalues = 0;
        T0 = v29;
       }
       T1 = ecl_function_dispatch(cl_env_copy,v23)(1, v25);
       v28 = ecl_list1(T1);
       (ECL_CONS_CDR(T0)=v28,T0);
       goto L228;
L229:;
       v22 = ecl_cdr(v27);
       goto L219;
      }
     }
    }
L219:;
    if (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*REGISTER-WITH-PDE-HOOK*",1211)))){
     goto L247;
    }
    T1 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*REGISTER-WITH-PDE-HOOK*",1211));
    T2 = cl_copy_tree(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*SOURCE-LOCATION*",1210)));
    T0 = ecl_function_dispatch(cl_env_copy,T1)(3, T2, v1, ECL_NIL);
    goto L246;
L247:;
    T0 = ECL_NIL;
L246:;
    T1 = cl_list(2, ECL_SYM("QUOTE",682), ECL_CONS_CAR(CLV2));
    T2 = cl_list(2, ECL_SYM("FIND-CLASS",947), T1);
    T3 = cl_list(2, ECL_SYM("LOAD-TIME-VALUE",491), T2);
    T4 = cl_subst(3, T3, VV[31], v22);
    T5 = cl_listX(5, ECL_SYM("EVAL-WHEN",342), VV[92], v21, T0, T4);
    T6 = cl_list(2, VV[31], v21);
    T7 = ecl_list1(T6);
    T8 = cl_listX(3, ECL_SYM("LET",479), T7, v22);
    T9 = cl_list(3, ECL_SYM("EVAL-WHEN",342), VV[93], T8);
    T10 = Null(v20atomic_accessors)?ECL_T:ECL_NIL;
    T11 = L301make_atomic_accessors(ECL_CONS_CAR(CLV2), v6conc_name, ECL_CONS_CAR(CLV3), ECL_CONS_CAR(CLV1), T10);
    T12 = cl_listX(3, ECL_SYM("EVAL-WHEN",342), VV[94], T11);
    T13 = cl_list(2, ECL_SYM("QUOTE",682), ECL_CONS_CAR(CLV2));
    value0 = cl_list(5, ECL_SYM("PROGN",674), T5, T9, T12, T13);
    return value0;
   }
  }
 }
}
static cl_object LC325defstruct_va(cl_narg narg, cl_object v23, cl_object v24env, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[95]);
 {
  return LC325defstruct(v23, v24env);
 }
}
/* closure LAMBDA14                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC302__lambda14(cl_narg narg, cl_object v1x, ...)
{
 cl_object CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV1 = env0;                                     /*  OFFSET                  */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[17]);
 {
L1:;
  value0 = si_structure_ref(v1x, ECL_CONS_CAR(CLV0), ECL_CONS_CAR(CLV1));
  return value0;
 }
 }
}
/* closure LAMBDA16                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC303__lambda16(cl_narg narg, cl_object v1x, ...)
{
 cl_object CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV1 = env0;                                     /*  OFFSET                  */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[19]);
 {
L1:;
  value0 = ecl_elt(v1x,ecl_to_size(ECL_CONS_CAR(CLV1)));
  cl_env_copy->nvalues = 1;
  return value0;
 }
 }
}
/* closure LAMBDA19                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC305__lambda19(cl_narg narg, cl_object v1newvalue, cl_object v2struct, ...)
{
 cl_object CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV1 = env0;                                     /*  INDEX                   */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[24]);
 {
L1:;
  value0 = cl_list(4, ECL_SYM("ELT-SET",1075), v2struct, ECL_CONS_CAR(CLV1), v1newvalue);
  return value0;
 }
 }
}
/* closure LAMBDA21                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC306__lambda21(cl_narg narg, cl_object v1newvalue, cl_object v2struct, ...)
{
 cl_object T0;
 cl_object CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV1 = env0;                                     /*  INDEX                   */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[25]);
 {
L1:;
  T0 = cl_list(3, ECL_SYM("THE",859), ECL_CONS_CAR(CLV0), v2struct);
  value0 = cl_list(4, ECL_SYM("ASET",1045), T0, ECL_CONS_CAR(CLV1), v1newvalue);
  return value0;
 }
 }
}
/* closure LAMBDA23                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC307__lambda23(cl_narg narg, cl_object v1newvalue, cl_object v2struct, ...)
{
 cl_object T0;
 cl_object CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV1 = env0;                                     /*  INDEX                   */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[26]);
 {
L1:;
  T0 = cl_list(2, ECL_SYM("QUOTE",682), ECL_CONS_CAR(CLV0));
  value0 = cl_list(5, ECL_SYM("STRUCTURE-SET",1179), v2struct, T0, ECL_CONS_CAR(CLV1), v1newvalue);
  return value0;
 }
 }
}
/* closure LAMBDA87                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC311__lambda87(cl_narg narg, cl_object v1x, ...)
{
 cl_object CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV1 = env0;
 CLV0 = _ecl_cdr(CLV1);                           /*  NAME                    */
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[36]);
 {
L1:;
  value0 = si_structure_subtype_p(v1x, ECL_CONS_CAR(CLV0));
  return value0;
 }
 }
}
/* closure LAMBDA89                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC312__lambda89(cl_narg narg, cl_object v1x, ...)
{
 cl_object T0;
 cl_object CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV1 = env0;                                     /*  NAME-OFFSET             */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[38]);
 {
L1:;
  if (!(ECL_VECTORP(v1x))){
   goto L3;
  }
  {
   cl_fixnum v2;
   v2 = ecl_length(v1x);
   if (!(ecl_greater(ecl_make_fixnum(v2),ECL_CONS_CAR(CLV1)))){
    goto L3;
   }
  }
  T0 = ecl_elt(v1x,ecl_to_size(ECL_CONS_CAR(CLV1)));
  value0 = ecl_make_bool((T0)==(ECL_CONS_CAR(CLV0)));
  cl_env_copy->nvalues = 1;
  return value0;
L3:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
 }
}
/* closure LAMBDA91                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC313__lambda91(cl_narg narg, cl_object v1x, ...)
{
 cl_object T0;
 cl_object CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV1 = env0;
 CLV0 = _ecl_cdr(CLV1);                           /*  NAME                    */
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[39]);
 {
L1:;
  if (!(ECL_CONSP(v1x))){
   goto L3;
  }
  T0 = ecl_car(v1x);
  value0 = ecl_make_bool((T0)==(ECL_CONS_CAR(CLV0)));
  cl_env_copy->nvalues = 1;
  return value0;
L3:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
 }
}
/* closure LAMBDA93                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC314__lambda93(cl_narg narg, cl_object v1x, ...)
{
 cl_object T0;
 cl_object CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV1 = env0;                                     /*  NAME-OFFSET             */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[40]);
 {
L1:;
  {
   cl_fixnum v2;
   cl_fixnum v3i;
   cl_object v4y;
   {
    cl_object v5;
    v5 = ECL_CONS_CAR(CLV1);
    {
     bool v6;
     v6 = ECL_FIXNUMP(v5);
     if (ecl_unlikely(!(v6)))
         FEwrong_type_argument(ECL_SYM("FIXNUM",374),v5);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
    }
    v2 = ecl_fixnum(v5);
   }
   v3i = v2;
   v4y = v1x;
   goto L9;
L8:;
   if (ECL_CONSP(v4y)) {
    goto L11;
   }
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L11:;
   {
    cl_object v5;
    v5 = ecl_make_integer((v3i)-1);
    {
     bool v6;
     v6 = ECL_FIXNUMP(v5);
     if (ecl_unlikely(!(v6)))
         FEwrong_type_argument(ECL_SYM("FIXNUM",374),v5);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
    }
    v3i = ecl_fixnum(v5);
   }
   v4y = ecl_cdr(v4y);
L9:;
   if ((v3i)==((cl_fixnum)(0))) {
    goto L18;
   }
   goto L8;
L18:;
   if (!(ECL_CONSP(v4y))){
    goto L21;
   }
   T0 = ecl_car(v4y);
   value0 = ecl_make_bool((T0)==(ECL_CONS_CAR(CLV0)));
   cl_env_copy->nvalues = 1;
   return value0;
L21:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
 }
}
/* local function LAMBDA159                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC319__lambda159(cl_object v1descriptions)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v2;
  cl_object v3arg_desc;
  v2 = v1descriptions;
  if (!(v2==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1descriptions);
L4:;
  {
   cl_object v4;
   v4 = ecl_car(v2);
   v2 = ecl_cdr(v2);
   v3arg_desc = v4;
  }
  {
   cl_object v4name;
   v4name = ecl_car(v3arg_desc);
   if (Null(v3arg_desc)){
    goto L10;
   }
   if ((v4name)==(VV[29])) {
    goto L10;
   }
   {
    cl_object v5;
    cl_object v6;
    v5 = (ECL_SYM("CAR",182)->symbol.gfdef);
    v6 = (ECL_SYM("EQUAL",337)->symbol.gfdef);
    {
     cl_object v7;
     v7 = v2;
     goto L19;
L18:;
     {
      cl_object v8;
      cl_object v9;
      {
       cl_object v10;
       v10 = v7;
       if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v8 = v10;
      }
      v9 = ECL_CONS_CAR(v8);
      T0 = ecl_car(v9);
      if (!(ecl_equal(v4name,T0))){
       goto L21;
      }
      if (Null(v8)){
       goto L10;
      }
      goto L11;
     }
L21:;
     v7 = ECL_CONS_CDR(v7);
L19:;
     if (v7==ECL_NIL) {
      goto L29;
     }
     goto L18;
L29:;
     goto L10;
    }
   }
L11:;
   value0 = cl_error(2, VV[55], v4name);
   return value0;
L10:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
static cl_object LC319__lambda159_va(cl_narg narg, cl_object v5descriptions, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[54]);
 {
  return LC319__lambda159(v5descriptions);
 }
}
/* local function LAMBDA184                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC320__lambda184(cl_object v1sd)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (Null(v1sd)){
  goto L2;
 }
 T0 = ecl_car(v1sd);
 T1 = ecl_cadr(v1sd);
 T2 = ecl_car(v1sd);
 T3 = ecl_symbol_name(T2);
 T4 = cl_find_package(ECL_SYM("KEYWORD",451));
 T5 = cl_intern(2, T3, T4);
 T6 = ecl_list1(T5);
 if (Null(ecl_caddr(v1sd))){
  goto L5;
 }
 T8 = ecl_caddr(v1sd);
 T7 = cl_list(2, ECL_SYM("TYPE",1356), T8);
 goto L4;
L5:;
 T7 = ECL_NIL;
L4:;
 value0 = cl_listX(7, ECL_SYM("NAME",1309), T0, ECL_SYM("INITFORM",1000), T1, ECL_SYM("INITARGS",999), T6, T7);
 return value0;
L2:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC320__lambda184_va(cl_narg narg, cl_object v2sd, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[60]);
 {
  return LC320__lambda184(v2sd);
 }
}
/* closure LAMBDA188                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC321__lambda188(cl_narg narg, cl_object v1obj, cl_object v2stream, ...)
{
 cl_object CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV1 = env0;
 CLV0 = _ecl_cdr(CLV1);                           /*  PRINT-FUNCTION          */
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[66]);
 {
L1:;
  ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV0))(3, v1obj, v2stream, ecl_make_int8_t(0));
  value0 = v1obj;
  cl_env_copy->nvalues = 1;
  return value0;
 }
 }
}
/* closure LAMBDA190                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC322__lambda190(cl_narg narg, cl_object v1obj, cl_object v2stream, ...)
{
 cl_object CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV1 = env0;                                     /*  PRINT-OBJECT            */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[67]);
 {
L1:;
  ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV1))(2, v1obj, v2stream);
  value0 = v1obj;
  cl_env_copy->nvalues = 1;
  return value0;
 }
 }
}
/* local function LAMBDA237                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC323__lambda237(cl_object v1sd)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 value0 = L316parse_slot_description(3, v1sd, ecl_make_int8_t(0), VV[49]);
 return value0;
}
static cl_object LC323__lambda237_va(cl_narg narg, cl_object v2sd, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[87]);
 {
  return LC323__lambda237(v2sd);
 }
}
/* closure LAMBDA248                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC324__lambda248(cl_narg narg, cl_object v1constructor, ...)
{
 cl_object CLV0, CLV1, CLV2, CLV3, CLV4;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV4 = env0;                                     /*  NAMED                   */
 CLV3 = _ecl_cdr(CLV4);
 CLV2 = _ecl_cdr(CLV3);
 CLV1 = _ecl_cdr(CLV2);
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[91]);
 {
L1:;
  value0 = L310make_constructor(ECL_CONS_CAR(CLV2), v1constructor, ECL_CONS_CAR(CLV3), ECL_CONS_CAR(CLV4), ECL_CONS_CAR(CLV1), ECL_CONS_CAR(CLV0));
  return value0;
 }
 }
}
#include "lsp/defstruct.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _eclYQHp5HAKwmnr9_MufzL881(cl_object flag)
{
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 cl_object *VVtemp;
 if (flag != OBJNULL){
 Cblock = flag;
 #ifndef ECL_DYNAMIC_VV
 flag->cblock.data = VV;
 #endif
 flag->cblock.data_size = VM;
 flag->cblock.temp_data_size = VMtemp;
 flag->cblock.data_text = compiler_data_text;
 flag->cblock.cfuns_size = compiler_cfuns_size;
 flag->cblock.cfuns = compiler_cfuns;
 flag->cblock.source = ecl_make_constant_base_string("SRC:LSP;DEFSTRUCT.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclYQHp5HAKwmnr9_MufzL881@";
 VVtemp = Cblock->cblock.temp_data;
 ECL_DEFINE_SETF_FUNCTIONS
/* MAKE-LOAD-FORMs                                                            */
/* TOP-LEVEL-FORMs                                                            */
  si_select_package(VVtemp[0]);
  ecl_cmp_defun(VV[96]);                          /*  SLOT-ACCESS-FUNCTION    */
  ecl_cmp_defun(VV[97]);                          /*  MAKE-ATOMIC-ACCESSORS   */
  ecl_cmp_defun(VV[98]);                          /*  STRUCTURE-TYPE-ERROR    */
  (void)0; /* No entry created for MAKE-ACCESS-FUNCTION */
  (void)0; /* No entry created for DO-SETF-STRUCTURE-METHOD */
  (void)0; /* No entry created for PROCESS-BOA-LAMBDA-LIST */
  (void)0; /* No entry created for MAKE-CONSTRUCTOR */
  (void)0; /* No entry created for MAKE-PREDICATE */
  (void)0; /* No entry created for PARSE-SLOT-DESCRIPTION */
  (void)0; /* No entry created for OVERWRITE-SLOT-DESCRIPTIONS */
  (void)0; /* No entry created for %STRUCT-LAYOUT-COMPATIBLE-P */
  ecl_cmp_defun(VV[99]);                          /*  DEFINE-STRUCTURE        */
  ecl_cmp_defmacro(VV[100]);                      /*  DEFSTRUCT               */
}
