/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/src/lsp/iolib.lsp                       */
#include <ecl/ecl-cmp.h>
#include "lsp/iolib.eclh"
/* local function WITH-OPEN-STREAM                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC326with_open_stream(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3, T4, T5, T6;
 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 v3;
  cl_object v4;
  cl_object v5;
  cl_object v6var;
  cl_object v7stream;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v8;
   v8 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4 = v8;
  }
  v5 = v4;
  if (!(v5==ECL_NIL)){
   goto L11;
  }
  si_dm_too_few_arguments(v1);
L11:;
  {
   cl_object v8;
   v8 = ecl_car(v5);
   v5 = ecl_cdr(v5);
   v6var = v8;
  }
  if (!(v5==ECL_NIL)){
   goto L17;
  }
  si_dm_too_few_arguments(v1);
L17:;
  {
   cl_object v8;
   v8 = ecl_car(v5);
   v5 = ecl_cdr(v5);
   v7stream = v8;
  }
  if (Null(v5)){
   goto L22;
  }
  si_dm_too_many_arguments(v1);
L22:;
  {
   cl_object v8;                                  /*  DS                      */
   cl_object v9;                                  /*  B                       */
   value0 = si_find_declarations(1, v3);
   {
    const int v10 = cl_env_copy->nvalues;
    v8 = value0;
    cl_object v11;
    v11 = (v10<=1)? ECL_NIL : cl_env_copy->values[1];
    v9 = v11;
   }
   T0 = cl_list(2, v6var, v7stream);
   T1 = ecl_list1(T0);
   T2 = CONS(ECL_SYM("PROGN",674),v9);
   T3 = cl_list(2, ECL_SYM("CLOSE",230), v6var);
   T4 = cl_list(3, ECL_SYM("UNWIND-PROTECT",892), T2, T3);
   T5 = ecl_list1(T4);
   T6 = ecl_append(v8,T5);
   value0 = cl_listX(3, ECL_SYM("LET",479), T1, T6);
   return value0;
  }
 }
}
static cl_object LC326with_open_stream_va(cl_narg narg, cl_object v8, cl_object v9, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[3]);
 {
  return LC326with_open_stream(v8, v9);
 }
}
/* local function WITH-INPUT-FROM-STRING                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC327with_input_from_string(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7;
 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 v3;
  cl_object v4;
  cl_object v5;
  cl_object v6var;
  cl_object v7string;
  cl_object v8;
  cl_object v9index;
  cl_object v10;
  cl_object v11start;
  cl_object v12;
  cl_object v13end;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v14;
   v14 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4 = v14;
  }
  v5 = v4;
  if (!(v5==ECL_NIL)){
   goto L11;
  }
  si_dm_too_few_arguments(v1);
L11:;
  {
   cl_object v14;
   v14 = ecl_car(v5);
   v5 = ecl_cdr(v5);
   v6var = v14;
  }
  if (!(v5==ECL_NIL)){
   goto L17;
  }
  si_dm_too_few_arguments(v1);
L17:;
  {
   cl_object v14;
   v14 = ecl_car(v5);
   v5 = ecl_cdr(v5);
   v7string = v14;
  }
  v8 = si_search_keyword(v5, VV[5]);
  if (!((v8)==(ECL_SYM("MISSING-KEYWORD",2044)))){
   goto L24;
  }
  v9index = ECL_NIL;
  goto L23;
L24:;
  v9index = v8;
L23:;
  v10 = si_search_keyword(v5, ECL_SYM("START",1347));
  if (!((v10)==(ECL_SYM("MISSING-KEYWORD",2044)))){
   goto L28;
  }
  v11start = ecl_make_int8_t(0);
  goto L27;
L28:;
  v11start = v10;
L27:;
  v12 = si_search_keyword(v5, ECL_SYM("END",1256));
  if (!((v12)==(ECL_SYM("MISSING-KEYWORD",2044)))){
   goto L32;
  }
  v13end = ECL_NIL;
  goto L31;
L32:;
  v13end = v12;
L31:;
  si_check_keyword(2, v5, VV[7]);
  {
   cl_object v14;                                 /*  DS                      */
   cl_object v15;                                 /*  B                       */
   value0 = si_find_declarations(1, v3);
   {
    const int v16 = cl_env_copy->nvalues;
    v14 = value0;
    cl_object v17;
    v17 = (v16<=1)? ECL_NIL : cl_env_copy->values[1];
    v15 = v17;
   }
   T0 = cl_list(4, ECL_SYM("MAKE-STRING-INPUT-STREAM",537), v7string, v11start, v13end);
   T1 = cl_list(2, v6var, T0);
   T2 = ecl_list1(T1);
   if (Null(v9index)){
    goto L37;
   }
   T4 = CONS(ECL_SYM("PROGN",674),v15);
   T5 = cl_list(2, ECL_SYM("FILE-POSITION",359), v6var);
   T6 = cl_list(3, ECL_SYM("SETF",753), v9index, T5);
   T3 = cl_list(3, ECL_SYM("MULTIPLE-VALUE-PROG1",577), T4, T6);
   goto L36;
L37:;
   T3 = CONS(ECL_SYM("PROGN",674),v15);
L36:;
   T4 = cl_list(2, ECL_SYM("CLOSE",230), v6var);
   T5 = cl_list(3, ECL_SYM("UNWIND-PROTECT",892), T3, T4);
   T6 = ecl_list1(T5);
   T7 = ecl_append(v14,T6);
   value0 = cl_listX(3, ECL_SYM("LET",479), T2, T7);
   return value0;
  }
 }
}
static cl_object LC327with_input_from_string_va(cl_narg narg, cl_object v14, cl_object v15, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[8]);
 {
  return LC327with_input_from_string(v14, v15);
 }
}
/* local function WITH-OUTPUT-TO-STRING                                       */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC328with_output_to_string(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
L1:;
 {
  cl_object v3;
  cl_object v4;
  cl_object v5;
  cl_object v6var;
  cl_object v7string;
  cl_object v8;
  cl_object v9element_type;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v10;
   v10 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4 = v10;
  }
  v5 = v4;
  if (!(v5==ECL_NIL)){
   goto L11;
  }
  si_dm_too_few_arguments(v1);
L11:;
  {
   cl_object v10;
   v10 = ecl_car(v5);
   v5 = ecl_cdr(v5);
   v6var = v10;
  }
  if (Null(v5)){
   goto L17;
  }
  {
   cl_object v10;
   v10 = ecl_car(v5);
   v5 = ecl_cdr(v5);
   v7string = v10;
   goto L16;
  }
L17:;
  v7string = ECL_NIL;
L16:;
  v8 = si_search_keyword(v5, ECL_SYM("ELEMENT-TYPE",1255));
  if (!((v8)==(ECL_SYM("MISSING-KEYWORD",2044)))){
   goto L24;
  }
  v9element_type = ECL_NIL;
  goto L23;
L24:;
  v9element_type = v8;
L23:;
  si_check_keyword(2, v5, VV[9]);
  {
   cl_object v10;                                 /*  DECLS                   */
   cl_object v11;                                 /*  BODY                    */
   value0 = si_find_declarations(1, v3);
   {
    const int v12 = cl_env_copy->nvalues;
    v10 = value0;
    cl_object v13;
    v13 = (v12<=1)? ECL_NIL : cl_env_copy->values[1];
    v11 = v13;
   }
   if (Null(v7string)){
    goto L28;
   }
   {
    cl_object v12elt_type_var;
    v12elt_type_var = cl_gensym(1, _ecl_static_0);
    T0 = cl_list(2, ECL_SYM("MAKE-STRING-OUTPUT-STREAM-FROM-STRING",1116), v7string);
    T1 = cl_list(2, v6var, T0);
    T2 = cl_list(2, v12elt_type_var, v9element_type);
    T3 = cl_list(2, T1, T2);
    T4 = cl_list(2, ECL_SYM("IGNORE",430), v12elt_type_var);
    T5 = cl_list(2, ECL_SYM("DECLARE",276), T4);
    T6 = CONS(ECL_SYM("PROGN",674),v11);
    T7 = cl_list(2, ECL_SYM("CLOSE",230), v6var);
    T8 = cl_list(3, ECL_SYM("UNWIND-PROTECT",892), T6, T7);
    T9 = ecl_list1(T8);
    T10 = ecl_append(v10,T9);
    value0 = cl_listX(4, ECL_SYM("LET",479), T3, T5, T10);
    return value0;
   }
L28:;
   T0 = CONS(ECL_SYM("MAKE-STRING-OUTPUT-STREAM",538),v5);
   T1 = cl_list(2, v6var, T0);
   T2 = ecl_list1(T1);
   T3 = cl_list(2, ECL_SYM("GET-OUTPUT-STREAM-STRING",410), v6var);
   T4 = ecl_list1(T3);
   T5 = ecl_append(v11,T4);
   T6 = CONS(ECL_SYM("PROGN",674),T5);
   T7 = cl_list(2, ECL_SYM("CLOSE",230), v6var);
   T8 = cl_list(3, ECL_SYM("UNWIND-PROTECT",892), T6, T7);
   T9 = ecl_list1(T8);
   T10 = ecl_append(v10,T9);
   value0 = cl_listX(3, ECL_SYM("LET",479), T2, T10);
   return value0;
  }
 }
}
static cl_object LC328with_output_to_string_va(cl_narg narg, cl_object v10, cl_object v11, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[10]);
 {
  return LC328with_output_to_string(v10, v11);
 }
}
/* function definition for READ-FROM-STRING                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object cl_read_from_string(cl_narg narg, cl_object v1string, ...)
{
 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);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(ECL_SYM("READ-FROM-STRING",698));
 {
  cl_object v2eof_error_p;
  cl_object v3eof_value;
  cl_object v4start;
  cl_object v5end;
  cl_object v6preserve_whitespace;
  ecl_va_list args; ecl_va_start(args,v1string,narg,1);
  {
   int i = 1;
   if (i >= narg) {
    v2eof_error_p = ECL_T;
   } else {
    i++;
    v2eof_error_p = ecl_va_arg(args);
   }
   if (i >= narg) {
    v3eof_value = ECL_NIL;
   } else {
    i++;
    v3eof_value = ecl_va_arg(args);
   }
  }
  {
   cl_object keyvars[6];
   cl_parse_key(args,3,cl_read_from_stringkeys,keyvars,NULL,FALSE);
   ecl_va_end(args);
   if (Null(keyvars[3])) {
    v4start = ecl_make_int8_t(0);
   } else {
    v4start = keyvars[0];
   }
   if (Null(keyvars[4])) {
    v5end = ecl_make_fixnum(ecl_length(v1string));
   } else {
    v5end = keyvars[1];
   }
   v6preserve_whitespace = keyvars[2];
  }
  {
   cl_object v7stream;
   v7stream = cl_make_string_input_stream(3, v1string, v4start, v5end);
   if (Null(v6preserve_whitespace)){
    goto L6;
   }
   T0 = cl_read_preserving_whitespace(3, v7stream, v2eof_error_p, v3eof_value);
   T1 = cl_file_position(1, v7stream);
   cl_env_copy->nvalues = 2;
   cl_env_copy->values[1] = T1;
   cl_env_copy->values[0] = T0;
   return cl_env_copy->values[0];
L6:;
   T0 = cl_read(3, v7stream, v2eof_error_p, v3eof_value);
   T1 = cl_file_position(1, v7stream);
   cl_env_copy->nvalues = 2;
   cl_env_copy->values[1] = T1;
   cl_env_copy->values[0] = T0;
   return cl_env_copy->values[0];
  }
 }
}
/* function definition for STRING-TO-OBJECT                                   */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_string_to_object(cl_narg narg, 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);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(ECL_SYM("STRING-TO-OBJECT",1175));
 if (ecl_unlikely(narg>2)) FEwrong_num_arguments(ECL_SYM("STRING-TO-OBJECT",1175));
 {
  cl_object v2err_value;
  cl_object v3err_value_p;
  va_list args; va_start(args,v1string);
  {
   int i = 1;
   if (i >= narg) {
    v2err_value = ECL_NIL;
    v3err_value_p = ECL_NIL;
   } else {
    i++;
    v2err_value = va_arg(args,cl_object);
    v3err_value_p = ECL_T;
   }
  }
  va_end(args);
  if (Null(v3err_value_p)){
   goto L2;
  }
  T0 = cl_list(2, ECL_SYM("READ-FROM-STRING",698), v1string);
  value0 = si_safe_eval(3, T0, ECL_NIL, v2err_value);
  return value0;
L2:;
  T0 = cl_list(2, ECL_SYM("READ-FROM-STRING",698), v1string);
  value0 = si_safe_eval(2, T0, ECL_NIL);
  return value0;
 }
}
/* function definition for WRITE-TO-STRING                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object cl_write_to_string(cl_narg narg, 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);
 if (ecl_unlikely(narg<1)) FEwrong_num_arguments(ECL_SYM("WRITE-TO-STRING",927));
 {
  cl_object v2rest;
  ecl_va_list args; ecl_va_start(args,v1object,narg,1);
  v2rest = cl_grab_rest_args(args);
  ecl_va_end(args);
  {
   cl_object v3stream;
   v3stream = cl_make_string_output_stream(0);
   T0 = (ECL_SYM("WRITE",921)->symbol.gfdef);
   cl_apply(5, T0, v1object, ECL_SYM("STREAM",1350), v3stream, v2rest);
   value0 = cl_get_output_stream_string(v3stream);
   return value0;
  }
 }
}
/* function definition for PRIN1-TO-STRING                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object cl_prin1_to_string(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:;
 {
  cl_object v2stream;
  v2stream = cl_make_string_output_stream(0);
  (ecl_prin1(v1object,v2stream));
  value0 = cl_get_output_stream_string(v2stream);
  return value0;
 }
}
/* function definition for PRINC-TO-STRING                                    */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object cl_princ_to_string(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:;
 {
  cl_object v2stream;
  v2stream = cl_make_string_output_stream(0);
  ecl_princ(v1object,v2stream);
  value0 = cl_get_output_stream_string(v2stream);
  return value0;
 }
}
/* local function WITH-OPEN-FILE                                              */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC329with_open_file(cl_object v1, cl_object v2)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11;
 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 v3;
  cl_object v4;
  cl_object v5;
  cl_object v6stream;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v7;
   v7 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4 = v7;
  }
  v5 = v4;
  if (!(v5==ECL_NIL)){
   goto L11;
  }
  si_dm_too_few_arguments(v1);
L11:;
  {
   cl_object v7;
   v7 = ecl_car(v5);
   v5 = ecl_cdr(v5);
   v6stream = v7;
  }
  {
   cl_object v7;                                  /*  DS                      */
   cl_object v8;                                  /*  B                       */
   value0 = si_find_declarations(1, v3);
   {
    const int v9 = cl_env_copy->nvalues;
    v7 = value0;
    cl_object v10;
    v10 = (v9<=1)? ECL_NIL : cl_env_copy->values[1];
    v8 = v10;
   }
   T0 = CONS(ECL_SYM("OPEN",613),v5);
   T1 = cl_list(2, v6stream, T0);
   T2 = ecl_list1(T1);
   T3 = CONS(ECL_SYM("PROGN",674),v8);
   T4 = cl_list(2, ECL_SYM("CLOSE",230), v6stream);
   T5 = cl_list(3, ECL_SYM("WHEN",909), v6stream, T4);
   T6 = cl_list(3, ECL_SYM("MULTIPLE-VALUE-PROG1",577), T3, T5);
   T7 = cl_listX(3, ECL_SYM("CLOSE",230), v6stream, VV[11]);
   T8 = cl_list(3, ECL_SYM("WHEN",909), v6stream, T7);
   T9 = cl_list(3, ECL_SYM("UNWIND-PROTECT",892), T6, T8);
   T10 = ecl_list1(T9);
   T11 = ecl_append(v7,T10);
   value0 = cl_listX(3, ECL_SYM("LET",479), T2, T11);
   return value0;
  }
 }
}
static cl_object LC329with_open_file_va(cl_narg narg, cl_object v7, cl_object v8, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[12]);
 {
  return LC329with_open_file(v7, v8);
 }
}
/* function definition for Y-OR-N-P                                           */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object cl_y_or_n_p(cl_narg narg, ...)
{
 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);
 {
  cl_object v1string;
  cl_object v2args;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  {
   int i = 0;
   if (i >= narg) {
    v1string = ECL_NIL;
   } else {
    i++;
    v1string = ecl_va_arg(args);
   }
  }
  v2args = cl_grab_rest_args(args);
  ecl_va_end(args);
  {
   cl_object v3reply;
   v3reply = ECL_NIL;
   goto L5;
L4:;
   if (Null(v1string)){
    goto L7;
   }
   cl_format(4, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)), VV[13], v1string, v2args);
L7:;
   v3reply = cl_read(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
   T0 = ecl_symbol_name(v3reply);
   if (Null(cl_string_equal(2, T0, VV[14]))){
    goto L12;
   }
   value0 = ECL_T;
   cl_env_copy->nvalues = 1;
   return value0;
L12:;
   T0 = ecl_symbol_name(v3reply);
   if (Null(cl_string_equal(2, T0, VV[15]))){
    goto L11;
   }
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L11:;
L5:;
   goto L4;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* function definition for YES-OR-NO-P                                        */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object cl_yes_or_no_p(cl_narg narg, ...)
{
 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);
 {
  cl_object v1string;
  cl_object v2args;
  ecl_va_list args; ecl_va_start(args,narg,narg,0);
  {
   int i = 0;
   if (i >= narg) {
    v1string = ECL_NIL;
   } else {
    i++;
    v1string = ecl_va_arg(args);
   }
  }
  v2args = cl_grab_rest_args(args);
  ecl_va_end(args);
  {
   cl_object v3reply;
   v3reply = ECL_NIL;
   goto L5;
L4:;
   if (Null(v1string)){
    goto L7;
   }
   cl_format(4, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)), VV[16], v1string, v2args);
L7:;
   v3reply = cl_read(1, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*QUERY-IO*",61)));
   T0 = ecl_symbol_name(v3reply);
   if (Null(cl_string_equal(2, T0, VV[17]))){
    goto L12;
   }
   value0 = ECL_T;
   cl_env_copy->nvalues = 1;
   return value0;
L12:;
   T0 = ecl_symbol_name(v3reply);
   if (Null(cl_string_equal(2, T0, VV[18]))){
    goto L11;
   }
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
L11:;
L5:;
   goto L4;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* function definition for SHARP-A-READER                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L330sharp_a_reader(cl_object v1stream, cl_object v2subchar, cl_object v3arg)
{
 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 v4initial_contents;
  v4initial_contents = cl_read(4, v1stream, ECL_NIL, ECL_NIL, ECL_T);
  if (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*READ-SUPPRESS*",66)))){
   goto L3;
  }
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L3:;
  if (!(v3arg==ECL_NIL)){
   goto L5;
  }
  {
   cl_object v5;
   cl_object v6;
   cl_object v7;
   v5 = ecl_car(v4initial_contents);
   v6 = ecl_cadr(v4initial_contents);
   v7 = ecl_caddr(v4initial_contents);
   value0 = cl_make_array(5, v6, ECL_SYM("ELEMENT-TYPE",1255), v5, ECL_SYM("INITIAL-CONTENTS",1287), v7);
   return value0;
  }
L5:;
  {
   cl_fixnum v8i;
   cl_object v9d;
   cl_object v10ic;
   v8i = (cl_fixnum)(0);
   v9d = ECL_NIL;
   v10ic = v4initial_contents;
   goto L15;
L14:;
   {
    cl_object v11;
    v11 = ecl_make_integer((v8i)+1);
    {
     bool v12;
     v12 = ECL_FIXNUMP(v11);
     if (ecl_unlikely(!(v12)))
         FEwrong_type_argument(ECL_SYM("FIXNUM",374),v11);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
    }
    v8i = ecl_fixnum(v11);
   }
   {
    cl_fixnum v11;
    v11 = ecl_length(v10ic);
    v9d = CONS(ecl_make_fixnum(v11),v9d);
   }
   {
    cl_fixnum v11;
    v11 = ecl_length(v10ic);
    if (!((v11)==0)){
     goto L25;
    }
   }
   goto L24;
L25:;
   v10ic = ecl_elt(v10ic,(cl_fixnum)(0));
L24:;
L15:;
   if (ecl_greatereq(ecl_make_fixnum(v8i),v3arg)) {
    goto L27;
   }
   goto L14;
L27:;
   T0 = cl_nreverse(v9d);
   value0 = cl_make_array(3, T0, ECL_SYM("INITIAL-CONTENTS",1287), v4initial_contents);
   return value0;
  }
 }
}
static cl_object L330sharp_a_reader_va(cl_narg narg, cl_object v11stream, cl_object v12subchar, cl_object v13arg, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[19]);
 {
  return L330sharp_a_reader(v11stream, v12subchar, v13arg);
 }
}
/* function definition for SHARP-S-READER                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object L331sharp_s_reader(cl_object v1stream, cl_object v2subchar, cl_object v3arg)
{
 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(v3arg)){
  goto L2;
 }
 if (!(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*READ-SUPPRESS*",66))==ECL_NIL)){
  goto L2;
 }
 cl_error(2, VV[20], v3arg);
L2:;
 {
  cl_object v4l;
  v4l = cl_read(4, v1stream, ECL_T, ECL_NIL, ECL_T);
  if (Null(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*READ-SUPPRESS*",66)))){
   goto L6;
  }
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L6:;
  T0 = ecl_car(v4l);
  if (si_get_sysprop(T0, VV[21])!=ECL_NIL) {
   goto L8;
  }
  T0 = ecl_car(v4l);
  cl_error(2, VV[22], T0);
L8:;
  {
   cl_object v5ll;
   v5ll = ecl_cdr(v4l);
   goto L13;
L12:;
   {
    cl_object v6;
    v6 = v5ll;
    if (ecl_unlikely(ECL_ATOM(v6))) FEtype_error_cons(v6);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    T0 = v6;
   }
   T1 = ecl_car(v5ll);
   T2 = cl_string(T1);
   T3 = cl_intern(2, T2, ECL_SYM("KEYWORD",451));
   (ECL_CONS_CAR(T0)=T3,T0);
   v5ll = ecl_cddr(v5ll);
L13:;
   if (ecl_endp(v5ll)) {
    goto L21;
   }
   goto L12;
L21:;
   {
    cl_object v6cs;
    T0 = ecl_car(v4l);
    v6cs = si_get_sysprop(T0, VV[23]);
    goto L26;
L25:;
    T0 = ecl_car(v6cs);
    if (!(ECL_SYMBOLP(T0))){
     goto L28;
    }
    T0 = ecl_car(v6cs);
    T1 = ecl_cdr(v4l);
    value0 = cl_apply(2, T0, T1);
    return value0;
L28:;
    v6cs = ecl_cdr(v6cs);
L26:;
    if (ecl_endp(v6cs)) {
     goto L32;
    }
    goto L25;
L32:;
    T0 = ecl_car(v4l);
    value0 = cl_error(2, VV[24], T0);
    return value0;
   }
  }
 }
}
static cl_object L331sharp_s_reader_va(cl_narg narg, cl_object v7stream, cl_object v8subchar, cl_object v9arg, ...)
{
 if (ecl_unlikely(narg!=3)) FEwrong_num_arguments(VV[25]);
 {
  return L331sharp_s_reader(v7stream, v8subchar, v9arg);
 }
}
/* function definition for DRIBBLE                                            */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object cl_dribble(cl_narg narg, ...)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 cl_object CLV0, CLV1, CLV2, CLV3, CLV4;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 if (ecl_unlikely(narg>1)) FEwrong_num_arguments(ECL_SYM("DRIBBLE",321));
 {
  cl_object v1pathname;
  cl_object v2psp;
  va_list args; va_start(args,narg);
  {
   int i = 0;
   if (i >= narg) {
    v1pathname = VV[27];
    v2psp = ECL_NIL;
   } else {
    i++;
    v1pathname = va_arg(args,cl_object);
    v2psp = ECL_T;
   }
  }
  va_end(args);
  if (Null(ecl_cmp_symbol_value(cl_env_copy,VV[26]))){
   goto L3;
  }
  ecl_function_dispatch(cl_env_copy,ecl_cmp_symbol_value(cl_env_copy,VV[26]))(1, v2psp);
  goto L2;
L3:;
  if (!(v2psp==ECL_NIL)){
   goto L5;
  }
  cl_error(1, VV[28]);
  goto L2;
L5:;
  {
   cl_object v3closure;
   cl_object env1 = env0;
   T0 = cl_namestring(v1pathname);
   env1 = ECL_NIL;
   CLV0 = env1 = CONS(T0,env1);                   /*  NAMESTRING              */
   T0 = cl_open(7, v1pathname, ECL_SYM("DIRECTION",1249), ECL_SYM("OUTPUT",1319), ECL_SYM("IF-EXISTS",1279), ECL_SYM("SUPERSEDE",1351), ECL_SYM("IF-DOES-NOT-EXIST",1277), ECL_SYM("CREATE",1244));
   CLV1 = env1 = CONS(T0,env1);                   /*  STREAM                  */
   T0 = cl_make_echo_stream(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*TERMINAL-IO*",70)), ECL_CONS_CAR(CLV1));
   T1 = cl_make_broadcast_stream(2, ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*TERMINAL-IO*",70)), ECL_CONS_CAR(CLV1));
   T2 = cl_make_two_way_stream(T0, T1);
   CLV2 = env1 = CONS(T2,env1);                   /*  DRIBBLE-STREAM          */
   CLV3 = env1 = CONS(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*STANDARD-INPUT*",68)),env1); /*  STANDARD-INPUT */
   CLV4 = env1 = CONS(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*STANDARD-OUTPUT*",69)),env1); /*  STANDARD-OUTPUT */
   {
    cl_object v4;
    v4 = ecl_make_cclosure_va((cl_objectfn)LC332__lambda102,env1,Cblock,1);
    v3closure = v4;
   }
   {
    cl_object v4;                                 /*  SEC                     */
    cl_object v5;                                 /*  MIN                     */
    cl_object v6;                                 /*  HOUR                    */
    cl_object v7;                                 /*  DAY                     */
    cl_object v8;                                 /*  MONTH                   */
    cl_object v9;                                 /*  YEAR                    */
    value0 = cl_get_decoded_time();
    {
     v4 = value0;
     v5 = cl_env_copy->values[1];
     v6 = cl_env_copy->values[2];
     v7 = cl_env_copy->values[3];
     v8 = cl_env_copy->values[4];
     v9 = cl_env_copy->values[5];
    }
    cl_format(9, ECL_CONS_CAR(CLV2), VV[33], ECL_CONS_CAR(CLV0), v9, v8, v7, v6, v5, v4);
    T0 = ECL_CONS_CAR(CLV2);
    ecl_cmp_setq(cl_env_copy,ECL_SYM("*STANDARD-INPUT*",68),T0);
    T0 = ECL_CONS_CAR(CLV2);
    ecl_cmp_setq(cl_env_copy,ECL_SYM("*STANDARD-OUTPUT*",69),T0);
    T0 = v3closure;
    ecl_cmp_setq(cl_env_copy,VV[26],T0);
   }
  }
L2:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 0;
  return value0;
 }
}
/* local function WITH-STANDARD-IO-SYNTAX                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC333with_standard_io_syntax(cl_object v1, cl_object v2)
{
 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 v3;
  v3 = ecl_cdr(v1);
  T0 = cl_listX(4, ECL_SYM("PROGV",676), VV[35], VV[36], v3);
  value0 = cl_list(3, ECL_SYM("LET",479), VV[34], T0);
  return value0;
 }
}
static cl_object LC333with_standard_io_syntax_va(cl_narg narg, cl_object v4, cl_object v5, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[37]);
 {
  return LC333with_standard_io_syntax(v4, v5);
 }
}
/* local function WITH-ECL-IO-SYNTAX                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC334with_ecl_io_syntax(cl_object v1, cl_object v2)
{
 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 v3;
  v3 = ecl_cdr(v1);
  T0 = cl_listX(4, ECL_SYM("PROGV",676), VV[39], VV[40], v3);
  value0 = cl_list(3, ECL_SYM("LET",479), VV[38], T0);
  return value0;
 }
}
static cl_object LC334with_ecl_io_syntax_va(cl_narg narg, cl_object v4, cl_object v5, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[41]);
 {
  return LC334with_ecl_io_syntax(v4, v5);
 }
}
/* local function PRINT-UNREADABLE-OBJECT                                     */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC335print_unreadable_object(cl_object v1, cl_object v2)
{
 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 v3;
  cl_object v4;
  cl_object v5;
  cl_object v6object;
  cl_object v7stream;
  cl_object v8;
  cl_object v9type;
  cl_object v10;
  cl_object v11identity;
  v3 = ecl_cdr(v1);
  if (!(v3==ECL_NIL)){
   goto L4;
  }
  si_dm_too_few_arguments(v1);
L4:;
  {
   cl_object v12;
   v12 = ecl_car(v3);
   v3 = ecl_cdr(v3);
   v4 = v12;
  }
  v5 = v4;
  if (!(v5==ECL_NIL)){
   goto L11;
  }
  si_dm_too_few_arguments(v1);
L11:;
  {
   cl_object v12;
   v12 = ecl_car(v5);
   v5 = ecl_cdr(v5);
   v6object = v12;
  }
  if (!(v5==ECL_NIL)){
   goto L17;
  }
  si_dm_too_few_arguments(v1);
L17:;
  {
   cl_object v12;
   v12 = ecl_car(v5);
   v5 = ecl_cdr(v5);
   v7stream = v12;
  }
  v8 = si_search_keyword(v5, ECL_SYM("TYPE",1356));
  if (!((v8)==(ECL_SYM("MISSING-KEYWORD",2044)))){
   goto L24;
  }
  v9type = ECL_NIL;
  goto L23;
L24:;
  v9type = v8;
L23:;
  v10 = si_search_keyword(v5, VV[42]);
  if (!((v10)==(ECL_SYM("MISSING-KEYWORD",2044)))){
   goto L28;
  }
  v11identity = ECL_NIL;
  goto L27;
L28:;
  v11identity = v10;
L27:;
  si_check_keyword(2, v5, VV[43]);
  if (Null(v3)){
   goto L31;
  }
  T0 = cl_listX(3, VV[44], ECL_NIL, v3);
  T1 = ecl_list1(T0);
  T2 = cl_list(6, ECL_SYM("PRINT-UNREADABLE-OBJECT-FUNCTION",1918), v6object, v7stream, v9type, v11identity, VV[45]);
  value0 = cl_list(3, ECL_SYM("FLET",375), T1, T2);
  return value0;
L31:;
  value0 = cl_list(6, ECL_SYM("PRINT-UNREADABLE-OBJECT-FUNCTION",1918), v6object, v7stream, v9type, v11identity, ECL_NIL);
  return value0;
 }
}
static cl_object LC335print_unreadable_object_va(cl_narg narg, cl_object v12, cl_object v13, ...)
{
 if (ecl_unlikely(narg!=2)) FEwrong_num_arguments(VV[46]);
 {
  return LC335print_unreadable_object(v12, v13);
 }
}
/* closure ALL-ENCODINGS                                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC336all_encodings(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;                                     /*  ALL-ENCODINGS           */
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=0)) FEwrong_num_arguments(ECL_SYM("ALL-ENCODINGS",1775));
 {
L1:;
  value0 = ECL_CONS_CAR(CLV1);
  if (value0!=ECL_NIL) {
   goto L3;
  }
  ECL_CONS_CAR(CLV1) = ECL_CONS_CAR(CLV0);
  {
   cl_object v1;
   v1 = cl_directory(1, VV[47]);
   goto L11;
L10:;
   {
    cl_object v2i;
    v2i = ecl_car(v1);
    T0 = cl_pathname_name(1, v2i);
    T1 = cl_string_upcase(1, T0);
    T2 = cl_intern(2, T1, VV[48]);
    ECL_CONS_CAR(CLV1) = CONS(T2,ECL_CONS_CAR(CLV1));
   }
   v1 = ecl_cdr(v1);
L11:;
   if (Null(v1)){
    goto L19;
   }
   goto L10;
L19:;
  }
  value0 = ECL_CONS_CAR(CLV1);
  cl_env_copy->nvalues = 1;
  return value0;
L3:;
  cl_env_copy->nvalues = 1;
  return value0;
 }
 }
}
/* function definition for LOAD-ENCODING                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_load_encoding(cl_object volatile v1name)
{
 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:;
 {
  volatile cl_object v2;
  volatile cl_object v3filename;
  T0 = ecl_symbol_name(v1name);
  v2 = cl_make_pathname(4, ECL_SYM("NAME",1309), T0, ECL_SYM("DEFAULTS",1247), VV[49]);
  ecl_bds_bind(cl_env_copy,ECL_SYM("*DEFAULT-EXTERNAL-FORMAT*",1872),ECL_T); /*  *DEFAULT-EXTERNAL-FORMAT* */
  v3filename = v2;
  if (Null(cl_probe_file(v3filename))){
   goto L4;
  }
  cl_load(3, v3filename, ECL_SYM("VERBOSE",1363), ECL_NIL);
  value0 = v1name;
  cl_env_copy->nvalues = 1;
  ecl_bds_unwind1(cl_env_copy);
  return value0;
L4:;
  v3filename = cl_make_pathname(4, ECL_SYM("TYPE",1356), VV[50], ECL_SYM("DEFAULTS",1247), v3filename);
  if (Null(cl_probe_file(v3filename))){
   goto L7;
  }
  {
   volatile cl_object v4in;
   v4in = cl_open(5, v3filename, ECL_SYM("ELEMENT-TYPE",1255), VV[51], ECL_SYM("EXTERNAL-FORMAT",1267), ECL_SYM("BIG-ENDIAN",1778));
   {
    struct ecl_stack_frame _ecl_inner_frame_aux;
    volatile cl_object _ecl_inner_frame=ecl_stack_frame_open(cl_env_copy,(cl_object)&_ecl_inner_frame_aux,0);
    volatile bool unwinding = FALSE;
    ecl_frame_ptr next_fr;
    {
     ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG);
     if (__ecl_frs_push_result!=0) {
       unwinding = TRUE; next_fr=cl_env_copy->frs_stack.nlj_fr;
     } else {
     {
      struct ecl_stack_frame _ecl_inner_frame_aux;
      volatile cl_object _ecl_inner_frame=ecl_stack_frame_open(cl_env_copy,(cl_object)&_ecl_inner_frame_aux,0);
      {
       cl_object v5l;
       cl_object v6s;
       v5l = cl_read_byte(1, v4in);
       T0 = si_make_pure_array(ECL_SYM("BYTE16",1369), v5l, ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_int8_t(0));
       v6s = si_fill_array_with_elt(T0, ecl_make_int8_t(0), ecl_make_int8_t(0), ECL_NIL);
       cl_read_sequence(2, v6s, v4in);
       cl_env_copy->values[0] = v6s;
       cl_env_copy->nvalues = 1;
      }
      ecl_stack_frame_push_values(_ecl_inner_frame);
      if (Null(v4in)){
       goto L16;
      }
      cl_close(1, v4in);
L16:;
      ecl_stack_frame_pop_values(_ecl_inner_frame);
      ecl_stack_frame_close(_ecl_inner_frame);
     }
     }
    }
    ecl_frs_pop(cl_env_copy);
    ecl_stack_frame_push_values(_ecl_inner_frame);
    if (Null(v4in)){
     goto L18;
    }
    cl_close(3, v4in, ECL_SYM("ABORT",1225), ECL_T);
L18:;
    ecl_stack_frame_pop_values(_ecl_inner_frame);
    if (unwinding) ecl_unwind(cl_env_copy,next_fr);
    ecl_stack_frame_close(_ecl_inner_frame);
    ecl_bds_unwind1(cl_env_copy);
    return cl_env_copy->values[0];
   }
  }
L7:;
  value0 = cl_error(3, VV[52], v3filename, v1name);
  ecl_bds_unwind1(cl_env_copy);
  return value0;
 }
}
/* function definition for MAKE-ENCODING                                      */
/* optimize speed 1, debug 1, space 1, safety 2                               */
cl_object si_make_encoding(cl_object v1mapping)
{
 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:;
 if (!(ECL_SYMBOLP(v1mapping))){
  goto L2;
 }
 {
  cl_object v2var;
  T0 = ecl_symbol_name(v1mapping);
  T1 = cl_find_package(VV[53]);
  v2var = cl_intern(2, T0, T1);
  if (ecl_boundp(cl_env_copy,v2var)) {
   goto L5;
  }
  T0 = si_load_encoding(v1mapping);
  T1 = si_make_encoding(T0);
  cl_set(v2var, T1);
L5:;
  value0 = cl_symbol_value(v2var);
  return value0;
 }
L2:;
 if (!(ECL_CONSP(v1mapping))){
  goto L7;
 }
 {
  cl_object v3output;
  v3output = cl_make_hash_table(4, ECL_SYM("SIZE",1345), ecl_make_fixnum(512), ECL_SYM("TEST",1353), ECL_SYM("EQ",335));
  {
   cl_object v4;
   v4 = v1mapping;
   goto L13;
L12:;
   {
    cl_object v5record;
    v5record = ecl_car(v4);
    {
     cl_object v6byte;
     cl_object v7unicode;
     cl_object v8unicode_char;
     v6byte = ecl_car(v5record);
     v7unicode = ecl_cdr(v5record);
     v8unicode_char = cl_code_char(v7unicode);
     if (!(ecl_greater(v6byte,ecl_make_uint8_t(255)))){
      goto L21;
     }
     T0 = cl_ash(v6byte, ecl_make_int8_t(-8));
     si_hash_set(T0, v3output, ECL_T);
L21:;
     si_hash_set(v6byte, v3output, v8unicode_char);
     si_hash_set(v8unicode_char, v3output, v6byte);
    }
   }
   v4 = ecl_cdr(v4);
L13:;
   if (Null(v4)){
    goto L26;
   }
   goto L12;
L26:;
   value0 = v3output;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
L7:;
 if (!(ECL_ARRAYP(v1mapping))){
  goto L28;
 }
 {
  cl_object v5l;
  cl_object v6output;
  cl_object v7i;
  v5l = cl_array_total_size(v1mapping);
  T0 = ecl_times(_ecl_static_1,v5l);
  T1 = ecl_floor1(T0);
  v6output = cl_make_hash_table(4, ECL_SYM("SIZE",1345), T1, ECL_SYM("TEST",1353), ECL_SYM("EQ",335));
  v7i = ecl_make_int8_t(0);
  goto L35;
L34:;
  {
   cl_object v8byte;
   cl_object v9unicode;
   cl_object v10unicode_char;
   {
    cl_object v11;
    v11 = v1mapping;
    T0 = v11;
    {
     cl_object v12;
     v12 = v7i;
     if (ecl_unlikely((ecl_fixnum(v12))>=(v11)->vector.dim))
           FEwrong_index(ECL_NIL,v11,-1,ecl_make_fixnum(ecl_fixnum(v12)),(v11)->vector.dim);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     T1 = v12;
    }
    v8byte = ecl_aref_unsafe(T0,ecl_fixnum(T1));
   }
   {
    cl_object v11;
    v11 = v1mapping;
    T0 = v11;
    {
     cl_object v12;
     v12 = ecl_one_plus(v7i);
     if (ecl_unlikely((ecl_fixnum(v12))>=(v11)->vector.dim))
           FEwrong_index(ECL_NIL,v11,-1,ecl_make_fixnum(ecl_fixnum(v12)),(v11)->vector.dim);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     T1 = v12;
    }
    v9unicode = ecl_aref_unsafe(T0,ecl_fixnum(T1));
   }
   v10unicode_char = cl_code_char(v9unicode);
   if (!(ecl_greater(v8byte,ecl_make_uint8_t(255)))){
    goto L53;
   }
   T0 = cl_ash(v8byte, ecl_make_int8_t(-8));
   si_hash_set(T0, v6output, ECL_T);
L53:;
   si_hash_set(v8byte, v6output, v10unicode_char);
   si_hash_set(v10unicode_char, v6output, v8byte);
  }
  v7i = ecl_plus(ecl_make_int8_t(2),v7i);
L35:;
  if (ecl_greatereq(v7i,v5l)) {
   goto L58;
  }
  goto L34;
L58:;
  value0 = v6output;
  cl_env_copy->nvalues = 1;
  return value0;
 }
L28:;
 value0 = cl_error(2, VV[56], v1mapping);
 return value0;
}
/* closure LAMBDA102                                                          */
/* optimize speed 1, debug 1, space 1, safety 2                               */
static cl_object LC332__lambda102(cl_narg narg, cl_object v1pathname_p, ...)
{
 cl_object T0;
 cl_object CLV0, CLV1, CLV2, CLV3, CLV4;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object env0 = cl_env_copy->function->cclosure.env;
 cl_object value0;
 ecl_cs_check(cl_env_copy,value0);
 /* Scanning closure data ... */
 CLV4 = env0;                                     /*  STANDARD-OUTPUT         */
 CLV3 = _ecl_cdr(CLV4);
 CLV2 = _ecl_cdr(CLV3);
 CLV1 = _ecl_cdr(CLV2);
 CLV0 = _ecl_cdr(CLV1);
 { /* ... closure scanning finished */
 if (ecl_unlikely(narg!=1)) FEwrong_num_arguments(VV[29]);
 {
L1:;
  if (Null(v1pathname_p)){
   goto L2;
  }
  cl_error(2, VV[30], ECL_CONS_CAR(CLV0));
L2:;
  if (!((ECL_CONS_CAR(CLV2))==(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*STANDARD-INPUT*",68))))){
   goto L7;
  }
  if ((ECL_CONS_CAR(CLV2))==(ecl_cmp_symbol_value(cl_env_copy,ECL_SYM("*STANDARD-OUTPUT*",69)))) {
   goto L4;
  }
  goto L5;
L7:;
  goto L5;
L5:;
  (cl_env_copy->function=(ECL_SYM("WARN",907)->symbol.gfdef))->cfun.entry(1, VV[31]) /*  WARN */;
L4:;
  cl_format(3, ECL_CONS_CAR(CLV1), VV[32], ECL_CONS_CAR(CLV0));
  cl_close(1, ECL_CONS_CAR(CLV1));
  T0 = ECL_CONS_CAR(CLV3);
  ecl_cmp_setq(cl_env_copy,ECL_SYM("*STANDARD-INPUT*",68),T0);
  T0 = ECL_CONS_CAR(CLV4);
  ecl_cmp_setq(cl_env_copy,ECL_SYM("*STANDARD-OUTPUT*",69),T0);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[26],T0);
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
 }
}
#include "lsp/iolib.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _eclBNvFYahOJwDj9_nigzL881(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;IOLIB.LSP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclBNvFYahOJwDj9_nigzL881@";
 VVtemp = Cblock->cblock.temp_data;
 ECL_DEFINE_SETF_FUNCTIONS
 {
  cl_object T0;
  cl_object volatile env0 = ECL_NIL;
  cl_object volatile CLV0, CLV1;
/* MAKE-LOAD-FORMs                                                            */
/* TOP-LEVEL-FORMs                                                            */
  si_select_package(VVtemp[0]);
  ecl_cmp_defmacro(VV[57]);                       /*  WITH-OPEN-STREAM        */
  ecl_cmp_defmacro(VV[58]);                       /*  WITH-INPUT-FROM-STRING  */
  ecl_cmp_defmacro(VV[59]);                       /*  WITH-OUTPUT-TO-STRING   */
  (void)0; /* No entry created for READ-FROM-STRING */
  (void)0; /* No entry created for STRING-TO-OBJECT */
  (void)0; /* No entry created for WRITE-TO-STRING */
  (void)0; /* No entry created for PRIN1-TO-STRING */
  (void)0; /* No entry created for PRINC-TO-STRING */
  ecl_cmp_defmacro(VV[60]);                       /*  WITH-OPEN-FILE          */
  (void)0; /* No entry created for Y-OR-N-P */
  (void)0; /* No entry created for YES-OR-NO-P */
  ecl_cmp_defun(VV[61]);                          /*  SHARP-A-READER          */
  cl_set_dispatch_macro_character(3, ECL_CODE_CHAR(35), ECL_CODE_CHAR(97), ECL_SYM("SHARP-A-READER",1160));
  cl_set_dispatch_macro_character(3, ECL_CODE_CHAR(35), ECL_CODE_CHAR(65), ECL_SYM("SHARP-A-READER",1160));
  ecl_cmp_defun(VV[62]);                          /*  SHARP-S-READER          */
  cl_set_dispatch_macro_character(3, ECL_CODE_CHAR(35), ECL_CODE_CHAR(115), ECL_SYM("SHARP-S-READER",1161));
  cl_set_dispatch_macro_character(3, ECL_CODE_CHAR(35), ECL_CODE_CHAR(83), ECL_SYM("SHARP-S-READER",1161));
  si_Xmake_special(VV[26]);
  T0 = ECL_NIL;
  ecl_cmp_setq(cl_env_copy,VV[26],T0);
  (void)0; /* No entry created for DRIBBLE */
  ecl_cmp_defmacro(VV[63]);                       /*  WITH-STANDARD-IO-SYNTAX */
  ecl_cmp_defmacro(VV[64]);                       /*  WITH-ECL-IO-SYNTAX      */
  ecl_cmp_defmacro(VV[65]);                       /*  PRINT-UNREADABLE-OBJECT */
  {
   cl_object env1 = env0;
   env1 = ECL_NIL;
   CLV0 = env1 = CONS(VVtemp[1],env1);            /*  BASIC-ENCODINGS         */
   CLV1 = env1 = CONS(ECL_NIL,env1);              /*  ALL-ENCODINGS           */
   {
    cl_object v1;
    v1 = ecl_make_cclosure_va((cl_objectfn)LC336all_encodings,env1,Cblock,0);
    T0 = v1;
   }
   si_fset(2, ECL_SYM("ALL-ENCODINGS",1775), T0);
  }
  (void)0; /* No entry created for LOAD-ENCODING */
  (void)0; /* No entry created for MAKE-ENCODING */
 }
}
