/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/lsp/describe.lsp                    */
#include <ecl/ecl-cmp.h>
#include "clos/describe.eclh"
/* function definition for INSPECT-READ-LINE                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2698inspect_read_line()
{
 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 v1char;
  v1char = cl_read_char(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
  goto L5;
L4:;
  v1char = cl_read_char(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
L5:;
  if (ecl_char_code(v1char)==ecl_char_code(ECL_CODE_CHAR(10))) {
   goto L9;
  }
  if (ecl_char_code(v1char)==ecl_char_code(ECL_CODE_CHAR(13))) {
   goto L9;
  }
  goto L4;
L9:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L2698inspect_read_line_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[7]);
 {
  return L2698inspect_read_line();
 }
}
/* function definition for SELECT-P                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2699select_p(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:;
 ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-PRETTY*",57),ECL_T); /*  *PRINT-PRETTY* */
 ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-LEVEL*",53),ECL_NIL); /*  *PRINT-LEVEL* */
 ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-LENGTH*",52),ECL_NIL); /*  *PRINT-LENGTH* */
 cl_prin1(1, v1object);
 value0 = cl_terpri(0);
 ecl_bds_unwind1(cl_env_copy);
 ecl_bds_unwind1(cl_env_copy);
 ecl_bds_unwind1(cl_env_copy);
 return value0;
}
static cl_object L2699select_p_va(cl_narg narg, cl_object v2object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[9]);
 {
  return L2699select_p(v2object);
 }
}
/* function definition for SELECT-E                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2700select_e()
{
 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 v1;
  {
   struct ecl_stack_frame _ecl_inner_frame_aux;
   cl_object _ecl_inner_frame=ecl_stack_frame_open(cl_env_copy,(cl_object)&_ecl_inner_frame_aux,0);
   {
    struct ecl_stack_frame _ecl_inner_frame_aux;
    cl_object _ecl_inner_frame=ecl_stack_frame_open(cl_env_copy,(cl_object)&_ecl_inner_frame_aux,0);
    T0 = cl_read_preserving_whitespace(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
    cl_env_copy->values[0] = cl_eval(T0);
    ecl_stack_frame_push_values(_ecl_inner_frame);
    L2698inspect_read_line();
    ecl_stack_frame_pop_values(_ecl_inner_frame);
    ecl_stack_frame_close(_ecl_inner_frame);
   }
   ecl_stack_frame_push_values(_ecl_inner_frame);
   v1 = ecl_apply_from_stack_frame(_ecl_inner_frame,ECL_SYM("LIST",483));
   ecl_stack_frame_close(_ecl_inner_frame);
  }
  goto L8;
L7:;
  {
   cl_object v2x;
   v2x = ecl_car(v1);
   cl_write(5, v2x, ECL_SYM("LEVEL",1299), ecl_cmp_symbol_value(cl_env_copy,VV[5]), ECL_SYM("LENGTH",1298), ecl_cmp_symbol_value(cl_env_copy,VV[6]));
   cl_terpri(0);
  }
  v1 = ecl_cdr(v1);
L8:;
  if (Null(v1)){
   goto L16;
  }
  goto L7;
L16:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L2700select_e_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[11]);
 {
  return L2700select_e();
 }
}
/* function definition for SELECT-U                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2701select_u()
{
 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 v1;
  T0 = cl_read_preserving_whitespace(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
  v1 = cl_eval(T0);
  L2698inspect_read_line();
  value0 = v1;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L2701select_u_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[13]);
 {
  return L2701select_u();
 }
}
/* function definition for SELECT-?                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2702select__()
{
 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_terpri(0);
 value0 = cl_format(2, ECL_T, VV[16]);
 return value0;
}
static cl_object L2702select___va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[15]);
 {
  return L2702select__();
 }
}
/* function definition for READ-INSPECT-COMMAND                               */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2705read_inspect_command(cl_object volatile v1label, cl_object volatile v2object, cl_object volatile v3allow_recursive)
{
 cl_object T0, T1, T2, T3, T4;
 cl_object volatile env0 = ECL_NIL;
 cl_object volatile CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 if (ecl_cmp_symbol_value(cl_env_copy,VV[4])!=ECL_NIL) {
  goto L2;
 }
 L2707inspect_indent_1();
 if (Null(v3allow_recursive)){
  goto L6;
 }
 ecl_princ(v1label,ECL_NIL);
 L2725inspect_object(v2object);
 goto L5;
L6:;
 cl_format(3, ECL_T, v1label, v2object);
L5:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 T0 = CONS(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUIT-TAG*",1836)),ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUIT-TAG*",1836)));
 ecl_bds_bind(cl_env_copy,VV[21],T0);             /*  *QUIT-TAGS*             */
 ecl_bds_bind(cl_env_copy,ECL_SYM("*QUIT-TAG*",1836),ecl_cmp_symbol_value(cl_env_copy,VV[21])); /*  *QUIT-TAG* */
L9:;
 value0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUIT-TAG*",1836)); /*  BEGIN CATCH CATCH371 */
 {
  ecl_frs_push(cl_env_copy,value0);
  if (__ecl_frs_push_result!=0) {
   value0 = cl_env_copy->values[0];
  } else {
   {
    volatile cl_object env1 = env0;
    env1 = ECL_NIL;
    CLV0 = env1 = CONS(ECL_NIL,env1);
    {
     volatile cl_object env2 = env1;
     CLV1 = env2 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env2); /*  TAGBODY      */
     {
      ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV1));
      if (__ecl_frs_push_result!=0) {
      if (cl_env_copy->values[0]==ecl_make_int8_t(0)) {
       goto L16;
      }
      ecl_internal_error("GO found an inexistent tag");
      } else {
      {
       cl_object v4;
       v4 = ecl_make_cclosure_va((cl_objectfn)LC2703__lambda18,env2,Cblock,0);
       T0 = v4;
      }
      {
       cl_object v4;
       v4 = ecl_make_cfun_va((cl_objectfn)LC2704__lambda20_va,ECL_NIL,Cblock,1);
       T1 = v4;
      }
      T2 = (cl_env_copy->function=(VV[23]->symbol.gfdef))->cfun.entry(6, ECL_SYM("NAME",1309), ECL_SYM("INSPECT",438), ECL_SYM("FUNCTION",1273), T0, VV[25], T1) /*  MAKE-RESTART */;
      T3 = ecl_list1(T2);
      T4 = CONS(T3,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5)));
      ecl_bds_bind(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5),T4); /*  *RESTART-CLUSTERS* */
      L2707inspect_indent_1();
      if (Null(v3allow_recursive)){
       goto L22;
      }
      ecl_princ(v1label,ECL_NIL);
      L2706inspect_indent();
      cl_prin1(1, v2object);
      goto L21;
L22:;
      cl_format(3, ECL_T, v1label, v2object);
L21:;
      (ecl_princ_char(ecl_char_code(ECL_CODE_CHAR(32)),ECL_NIL),(ECL_CODE_CHAR(32)));
      ecl_princ(VV[29],ECL_NIL);
      cl_finish_output(0);
      {
       cl_object v4;
       {
        cl_object v5char;
        v5char = cl_read_char(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
        goto L33;
L32:;
        v5char = cl_read_char(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
L33:;
        if (!(ecl_char_code(v5char)!=ecl_char_code(ECL_CODE_CHAR(32)))){
         goto L40;
        }
        if (ecl_char_code(v5char)!=ecl_char_code(ECL_CODE_CHAR(9))) {
         goto L37;
        }
        goto L38;
L40:;
        goto L38;
L38:;
        goto L32;
L37:;
        if (!(ecl_char_code(v5char)==ecl_char_code(ECL_CODE_CHAR(10)))){
         goto L42;
        }
        v4 = v5char;
        goto L29;
L42:;
        if (!(ecl_char_code(v5char)==ecl_char_code(ECL_CODE_CHAR(13)))){
         goto L44;
        }
        v4 = v5char;
        goto L29;
L44:;
        T0 = cl_peek_char(0);
        if (Null(cl_alphanumericp(T0))){
         goto L46;
        }
        v4 = ECL_CODE_CHAR(33);
        goto L29;
L46:;
        v4 = v5char;
       }
L29:;
       if (!(((v4)==ECL_CODE_CHAR((ecl_character)(10))))){
        goto L53;
       }
       goto L50;
L53:;
       goto L51;
L51:;
       if (!(((v4)==ECL_CODE_CHAR((ecl_character)(13))))){
        goto L48;
       }
       goto L49;
L50:;
L49:;
       if (Null(v3allow_recursive)){
        goto L56;
       }
       L2725inspect_object(v2object);
L56:;
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 1;
       ecl_frs_pop_n(cl_env_copy, 2);
       ecl_bds_unwind1(cl_env_copy);
       ecl_bds_unwind1(cl_env_copy);
       ecl_bds_unwind1(cl_env_copy);
       return value0;
L48:;
       if (!(((v4)==ECL_CODE_CHAR((ecl_character)(110))))){
        goto L63;
       }
       goto L60;
L63:;
       goto L61;
L61:;
       if (!(((v4)==ECL_CODE_CHAR((ecl_character)(78))))){
        goto L58;
       }
       goto L59;
L60:;
L59:;
       L2698inspect_read_line();
       if (Null(v3allow_recursive)){
        goto L67;
       }
       L2725inspect_object(v2object);
L67:;
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 1;
       ecl_frs_pop_n(cl_env_copy, 2);
       ecl_bds_unwind1(cl_env_copy);
       ecl_bds_unwind1(cl_env_copy);
       ecl_bds_unwind1(cl_env_copy);
       return value0;
L58:;
       if (!(((v4)==ECL_CODE_CHAR((ecl_character)(115))))){
        goto L74;
       }
       goto L71;
L74:;
       goto L72;
L72:;
       if (!(((v4)==ECL_CODE_CHAR((ecl_character)(83))))){
        goto L69;
       }
       goto L70;
L71:;
L70:;
       L2698inspect_read_line();
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 1;
       ecl_frs_pop_n(cl_env_copy, 2);
       ecl_bds_unwind1(cl_env_copy);
       ecl_bds_unwind1(cl_env_copy);
       ecl_bds_unwind1(cl_env_copy);
       return value0;
L69:;
       if (!(((v4)==ECL_CODE_CHAR((ecl_character)(112))))){
        goto L83;
       }
       goto L80;
L83:;
       goto L81;
L81:;
       if (!(((v4)==ECL_CODE_CHAR((ecl_character)(80))))){
        goto L78;
       }
       goto L79;
L80:;
L79:;
       L2698inspect_read_line();
       L2699select_p(v2object);
       ecl_frs_pop_n(cl_env_copy, 1);
       ecl_bds_unwind1(cl_env_copy);
       goto L15;
L78:;
       if (!(((v4)==ECL_CODE_CHAR((ecl_character)(97))))){
        goto L92;
       }
       goto L89;
L92:;
       goto L90;
L90:;
       if (!(((v4)==ECL_CODE_CHAR((ecl_character)(65))))){
        goto L87;
       }
       goto L88;
L89:;
L88:;
       L2698inspect_read_line();
       cl_env_copy->values[0] = ECL_NIL;
       cl_env_copy->nvalues = 1;
       cl_throw(VV[40]);
L87:;
       if (!(((v4)==ECL_CODE_CHAR((ecl_character)(117))))){
        goto L102;
       }
       goto L99;
L102:;
       goto L100;
L100:;
       if (!(((v4)==ECL_CODE_CHAR((ecl_character)(85))))){
        goto L97;
       }
       goto L98;
L99:;
L98:;
       T0 = L2701select_u();
       cl_env_copy->nvalues = 2;
       cl_env_copy->values[1] = T0;
       cl_env_copy->values[0] = ECL_T;
       ecl_frs_pop_n(cl_env_copy, 2);
       ecl_bds_unwind1(cl_env_copy);
       ecl_bds_unwind1(cl_env_copy);
       ecl_bds_unwind1(cl_env_copy);
       return cl_env_copy->values[0];
L97:;
       if (!(((v4)==ECL_CODE_CHAR((ecl_character)(101))))){
        goto L110;
       }
       goto L107;
L110:;
       goto L108;
L108:;
       if (!(((v4)==ECL_CODE_CHAR((ecl_character)(69))))){
        goto L105;
       }
       goto L106;
L107:;
L106:;
       L2700select_e();
       ecl_frs_pop_n(cl_env_copy, 1);
       ecl_bds_unwind1(cl_env_copy);
       goto L15;
L105:;
       if (!(((v4)==ECL_CODE_CHAR((ecl_character)(113))))){
        goto L118;
       }
       goto L115;
L118:;
       goto L116;
L116:;
       if (!(((v4)==ECL_CODE_CHAR((ecl_character)(81))))){
        goto L113;
       }
       goto L114;
L115:;
L114:;
       L2698inspect_read_line();
       cl_env_copy->values[0] = ECL_NIL;
       cl_env_copy->nvalues = 1;
       cl_throw(VV[47]);
L113:;
       if (!(((v4)==ECL_CODE_CHAR((ecl_character)(63))))){
        goto L123;
       }
       L2698inspect_read_line();
       L2702select__();
       ecl_frs_pop_n(cl_env_copy, 1);
       ecl_bds_unwind1(cl_env_copy);
       goto L15;
L123:;
       L2698inspect_read_line();
       L2706inspect_indent();
       cl_format(2, ECL_T, VV[49]);
       ecl_frs_pop_n(cl_env_copy, 1);
       ecl_bds_unwind1(cl_env_copy);
       goto L15;
      }
L16:;
      {
       cl_object v4;
       v4 = ECL_CONS_CAR(CLV0);
       if (Null(v4)){
        goto L131;
       }
       si_dm_too_many_arguments(ECL_NIL);
L131:;
       ecl_frs_pop_n(cl_env_copy, 1);
       goto L15;
      }
      }
     }
    }
   }
L15:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
  }
 }
 ecl_frs_pop(cl_env_copy);                        /*  END CATCH CATCH371      */
 if (Null(value0)){
  goto L10;
 }
 cl_format(2, ECL_T, VV[51]);
L10:;
 goto L9;
}
static cl_object L2705read_inspect_command_va(cl_narg narg, cl_object v4label, cl_object v5object, cl_object v6allow_recursive, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[18]);
 {
  return L2705read_inspect_command(v4label, v5object, v6allow_recursive);
 }
}
/* function definition for INSPECT-INDENT                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2706inspect_indent()
{
 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_fresh_line(0);
 if (!(ecl_lower(ecl_cmp_symbol_value(cl_env_copy,VV[2]),ecl_make_int8_t(8)))){
  goto L4;
 }
 T0 = ecl_cmp_symbol_value(cl_env_copy,VV[2]);
 goto L3;
L4:;
 T0 = ecl_make_int8_t(8);
L3:;
 T1 = ecl_times(ecl_make_int8_t(4),T0);
 value0 = cl_format(3, ECL_T, VV[53], T1);
 return value0;
}
static cl_object L2706inspect_indent_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[28]);
 {
  return L2706inspect_indent();
 }
}
/* function definition for INSPECT-INDENT-1                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2707inspect_indent_1()
{
 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_fresh_line(0);
 if (!(ecl_lower(ecl_cmp_symbol_value(cl_env_copy,VV[2]),ecl_make_int8_t(8)))){
  goto L4;
 }
 T0 = ecl_cmp_symbol_value(cl_env_copy,VV[2]);
 goto L3;
L4:;
 T0 = ecl_make_int8_t(8);
L3:;
 T1 = ecl_times(ecl_make_int8_t(4),T0);
 T2 = ecl_minus(T1,ecl_make_int8_t(3));
 value0 = cl_format(3, ECL_T, VV[53], T2);
 return value0;
}
static cl_object L2707inspect_indent_1_va(cl_narg narg, ...)
{
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(VV[19]);
 {
  return L2707inspect_indent_1();
 }
}
/* function definition for INSPECT-SYMBOL                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2708inspect_symbol(cl_object v1symbol)
{
 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 v2p;
  v2p = cl_symbol_package(v1symbol);
  if (!(v2p==ECL_NIL)){
   goto L4;
  }
  cl_format(3, ECL_T, VV[57], v1symbol);
  goto L2;
L4:;
  T0 = cl_find_package(VV[58]);
  if (!((v2p)==(T0))){
   goto L6;
  }
  cl_format(3, ECL_T, VV[59], v1symbol);
  goto L2;
L6:;
  {
   cl_object v3;                                  /*  F                       */
   T1 = ecl_symbol_name(v1symbol);
   value0 = cl_find_symbol(2, T1, v2p);
   {
    v3 = cl_env_copy->values[1];
   }
   T0 = ecl_make_bool((v3)==(ECL_SYM("EXTERNAL",1266)));
  }
  T1 = cl_package_name(v2p);
  cl_format(5, ECL_T, VV[60], v1symbol, T0, T1);
 }
L2:;
 if (Null(L2733print_doc(2, v1symbol, ECL_T))){
  goto L10;
 }
 cl_format(2, ECL_T, VV[62]);
L10:;
 if ((ECL_T)==(v1symbol)) {
  goto L15;
 }
 if ((ECL_NIL)==(v1symbol)) {
  goto L15;
 }
 if (Null(cl_keywordp(v1symbol))){
  goto L13;
 }
 goto L14;
L15:;
L14:;
 L2707inspect_indent_1();
 T0 = cl_symbol_value(v1symbol);
 cl_format(3, ECL_T, VV[63], T0);
 goto L12;
L13:;
 if (!(ecl_boundp(cl_env_copy,v1symbol))){
  goto L12;
 }
 if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[4]))){
  goto L20;
 }
 {
  cl_object v2;                                   /*  UPDATE-FLAG             */
  cl_object v3;                                   /*  NEW-VALUE               */
  T0 = cl_symbol_value(v1symbol);
  value0 = L2705read_inspect_command(VV[65], T0, ECL_T);
  {
   const int v4 = cl_env_copy->nvalues;
   v2 = value0;
   cl_object v5;
   v5 = (v4<=1)? ECL_NIL : cl_env_copy->values[1];
   v3 = v5;
  }
  if (Null(v2)){
   goto L12;
  }
  cl_set(v1symbol, v3);
  goto L12;
 }
L20:;
 {
  cl_object v2;                                   /*  UPDATE-FLAG             */
  cl_object v3;                                   /*  NEW-VALUE               */
  T0 = cl_symbol_value(v1symbol);
  value0 = L2705read_inspect_command(VV[67], T0, ECL_NIL);
  {
   const int v4 = cl_env_copy->nvalues;
   v2 = value0;
   cl_object v5;
   v5 = (v4<=1)? ECL_NIL : cl_env_copy->values[1];
   v3 = v5;
  }
  if (Null(v2)){
   goto L12;
  }
  cl_set(v1symbol, v3);
 }
L12:;
 {
  cl_object v2pl;
  v2pl = cl_symbol_plist(v1symbol);
  goto L29;
L28:;
  T0 = ecl_car(v2pl);
  if (!(ECL_SYMBOLP(T0))){
   goto L34;
  }
  T0 = ecl_car(v2pl);
  T1 = cl_symbol_package(T0);
  T2 = cl_find_package(ECL_SYM("SYSTEM",1185));
  if ((T1)==(T2)) {
   goto L31;
  }
  T0 = ecl_car(v2pl);
  T1 = cl_symbol_package(T0);
  T2 = cl_find_package(VV[68]);
  if ((T1)==(T2)) {
   goto L31;
  }
  goto L32;
L34:;
  goto L32;
L32:;
  if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[4]))){
   goto L37;
  }
  {
   cl_object v3;                                  /*  UPDATE-FLAG             */
   cl_object v4;                                  /*  NEW-VALUE               */
   T0 = ecl_car(v2pl);
   T1 = cl_format(3, ECL_NIL, VV[69], T0);
   T2 = ecl_cadr(v2pl);
   value0 = L2705read_inspect_command(T1, T2, ECL_T);
   {
    const int v5 = cl_env_copy->nvalues;
    v3 = value0;
    cl_object v6;
    v6 = (v5<=1)? ECL_NIL : cl_env_copy->values[1];
    v4 = v6;
   }
   if (Null(v3)){
    goto L31;
   }
   {
    cl_object v5;
    v5 = ecl_car(v2pl);
    si_putprop(v1symbol, v4, v5);
    goto L31;
   }
  }
L37:;
  {
   cl_object v3;                                  /*  UPDATE-FLAG             */
   cl_object v4;                                  /*  NEW-VALUE               */
   T0 = ecl_car(v2pl);
   T1 = cl_format(3, ECL_NIL, VV[70], T0);
   T2 = ecl_cadr(v2pl);
   value0 = L2705read_inspect_command(T1, T2, ECL_NIL);
   {
    const int v5 = cl_env_copy->nvalues;
    v3 = value0;
    cl_object v6;
    v6 = (v5<=1)? ECL_NIL : cl_env_copy->values[1];
    v4 = v6;
   }
   if (Null(v3)){
    goto L31;
   }
   {
    cl_object v5;
    v5 = ecl_car(v2pl);
    si_putprop(v1symbol, v4, v5);
   }
  }
L31:;
  v2pl = ecl_cddr(v2pl);
L29:;
  if (ecl_endp(v2pl)) {
   goto L47;
  }
  goto L28;
L47:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for INSPECT-PACKAGE                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2709inspect_package(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);
L1:;
 cl_format(3, ECL_T, VV[72], v1package);
 if (Null(cl_package_nicknames(v1package))){
  goto L3;
 }
 T0 = cl_package_nicknames(v1package);
 if (Null(L2705read_inspect_command(VV[73], T0, ECL_NIL))){
  goto L3;
 }
 ecl_princ(VV[74],ECL_NIL);
 cl_terpri(0);
L3:;
 if (Null(cl_package_use_list(v1package))){
  goto L7;
 }
 T0 = cl_package_use_list(v1package);
 if (Null(L2705read_inspect_command(VV[75], T0, ECL_NIL))){
  goto L7;
 }
 ecl_princ(VV[74],ECL_NIL);
 cl_terpri(0);
L7:;
 if (Null(cl_package_used_by_list(v1package))){
  goto L11;
 }
 T0 = cl_package_used_by_list(v1package);
 if (Null(L2705read_inspect_command(VV[76], T0, ECL_NIL))){
  goto L11;
 }
 ecl_princ(VV[74],ECL_NIL);
 cl_terpri(0);
L11:;
 if (Null(cl_package_shadowing_symbols(v1package))){
  goto L15;
 }
 T0 = cl_package_shadowing_symbols(v1package);
 if (Null(L2705read_inspect_command(VV[77], T0, ECL_NIL))){
  goto L17;
 }
 ecl_princ(VV[74],ECL_NIL);
 value0 = cl_terpri(0);
 return value0;
L17:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
L15:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for INSPECT-CHARACTER                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2710inspect_character(cl_object v1character)
{
 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(cl_standard_char_p(v1character))){
  goto L4;
 }
 T0 = VV[79];
 goto L3;
L4:;
 T0 = VV[80];
L3:;
 cl_format(3, ECL_T, T0, v1character);
 T0 = cl_char_code(v1character);
 if (Null(L2705read_inspect_command(VV[81], T0, ECL_NIL))){
  goto L6;
 }
 ecl_princ(VV[74],ECL_NIL);
 value0 = cl_terpri(0);
 return value0;
L6:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for INSPECT-NUMBER                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2711inspect_number(cl_object v1number)
{
 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 v2type;
  v2type = cl_type_of(v1number);
  if (!(ECL_CONSP(v2type))){
   goto L3;
  }
  v2type = ecl_car(v2type);
L3:;
  T0 = cl_string_downcase(1, v2type);
  cl_format(4, ECL_T, VV[83], v1number, T0);
  if (!((v2type)==(ECL_SYM("INTEGER",439)))){
   goto L7;
  }
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L7:;
  if (!((v2type)==(ECL_SYM("RATIO",689)))){
   goto L9;
  }
  T0 = cl_numerator(v1number);
  if (Null(L2705read_inspect_command(VV[84], T0, ECL_T))){
   goto L11;
  }
  ecl_princ(VV[74],ECL_NIL);
  cl_terpri(0);
L11:;
  T0 = cl_denominator(v1number);
  if (Null(L2705read_inspect_command(VV[85], T0, ECL_T))){
   goto L14;
  }
  ecl_princ(VV[74],ECL_NIL);
  value0 = cl_terpri(0);
  return value0;
L14:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L9:;
  if (!((v2type)==(ECL_SYM("COMPLEX",243)))){
   goto L17;
  }
  T0 = cl_realpart(v1number);
  if (Null(L2705read_inspect_command(VV[86], T0, ECL_T))){
   goto L19;
  }
  ecl_princ(VV[74],ECL_NIL);
  cl_terpri(0);
L19:;
  T0 = cl_imagpart(v1number);
  if (Null(L2705read_inspect_command(VV[87], T0, ECL_T))){
   goto L22;
  }
  ecl_princ(VV[74],ECL_NIL);
  value0 = cl_terpri(0);
  return value0;
L22:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L17:;
  if (!((v2type)==(ECL_SYM("SHORT-FLOAT",759)))){
   goto L30;
  }
  goto L27;
L30:;
  goto L28;
L28:;
  if (!((v2type)==(ECL_SYM("SINGLE-FLOAT",781)))){
   goto L34;
  }
  goto L27;
L34:;
  goto L32;
L32:;
  if (!((v2type)==(ECL_SYM("LONG-FLOAT",510)))){
   goto L38;
  }
  goto L27;
L38:;
  goto L36;
L36:;
  if (!((v2type)==(ECL_SYM("DOUBLE-FLOAT",317)))){
   goto L25;
  }
  goto L26;
L27:;
L26:;
  {
   cl_object v3;                                  /*  SIGNIF                  */
   cl_object v4;                                  /*  EXPON                   */
   value0 = cl_integer_decode_float(v1number);
   {
    v3 = value0;
    v4 = cl_env_copy->values[1];
   }
   if (Null(L2705read_inspect_command(VV[92], v4, ECL_NIL))){
    goto L42;
   }
   ecl_princ(VV[74],ECL_NIL);
   cl_terpri(0);
L42:;
   if (Null(L2705read_inspect_command(VV[93], v3, ECL_NIL))){
    goto L45;
   }
   ecl_princ(VV[74],ECL_NIL);
   value0 = cl_terpri(0);
   return value0;
L45:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
L25:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
/* function definition for INSPECT-CONS                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2712inspect_cons(cl_object v1cons)
{
 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_format(3, ECL_T, VV[95], v1cons);
 if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[4]))){
  goto L3;
 }
 {
  cl_object v2i;
  cl_object v3l;
  v2i = ecl_make_int8_t(0);
  v3l = v1cons;
  goto L9;
L8:;
  {
   cl_object v4;                                  /*  UPDATE-FLAG             */
   cl_object v5;                                  /*  NEW-VALUE               */
   T0 = cl_format(3, ECL_NIL, VV[96], v2i);
   T1 = ecl_car(v3l);
   value0 = L2705read_inspect_command(T0, T1, ECL_T);
   {
    const int v6 = cl_env_copy->nvalues;
    v4 = value0;
    cl_object v7;
    v7 = (v6<=1)? ECL_NIL : cl_env_copy->values[1];
    v5 = v7;
   }
   if (Null(v4)){
    goto L11;
   }
   {
    cl_object v6;
    v6 = v5;
    {
     cl_object v7;
     v7 = ecl_nthcdr(ecl_to_size(v2i),v1cons);
     if (ecl_unlikely(ECL_ATOM(v7))) FEtype_error_cons(v7);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     T0 = v7;
    }
    (ECL_CONS_CAR(T0)=v6,T0);
   }
  }
L11:;
  v2i = ecl_one_plus(v2i);
  v3l = ecl_cdr(v3l);
L9:;
  if (ECL_ATOM(v3l)) {
   goto L22;
  }
  goto L8;
L22:;
  if (!((v3l)==(ECL_T))){
   goto L29;
  }
  goto L26;
L29:;
  goto L27;
L27:;
  if (!((v3l)==(ECL_NIL))){
   goto L24;
  }
  goto L25;
L26:;
L25:;
  T0 = cl_format(3, ECL_NIL, VV[99], v2i);
  if (Null(L2705read_inspect_command(T0, v3l, ECL_NIL))){
   goto L32;
  }
  ecl_princ(VV[74],ECL_NIL);
  value0 = cl_terpri(0);
  return value0;
L32:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L24:;
  {
   cl_object v4;                                  /*  UPDATE-FLAG             */
   cl_object v5;                                  /*  NEW-VALUE               */
   T0 = cl_format(3, ECL_NIL, VV[100], v2i);
   value0 = L2705read_inspect_command(T0, v3l, ECL_T);
   {
    const int v6 = cl_env_copy->nvalues;
    v4 = value0;
    cl_object v7;
    v7 = (v6<=1)? ECL_NIL : cl_env_copy->values[1];
    v5 = v7;
   }
   if (Null(v4)){
    goto L36;
   }
   {
    cl_object v6;
    T0 = ecl_one_minus(v2i);
    v6 = ecl_nthcdr(ecl_to_size(T0),v1cons);
    {
     cl_object v7;
     v7 = v5;
     {
      cl_object v8;
      v8 = v6;
      if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T0 = v8;
     }
     (ECL_CONS_CDR(T0)=v7,T0);
     value0 = v7;
     cl_env_copy->nvalues = 1;
     return value0;
    }
   }
L36:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
L3:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for INSPECT-STRING                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2713inspect_string(cl_object v1string)
{
 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(cl_simple_string_p(v1string))){
  goto L4;
 }
 T0 = VV[102];
 goto L3;
L4:;
 T0 = VV[103];
L3:;
 cl_format(3, ECL_T, T0, v1string);
 {
  cl_fixnum v2;
  v2 = ecl_array_dimension(v1string,(cl_fixnum)(0));
  if (Null(L2705read_inspect_command(VV[104], ecl_make_fixnum(v2), ECL_NIL))){
   goto L6;
  }
 }
 ecl_princ(VV[74],ECL_NIL);
 cl_terpri(0);
L6:;
 if (!((ECL_ARRAYP(v1string)?(void)0:FEtype_error_array(v1string),ECL_ARRAY_HAS_FILL_POINTER_P(v1string)))){
  goto L9;
 }
 {
  cl_object v2;                                   /*  UPDATE-FLAG             */
  cl_object v3;                                   /*  NEW-VALUE               */
  T0 = cl_fill_pointer(v1string);
  value0 = L2705read_inspect_command(VV[105], T0, ECL_NIL);
  {
   const int v4 = cl_env_copy->nvalues;
   v2 = value0;
   cl_object v5;
   v5 = (v4<=1)? ECL_NIL : cl_env_copy->values[1];
   v3 = v5;
  }
  if (Null(v2)){
   goto L9;
  }
  si_fill_pointer_set(v1string, v3);
 }
L9:;
 if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[4]))){
  goto L13;
 }
 {
  cl_object v2;
  v2 = ecl_make_fixnum(ecl_array_dimension(v1string,(cl_fixnum)(0)));
  {
   cl_fixnum v3i;
   v3i = (cl_fixnum)(0);
   goto L18;
L17:;
   {
    cl_object v4;                                 /*  UPDATE-FLAG             */
    cl_object v5;                                 /*  NEW-VALUE               */
    T0 = cl_format(3, ECL_NIL, VV[106], ecl_make_fixnum(v3i));
    {
     ecl_character v6;
     v6 = ecl_char(v1string,v3i);
     value0 = L2705read_inspect_command(T0, ECL_CODE_CHAR(v6), ECL_T);
    }
    {
     const int v6 = cl_env_copy->nvalues;
     v4 = value0;
     cl_object v7;
     v7 = (v6<=1)? ECL_NIL : cl_env_copy->values[1];
     v5 = v7;
    }
    if (Null(v4)){
     goto L20;
    }
    ecl_aset1(v1string,v3i,v5);
   }
L20:;
   v3i = (v3i)+1;
L18:;
   if (!((v3i)<(ecl_fixnum(v2)))){
    goto L25;
   }
   goto L17;
L25:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
L13:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for INSPECT-VECTOR                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2714inspect_vector(cl_object v1vector)
{
 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(cl_simple_vector_p(v1vector))){
  goto L4;
 }
 T0 = VV[108];
 goto L3;
L4:;
 T0 = VV[109];
L3:;
 cl_format(3, ECL_T, T0, v1vector);
 {
  cl_fixnum v2;
  v2 = ecl_array_dimension(v1vector,(cl_fixnum)(0));
  if (Null(L2705read_inspect_command(VV[104], ecl_make_fixnum(v2), ECL_NIL))){
   goto L6;
  }
 }
 ecl_princ(VV[74],ECL_NIL);
 cl_terpri(0);
L6:;
 if (!((ECL_ARRAYP(v1vector)?(void)0:FEtype_error_array(v1vector),ECL_ARRAY_HAS_FILL_POINTER_P(v1vector)))){
  goto L9;
 }
 {
  cl_object v2;                                   /*  UPDATE-FLAG             */
  cl_object v3;                                   /*  NEW-VALUE               */
  T0 = cl_fill_pointer(v1vector);
  value0 = L2705read_inspect_command(VV[105], T0, ECL_NIL);
  {
   const int v4 = cl_env_copy->nvalues;
   v2 = value0;
   cl_object v5;
   v5 = (v4<=1)? ECL_NIL : cl_env_copy->values[1];
   v3 = v5;
  }
  if (Null(v2)){
   goto L9;
  }
  si_fill_pointer_set(v1vector, v3);
 }
L9:;
 if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[4]))){
  goto L13;
 }
 {
  cl_object v2;
  v2 = ecl_make_fixnum(ecl_array_dimension(v1vector,(cl_fixnum)(0)));
  {
   cl_fixnum v3i;
   v3i = (cl_fixnum)(0);
   goto L18;
L17:;
   {
    cl_object v4;                                 /*  UPDATE-FLAG             */
    cl_object v5;                                 /*  NEW-VALUE               */
    T0 = cl_format(3, ECL_NIL, VV[106], ecl_make_fixnum(v3i));
    {
     cl_object v6;
     v6 = v1vector;
     T2 = v6;
     {
      cl_fixnum v7;
      v7 = v3i;
      if (ecl_unlikely((v7)>=(v6)->vector.dim))
           FEwrong_index(ECL_NIL,v6,-1,ecl_make_fixnum(v7),(v6)->vector.dim);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T3 = ecl_make_fixnum(v7);
     }
     T1 = ecl_aref_unsafe(T2,ecl_fixnum(T3));
    }
    value0 = L2705read_inspect_command(T0, T1, ECL_T);
    {
     const int v6 = cl_env_copy->nvalues;
     v4 = value0;
     cl_object v7;
     v7 = (v6<=1)? ECL_NIL : cl_env_copy->values[1];
     v5 = v7;
    }
    if (Null(v4)){
     goto L20;
    }
    {
     cl_object v6;
     v6 = v1vector;
     T0 = v6;
     {
      cl_fixnum v7;
      v7 = v3i;
      if (ecl_unlikely((v7)>=(v6)->vector.dim))
           FEwrong_index(ECL_NIL,v6,-1,ecl_make_fixnum(v7),(v6)->vector.dim);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      T1 = ecl_make_fixnum(v7);
     }
     ecl_aset_unsafe(T0,ecl_fixnum(T1),v5);
    }
   }
L20:;
   v3i = (v3i)+1;
L18:;
   if (!((v3i)<(ecl_fixnum(v2)))){
    goto L38;
   }
   goto L17;
L38:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
L13:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for INSPECT-ARRAY                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2715inspect_array(cl_object v1array)
{
 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 (!((ECL_ARRAYP(v1array)? (void)0: FEtype_error_array(v1array),ECL_ADJUSTABLE_ARRAY_P(v1array)))){
  goto L4;
 }
 T0 = VV[113];
 goto L3;
L4:;
 T0 = VV[114];
L3:;
 cl_format(3, ECL_T, T0, v1array);
 T0 = cl_array_rank(v1array);
 if (Null(L2705read_inspect_command(VV[115], T0, ECL_NIL))){
  goto L6;
 }
 ecl_princ(VV[74],ECL_NIL);
 cl_terpri(0);
L6:;
 T0 = cl_array_dimensions(v1array);
 if (Null(L2705read_inspect_command(VV[116], T0, ECL_NIL))){
  goto L9;
 }
 ecl_princ(VV[74],ECL_NIL);
 cl_terpri(0);
L9:;
 T0 = cl_array_total_size(v1array);
 if (Null(L2705read_inspect_command(VV[117], T0, ECL_NIL))){
  goto L12;
 }
 ecl_princ(VV[74],ECL_NIL);
 value0 = cl_terpri(0);
 return value0;
L12:;
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for SELECT-HT-N                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2717select_ht_n(cl_object v1hashtable)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 cl_object CLV0;
 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(v1hashtable,env0);            /*  HASHTABLE               */
 T0 = ecl_plus(ecl_cmp_symbol_value(cl_env_copy,VV[2]),ecl_make_int8_t(1));
 ecl_cmp_setq(cl_env_copy,VV[2],T0);
 {
  cl_object v2;
  v2 = ecl_make_cclosure_va((cl_objectfn)LC2716__lambda201,env0,Cblock,2);
  T0 = v2;
 }
 cl_maphash(T0, ECL_CONS_CAR(CLV0));
 T0 = ecl_minus(ecl_cmp_symbol_value(cl_env_copy,VV[2]),ecl_make_int8_t(1));
 ecl_cmp_setq(cl_env_copy,VV[2],T0);
 value0 = ecl_cmp_symbol_value(cl_env_copy,VV[2]);
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for SELECT-HT-L                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2719select_ht_l(cl_object v1hashtable)
{
 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_terpri(0);
 cl_format(2, ECL_T, VV[122]);
 {
  cl_object v2;
  v2 = ecl_make_cfun_va((cl_objectfn)LC2718__lambda209_va,ECL_NIL,Cblock,2);
  T0 = v2;
 }
 cl_maphash(T0, v1hashtable);
 value0 = cl_terpri(0);
 return value0;
}
/* function definition for SELECT-HT-J                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2720select_ht_j(cl_object v1hashtable)
{
 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 v2key;
  cl_object v3val;
  {
   cl_object v4;
   v4 = cl_read_preserving_whitespace(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
   L2698inspect_read_line();
   v2key = v4;
  }
  v3val = ecl_gethash_safe(v2key,v1hashtable,ECL_NIL);
  if (Null(v3val)){
   goto L6;
  }
  T0 = ecl_plus(ecl_cmp_symbol_value(cl_env_copy,VV[2]),ecl_make_int8_t(1));
  ecl_cmp_setq(cl_env_copy,VV[2],T0);
  L2707inspect_indent_1();
  cl_format(3, ECL_T, VV[120], v2key);
  {
   cl_object v4;                                  /*  UPDATE-FLAG             */
   cl_object v5;                                  /*  NEW-VALUE               */
   value0 = L2705read_inspect_command(VV[65], v3val, ECL_T);
   {
    const int v6 = cl_env_copy->nvalues;
    v4 = value0;
    cl_object v7;
    v7 = (v6<=1)? ECL_NIL : cl_env_copy->values[1];
    v5 = v7;
   }
   if (Null(v4)){
    goto L12;
   }
   si_hash_set(v2key, v1hashtable, v5);
  }
L12:;
  T0 = ecl_minus(ecl_cmp_symbol_value(cl_env_copy,VV[2]),ecl_make_int8_t(1));
  ecl_cmp_setq(cl_env_copy,VV[2],T0);
  value0 = ecl_cmp_symbol_value(cl_env_copy,VV[2]);
  cl_env_copy->nvalues = 1;
  return value0;
L6:;
  cl_terpri(0);
  cl_format(3, ECL_T, VV[126], v2key);
  cl_terpri(0);
  value0 = cl_terpri(0);
  return value0;
 }
}
/* function definition for SELECT-HT-?                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2721select_ht__()
{
 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_terpri(0);
 value0 = cl_format(2, ECL_T, VV[128]);
 return value0;
}
/* function definition for INSPECT-HASHTABLE                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2723inspect_hashtable(cl_object v1hashtable)
{
 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(ecl_cmp_symbol_value(cl_env_copy,VV[4]))){
  goto L2;
 }
 T0 = ecl_minus(ecl_cmp_symbol_value(cl_env_copy,VV[2]),ecl_make_int8_t(1));
 ecl_cmp_setq(cl_env_copy,VV[2],T0);
L6:;
 cl_format(3, ECL_T, VV[130], v1hashtable);
 cl_finish_output(0);
 {
  cl_object v2;
  {
   cl_object v3char;
   v3char = cl_read_char(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
   goto L15;
L14:;
   v3char = cl_read_char(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
L15:;
   if (!(ecl_char_code(v3char)!=ecl_char_code(ECL_CODE_CHAR(32)))){
    goto L22;
   }
   if (cl_charNE(1, ECL_CODE_CHAR(9))!=ECL_NIL) {
    goto L19;
   }
   goto L20;
L22:;
   goto L20;
L20:;
   goto L14;
L19:;
   v2 = v3char;
  }
  if (!(((v2)==ECL_CODE_CHAR((ecl_character)(10))))){
   goto L29;
  }
  goto L26;
L29:;
  goto L27;
L27:;
  if (!(((v2)==ECL_CODE_CHAR((ecl_character)(13))))){
   goto L24;
  }
  goto L25;
L26:;
L25:;
  L2717select_ht_n(v1hashtable);
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L24:;
  if (!(((v2)==ECL_CODE_CHAR((ecl_character)(110))))){
   goto L38;
  }
  goto L35;
L38:;
  goto L36;
L36:;
  if (!(((v2)==ECL_CODE_CHAR((ecl_character)(78))))){
   goto L33;
  }
  goto L34;
L35:;
L34:;
  L2698inspect_read_line();
  L2717select_ht_n(v1hashtable);
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L33:;
  if (!(((v2)==ECL_CODE_CHAR((ecl_character)(115))))){
   goto L48;
  }
  goto L45;
L48:;
  goto L46;
L46:;
  if (!(((v2)==ECL_CODE_CHAR((ecl_character)(83))))){
   goto L43;
  }
  goto L44;
L45:;
L44:;
  L2698inspect_read_line();
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L43:;
  if (!(((v2)==ECL_CODE_CHAR((ecl_character)(112))))){
   goto L57;
  }
  goto L54;
L57:;
  goto L55;
L55:;
  if (!(((v2)==ECL_CODE_CHAR((ecl_character)(80))))){
   goto L52;
  }
  goto L53;
L54:;
L53:;
  L2698inspect_read_line();
  L2699select_p(v1hashtable);
  goto L10;
L52:;
  if (!(((v2)==ECL_CODE_CHAR((ecl_character)(97))))){
   goto L66;
  }
  goto L63;
L66:;
  goto L64;
L64:;
  if (!(((v2)==ECL_CODE_CHAR((ecl_character)(65))))){
   goto L61;
  }
  goto L62;
L63:;
L62:;
  L2698inspect_read_line();
  cl_env_copy->values[0] = ECL_NIL;
  cl_env_copy->nvalues = 1;
  cl_throw(VV[40]);
L61:;
  if (!(((v2)==ECL_CODE_CHAR((ecl_character)(101))))){
   goto L76;
  }
  goto L73;
L76:;
  goto L74;
L74:;
  if (!(((v2)==ECL_CODE_CHAR((ecl_character)(69))))){
   goto L71;
  }
  goto L72;
L73:;
L72:;
  L2700select_e();
  goto L10;
L71:;
  if (!(((v2)==ECL_CODE_CHAR((ecl_character)(113))))){
   goto L84;
  }
  goto L81;
L84:;
  goto L82;
L82:;
  if (!(((v2)==ECL_CODE_CHAR((ecl_character)(81))))){
   goto L79;
  }
  goto L80;
L81:;
L80:;
  L2698inspect_read_line();
  cl_env_copy->values[0] = ECL_NIL;
  cl_env_copy->nvalues = 1;
  cl_throw(VV[47]);
L79:;
  if (!(((v2)==ECL_CODE_CHAR((ecl_character)(108))))){
   goto L94;
  }
  goto L91;
L94:;
  goto L92;
L92:;
  if (!(((v2)==ECL_CODE_CHAR((ecl_character)(76))))){
   goto L89;
  }
  goto L90;
L91:;
L90:;
  L2698inspect_read_line();
  L2719select_ht_l(v1hashtable);
  goto L10;
L89:;
  if (!(((v2)==ECL_CODE_CHAR((ecl_character)(106))))){
   goto L103;
  }
  goto L100;
L103:;
  goto L101;
L101:;
  if (!(((v2)==ECL_CODE_CHAR((ecl_character)(74))))){
   goto L98;
  }
  goto L99;
L100:;
L99:;
  L2720select_ht_j(v1hashtable);
  goto L10;
L98:;
  if (!(((v2)==ECL_CODE_CHAR((ecl_character)(63))))){
   goto L10;
  }
  L2698inspect_read_line();
  L2721select_ht__();
 }
L10:;
 L2706inspect_indent();
 goto L6;
L2:;
 cl_format(3, ECL_T, VV[130], v1hashtable);
 {
  cl_object v2;
  v2 = ecl_make_cfun_va((cl_objectfn)LC2722__lambda328_va,ECL_NIL,Cblock,2);
  T0 = v2;
 }
 value0 = cl_maphash(T0, v1hashtable);
 return value0;
}
/* function definition for INSPECT-INSTANCE                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2724inspect_instance(cl_object v1instance)
{
 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(ecl_cmp_symbol_value(cl_env_copy,VV[4]))){
  goto L2;
 }
 value0 = (cl_env_copy->function=(VV[137]->symbol.gfdef))->cfun.entry(1, v1instance) /*  INSPECT-OBJ */;
 return value0;
L2:;
 value0 = (cl_env_copy->function=(ECL_SYM("DESCRIBE-OBJECT",945)->symbol.gfdef))->cfun.entry(2, v1instance, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*STANDARD-OUTPUT*",69))) /*  DESCRIBE-OBJECT */;
 return value0;
}
static cl_object L2724inspect_instance_va(cl_narg narg, cl_object v2instance, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[136]);
 {
  return L2724inspect_instance(v2instance);
 }
}
/* function definition for INSPECT-OBJECT                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2725inspect_object(cl_object volatile v1object)
{
 cl_object T0;
 cl_object volatile env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 ecl_bds_push(cl_env_copy,VV[2]);                 /*  *INSPECT-LEVEL*         */
 L2706inspect_indent();
 if (ecl_cmp_symbol_value(cl_env_copy,VV[4])!=ECL_NIL) {
  goto L3;
 }
 if (ecl_greater(ecl_cmp_symbol_value(cl_env_copy,VV[2]),ecl_make_int8_t(5))) {
  goto L6;
 }
 {
  cl_object v2;
  cl_object v3;
  cl_object v4;
  v2 = ecl_cmp_symbol_value(cl_env_copy,VV[3]);
  v3 = v1object;
  v4 = v2;
  if (Null(ecl_memql(v3,v4))){
   goto L3;
  }
  goto L4;
 }
L6:;
L4:;
 cl_prin1(1, v1object);
 value0 = ECL_NIL;
 cl_env_copy->nvalues = 1;
 ecl_bds_unwind1(cl_env_copy);
 return value0;
L3:;
 T0 = ecl_plus(ecl_cmp_symbol_value(cl_env_copy,VV[2]),ecl_make_int8_t(1));
 ecl_cmp_setq(cl_env_copy,VV[2],T0);
 T0 = CONS(v1object,ecl_cmp_symbol_value(cl_env_copy,VV[3]));
 ecl_cmp_setq(cl_env_copy,VV[3],T0);
 value0 = VV[40];                                 /*  BEGIN CATCH CATCH372    */
 {
  ecl_frs_push(cl_env_copy,value0);
  if (__ecl_frs_push_result!=0) {
   value0 = cl_env_copy->values[0];
  } else {
   if (!(ECL_SYMBOLP(v1object))){
    goto L19;
   }
   value0 = L2708inspect_symbol(v1object);
   goto L18;
L19:;
   if (Null(cl_packagep(v1object))){
    goto L21;
   }
   value0 = L2709inspect_package(v1object);
   goto L18;
L21:;
   if (!(ECL_CHARACTERP(v1object))){
    goto L23;
   }
   value0 = L2710inspect_character(v1object);
   goto L18;
L23:;
   if (!(ecl_numberp(v1object))){
    goto L25;
   }
   value0 = L2711inspect_number(v1object);
   goto L18;
L25:;
   if (!(ECL_CONSP(v1object))){
    goto L27;
   }
   value0 = L2712inspect_cons(v1object);
   goto L18;
L27:;
   if (!(ECL_STRINGP(v1object))){
    goto L29;
   }
   value0 = L2713inspect_string(v1object);
   goto L18;
L29:;
   if (!(ECL_VECTORP(v1object))){
    goto L31;
   }
   value0 = L2714inspect_vector(v1object);
   goto L18;
L31:;
   if (!(ECL_ARRAYP(v1object))){
    goto L33;
   }
   value0 = L2715inspect_array(v1object);
   goto L18;
L33:;
   if (Null(cl_hash_table_p(v1object))){
    goto L35;
   }
   value0 = L2723inspect_hashtable(v1object);
   goto L18;
L35:;
   if (!(ECL_INSTANCEP(v1object))){
    goto L37;
   }
   value0 = L2724inspect_instance(v1object);
   goto L18;
L37:;
   T0 = cl_type_of(v1object);
   value0 = cl_format(4, ECL_T, VV[139], v1object, T0);
L18:;
  }
 }
 ecl_frs_pop(cl_env_copy);                        /*  END CATCH CATCH372      */
 ecl_bds_unwind1(cl_env_copy);
 return value0;
}
static cl_object L2725inspect_object_va(cl_narg narg, cl_object v2object, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[20]);
 {
  return L2725inspect_object(v2object);
 }
}
/* function definition for DEFAULT-INSPECTOR                                  */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2726default_inspector(cl_object volatile v1object)
{
 cl_object volatile env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  volatile cl_object v2;
  volatile cl_object v3;
  v2 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*PRINT-LEVEL*",53));
  v3 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*PRINT-LENGTH*",52));
  ecl_bds_bind(cl_env_copy,VV[4],ECL_T);          /*  *INSPECT-MODE*          */
  ecl_bds_bind(cl_env_copy,VV[2],ecl_make_int8_t(0)); /*  *INSPECT-LEVEL*     */
  ecl_bds_bind(cl_env_copy,VV[3],ECL_NIL);        /*  *INSPECT-HISTORY*       */
  ecl_bds_bind(cl_env_copy,VV[5],v2);             /*  *OLD-PRINT-LEVEL*       */
  ecl_bds_bind(cl_env_copy,VV[6],v3);             /*  *OLD-PRINT-LENGTH*      */
  ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-LEVEL*",53),ecl_make_int8_t(3)); /*  *PRINT-LEVEL* */
  ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-LENGTH*",52),ecl_make_int8_t(3)); /*  *PRINT-LENGTH* */
  cl_terpri(0);
  ecl_princ(VV[142],ECL_NIL);
  cl_terpri(0);
  cl_terpri(0);
  value0 = VV[47];                                /*  BEGIN CATCH CATCH373    */
  {
   ecl_frs_push(cl_env_copy,value0);
   if (__ecl_frs_push_result!=0) {
   } else {
    L2725inspect_object(v1object);
   }
  }
  ecl_frs_pop(cl_env_copy);                       /*  END CATCH CATCH373      */
  cl_terpri(0);
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 0;
  ecl_bds_unwind_n(cl_env_copy,7);
  return value0;
 }
}
/* function definition for INSPECT                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object cl_inspect(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 (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*INSPECTOR-HOOK*",1949)))){
  goto L3;
 }
 ecl_function_dispatch(cl_env_copy,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*INSPECTOR-HOOK*",1949)))(1, v1object);
 goto L2;
L3:;
 L2726default_inspector(v1object);
L2:;
 value0 = v1object;
 cl_env_copy->nvalues = 1;
 return value0;
}
/* function definition for DESCRIBE                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object cl_describe(volatile cl_narg narg, cl_object volatile v1object, ...)
{
 cl_object T0;
 cl_object volatile env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(ECL_SYM("DESCRIBE",301));
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(ECL_SYM("DESCRIBE",301));
 {
  cl_object volatile v2stream;
  va_list args; va_start(args,v1object);
  {
   int i = 1;
   if (i >= narg) {
    v2stream = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*STANDARD-OUTPUT*",69));
   } else {
    i++;
    v2stream = va_arg(args,cl_object);
   }
  }
  va_end(args);
  ecl_bds_bind(cl_env_copy,VV[4],ECL_NIL);        /*  *INSPECT-MODE*          */
  ecl_bds_bind(cl_env_copy,VV[2],ecl_make_int8_t(0)); /*  *INSPECT-LEVEL*     */
  ecl_bds_bind(cl_env_copy,VV[3],ECL_NIL);        /*  *INSPECT-HISTORY*       */
  ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-LEVEL*",53),ECL_NIL); /*  *PRINT-LEVEL* */
  ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-LENGTH*",52),ECL_NIL); /*  *PRINT-LENGTH* */
  if (Null(cl_streamp(v2stream))){
   goto L3;
  }
  T0 = v2stream;
  goto L2;
L3:;
  if (!(v2stream==ECL_NIL)){
   goto L5;
  }
  T0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*STANDARD-OUTPUT*",69));
  goto L2;
L5:;
  if (!((v2stream)==(ECL_T))){
   goto L7;
  }
  T0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*TERMINAL-IO*",70));
  goto L2;
L7:;
  T0 = cl_error(5, ECL_SYM("TYPE-ERROR",873), ECL_SYM("DATUM",1245), v2stream, ECL_SYM("EXPECTED-TYPE",1263), VV[143]);
L2:;
  ecl_bds_bind(cl_env_copy,ECL_SYM("*STANDARD-OUTPUT*",69),T0); /*  *STANDARD-OUTPUT* */
  cl_terpri(0);
  value0 = VV[47];                                /*  BEGIN CATCH CATCH374    */
  {
   ecl_frs_push(cl_env_copy,value0);
   if (__ecl_frs_push_result!=0) {
   } else {
    L2725inspect_object(v1object);
   }
  }
  ecl_frs_pop(cl_env_copy);                       /*  END CATCH CATCH374      */
  cl_terpri(0);
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 0;
  ecl_bds_unwind_n(cl_env_copy,6);
  return value0;
 }
}
/* function definition for PRINT-DOC                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2733print_doc(volatile cl_narg narg, cl_object volatile v1symbol, ...)
{
 cl_object T0, T1;
 volatile cl_object lex0[2];
 cl_object volatile env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(VV[61]);
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(VV[61]);
 {
  cl_object volatile v2called_from_apropos_doc_p;
  va_list args; va_start(args,v1symbol);
  lex0[0] = v1symbol;                             /*  SYMBOL                  */
  {
   int i = 1;
   if (i >= narg) {
    v2called_from_apropos_doc_p = ECL_NIL;
   } else {
    i++;
    v2called_from_apropos_doc_p = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   volatile cl_object v3x;
   lex0[1] = ECL_NIL;                             /*  F                       */
   v3x = ECL_NIL;
   if (Null(cl_special_operator_p(lex0[0]))){
    goto L5;
   }
   if (Null(cl_macro_function(1, lex0[0]))){
    goto L9;
   }
   T0 = VV[157];
   goto L8;
L9:;
   T0 = VV[158];
L8:;
   LC2727head(lex0, T0);
   value0 = si_get_documentation(lex0[0], ECL_SYM("FUNCTION",398));
   if (value0!=ECL_NIL) {
    goto L14;
   }
   T0 = VV[160];
   goto L12;
L14:;
   T0 = value0;
   goto L12;
L12:;
   LC2728doc(T0);
   LC2729arg(lex0[0]);
   LC2731src(lex0[0]);
   goto L4;
L5:;
   if (Null(cl_macro_function(1, lex0[0]))){
    goto L17;
   }
   LC2727head(lex0, VV[161]);
   value0 = si_get_documentation(lex0[0], ECL_SYM("FUNCTION",398));
   if (value0!=ECL_NIL) {
    goto L23;
   }
   T0 = VV[160];
   goto L21;
L23:;
   T0 = value0;
   goto L21;
L21:;
   LC2728doc(T0);
   LC2729arg(lex0[0]);
   LC2731src(lex0[0]);
   goto L4;
L17:;
   if (Null(cl_fboundp(lex0[0]))){
    goto L26;
   }
   LC2727head(lex0, VV[162]);
   value0 = si_get_documentation(lex0[0], ECL_SYM("FUNCTION",398));
   if (value0!=ECL_NIL) {
    goto L32;
   }
   T0 = VV[160];
   goto L30;
L32:;
   T0 = value0;
   goto L30;
L30:;
   LC2728doc(T0);
   LC2729arg(lex0[0]);
   LC2731src(lex0[0]);
   goto L4;
L26:;
   v3x = si_get_documentation(lex0[0], ECL_SYM("FUNCTION",398));
   if (Null(v3x)){
    goto L4;
   }
   LC2727head(lex0, VV[163]);
   LC2728doc(v3x);
   LC2729arg(lex0[0]);
   LC2731src(lex0[0]);
L4:;
   if (Null(cl_constantp(1, lex0[0]))){
    goto L41;
   }
   T0 = cl_symbol_package(lex0[0]);
   T1 = cl_find_package(VV[58]);
   if (!((T0)==(T1))){
    goto L45;
   }
   T0 = si_get_documentation(lex0[0], ECL_SYM("VARIABLE",901));
   if (T0==ECL_NIL) {
    goto L40;
   }
   goto L43;
L45:;
   goto L43;
L43:;
   LC2727head(lex0, VV[164]);
   value0 = si_get_documentation(lex0[0], ECL_SYM("VARIABLE",901));
   if (value0!=ECL_NIL) {
    goto L50;
   }
   T0 = VV[160];
   goto L48;
L50:;
   T0 = value0;
   goto L48;
L48:;
   LC2728doc(T0);
   goto L40;
L41:;
   if (Null(si_specialp(lex0[0]))){
    goto L52;
   }
   LC2727head(lex0, VV[165]);
   value0 = si_get_documentation(lex0[0], ECL_SYM("VARIABLE",901));
   if (value0!=ECL_NIL) {
    goto L57;
   }
   T0 = VV[160];
   goto L55;
L57:;
   T0 = value0;
   goto L55;
L55:;
   LC2728doc(T0);
   goto L40;
L52:;
   v3x = si_get_documentation(lex0[0], ECL_SYM("VARIABLE",901));
   if (v3x!=ECL_NIL) {
    goto L60;
   }
   if (!(ecl_boundp(cl_env_copy,lex0[0]))){
    goto L40;
   }
   goto L59;
L60:;
L59:;
   LC2727head(lex0, VV[166]);
   value0 = v3x;
   if (value0!=ECL_NIL) {
    goto L66;
   }
   T0 = VV[160];
   goto L64;
L66:;
   T0 = value0;
   goto L64;
L64:;
   LC2728doc(T0);
L40:;
   v3x = si_get_documentation(lex0[0], ECL_SYM("TYPE",872));
   if (Null(v3x)){
    goto L69;
   }
   LC2727head(lex0, VV[167]);
   LC2728doc(v3x);
   goto L68;
L69:;
   v3x = si_get_sysprop(lex0[0], VV[168]);
   if (Null(v3x)){
    goto L68;
   }
   T0 = LC2732good_package(lex0);
   ecl_bds_bind(cl_env_copy,ECL_SYM("*PACKAGE*",45),T0); /*  *PACKAGE*        */
   LC2727head(lex0, VV[167]);
   T0 = cl_format(3, ECL_NIL, VV[169], v3x);
   LC2728doc(T0);
   ecl_bds_unwind1(cl_env_copy);
L68:;
   v3x = si_get_documentation(lex0[0], ECL_SYM("STRUCTURE",829));
   if (Null(v3x)){
    goto L78;
   }
   LC2727head(lex0, VV[170]);
   LC2728doc(v3x);
   goto L77;
L78:;
   v3x = si_get_sysprop(lex0[0], VV[171]);
   if (Null(v3x)){
    goto L77;
   }
   LC2727head(lex0, VV[170]);
   T0 = cl_format(3, ECL_NIL, VV[172], v3x);
   LC2728doc(T0);
L77:;
   v3x = si_get_documentation(lex0[0], ECL_SYM("SETF",753));
   if (Null(v3x)){
    goto L85;
   }
   LC2727head(lex0, VV[173]);
   LC2728doc(v3x);
   goto L3;
L85:;
   v3x = si_get_sysprop(lex0[0], ECL_SYM("SETF-METHOD",1165));
   if (Null(v3x)){
    goto L3;
   }
   T0 = LC2732good_package(lex0);
   ecl_bds_bind(cl_env_copy,ECL_SYM("*PACKAGE*",45),T0); /*  *PACKAGE*        */
   LC2727head(lex0, VV[173]);
   if (!(ECL_CONSP(v3x))){
    goto L94;
   }
   {
    cl_object v4;
    v4 = ecl_car(v3x);
    if (!((v4)==(ECL_SYM("LAMBDA",454)))){
     goto L97;
    }
    T1 = ecl_cdr(v3x);
    T0 = CONS(ECL_SYM("DEFINE-SETF-EXPANDER",283),T1);
    goto L93;
L97:;
    if (!((v4)==(ECL_SYM("LAMBDA-BLOCK",1377)))){
     goto L99;
    }
    T1 = ecl_cddr(v3x);
    T0 = CONS(ECL_SYM("DEFINE-SETF-EXPANDER",283),T1);
    goto L93;
L99:;
    T0 = ECL_NIL;
    goto L93;
   }
L94:;
   T0 = ECL_NIL;
L93:;
   T1 = cl_format(3, ECL_NIL, VV[174], T0);
   LC2728doc(T1);
   ecl_bds_unwind1(cl_env_copy);
L3:;
   if (Null(v2called_from_apropos_doc_p)){
    goto L101;
   }
   value0 = lex0[1];
   cl_env_copy->nvalues = 1;
   return value0;
L101:;
   if (Null(lex0[1])){
    goto L104;
   }
   cl_format(2, ECL_T, VV[175]);
   goto L103;
L104:;
   cl_format(3, ECL_T, VV[176], lex0[0]);
L103:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 0;
   return value0;
  }
 }
}
/* function definition for HELP*                                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L2734help_(cl_narg narg, cl_object v1string, ...)
{
 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);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(VV[178]);
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(VV[178]);
 {
  cl_object v2package;
  va_list args; va_start(args,v1string);
  {
   int i = 1;
   if (i >= narg) {
    v2package = VV[156];
   } else {
    i++;
    v2package = va_arg(args,cl_object);
   }
  }
  va_end(args);
  {
   cl_object v3f;
   cl_object v4l;
   v3f = ECL_NIL;
   v4l = cl_apropos_list(2, v1string, v2package);
   goto L7;
L6:;
   T0 = ecl_car(v4l);
   if (Null(L2733print_doc(2, T0, ECL_T))){
    goto L9;
   }
   v3f = ECL_T;
L9:;
   v4l = ecl_cdr(v4l);
L7:;
   if (ecl_endp(v4l)) {
    goto L14;
   }
   goto L6;
L14:;
   if (Null(v3f)){
    goto L17;
   }
   T0 = VV[175];
   goto L16;
L17:;
   T0 = VV[179];
L16:;
   if (Null(v2package)){
    goto L21;
   }
   T2 = si_coerce_to_package(v2package);
   T1 = cl_package_name(T2);
   goto L19;
L21:;
   T1 = ECL_NIL;
   goto L19;
L19:;
   cl_format(5, ECL_T, T0, v1string, v2package, T1);
  }
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 0;
  return value0;
 }
}
/* closure LAMBDA18                                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2703__lambda18(cl_narg narg, ...)
{
 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;                                     /*  TAGBODY                 */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 {
  cl_object v1temp;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  v1temp = cl_grab_rest_args(args);
  ecl_va_end(args);
  ECL_CONS_CAR(CLV0) = v1temp;
  cl_go(ECL_CONS_CAR(CLV1),ecl_make_fixnum(0));
 }
 }
}
/* local function LAMBDA20                                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2704__lambda20(cl_object v1stream)
{
 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 = cl_format(2, v1stream, VV[27]);
 return value0;
}
static cl_object LC2704__lambda20_va(cl_narg narg, cl_object v2stream, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[26]);
 {
  return LC2704__lambda20(v2stream);
 }
}
/* closure LAMBDA201                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2716__lambda201(cl_narg narg, cl_object v1key, cl_object v2val, ...)
{
 cl_object CLV0;
 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 ... */
 CLV0 = env0;                                     /*  HASHTABLE               */
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[119]);
 {
L1:;
  L2707inspect_indent_1();
  cl_format(3, ECL_T, VV[120], v1key);
  {
   cl_object v3;                                  /*  UPDATE-FLAG             */
   cl_object v4;                                  /*  NEW-VALUE               */
   value0 = L2705read_inspect_command(VV[65], v2val, ECL_T);
   {
    const int v5 = cl_env_copy->nvalues;
    v3 = value0;
    cl_object v6;
    v6 = (v5<=1)? ECL_NIL : cl_env_copy->values[1];
    v4 = v6;
   }
   if (Null(v3)){
    goto L5;
   }
   value0 = si_hash_set(v1key, ECL_CONS_CAR(CLV0), v4);
   return value0;
L5:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
 }
}
/* local function LAMBDA209                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2718__lambda209(cl_object v1key, cl_object v2val)
{
 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 = cl_format(3, ECL_T, VV[124], v1key);
 return value0;
}
static cl_object LC2718__lambda209_va(cl_narg narg, cl_object v3key, cl_object v4val, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[123]);
 {
  return LC2718__lambda209(v3key, v4val);
 }
}
/* local function LAMBDA328                                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2722__lambda328(cl_object v1key, cl_object v2val)
{
 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:;
 L2707inspect_indent_1();
 cl_format(3, ECL_T, VV[120], v1key);
 L2707inspect_indent_1();
 cl_format(2, ECL_T, VV[65]);
 value0 = L2725inspect_object(v2val);
 return value0;
}
static cl_object LC2722__lambda328_va(cl_narg narg, cl_object v3key, cl_object v4val, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[135]);
 {
  return LC2722__lambda328(v3key, v4val);
 }
}
/* local function GOOD-PACKAGE                                                */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2732good_package(volatile cl_object *lex0)
{
 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:;
 T0 = cl_symbol_package(lex0[0]);
 T1 = cl_find_package(VV[156]);
 if (!((T0)==(T1))){
  goto L2;
 }
 value0 = cl_find_package(VV[0]);
 return value0;
L2:;
 value0 = ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*PACKAGE*",45));
 cl_env_copy->nvalues = 1;
 return value0;
}
/* local function SRC                                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2731src(cl_object volatile v1sym)
{
 cl_object T0, T1, T2, T3;
 cl_object volatile env0 = ECL_NIL;
 cl_object volatile CLV0, CLV1;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  volatile cl_object v2obj;
  {
   volatile cl_object env1 = env0;
   env1 = ECL_NIL;
   CLV0 = env1 = CONS(ECL_NIL,env1);
   {
    volatile cl_object env2 = env1;
    CLV1 = env2 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env2); /*  TAGBODY       */
    {
     ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV1));
     if (__ecl_frs_push_result!=0) {
     if (cl_env_copy->values[0]==ecl_make_int8_t(0)) {
      goto L3;
     }
     ecl_internal_error("GO found an inexistent tag");
     } else {
     {
      cl_object v3;
      v3 = ecl_make_cclosure_va((cl_objectfn)LC2730__lambda364,env2,Cblock,1);
      T0 = v3;
     }
     T1 = CONS(ECL_SYM("ERROR",339),T0);
     T2 = ecl_list1(T1);
     T3 = CONS(T2,ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*HANDLER-CLUSTERS*",6)));
     ecl_bds_bind(cl_env_copy,ECL_SYM("*HANDLER-CLUSTERS*",6),T3); /*  *HANDLER-CLUSTERS* */
     v2obj = cl_fdefinition(v1sym);
     ecl_frs_pop_n(cl_env_copy, 1);
     ecl_bds_unwind1(cl_env_copy);
     goto L2;
L3:;
     {
      cl_object v3condition;
      v3condition = ECL_CONS_CAR(CLV0);
      cl_env_copy->nvalues = 2;
      cl_env_copy->values[1] = v3condition;
      cl_env_copy->values[0] = ECL_NIL;
      v2obj = cl_env_copy->values[0];
      ecl_frs_pop_n(cl_env_copy, 1);
      goto L2;
     }
     }
    }
   }
  }
L2:;
  if (Null(v2obj)){
   goto L8;
  }
  {
   cl_object v3src;
   v3src = si_compiled_function_file(v2obj);
   if (Null(v3src)){
    goto L11;
   }
   T0 = cl_pathname(v3src);
   value0 = cl_format(3, ECL_T, VV[153], T0);
   return value0;
L11:;
   value0 = cl_format(2, ECL_T, VV[154]);
   return value0;
  }
L8:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC2731src_va(cl_narg narg, cl_object v4sym, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[150]);
 {
  return LC2731src(v4sym);
 }
}
/* local function ARG                                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2729arg(cl_object v1sym)
{
 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_env_copy->function=ecl_fdefinition(ECL_SYM("FUNCTION-LAMBDA-LIST",1866)))->cfun.entry(1, v1sym) /*  FUNCTION-LAMBDA-LIST */;
 value0 = cl_format(3, ECL_T, VV[149], T0);
 return value0;
}
static cl_object LC2729arg_va(cl_narg narg, cl_object v2sym, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[148]);
 {
  return LC2729arg(v2sym);
 }
}
/* local function DOC                                                         */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2728doc(cl_object v1str)
{
 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 = cl_format(3, ECL_T, VV[147], v1str);
 return value0;
}
static cl_object LC2728doc_va(cl_narg narg, cl_object v2str, ...)
{
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[146]);
 {
  return LC2728doc(v2str);
 }
}
/* local function HEAD                                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2727head(volatile cl_object *lex0, cl_object v1ind)
{
 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:;
 lex0[1] = ECL_T;
 value0 = cl_format(4, ECL_T, VV[145], lex0[0], v1ind);
 return value0;
}
/* closure LAMBDA364                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC2730__lambda364(cl_narg narg, cl_object v1temp, ...)
{
 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;                                     /*  TAGBODY                 */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[152]);
 {
L1:;
  ECL_CONS_CAR(CLV0) = v1temp;
  cl_go(ECL_CONS_CAR(CLV1),ecl_make_fixnum(0));
 }
 }
}
#include "clos/describe.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _eclwYtlmu9G2Xrk9_KBF0M881(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;DESCRIBE.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclwYtlmu9G2Xrk9_KBF0M881@";
 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(VV[0]);
  T0 = cl_adjoin(2, VV[1], ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*FEATURES*",36)));
  ecl_cmp_setq(cl_env_copy,ECL_SYM("*FEATURES*",36),T0);
  si_Xmake_special(VV[2]);
  T0 = ecl_make_int8_t(0);
  ecl_cmp_setq(cl_env_copy,VV[2],T0);
  si_Xmake_special(VV[3]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[3],T0);
  si_Xmake_special(VV[4]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[4],T0);
  si_Xmake_special(VV[5]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[5],T0);
  si_Xmake_special(VV[6]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[6],T0);
  ecl_cmp_defun(VV[181]);                         /*  INSPECT-READ-LINE       */
  ecl_cmp_defun(VV[182]);                         /*  SELECT-P                */
  ecl_cmp_defun(VV[183]);                         /*  SELECT-E                */
  ecl_cmp_defun(VV[184]);                         /*  SELECT-U                */
  ecl_cmp_defun(VV[185]);                         /*  SELECT-?                */
  ecl_cmp_defun(VV[186]);                         /*  READ-INSPECT-COMMAND    */
  ecl_cmp_defun(VV[187]);                         /*  INSPECT-INDENT          */
  ecl_cmp_defun(VV[188]);                         /*  INSPECT-INDENT-1        */
  (void)0; /* No entry created for INSPECT-SYMBOL */
  (void)0; /* No entry created for INSPECT-PACKAGE */
  (void)0; /* No entry created for INSPECT-CHARACTER */
  (void)0; /* No entry created for INSPECT-NUMBER */
  (void)0; /* No entry created for INSPECT-CONS */
  (void)0; /* No entry created for INSPECT-STRING */
  (void)0; /* No entry created for INSPECT-VECTOR */
  (void)0; /* No entry created for INSPECT-ARRAY */
  (void)0; /* No entry created for SELECT-HT-N */
  (void)0; /* No entry created for SELECT-HT-L */
  (void)0; /* No entry created for SELECT-HT-J */
  (void)0; /* No entry created for SELECT-HT-? */
  (void)0; /* No entry created for INSPECT-HASHTABLE */
  ecl_cmp_defun(VV[189]);                         /*  INSPECT-INSTANCE        */
  ecl_cmp_defun(VV[190]);                         /*  INSPECT-OBJECT          */
  (void)0; /* No entry created for DEFAULT-INSPECTOR */
  (void)0; /* No entry created for INSPECT */
  (void)0; /* No entry created for DESCRIBE */
  ecl_cmp_defun(VV[191]);                         /*  PRINT-DOC               */
  ecl_cmp_defun(VV[192]);                         /*  HELP*                   */
 }
}
