/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/clos/print.lsp                      */
#include <ecl/ecl-cmp.h>
#include "clos/print.eclh"
/* function definition for MAKE-LOAD-FORM-SAVING-SLOTS                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2414make_load_form_saving_slots(cl_narg narg, cl_object v1object, ...)
{
 cl_object T0, T1;
 volatile cl_object lex0[4];
 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<1)) FEwrong_num_arguments(VV[5]);
 {
  cl_object v2slot_names;
  cl_object v3environment;
  ecl_va_list args; ecl_va_start(args,v1object,narg,1);
  lex0[0] = v1object;                             /*  OBJECT                  */
  {
   cl_object keyvars[4];
   cl_parse_key(args,2,L2414make_load_form_saving_slotskeys,keyvars,NULL,FALSE);
   ecl_va_end(args);
   v2slot_names = keyvars[0];
   v3environment = keyvars[1];
  }
  {
   cl_object v4class;
   cl_object v5initialization_form;
   cl_object v6slots;
   cl_object v7decls;
   v4class = cl_class_of(lex0[0]);
   T0 = (cl_env_copy->function=(ECL_SYM("CLASS-NAME",938)->symbol.gfdef))->cfun.entry(1, v4class) /*  CLASS-NAME */;
   lex0[1] = T0;                                  /*  CLASS-NAME              */
   v5initialization_form = ecl_list1(ECL_SYM("PROGN",674));
   v6slots = (cl_env_copy->function=(ECL_SYM("CLASS-SLOTS",1570)->symbol.gfdef))->cfun.entry(1, v4class) /*  CLASS-SLOTS */;
   if (Null(si_of_class_p(2, lex0[0], ECL_SYM("STRUCTURE-OBJECT",982)))){
    goto L5;
   }
   v7decls = si_get_sysprop(lex0[1], ECL_SYM("STRUCTURE-SLOT-DESCRIPTIONS",1180));
   goto L4;
L5:;
   v7decls = ECL_NIL;
L4:;
   {
    cl_object v8;
    cl_object v9;
    cl_object v10slot;
    {
     cl_object v11;
     v11 = v6slots;
     {
      cl_object v12;
      v12 = v11;
      {
       bool v13;
       v13 = ECL_LISTP(v12);
       if (ecl_unlikely(!(v13)))
         FEwrong_type_argument(VV[2],v12);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
      }
     }
     if (Null(v11)){
      goto L12;
     }
     {
      cl_object v12;
      v12 = ECL_CONS_CDR(v11);
      v6slots = v12;
      v11 = ECL_CONS_CAR(v11);
     }
L12:;
     v8 = v11;
    }
    {
     cl_object v11;
     v11 = v7decls;
     {
      cl_object v12;
      v12 = v11;
      {
       bool v13;
       v13 = ECL_LISTP(v12);
       if (ecl_unlikely(!(v13)))
         FEwrong_type_argument(VV[2],v12);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
      }
     }
     if (Null(v11)){
      goto L23;
     }
     {
      cl_object v12;
      v12 = ECL_CONS_CDR(v11);
      v7decls = v12;
      v11 = ECL_CONS_CAR(v11);
     }
L23:;
     v9 = v11;
    }
    v10slot = v8;
    lex0[2] = v9;                                 /*  DESC                    */
    goto L32;
L31:;
    T0 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef))->cfun.entry(1, v10slot) /*  SLOT-DEFINITION-NAME */;
    lex0[3] = T0;                                 /*  SLOT-NAME               */
    if (!(v2slot_names==ECL_NIL)){
     goto L39;
    }
    T0 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-ALLOCATION",1619)->symbol.gfdef))->cfun.entry(1, v10slot) /*  SLOT-DEFINITION-ALLOCATION */;
    if ((T0)==(ECL_SYM("INSTANCE",1291))) {
     goto L36;
    }
    goto L37;
L39:;
    goto L37;
L37:;
    {
     cl_object v11;
     cl_object v12;
     v11 = lex0[3];
     v12 = v2slot_names;
     if (Null(ecl_memql(v11,v12))){
      goto L34;
     }
     goto L35;
    }
L36:;
L35:;
    if (Null(cl_slot_boundp(lex0[0], lex0[3]))){
     goto L45;
    }
    T1 = cl_slot_value(lex0[0], lex0[3]);
    T0 = LC2412primitive_set(lex0, T1);
    goto L44;
L45:;
    T0 = LC2413primitive_nil(lex0);
L44:;
    v5initialization_form = CONS(T0,v5initialization_form);
L34:;
    {
     cl_object v11;
     v11 = v6slots;
     {
      cl_object v12;
      v12 = v11;
      {
       bool v13;
       v13 = ECL_LISTP(v12);
       if (ecl_unlikely(!(v13)))
         FEwrong_type_argument(VV[2],v12);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
      }
     }
     if (Null(v11)){
      goto L53;
     }
     {
      cl_object v12;
      v12 = ECL_CONS_CDR(v11);
      v6slots = v12;
      v11 = ECL_CONS_CAR(v11);
     }
L53:;
     v10slot = v11;
    }
    {
     cl_object v11;
     v11 = v7decls;
     {
      cl_object v12;
      v12 = v11;
      {
       bool v13;
       v13 = ECL_LISTP(v12);
       if (ecl_unlikely(!(v13)))
         FEwrong_type_argument(VV[2],v12);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
      }
     }
     if (Null(v11)){
      goto L64;
     }
     {
      cl_object v12;
      v12 = ECL_CONS_CDR(v11);
      v7decls = v12;
      v11 = ECL_CONS_CAR(v11);
     }
L64:;
     lex0[2] = v11;
    }
L32:;
    if (v10slot==ECL_NIL) {
     goto L70;
    }
    goto L31;
L70:;
    T0 = cl_list(2, ECL_SYM("ALLOCATE-INSTANCE",931), v4class);
    T1 = cl_nreverse(v5initialization_form);
    cl_env_copy->nvalues = 2;
    cl_env_copy->values[1] = T1;
    cl_env_copy->values[0] = T0;
    return cl_env_copy->values[0];
   }
  }
 }
}
/* local function MAKE-LOAD-FORM                                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2416make_load_form(cl_narg narg, cl_object v1object, ...)
{
 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);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(ECL_SYM("MAKE-LOAD-FORM",955));
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(ECL_SYM("MAKE-LOAD-FORM",955));
 {
  cl_object v2env;
  va_list args; va_start(args,v1object);
  {
   int i = 1;
   if (i >= narg) {
    v2env = ECL_NIL;
   } else {
    i++;
    v2env = va_arg(args,cl_object);
   }
  }
  va_end(args);
  if (si_need_to_make_load_form_p(v1object)!=ECL_NIL) {
   goto L2;
  }
  value0 = LC2415maybe_quote(v1object);
  return value0;
L2:;
  if (Null(cl_compiled_function_p(v1object))){
   goto L4;
  }
  {
   cl_object v3;                                  /*  LEX                     */
   cl_object v4;                                  /*  CODE                    */
   cl_object v5;                                  /*  DATA                    */
   cl_object v6;                                  /*  NAME                    */
   value0 = si_bc_split(v1object);
   {
    const int v7 = cl_env_copy->nvalues;
    v3 = value0;
    cl_object v8;
    v8 = (v7<=1)? ECL_NIL : cl_env_copy->values[1];
    v4 = v8;
    v8 = (v7<=2)? ECL_NIL : cl_env_copy->values[2];
    v5 = v8;
    v8 = (v7<=3)? ECL_NIL : cl_env_copy->values[3];
    v6 = v8;
   }
   if (v4!=ECL_NIL) {
    goto L7;
   }
   cl_error(2, VV[7], v1object);
L7:;
   T0 = (cl_env_copy->function=(ECL_SYM("MAKE-LOAD-FORM",955)->symbol.gfdef))->cfun.entry(2, v3, v2env) /*  MAKE-LOAD-FORM */;
   T1 = cl_list(2, ECL_SYM("QUOTE",682), v4);
   T2 = (cl_env_copy->function=(ECL_SYM("MAKE-LOAD-FORM",955)->symbol.gfdef))->cfun.entry(2, v5, v2env) /*  MAKE-LOAD-FORM */;
   T3 = (cl_env_copy->function=(ECL_SYM("MAKE-LOAD-FORM",955)->symbol.gfdef))->cfun.entry(2, v6, v2env) /*  MAKE-LOAD-FORM */;
   value0 = cl_list(5, ECL_SYM("BC-JOIN",1051), T0, T1, T2, T3);
   return value0;
  }
L4:;
  if (!(ECL_ARRAYP(v1object))){
   goto L9;
  }
  {
   cl_object v3init_forms;
   v3init_forms = ECL_NIL;
   T0 = cl_array_dimensions(v1object);
   T1 = cl_list(2, ECL_SYM("QUOTE",682), T0);
   T2 = cl_array_element_type(v1object);
   T3 = cl_list(2, ECL_SYM("QUOTE",682), T2);
   {
    bool v4;
    v4 = (ECL_ARRAYP(v1object)? (void)0: FEtype_error_array(v1object),ECL_ADJUSTABLE_ARRAY_P(v1object));
    T4 = cl_list(2, ECL_SYM("QUOTE",682), ecl_make_bool(v4));
    {
     cl_object v5;
     cl_object v6i;
     v5 = cl_array_total_size(v1object);
     v6i = ecl_make_int8_t(0);
     {
      cl_object v7;
      cl_object v8;
      v7 = ecl_list1(ECL_NIL);
      v8 = v7;
L17:;
      if (!(ecl_greatereq(v6i,v5))){
       goto L19;
      }
      goto L18;
L19:;
      {
       cl_object v9;
       v9 = v8;
       if (ecl_unlikely(ECL_ATOM(v9))) FEtype_error_cons(v9);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T6 = v9;
      }
      {
       cl_object v9x;
       v9x = ecl_aref(v1object,ecl_to_size(v6i));
       if (Null(si_need_to_make_load_form_p(v9x))){
        goto L28;
       }
       T8 = cl_list(3, ECL_SYM("ROW-MAJOR-AREF",734), v1object, v6i);
       T9 = cl_list(2, ECL_SYM("QUOTE",682), v9x);
       T10 = cl_list(3, ECL_SYM("SETF",753), T8, T9);
       v3init_forms = CONS(T10,v3init_forms);
       T7 = ecl_make_int8_t(0);
       goto L26;
L28:;
       T7 = v9x;
      }
L26:;
      v8 = ecl_list1(T7);
      (ECL_CONS_CDR(T6)=v8,T6);
      v6i = ecl_one_plus(v6i);
      goto L17;
L18:;
      T5 = ecl_cdr(v7);
      goto L12;
     }
    }
L12:;
    T6 = cl_list(2, ECL_SYM("QUOTE",682), T5);
    T7 = cl_list(8, ECL_SYM("MAKE-ARRAY",524), T1, ECL_SYM("ELEMENT-TYPE",1255), T3, ECL_SYM("ADJUSTABLE",1224), T4, ECL_SYM("INITIAL-CONTENTS",1287), T6);
    if (Null(v3init_forms)){
     goto L38;
    }
    T8 = CONS(ECL_SYM("PROGN",674),v3init_forms);
    goto L36;
L38:;
    T8 = ECL_NIL;
    goto L36;
L36:;
    cl_env_copy->nvalues = 2;
    cl_env_copy->values[1] = T8;
    cl_env_copy->values[0] = T7;
    return cl_env_copy->values[0];
   }
  }
L9:;
  if (!(ECL_CONSP(v1object))){
   goto L40;
  }
  T0 = LC2415maybe_quote(v1object);
  T2 = ecl_car(v1object);
  T1 = LC2415maybe_quote(T2);
  T2 = cl_list(3, ECL_SYM("RPLACA",735), T0, T1);
  T3 = LC2415maybe_quote(v1object);
  T5 = ecl_cdr(v1object);
  T4 = LC2415maybe_quote(T5);
  T5 = cl_list(3, ECL_SYM("RPLACD",736), T3, T4);
  T6 = cl_list(3, ECL_SYM("PROGN",674), T2, T5);
  cl_env_copy->nvalues = 2;
  cl_env_copy->values[1] = T6;
  cl_env_copy->values[0] = VV[14];
  return cl_env_copy->values[0];
L40:;
  if (Null(cl_hash_table_p(v1object))){
   goto L46;
  }
  {
   cl_object v4content;
   cl_object v5make_form;
   v4content = si_hash_table_content(v1object);
   T0 = cl_hash_table_size(v1object);
   T1 = cl_hash_table_rehash_size(v1object);
   T2 = cl_hash_table_rehash_threshold(v1object);
   T3 = cl_hash_table_test(v1object);
   T4 = cl_list(2, ECL_SYM("QUOTE",682), T3);
   v5make_form = cl_list(9, ECL_SYM("MAKE-HASH-TABLE",530), ECL_SYM("SIZE",1345), T0, ECL_SYM("REHASH-SIZE",1334), T1, ECL_SYM("REHASH-THRESHOLD",1335), T2, ECL_SYM("TEST",1353), T4);
   if (Null(si_need_to_make_load_form_p(v4content))){
    goto L50;
   }
   {
    cl_object v6;
    cl_object v7key;
    cl_object v8obj;
    v6 = ECL_NIL;
    v7key = ECL_NIL;
    v8obj = ECL_NIL;
    {
     cl_object v9;
     v9 = si_hash_table_iterator(v1object);
     {
      cl_object v10;
      cl_object v11;
      v10 = ecl_list1(ECL_NIL);
      v11 = v10;
L59:;
      {
       cl_object v12;
       cl_object v13;
       cl_object v14;
       value0 = ecl_function_dispatch(cl_env_copy,v9)(0);
       {
        const int v15 = cl_env_copy->nvalues;
        v12 = value0;
        cl_object v16;
        v16 = (v15<=1)? ECL_NIL : cl_env_copy->values[1];
        v13 = v16;
        v16 = (v15<=2)? ECL_NIL : cl_env_copy->values[2];
        v14 = v16;
       }
       if (Null(v12)){
        goto L64;
       }
       v8obj = v14;
       v7key = v13;
L64:;
       v6 = v12;
       if (v6!=ECL_NIL) {
        goto L61;
       }
      }
      goto L60;
L61:;
      {
       cl_object v12;
       v12 = v11;
       if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       T1 = v12;
      }
      T2 = CONS(v7key,v8obj);
      v11 = ecl_list1(T2);
      (ECL_CONS_CDR(T1)=v11,T1);
      goto L59;
L60:;
      T0 = ecl_cdr(v10);
      goto L52;
     }
    }
   }
L52:;
   T1 = cl_list(2, ECL_SYM("QUOTE",682), T0);
   T2 = cl_list(2, VV[15], T1);
   T3 = cl_list(3, ECL_SYM("GETHASH",415), VV[17], v1object);
   T4 = cl_list(3, ECL_SYM("SETF",753), T3, VV[18]);
   T5 = cl_list(3, ECL_SYM("DOLIST",315), T2, T4);
   cl_env_copy->nvalues = 2;
   cl_env_copy->values[1] = T5;
   cl_env_copy->values[0] = v5make_form;
   return cl_env_copy->values[0];
L50:;
   T0 = cl_list(2, ECL_SYM("QUOTE",682), v4content);
   T1 = cl_list(3, ECL_SYM("HASH-TABLE-FILL",2046), v5make_form, T0);
   cl_env_copy->nvalues = 2;
   cl_env_copy->values[1] = ECL_NIL;
   cl_env_copy->values[0] = T1;
   return cl_env_copy->values[0];
  }
L46:;
  if (Null(cl_random_state_p(v1object))){
   goto L77;
  }
  {
   cl_object v6state;
   v6state = si_random_state_array(v1object);
   T0 = cl_list(2, ECL_SYM("MAKE-RANDOM-STATE",534), v6state);
   cl_env_copy->nvalues = 2;
   cl_env_copy->values[1] = ECL_NIL;
   cl_env_copy->values[0] = T0;
   return cl_env_copy->values[0];
  }
L77:;
  value0 = L2420no_make_load_form(v1object);
  return value0;
 }
}
/* local function MAKE-LOAD-FORM                                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2417make_load_form(cl_narg narg, cl_object v1object, ...)
{
 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<1)) FEwrong_num_arguments(ECL_SYM("MAKE-LOAD-FORM",955));
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(ECL_SYM("MAKE-LOAD-FORM",955));
 {
  cl_object v2environment;
  va_list args; va_start(args,v1object);
  {
   int i = 1;
   if (i >= narg) {
    v2environment = ECL_NIL;
   } else {
    i++;
    v2environment = va_arg(args,cl_object);
   }
  }
  va_end(args);
  value0 = L2420no_make_load_form(v1object);
  return value0;
 }
}
/* local function MAKE-LOAD-FORM                                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2418make_load_form(cl_narg narg, cl_object v1object, ...)
{
 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<1)) FEwrong_num_arguments(ECL_SYM("MAKE-LOAD-FORM",955));
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(ECL_SYM("MAKE-LOAD-FORM",955));
 {
  cl_object v2environment;
  va_list args; va_start(args,v1object);
  {
   int i = 1;
   if (i >= narg) {
    v2environment = ECL_NIL;
   } else {
    i++;
    v2environment = va_arg(args,cl_object);
   }
  }
  va_end(args);
  value0 = L2420no_make_load_form(v1object);
  return value0;
 }
}
/* local function MAKE-LOAD-FORM                                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2419make_load_form(cl_narg narg, cl_object v1object, ...)
{
 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<1)) FEwrong_num_arguments(ECL_SYM("MAKE-LOAD-FORM",955));
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(ECL_SYM("MAKE-LOAD-FORM",955));
 {
  cl_object v2environment;
  va_list args; va_start(args,v1object);
  {
   int i = 1;
   if (i >= narg) {
    v2environment = ECL_NIL;
   } else {
    i++;
    v2environment = va_arg(args,cl_object);
   }
  }
  va_end(args);
  value0 = L2420no_make_load_form(v1object);
  return value0;
 }
}
/* function definition for NO-MAKE-LOAD-FORM                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2420no_make_load_form(cl_object v1object)
{
 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_type_of(v1object);
 value0 = cl_error(2, VV[20], T0);
 return value0;
}
/* local function MAKE-LOAD-FORM                                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2421make_load_form(cl_narg narg, cl_object v1class, ...)
{
 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<1)) FEwrong_num_arguments(ECL_SYM("MAKE-LOAD-FORM",955));
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(ECL_SYM("MAKE-LOAD-FORM",955));
 {
  cl_object v2environment;
  va_list args; va_start(args,v1class);
  {
   int i = 1;
   if (i >= narg) {
    v2environment = ECL_NIL;
   } else {
    i++;
    v2environment = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v3name;
   v3name = (cl_env_copy->function=(ECL_SYM("CLASS-NAME",938)->symbol.gfdef))->cfun.entry(1, v1class) /*  CLASS-NAME */;
   if (Null(v3name)){
    goto L3;
   }
   T0 = cl_find_class(1, v3name);
   if (!((T0)==(v1class))){
    goto L3;
   }
   T0 = cl_list(2, ECL_SYM("QUOTE",682), v3name);
   value0 = cl_list(2, ECL_SYM("FIND-CLASS",947), T0);
   return value0;
L3:;
   value0 = cl_error(2, VV[21], v1class);
   return value0;
  }
 }
}
/* local function MAKE-LOAD-FORM                                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2422make_load_form(cl_narg narg, cl_object v1package, ...)
{
 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<1)) FEwrong_num_arguments(ECL_SYM("MAKE-LOAD-FORM",955));
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(ECL_SYM("MAKE-LOAD-FORM",955));
 {
  cl_object v2environment;
  va_list args; va_start(args,v1package);
  {
   int i = 1;
   if (i >= narg) {
    v2environment = ECL_NIL;
   } else {
    i++;
    v2environment = va_arg(args,cl_object);
   }
  }
  va_end(args);
  T0 = cl_package_name(v1package);
  value0 = cl_list(2, ECL_SYM("FIND-PACKAGE",369), T0);
  return value0;
 }
}
/* local function PRINT-OBJECT                                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2424print_object(cl_object v1instance, cl_object v2stream)
{
 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(v1instance,env0);             /*  INSTANCE                */
 CLV1 = env0 = CONS(v2stream,env0);               /*  STREAM                  */
 T0 = cl_find_package(VV[22]);
 ecl_bds_bind(cl_env_copy,ECL_SYM("*PACKAGE*",45),T0); /*  *PACKAGE*          */
 {
  cl_object v3;
  v3 = ecl_make_cclosure_va((cl_objectfn)LC2423si___print_unreadable_object_body_,env0,Cblock,0);
  si_print_unreadable_object_function(ECL_CONS_CAR(CLV0), ECL_CONS_CAR(CLV1), ECL_NIL, ECL_NIL, v3);
  ecl_bds_unwind1(cl_env_copy);
 }
 value0 = ECL_CONS_CAR(CLV0);
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC2424print_object_va(cl_narg narg, cl_object v3instance, cl_object v4stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(ECL_SYM("PRINT-OBJECT",965));
 {
  return LC2424print_object(v3instance, v4stream);
 }
}
/* local function PRINT-OBJECT                                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2426print_object(cl_object v1instance, cl_object v2stream)
{
 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(v1instance,env0);             /*  INSTANCE                */
 CLV1 = env0 = CONS(v2stream,env0);               /*  STREAM                  */
 {
  cl_object v3;
  v3 = ecl_make_cclosure_va((cl_objectfn)LC2425si___print_unreadable_object_body_,env0,Cblock,0);
  si_print_unreadable_object_function(ECL_CONS_CAR(CLV0), ECL_CONS_CAR(CLV1), ECL_NIL, ECL_T, v3);
 }
 value0 = ECL_CONS_CAR(CLV0);
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC2426print_object_va(cl_narg narg, cl_object v3instance, cl_object v4stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(ECL_SYM("PRINT-OBJECT",965));
 {
  return LC2426print_object(v3instance, v4stream);
 }
}
/* local function PRINT-OBJECT                                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2428print_object(cl_object v1class, cl_object v2stream)
{
 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(v1class,env0);                /*  CLASS                   */
 CLV1 = env0 = CONS(v2stream,env0);               /*  STREAM                  */
 {
  cl_object v3;
  v3 = ecl_make_cclosure_va((cl_objectfn)LC2427si___print_unreadable_object_body_,env0,Cblock,0);
  si_print_unreadable_object_function(ECL_CONS_CAR(CLV0), ECL_CONS_CAR(CLV1), ECL_NIL, ECL_NIL, v3);
 }
 value0 = ECL_CONS_CAR(CLV0);
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC2428print_object_va(cl_narg narg, cl_object v3class, cl_object v4stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(ECL_SYM("PRINT-OBJECT",965));
 {
  return LC2428print_object(v3class, v4stream);
 }
}
/* local function PRINT-OBJECT                                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2430print_object(cl_object v1gf, cl_object v2stream)
{
 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(v1gf,env0);                   /*  GF                      */
 CLV1 = env0 = CONS(v2stream,env0);               /*  STREAM                  */
 {
  cl_object v3;
  v3 = ecl_make_cclosure_va((cl_objectfn)LC2429si___print_unreadable_object_body_,env0,Cblock,0);
  si_print_unreadable_object_function(ECL_CONS_CAR(CLV0), ECL_CONS_CAR(CLV1), ECL_T, ECL_NIL, v3);
 }
 value0 = ECL_CONS_CAR(CLV0);
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC2430print_object_va(cl_narg narg, cl_object v3gf, cl_object v4stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(ECL_SYM("PRINT-OBJECT",965));
 {
  return LC2430print_object(v3gf, v4stream);
 }
}
/* local function PRINT-OBJECT                                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2432print_object(cl_object v1m, cl_object v2stream)
{
 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(v1m,env0);                    /*  M                       */
 CLV1 = env0 = CONS(v2stream,env0);               /*  STREAM                  */
 {
  cl_object v3;
  v3 = ecl_make_cclosure_va((cl_objectfn)LC2431si___print_unreadable_object_body_,env0,Cblock,0);
  si_print_unreadable_object_function(ECL_CONS_CAR(CLV0), ECL_CONS_CAR(CLV1), ECL_T, ECL_NIL, v3);
 }
 value0 = ECL_CONS_CAR(CLV0);
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC2432print_object_va(cl_narg narg, cl_object v3m, cl_object v4stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(ECL_SYM("PRINT-OBJECT",965));
 {
  return LC2432print_object(v3m, v4stream);
 }
}
/* function definition for FLOAT-NAN-STRING                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2433float_nan_string(cl_object v1x)
{
 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 (si_float_nan_p(v1x)!=ECL_NIL) {
  goto L2;
 }
 (cl_env_copy->function=(ECL_SYM("SIGNAL",763)->symbol.gfdef))->cfun.entry(5, ECL_SYM("TYPE-ERROR",873), ECL_SYM("DATUM",1245), v1x, ECL_SYM("EXPECTED-TYPE",1263), VV[30]) /*  SIGNAL */;
L2:;
 if (!(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*PRINT-READABLY*",59))==ECL_NIL)){
  goto L4;
 }
 if (!(ECL_SINGLE_FLOAT_P(v1x))){
  goto L6;
 }
 value0 = VV[31];
 cl_env_copy->nvalues = 1;
 return value0;
L6:;
 if (!(ECL_DOUBLE_FLOAT_P(v1x))){
  goto L8;
 }
 value0 = VV[32];
 cl_env_copy->nvalues = 1;
 return value0;
L8:;
 if (!(ECL_LONG_FLOAT_P(v1x))){
  goto L10;
 }
 value0 = VV[33];
 cl_env_copy->nvalues = 1;
 return value0;
L10:;
 if (!(ECL_SINGLE_FLOAT_P(v1x))){
  goto L12;
 }
 value0 = VV[34];
 cl_env_copy->nvalues = 1;
 return value0;
L12:;
 value0 = si_etypecase_error(v1x, VV[35]);
 return value0;
L4:;
 if (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*READ-EVAL*",65)))){
  goto L14;
 }
 if (!(ECL_SINGLE_FLOAT_P(v1x))){
  goto L16;
 }
 value0 = VV[36];
 cl_env_copy->nvalues = 1;
 return value0;
L16:;
 if (!(ECL_DOUBLE_FLOAT_P(v1x))){
  goto L18;
 }
 value0 = VV[37];
 cl_env_copy->nvalues = 1;
 return value0;
L18:;
 if (!(ECL_LONG_FLOAT_P(v1x))){
  goto L20;
 }
 value0 = VV[38];
 cl_env_copy->nvalues = 1;
 return value0;
L20:;
 if (!(ECL_SINGLE_FLOAT_P(v1x))){
  goto L22;
 }
 value0 = VV[39];
 cl_env_copy->nvalues = 1;
 return value0;
L22:;
 value0 = si_etypecase_error(v1x, VV[35]);
 return value0;
L14:;
 value0 = cl_error(3, ECL_SYM("PRINT-NOT-READABLE",666), ECL_SYM("OBJECT",1315), v1x);
 return value0;
}
static cl_object L2433float_nan_string_va(cl_narg narg, cl_object v2x, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[40]);
 {
  return L2433float_nan_string(v2x);
 }
}
/* function definition for FLOAT-INFINITY-STRING                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2434float_infinity_string(cl_object v1x)
{
 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 (si_float_infinity_p(v1x)!=ECL_NIL) {
  goto L2;
 }
 (cl_env_copy->function=(ECL_SYM("SIGNAL",763)->symbol.gfdef))->cfun.entry(5, ECL_SYM("TYPE-ERROR",873), ECL_SYM("DATUM",1245), v1x, ECL_SYM("EXPECTED-TYPE",1263), VV[41]) /*  SIGNAL */;
L2:;
 if (!(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*PRINT-READABLY*",59))==ECL_NIL)){
  goto L4;
 }
 {
  float v2;
  v2 = ecl_single_float(cl_core.singlefloat_zero);
  if (!(ECL_SINGLE_FLOAT_P(v1x))){
   goto L6;
  }
  v2 = ecl_single_float(v1x);
  if (!((v2)<(ecl_single_float(cl_core.singlefloat_zero)))){
   goto L6;
  }
 }
 value0 = VV[42];
 cl_env_copy->nvalues = 1;
 return value0;
L6:;
 {
  float v2;
  v2 = ecl_single_float(cl_core.singlefloat_zero);
  if (!(ECL_SINGLE_FLOAT_P(v1x))){
   goto L12;
  }
  v2 = ecl_single_float(v1x);
  if (!((v2)>(ecl_single_float(cl_core.singlefloat_zero)))){
   goto L12;
  }
 }
 value0 = VV[43];
 cl_env_copy->nvalues = 1;
 return value0;
L12:;
 {
  double v2;
  v2 = ecl_double_float(cl_core.doublefloat_zero);
  if (!(ECL_DOUBLE_FLOAT_P(v1x))){
   goto L18;
  }
  v2 = ecl_double_float(v1x);
  if (!((v2)<(ecl_double_float(cl_core.doublefloat_zero)))){
   goto L18;
  }
 }
 value0 = VV[44];
 cl_env_copy->nvalues = 1;
 return value0;
L18:;
 {
  double v2;
  v2 = ecl_double_float(cl_core.doublefloat_zero);
  if (!(ECL_DOUBLE_FLOAT_P(v1x))){
   goto L24;
  }
  v2 = ecl_double_float(v1x);
  if (!((v2)>(ecl_double_float(cl_core.doublefloat_zero)))){
   goto L24;
  }
 }
 value0 = VV[45];
 cl_env_copy->nvalues = 1;
 return value0;
L24:;
 {
  long double v2;
  v2 = ecl_long_float(cl_core.longfloat_zero);
  if (!(ECL_LONG_FLOAT_P(v1x))){
   goto L30;
  }
  v2 = ecl_long_float(v1x);
  if (!((v2)<(ecl_long_float(cl_core.longfloat_zero)))){
   goto L30;
  }
 }
 value0 = VV[46];
 cl_env_copy->nvalues = 1;
 return value0;
L30:;
 {
  long double v2;
  v2 = ecl_long_float(cl_core.longfloat_zero);
  if (!(ECL_LONG_FLOAT_P(v1x))){
   goto L36;
  }
  v2 = ecl_long_float(v1x);
  if (!((v2)>(ecl_long_float(cl_core.longfloat_zero)))){
   goto L36;
  }
 }
 value0 = VV[47];
 cl_env_copy->nvalues = 1;
 return value0;
L36:;
 {
  float v2;
  v2 = ecl_single_float(cl_core.singlefloat_zero);
  if (!(ECL_SINGLE_FLOAT_P(v1x))){
   goto L42;
  }
  v2 = ecl_single_float(v1x);
  if (!((v2)<(ecl_single_float(cl_core.singlefloat_zero)))){
   goto L42;
  }
 }
 value0 = VV[48];
 cl_env_copy->nvalues = 1;
 return value0;
L42:;
 {
  float v2;
  v2 = ecl_single_float(cl_core.singlefloat_zero);
  if (!(ECL_SINGLE_FLOAT_P(v1x))){
   goto L48;
  }
  v2 = ecl_single_float(v1x);
  if (!((v2)>(ecl_single_float(cl_core.singlefloat_zero)))){
   goto L48;
  }
 }
 value0 = VV[49];
 cl_env_copy->nvalues = 1;
 return value0;
L48:;
 value0 = si_etypecase_error(v1x, VV[50]);
 return value0;
L4:;
 if (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*READ-EVAL*",65)))){
  goto L54;
 }
 {
  float v2;
  v2 = ecl_single_float(cl_core.singlefloat_zero);
  if (!(ECL_SINGLE_FLOAT_P(v1x))){
   goto L56;
  }
  v2 = ecl_single_float(v1x);
  if (!((v2)<(ecl_single_float(cl_core.singlefloat_zero)))){
   goto L56;
  }
 }
 value0 = VV[51];
 cl_env_copy->nvalues = 1;
 return value0;
L56:;
 {
  float v2;
  v2 = ecl_single_float(cl_core.singlefloat_zero);
  if (!(ECL_SINGLE_FLOAT_P(v1x))){
   goto L62;
  }
  v2 = ecl_single_float(v1x);
  if (!((v2)>(ecl_single_float(cl_core.singlefloat_zero)))){
   goto L62;
  }
 }
 value0 = VV[52];
 cl_env_copy->nvalues = 1;
 return value0;
L62:;
 {
  double v2;
  v2 = ecl_double_float(cl_core.doublefloat_zero);
  if (!(ECL_DOUBLE_FLOAT_P(v1x))){
   goto L68;
  }
  v2 = ecl_double_float(v1x);
  if (!((v2)<(ecl_double_float(cl_core.doublefloat_zero)))){
   goto L68;
  }
 }
 value0 = VV[53];
 cl_env_copy->nvalues = 1;
 return value0;
L68:;
 {
  double v2;
  v2 = ecl_double_float(cl_core.doublefloat_zero);
  if (!(ECL_DOUBLE_FLOAT_P(v1x))){
   goto L74;
  }
  v2 = ecl_double_float(v1x);
  if (!((v2)>(ecl_double_float(cl_core.doublefloat_zero)))){
   goto L74;
  }
 }
 value0 = VV[54];
 cl_env_copy->nvalues = 1;
 return value0;
L74:;
 {
  long double v2;
  v2 = ecl_long_float(cl_core.longfloat_zero);
  if (!(ECL_LONG_FLOAT_P(v1x))){
   goto L80;
  }
  v2 = ecl_long_float(v1x);
  if (!((v2)<(ecl_long_float(cl_core.longfloat_zero)))){
   goto L80;
  }
 }
 value0 = VV[55];
 cl_env_copy->nvalues = 1;
 return value0;
L80:;
 {
  long double v2;
  v2 = ecl_long_float(cl_core.longfloat_zero);
  if (!(ECL_LONG_FLOAT_P(v1x))){
   goto L86;
  }
  v2 = ecl_long_float(v1x);
  if (!((v2)>(ecl_long_float(cl_core.longfloat_zero)))){
   goto L86;
  }
 }
 value0 = VV[56];
 cl_env_copy->nvalues = 1;
 return value0;
L86:;
 {
  float v2;
  v2 = ecl_single_float(cl_core.singlefloat_zero);
  if (!(ECL_SINGLE_FLOAT_P(v1x))){
   goto L92;
  }
  v2 = ecl_single_float(v1x);
  if (!((v2)<(ecl_single_float(cl_core.singlefloat_zero)))){
   goto L92;
  }
 }
 value0 = VV[57];
 cl_env_copy->nvalues = 1;
 return value0;
L92:;
 {
  float v2;
  v2 = ecl_single_float(cl_core.singlefloat_zero);
  if (!(ECL_SINGLE_FLOAT_P(v1x))){
   goto L98;
  }
  v2 = ecl_single_float(v1x);
  if (!((v2)>(ecl_single_float(cl_core.singlefloat_zero)))){
   goto L98;
  }
 }
 value0 = VV[58];
 cl_env_copy->nvalues = 1;
 return value0;
L98:;
 value0 = si_etypecase_error(v1x, VV[50]);
 return value0;
L54:;
 value0 = cl_error(3, ECL_SYM("PRINT-NOT-READABLE",666), ECL_SYM("OBJECT",1315), v1x);
 return value0;
}
static cl_object L2434float_infinity_string_va(cl_narg narg, cl_object v2x, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[59]);
 {
  return L2434float_infinity_string(v2x);
 }
}
/* local function DESCRIBE-OBJECT                                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2435describe_object(cl_object v1obj, cl_object v2stream)
{
 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 v3class;
  cl_object v4slotds;
  v3class = cl_class_of(v1obj);
  v4slotds = (cl_env_copy->function=(ECL_SYM("CLASS-SLOTS",1570)->symbol.gfdef))->cfun.entry(1, v3class) /*  CLASS-SLOTS */;
  T0 = (cl_env_copy->function=(ECL_SYM("CLASS-NAME",938)->symbol.gfdef))->cfun.entry(1, v3class) /*  CLASS-NAME */;
  cl_format(4, v2stream, VV[60], v1obj, T0);
  {
   cl_object v5scan;
   cl_fixnum v6i;
   cl_object v7sv;
   v5scan = v4slotds;
   v6i = (cl_fixnum)(0);
   v7sv = ECL_NIL;
   goto L11;
L10:;
   v7sv = ecl_instance_ref((v1obj),(v6i));
   T0 = ecl_car(v5scan);
   T1 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef))->cfun.entry(1, T0) /*  SLOT-DEFINITION-NAME */;
   (ecl_print(T1,v2stream));
   ecl_princ(VV[61],v2stream);
   if (!((v7sv)!=ECL_UNBOUND)){
    goto L18;
   }
   (ecl_prin1(v7sv,v2stream));
   goto L17;
L18:;
   (ecl_prin1(VV[62],v2stream));
L17:;
   v5scan = ecl_cdr(v5scan);
   {
    cl_object v8;
    v8 = ecl_make_integer((v6i)+1);
    {
     bool v9;
     v9 = ECL_FIXNUMP(v8);
     if (ecl_unlikely(!(v9)))
         FEwrong_type_argument(ECL_SYM("FIXNUM",374),v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
    }
    v6i = ecl_fixnum(v8);
   }
L11:;
   if (v5scan==ECL_NIL) {
    goto L25;
   }
   goto L10;
L25:;
  }
 }
 value0 = v1obj;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC2435describe_object_va(cl_narg narg, cl_object v3obj, cl_object v4stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(ECL_SYM("DESCRIBE-OBJECT",945));
 {
  return LC2435describe_object(v3obj, v4stream);
 }
}
/* local function DESCRIBE-OBJECT                                             */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2436describe_object(cl_object v1obj, cl_object v2stream)
{
 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 v3class;
  cl_object v4slotds;
  v3class = si_instance_class(v1obj);
  v4slotds = (cl_env_copy->function=(ECL_SYM("CLASS-SLOTS",1570)->symbol.gfdef))->cfun.entry(1, v3class) /*  CLASS-SLOTS */;
  T0 = (cl_env_copy->function=(ECL_SYM("CLASS-NAME",938)->symbol.gfdef))->cfun.entry(1, v3class) /*  CLASS-NAME */;
  cl_format(4, v2stream, VV[60], v1obj, T0);
  {
   cl_object v5scan;
   cl_fixnum v6i;
   cl_object v7sv;
   v5scan = v4slotds;
   v6i = (cl_fixnum)(0);
   v7sv = ECL_NIL;
   goto L11;
L10:;
   T0 = ecl_car(v5scan);
   T1 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef))->cfun.entry(1, T0) /*  SLOT-DEFINITION-NAME */;
   (ecl_print(T1,v2stream));
   ecl_princ(VV[61],v2stream);
   {
    cl_object v8;
    T0 = ecl_car(v5scan);
    v8 = (cl_env_copy->function=(ECL_SYM("SLOT-DEFINITION-NAME",1624)->symbol.gfdef))->cfun.entry(1, T0) /*  SLOT-DEFINITION-NAME */;
    if (!((v8)==(VV[64]))){
     goto L22;
    }
    goto L19;
L22:;
    goto L20;
L20:;
    if (!((v8)==(VV[65]))){
     goto L17;
    }
    goto L18;
L19:;
L18:;
    ecl_princ_char((ecl_character)(40),v2stream);
    {
     cl_object v9scan;
     cl_object v10e;
     v9scan = ecl_instance_ref((v1obj),(v6i));
     v10e = ecl_car(v9scan);
     goto L31;
L30:;
     T0 = (cl_env_copy->function=(ECL_SYM("CLASS-NAME",938)->symbol.gfdef))->cfun.entry(1, v10e) /*  CLASS-NAME */;
     (ecl_prin1(T0,v2stream));
     if (Null(ecl_cdr(v9scan))){
      goto L34;
     }
     ecl_princ_char((ecl_character)(32),v2stream);
L34:;
     v9scan = ecl_cdr(v9scan);
     v10e = ecl_car(v9scan);
L31:;
     if (v9scan==ECL_NIL) {
      goto L40;
     }
     goto L30;
L40:;
    }
    ecl_princ_char((ecl_character)(41),v2stream);
    goto L15;
L17:;
    v7sv = ecl_instance_ref((v1obj),(v6i));
    if (!((v7sv)!=ECL_UNBOUND)){
     goto L44;
    }
    (ecl_prin1(v7sv,v2stream));
    goto L15;
L44:;
    (ecl_prin1(VV[62],v2stream));
   }
L15:;
   v5scan = ecl_cdr(v5scan);
   {
    cl_object v8;
    v8 = ecl_make_integer((v6i)+1);
    {
     bool v9;
     v9 = ECL_FIXNUMP(v8);
     if (ecl_unlikely(!(v9)))
         FEwrong_type_argument(ECL_SYM("FIXNUM",374),v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
    }
    v6i = ecl_fixnum(v8);
   }
L11:;
   if (v5scan==ECL_NIL) {
    goto L51;
   }
   goto L10;
L51:;
  }
 }
 value0 = v1obj;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC2436describe_object_va(cl_narg narg, cl_object v3obj, cl_object v4stream, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(ECL_SYM("DESCRIBE-OBJECT",945));
 {
  return LC2436describe_object(v3obj, v4stream);
 }
}
/* local function PRIMITIVE-NIL                                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2413primitive_nil(volatile cl_object *lex0)
{
 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:;
 if (Null(si_of_class_p(2, lex0[0], ECL_SYM("STRUCTURE-OBJECT",982)))){
  goto L2;
 }
 T0 = cl_list(2, ECL_SYM("QUOTE",682), lex0[1]);
 T1 = ecl_cddddr(lex0[2]);
 T2 = ecl_car(T1);
 value0 = cl_list(5, ECL_SYM("STRUCTURE-SET",1179), lex0[0], T0, T2, ECL_NIL);
 return value0;
L2:;
 T0 = cl_list(2, ECL_SYM("QUOTE",682), lex0[3]);
 value0 = cl_list(3, ECL_SYM("SLOT-MAKUNBOUND",972), lex0[0], T0);
 return value0;
}
/* local function PRIMITIVE-SET                                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2412primitive_set(volatile cl_object *lex0, cl_object v1val)
{
 cl_object T0, T1, T2, T3;
 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(si_of_class_p(2, lex0[0], ECL_SYM("STRUCTURE-OBJECT",982)))){
  goto L2;
 }
 T0 = cl_list(2, ECL_SYM("QUOTE",682), lex0[1]);
 T1 = ecl_cddddr(lex0[2]);
 T2 = ecl_car(T1);
 T3 = cl_list(2, ECL_SYM("QUOTE",682), v1val);
 value0 = cl_list(5, ECL_SYM("STRUCTURE-SET",1179), lex0[0], T0, T2, T3);
 return value0;
L2:;
 T0 = cl_list(2, ECL_SYM("QUOTE",682), lex0[3]);
 T1 = cl_list(3, ECL_SYM("SLOT-VALUE",975), lex0[0], T0);
 T2 = cl_list(2, ECL_SYM("QUOTE",682), v1val);
 value0 = cl_list(3, ECL_SYM("SETF",753), T1, T2);
 return value0;
}
/* local function MAYBE-QUOTE                                                 */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2415maybe_quote(cl_object v1object)
{
 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 (ECL_CONSP(v1object)) {
  goto L4;
 }
 if (!(ECL_SYMBOLP(v1object))){
  goto L2;
 }
 goto L3;
L4:;
L3:;
 value0 = cl_list(2, ECL_SYM("QUOTE",682), v1object);
 return value0;
L2:;
 value0 = v1object;
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object LC2415maybe_quote_va(cl_narg narg, cl_object v2object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(ECL_SYM("MAYBE-QUOTE",1764));
 {
  return LC2415maybe_quote(v2object);
 }
}
/* closure .PRINT-UNREADABLE-OBJECT-BODY.                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2423si___print_unreadable_object_body_(cl_narg narg, ...)
{
 cl_object T0, T1;
 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;                                     /*  STREAM                  */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[23]);
 {
L1:;
  T0 = si_instance_class(ECL_CONS_CAR(CLV0));
  T1 = (cl_env_copy->function=(ECL_SYM("CLASS-NAME",938)->symbol.gfdef))->cfun.entry(1, T0) /*  CLASS-NAME */;
  value0 = cl_format(3, ECL_CONS_CAR(CLV1), VV[24], T1);
  return value0;
 }
 }
}
/* closure .PRINT-UNREADABLE-OBJECT-BODY.                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2425si___print_unreadable_object_body_(cl_narg narg, ...)
{
 cl_object T0, T1;
 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;                                     /*  STREAM                  */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[23]);
 {
L1:;
  T0 = cl_find_package(VV[22]);
  ecl_bds_bind(cl_env_copy,ECL_SYM("*PACKAGE*",45),T0); /*  *PACKAGE*         */
  T0 = si_instance_class(ECL_CONS_CAR(CLV0));
  T1 = (cl_env_copy->function=(ECL_SYM("CLASS-NAME",938)->symbol.gfdef))->cfun.entry(1, T0) /*  CLASS-NAME */;
  value0 = cl_format(3, ECL_CONS_CAR(CLV1), VV[25], T1);
  ecl_bds_unwind1(cl_env_copy);
  return value0;
 }
 }
}
/* closure .PRINT-UNREADABLE-OBJECT-BODY.                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2427si___print_unreadable_object_body_(cl_narg narg, ...)
{
 cl_object T0, T1, T2;
 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;                                     /*  STREAM                  */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[23]);
 {
L1:;
  T0 = cl_find_package(VV[22]);
  ecl_bds_bind(cl_env_copy,ECL_SYM("*PACKAGE*",45),T0); /*  *PACKAGE*         */
  T0 = si_instance_class(ECL_CONS_CAR(CLV0));
  T1 = (cl_env_copy->function=(ECL_SYM("CLASS-NAME",938)->symbol.gfdef))->cfun.entry(1, T0) /*  CLASS-NAME */;
  T2 = (cl_env_copy->function=(ECL_SYM("CLASS-NAME",938)->symbol.gfdef))->cfun.entry(1, ECL_CONS_CAR(CLV0)) /*  CLASS-NAME */;
  value0 = cl_format(4, ECL_CONS_CAR(CLV1), VV[26], T1, T2);
  ecl_bds_unwind1(cl_env_copy);
  return value0;
 }
 }
}
/* closure .PRINT-UNREADABLE-OBJECT-BODY.                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2429si___print_unreadable_object_body_(cl_narg narg, ...)
{
 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;                                     /*  STREAM                  */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[23]);
 {
L1:;
  T0 = (cl_env_copy->function=(ECL_SYM("GENERIC-FUNCTION-NAME",1601)->symbol.gfdef))->cfun.entry(1, ECL_CONS_CAR(CLV0)) /*  GENERIC-FUNCTION-NAME */;
  value0 = (ecl_prin1(T0,ECL_CONS_CAR(CLV1)));
  cl_env_copy->nvalues = 1;
  return value0;
 }
 }
}
/* closure .PRINT-UNREADABLE-OBJECT-BODY.                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2431si___print_unreadable_object_body_(cl_narg narg, ...)
{
 cl_object T0, T1, T2, T3, T4, T5;
 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;                                     /*  STREAM                  */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[23]);
 {
L1:;
  {
   cl_object v1gf;
   v1gf = (cl_env_copy->function=(ECL_SYM("METHOD-GENERIC-FUNCTION",1608)->symbol.gfdef))->cfun.entry(1, ECL_CONS_CAR(CLV0)) /*  METHOD-GENERIC-FUNCTION */;
   if (Null(v1gf)){
    goto L4;
   }
   T0 = (cl_env_copy->function=(ECL_SYM("GENERIC-FUNCTION-NAME",1601)->symbol.gfdef))->cfun.entry(1, v1gf) /*  GENERIC-FUNCTION-NAME */;
   goto L2;
L4:;
   T0 = VV[28];
  }
L2:;
  T1 = (cl_env_copy->function=(ECL_SYM("METHOD-QUALIFIERS",961)->symbol.gfdef))->cfun.entry(1, ECL_CONS_CAR(CLV0)) /*  METHOD-QUALIFIERS */;
  {
   cl_object v1;
   cl_object v2spec;
   cl_object v3;
   {
    cl_object v4;
    v4 = (cl_env_copy->function=(ECL_SYM("METHOD-SPECIALIZERS",1610)->symbol.gfdef))->cfun.entry(1, ECL_CONS_CAR(CLV0)) /*  METHOD-SPECIALIZERS */;
    if (ecl_unlikely(!ECL_LISTP(v4))) FEtype_error_list(v4);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v1 = v4;
   }
   v2spec = ECL_NIL;
   v3 = v1;
   {
    cl_object v4;
    cl_object v5;
    v4 = ecl_list1(ECL_NIL);
    v5 = v4;
L14:;
    if (!(ecl_endp(v3))){
     goto L16;
    }
    goto L15;
L16:;
    v2spec = ECL_CONS_CAR(v3);
    {
     cl_object v6;
     v6 = ECL_CONS_CDR(v3);
     if (ecl_unlikely(!ECL_LISTP(v6))) FEtype_error_list(v6);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v3 = v6;
    }
    {
     cl_object v6;
     v6 = v5;
     if (ecl_unlikely(ECL_ATOM(v6))) FEtype_error_cons(v6);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     T3 = v6;
    }
    {
     cl_object v6;
     if (Null((cl_env_copy->function=(VV[29]->symbol.gfdef))->cfun.entry(1, v2spec) /*  CLASSP */)){
      goto L32;
     }
     v6 = (cl_env_copy->function=(ECL_SYM("CLASS-NAME",938)->symbol.gfdef))->cfun.entry(1, v2spec) /*  CLASS-NAME */;
     goto L30;
L32:;
     v6 = ECL_NIL;
     goto L30;
L30:;
     if (Null(v6)){
      goto L34;
     }
     T4 = v6;
     goto L29;
L34:;
     if (Null(si_of_class_p(2, v2spec, ECL_SYM("EQL-SPECIALIZER",1585)))){
      goto L36;
     }
     T5 = (cl_env_copy->function=(ECL_SYM("EQL-SPECIALIZER-OBJECT",1586)->symbol.gfdef))->cfun.entry(1, v2spec) /*  EQL-SPECIALIZER-OBJECT */;
     T4 = cl_list(2, ECL_SYM("EQL",336), T5);
     goto L29;
L36:;
     T4 = v2spec;
    }
L29:;
    v5 = ecl_list1(T4);
    (ECL_CONS_CDR(T3)=v5,T3);
    goto L14;
L15:;
    T2 = ecl_cdr(v4);
    goto L6;
   }
  }
L6:;
  value0 = cl_format(5, ECL_CONS_CAR(CLV1), VV[27], T0, T1, T2);
  return value0;
 }
 }
}
#include "clos/print.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _eclPYi82pfe0Mxk9_TX70M881(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:CLOS;PRINT.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclPYi82pfe0Mxk9_TX70M881@";
 VVtemp = Cblock->cblock.temp_data;
 ECL_DEFINE_SETF_FUNCTIONS
 {
  cl_object T0;
  cl_object volatile env0 = ECL_NIL;
/* MAKE-LOAD-FORMs                                                            */
/* TOP-LEVEL-FORMs                                                            */
  si_select_package(VVtemp[0]);
  ecl_cmp_defun(VV[67]);                          /*  MAKE-LOAD-FORM-SAVING-SLOTS */
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2416make_load_form,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("MAKE-LOAD-FORM",955), ECL_NIL, VVtemp[1], VVtemp[2], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2417make_load_form,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("MAKE-LOAD-FORM",955), ECL_NIL, VVtemp[3], VVtemp[4], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2418make_load_form,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("MAKE-LOAD-FORM",955), ECL_NIL, VVtemp[5], VVtemp[4], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2419make_load_form,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("MAKE-LOAD-FORM",955), ECL_NIL, VVtemp[6], VVtemp[4], T0);
  (void)0; /* No entry created for NO-MAKE-LOAD-FORM */
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2421make_load_form,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("MAKE-LOAD-FORM",955), ECL_NIL, VVtemp[7], VVtemp[8], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2422make_load_form,ECL_NIL,Cblock,1);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("MAKE-LOAD-FORM",955), ECL_NIL, VVtemp[9], VVtemp[10], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2424print_object_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("PRINT-OBJECT",965), ECL_NIL, VVtemp[11], VVtemp[12], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2426print_object_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("PRINT-OBJECT",965), ECL_NIL, VVtemp[13], VVtemp[12], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2428print_object_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("PRINT-OBJECT",965), ECL_NIL, VVtemp[14], VVtemp[15], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2430print_object_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("PRINT-OBJECT",965), ECL_NIL, VVtemp[16], VVtemp[17], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2432print_object_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("PRINT-OBJECT",965), ECL_NIL, VVtemp[18], VVtemp[19], T0);
  ecl_cmp_defun(VV[68]);                          /*  FLOAT-NAN-STRING        */
  ecl_cmp_defun(VV[69]);                          /*  FLOAT-INFINITY-STRING   */
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2435describe_object_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("DESCRIBE-OBJECT",945), ECL_NIL, VVtemp[11], VVtemp[20], T0);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC2436describe_object_va,ECL_NIL,Cblock,2);
   T0 = v1;
  }
  clos_install_method(5, ECL_SYM("DESCRIBE-OBJECT",945), ECL_NIL, VVtemp[14], VVtemp[20], T0);
 }
}
