/* Compiler: ECL 26.3.27                                                      */
/* Source: /build/ecl/src/ecl-26.3.27/contrib/deflate/deflate.lisp            */
#include <ecl/ecl-cmp.h>
#include "ext/deflate.eclh"
/* local function LAMBDA0                                                     */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object LC5434__lambda0()
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 {
  cl_object v1;
  v1 = ecl_make_cfun_va((cl_objectfn)LC5433__lambda2_va,ECL_NIL,Cblock,2);
  value0 = v1;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC5434__lambda0_va(cl_narg narg, ...)
{
 return LC5434__lambda0();
}
/* local function LAMBDA4                                                     */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object LC5436__lambda4()
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 {
  cl_object v1;
  v1 = ecl_make_cfun_va((cl_objectfn)LC5435__lambda6_va,ECL_NIL,Cblock,2);
  value0 = v1;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC5436__lambda4_va(cl_narg narg, ...)
{
 return LC5436__lambda4();
}
/* local function LAMBDA8                                                     */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object LC5438__lambda8()
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 {
  cl_object v1;
  v1 = ecl_make_cfun_va((cl_objectfn)LC5437__lambda10_va,ECL_NIL,Cblock,2);
  value0 = v1;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object LC5438__lambda8_va(cl_narg narg, ...)
{
 return LC5438__lambda8();
}
/* function definition for UPDATE-ADLER32-CHECKSUM                            */
/* optimize speed 3, debug 0, space 0, safety 0                               */
static cl_object L5439update_adler32_checksum(cl_object v1crc, cl_object v2buffer, cl_object v3end)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 cl_fixnum v4crc;
 cl_fixnum v5end;
 v4crc = ecl_fixnum(v1crc);
 v5end = ecl_fixnum(v3end);
L1:;
 {
  cl_fixnum v6;
  cl_fixnum v7;
  cl_fixnum v8s1;
  cl_fixnum v9s2;
  T0 = cl_ash(ecl_make_fixnum(v4crc), ecl_make_int8_t(0));
  v6 = ecl_fixnum(ecl_boole(ECL_BOOLAND,(ecl_make_fixnum(65535)),(T0)));
  T0 = cl_ash(ecl_make_fixnum(v4crc), ecl_make_int8_t(-16));
  v7 = ecl_fixnum(ecl_boole(ECL_BOOLAND,(ecl_make_fixnum(65535)),(T0)));
  v8s1 = v6;
  v9s2 = v7;
  {
   cl_fixnum v10i;
   v10i = (cl_fixnum)(0);
   goto L9;
L8:;
   T0 = ecl_make_uint8_t((v2buffer)->vector.self.b8[v10i]);
   T1 = ecl_plus(ecl_make_fixnum(v8s1),T0);
   v8s1 = ecl_fixnum((ecl_floor2(T1,ECL_SYM_VAL(cl_env_copy,VV[14])),cl_env_copy->values[1]));
   T0 = ecl_plus(ecl_make_fixnum(v9s2),ecl_make_fixnum(v8s1));
   v9s2 = ecl_fixnum((ecl_floor2(T0,ECL_SYM_VAL(cl_env_copy,VV[14])),cl_env_copy->values[1]));
   v10i = (v10i)+1;
L9:;
   if (!((v10i)<(v5end))){
    goto L18;
   }
   goto L8;
L18:;
  }
  T0 = cl_ash(ecl_make_fixnum(v9s2), ecl_make_int8_t(16));
  T1 = ecl_boole(ECL_BOOLAND,(T0),(ecl_make_fixnum(4294901760)));
  {
   cl_fixnum v10;
   v10 = ((v8s1) & ~(4294901760));
   value0 = ecl_boole(ECL_BOOLIOR,(T1),(ecl_make_fixnum(v10)));
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
static cl_object L5439update_adler32_checksum_va(cl_narg narg, cl_object v10crc, cl_object v11buffer, cl_object v12end, ...)
{
 return L5439update_adler32_checksum(v10crc, v11buffer, v12end);
}
/* function definition for GENERATE-CRC32-TABLE                               */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5440generate_crc32_table()
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 {
  cl_object v1result;
  v1result = si_make_vector(ECL_SYM("BYTE32",1370), ecl_make_fixnum(256), ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_int8_t(0));
  {
   cl_object v2;
   v2 = ecl_make_fixnum((v1result)->vector.fillp);
   {
    cl_fixnum v3i;
    v3i = (cl_fixnum)(0);
    goto L7;
L6:;
    {
     cl_object v4cur;
     v4cur = ecl_make_fixnum(v3i);
     {
      cl_fixnum v5k;
      v5k = (cl_fixnum)(0);
      goto L14;
L13:;
      T0 = ecl_boole(ECL_BOOLAND,(v4cur),(ecl_make_int8_t(1)));
      if (!(ecl_number_equalp(ecl_make_int8_t(1),T0))){
       goto L18;
      }
      T0 = ecl_ash(v4cur,(cl_fixnum)(-1));
      v4cur = ecl_boole(ECL_BOOLXOR,(T0),(ECL_SYM_VAL(cl_env_copy,VV[20])));
      goto L17;
L18:;
      v4cur = ecl_ash(v4cur,(cl_fixnum)(-1));
L17:;
      v5k = (v5k)+1;
L14:;
      if (!((v5k)<((cl_fixnum)(8)))){
       goto L22;
      }
      goto L13;
L22:;
     }
     (v1result)->vector.self.b32[v3i]= ecl_fixnum(v4cur);
    }
    v3i = (v3i)+1;
L7:;
    if (!((v3i)<(ecl_fixnum(v2)))){
     goto L26;
    }
    goto L6;
L26:;
    value0 = v1result;
    cl_env_copy->nvalues = 1;
    return value0;
   }
  }
 }
}
static cl_object L5440generate_crc32_table_va(cl_narg narg, ...)
{
 return L5440generate_crc32_table();
}
/* function definition for UPDATE-CRC32-CHECKSUM                              */
/* optimize speed 3, debug 0, space 0, safety 0                               */
static cl_object L5441update_crc32_checksum(cl_object v1crc, cl_object v2buffer, cl_object v3end)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 cl_fixnum v4crc;
 cl_fixnum v5end;
 v4crc = ecl_fixnum(v1crc);
 v5end = ecl_fixnum(v3end);
L1:;
 {
  cl_fixnum v6;
  cl_fixnum v7cur;
  v6 = ((v4crc) ^ (4294967295));
  v7cur = v6;
  {
   cl_fixnum v8i;
   v8i = (cl_fixnum)(0);
   goto L7;
L6:;
   {
    uint8_t v9index;
    T0 = ecl_make_uint8_t((v2buffer)->vector.self.b8[v8i]);
    {
     cl_fixnum v10;
     v10 = ((v7cur) ^ (ecl_fixnum(T0)));
     v9index = (uint8_t)((((cl_fixnum)(255)) & (v10)));
    }
    T0 = ecl_make_uint32_t((VV[25])->vector.self.b32[(cl_fixnum)(v9index)]);
    T1 = ecl_ash(ecl_make_fixnum(v7cur),(cl_fixnum)(-8));
    v7cur = ecl_fixnum(ecl_boole(ECL_BOOLXOR,(T0),(T1)));
   }
   v8i = (v8i)+1;
L7:;
   if (!((v8i)<(v5end))){
    goto L16;
   }
   goto L6;
L16:;
  }
  value0 = ecl_make_fixnum(((v7cur) ^ (4294967295)));
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L5441update_crc32_checksum_va(cl_narg narg, cl_object v8crc, cl_object v9buffer, cl_object v10end, ...)
{
 return L5441update_crc32_checksum(v8crc, v9buffer, v10end);
}
/* function definition for MAKE-SLIDING-WINDOW-STREAM                         */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5442make_sliding_window_stream(cl_narg narg, ...)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 cl_object v1;
 cl_object v2;
 cl_object v3;
 cl_object v4;
 cl_object v5;
 ecl_va_list args; ecl_va_start(args,narg,narg,0);
 {
  cl_object keyvars[10];
  cl_parse_key(args,5,L5442make_sliding_window_streamkeys,keyvars,NULL,FALSE);
  ecl_va_end(args);
  v1 = keyvars[0];
  if (Null(keyvars[6])) {
   v2 = si_make_vector(ECL_SYM("BYTE8",1368), ecl_make_fixnum(32768), ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_int8_t(0));
  } else {
   v2 = keyvars[1];
  }
  if (Null(keyvars[7])) {
   v3 = ecl_make_int8_t(0);
  } else {
   v3 = keyvars[2];
  }
  v4 = keyvars[3];
  if (Null(keyvars[9])) {
   v5 = ecl_make_int8_t(0);
  } else {
   v5 = keyvars[4];
  }
 }
 {
  cl_fixnum v6;
  v6 = (cl_fixnum)(0);
  if (!(ECL_FIXNUMP(v5))){
   goto L8;
  }
  v6 = ecl_fixnum(v5);
  if (!((v6)<=(4294967295))){
   goto L13;
  }
  if ((v6)>=((cl_fixnum)(0))) {
   goto L4;
  }
  goto L5;
L13:;
  goto L5;
L8:;
  goto L5;
 }
L5:;
 si_structure_type_error(v5, VV[34], VV[29], VV[35]);
L4:;
 if (ECL_SYMBOLP(v4)) {
  goto L15;
 }
 si_structure_type_error(v4, ECL_SYM("SYMBOL",843), VV[29], VV[36]);
L15:;
 if (ECL_FIXNUMP(v3)) {
  goto L17;
 }
 si_structure_type_error(v3, ECL_SYM("FIXNUM",374), VV[29], VV[37]);
L17:;
 if (cl_typep(2, v2, VV[38])!=ECL_NIL) {
  goto L19;
 }
 si_structure_type_error(v2, VV[38], VV[29], VV[39]);
L19:;
 if (cl_streamp(v1)!=ECL_NIL) {
  goto L21;
 }
 si_structure_type_error(v1, ECL_SYM("STREAM",802), VV[29], ECL_SYM("STREAM",802));
L21:;
 value0 = si_make_structure(6, VV[40], v1, v2, v3, v4, v5);
 return value0;
}
/* local function LAMBDA83                                                    */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object LC5443__lambda83(cl_object v1, cl_object v2si__x)
{
 cl_object T0, T1, T2, T3;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 {
  cl_object v3;
  cl_object v4;
  v3 = cl_gensym(0);
  v4 = cl_gensym(0);
  T0 = cl_list(2, ECL_SYM("QUOTE",682), VV[29]);
  T1 = cl_list(6, ECL_SYM("COMPARE-AND-SWAP-STRUCTURE",1527), v2si__x, T0, ecl_make_int8_t(4), v3, v4);
  T2 = cl_list(2, ECL_SYM("QUOTE",682), VV[29]);
  T3 = cl_list(4, ECL_SYM("STRUCTURE-REF",1178), v2si__x, T2, ecl_make_int8_t(4));
  cl_env_copy->nvalues = 6;
  cl_env_copy->values[5] = T3;
  cl_env_copy->values[4] = T1;
  cl_env_copy->values[3] = v4;
  cl_env_copy->values[2] = v3;
  cl_env_copy->values[1] = ECL_NIL;
  cl_env_copy->values[0] = ECL_NIL;
  return cl_env_copy->values[0];
 }
}
static cl_object LC5443__lambda83_va(cl_narg narg, cl_object v5, cl_object v6si__x, ...)
{
 return LC5443__lambda83(v5, v6si__x);
}
/* local function LAMBDA88                                                    */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object LC5444__lambda88(cl_object v1, cl_object v2si__x)
{
 cl_object T0, T1, T2, T3;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 {
  cl_object v3;
  cl_object v4;
  v3 = cl_gensym(0);
  v4 = cl_gensym(0);
  T0 = cl_list(2, ECL_SYM("QUOTE",682), VV[29]);
  T1 = cl_list(6, ECL_SYM("COMPARE-AND-SWAP-STRUCTURE",1527), v2si__x, T0, ecl_make_int8_t(2), v3, v4);
  T2 = cl_list(2, ECL_SYM("QUOTE",682), VV[29]);
  T3 = cl_list(4, ECL_SYM("STRUCTURE-REF",1178), v2si__x, T2, ecl_make_int8_t(2));
  cl_env_copy->nvalues = 6;
  cl_env_copy->values[5] = T3;
  cl_env_copy->values[4] = T1;
  cl_env_copy->values[3] = v4;
  cl_env_copy->values[2] = v3;
  cl_env_copy->values[1] = ECL_NIL;
  cl_env_copy->values[0] = ECL_NIL;
  return cl_env_copy->values[0];
 }
}
static cl_object LC5444__lambda88_va(cl_narg narg, cl_object v5, cl_object v6si__x, ...)
{
 return LC5444__lambda88(v5, v6si__x);
}
/* function definition for SLIDING-WINDOW-STREAM-WRITE-BYTE                   */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5445sliding_window_stream_write_byte(cl_object v1stream, cl_object v2byte)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 uint8_t v3byte;
 v3byte = ecl_fixnum(v2byte);
L1:;
 {
  cl_fixnum v4end;
  v4end = ecl_fixnum((cl_env_copy->function=(VV[46]->symbol.gfdef))->cfun.entry(1, v1stream) /*  SLIDING-WINDOW-STREAM-BUFFER-END */);
  if ((v4end)<(ecl_fixnum(ECL_SYM_VAL(cl_env_copy,VV[27])))) {
   goto L3;
  }
  T0 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, v1stream) /*  SLIDING-WINDOW-STREAM-BUFFER */;
  T1 = (cl_env_copy->function=(VV[49]->symbol.gfdef))->cfun.entry(1, v1stream) /*  SLIDING-WINDOW-STREAM-STREAM */;
  cl_write_sequence(2, T0, T1);
  {
   cl_object v5;
   v5 = (cl_env_copy->function=(VV[45]->symbol.gfdef))->cfun.entry(1, v1stream) /*  SLIDING-WINDOW-STREAM-CHECKSUM */;
   if (!((v5)==(VV[51]))){
    goto L8;
   }
   {
    cl_object v6;
    T0 = (cl_env_copy->function=(VV[42]->symbol.gfdef))->cfun.entry(1, v1stream) /*  SLIDING-WINDOW-STREAM-CHECKSUM-VALUE */;
    T1 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, v1stream) /*  SLIDING-WINDOW-STREAM-BUFFER */;
    v6 = L5439update_adler32_checksum(T0, T1, ECL_SYM_VAL(cl_env_copy,VV[27]));
    {
     cl_object v7;
     v7 = v1stream;
     (v7)->instance.slots[(cl_fixnum)(4)]=v6;
     goto L6;
    }
   }
L8:;
   if (!((v5)==(VV[52]))){
    goto L6;
   }
   {
    cl_object v8;
    T0 = (cl_env_copy->function=(VV[42]->symbol.gfdef))->cfun.entry(1, v1stream) /*  SLIDING-WINDOW-STREAM-CHECKSUM-VALUE */;
    T1 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, v1stream) /*  SLIDING-WINDOW-STREAM-BUFFER */;
    v8 = L5441update_crc32_checksum(T0, T1, ECL_SYM_VAL(cl_env_copy,VV[27]));
    {
     cl_object v9;
     v9 = v1stream;
     (v9)->instance.slots[(cl_fixnum)(4)]=v8;
    }
   }
  }
L6:;
  v4end = (cl_fixnum)(0);
L3:;
  {
   cl_object v5;
   v5 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, v1stream) /*  SLIDING-WINDOW-STREAM-BUFFER */;
   ecl_aset_unsafe(v5,v4end,ecl_make_uint8_t(v3byte));
  }
  {
   cl_object v5;
   v5 = ecl_make_integer((v4end)+1);
   {
    cl_object v6;
    v6 = v1stream;
    value0 = (v6)->instance.slots[(cl_fixnum)(2)]=v5;
    cl_env_copy->nvalues = 1;
    return value0;
   }
  }
 }
}
static cl_object L5445sliding_window_stream_write_byte_va(cl_narg narg, cl_object v7stream, cl_object v8byte, ...)
{
 return L5445sliding_window_stream_write_byte(v7stream, v8byte);
}
/* function definition for SLIDING-WINDOW-STREAM-FLUSH                        */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5446sliding_window_stream_flush(cl_object v1stream)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 {
  cl_fixnum v2end;
  v2end = ecl_fixnum((cl_env_copy->function=(VV[46]->symbol.gfdef))->cfun.entry(1, v1stream) /*  SLIDING-WINDOW-STREAM-BUFFER-END */);
  if ((v2end)==0) {
   goto L3;
  }
  {
   cl_object v3;
   v3 = (cl_env_copy->function=(VV[45]->symbol.gfdef))->cfun.entry(1, v1stream) /*  SLIDING-WINDOW-STREAM-CHECKSUM */;
   if (!((v3)==(VV[51]))){
    goto L7;
   }
   {
    cl_object v4;
    T0 = (cl_env_copy->function=(VV[42]->symbol.gfdef))->cfun.entry(1, v1stream) /*  SLIDING-WINDOW-STREAM-CHECKSUM-VALUE */;
    T1 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, v1stream) /*  SLIDING-WINDOW-STREAM-BUFFER */;
    v4 = L5439update_adler32_checksum(T0, T1, ecl_make_fixnum(v2end));
    {
     cl_object v5;
     v5 = v1stream;
     (v5)->instance.slots[(cl_fixnum)(4)]=v4;
     goto L5;
    }
   }
L7:;
   if (!((v3)==(VV[52]))){
    goto L5;
   }
   {
    cl_object v6;
    T0 = (cl_env_copy->function=(VV[42]->symbol.gfdef))->cfun.entry(1, v1stream) /*  SLIDING-WINDOW-STREAM-CHECKSUM-VALUE */;
    T1 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, v1stream) /*  SLIDING-WINDOW-STREAM-BUFFER */;
    v6 = L5441update_crc32_checksum(T0, T1, ecl_make_fixnum(v2end));
    {
     cl_object v7;
     v7 = v1stream;
     (v7)->instance.slots[(cl_fixnum)(4)]=v6;
    }
   }
  }
L5:;
  T0 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, v1stream) /*  SLIDING-WINDOW-STREAM-BUFFER */;
  T1 = (cl_env_copy->function=(VV[49]->symbol.gfdef))->cfun.entry(1, v1stream) /*  SLIDING-WINDOW-STREAM-STREAM */;
  value0 = cl_write_sequence(4, T0, T1, ECL_SYM("END",1256), ecl_make_fixnum(v2end));
  return value0;
L3:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L5446sliding_window_stream_flush_va(cl_narg narg, cl_object v3stream, ...)
{
 return L5446sliding_window_stream_flush(v3stream);
}
/* function definition for SLIDING-WINDOW-STREAM-COPY-BYTES                   */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5447sliding_window_stream_copy_bytes(cl_object v1stream, cl_object v2distance, cl_object v3length)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 cl_fixnum v4distance;
 cl_fixnum v5length;
 v4distance = ecl_fixnum(v2distance);
 v5length = ecl_fixnum(v3length);
L1:;
 {
  cl_fixnum v6end;
  cl_fixnum v7start;
  cl_object v8buffer;
  v6end = ecl_fixnum((cl_env_copy->function=(VV[46]->symbol.gfdef))->cfun.entry(1, v1stream) /*  SLIDING-WINDOW-STREAM-BUFFER-END */);
  T0 = ecl_minus(ecl_make_fixnum(v6end),ecl_make_fixnum(v4distance));
  v7start = ecl_fixnum((ecl_floor2(T0,ECL_SYM_VAL(cl_env_copy,VV[27])),cl_env_copy->values[1]));
  v8buffer = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, v1stream) /*  SLIDING-WINDOW-STREAM-BUFFER */;
  {
   cl_fixnum v9i;
   v9i = (cl_fixnum)(0);
   goto L7;
L6:;
   {
    cl_object v10;
    T0 = ecl_plus(ecl_make_fixnum(v7start),ecl_make_fixnum(v9i));
    T1 = (ecl_floor2(T0,ECL_SYM_VAL(cl_env_copy,VV[27])),cl_env_copy->values[1]);
    v10 = ecl_make_uint8_t((v8buffer)->vector.self.b8[ecl_fixnum(T1)]);
    {
     cl_fixnum v11end;
     v11end = ecl_fixnum((cl_env_copy->function=(VV[46]->symbol.gfdef))->cfun.entry(1, v1stream) /*  SLIDING-WINDOW-STREAM-BUFFER-END */);
     if ((v11end)<(ecl_fixnum(ECL_SYM_VAL(cl_env_copy,VV[27])))) {
      goto L12;
     }
     T0 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, v1stream) /*  SLIDING-WINDOW-STREAM-BUFFER */;
     T1 = (cl_env_copy->function=(VV[49]->symbol.gfdef))->cfun.entry(1, v1stream) /*  SLIDING-WINDOW-STREAM-STREAM */;
     cl_write_sequence(2, T0, T1);
     {
      cl_object v12;
      v12 = (cl_env_copy->function=(VV[45]->symbol.gfdef))->cfun.entry(1, v1stream) /*  SLIDING-WINDOW-STREAM-CHECKSUM */;
      if (!((v12)==(VV[51]))){
       goto L17;
      }
      {
       cl_object v13;
       T0 = (cl_env_copy->function=(VV[42]->symbol.gfdef))->cfun.entry(1, v1stream) /*  SLIDING-WINDOW-STREAM-CHECKSUM-VALUE */;
       T1 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, v1stream) /*  SLIDING-WINDOW-STREAM-BUFFER */;
       v13 = L5439update_adler32_checksum(T0, T1, ECL_SYM_VAL(cl_env_copy,VV[27]));
       {
        cl_object v14;
        v14 = v1stream;
        (v14)->instance.slots[(cl_fixnum)(4)]=v13;
        goto L15;
       }
      }
L17:;
      if (!((v12)==(VV[52]))){
       goto L15;
      }
      {
       cl_object v15;
       T0 = (cl_env_copy->function=(VV[42]->symbol.gfdef))->cfun.entry(1, v1stream) /*  SLIDING-WINDOW-STREAM-CHECKSUM-VALUE */;
       T1 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, v1stream) /*  SLIDING-WINDOW-STREAM-BUFFER */;
       v15 = L5441update_crc32_checksum(T0, T1, ECL_SYM_VAL(cl_env_copy,VV[27]));
       {
        cl_object v16;
        v16 = v1stream;
        (v16)->instance.slots[(cl_fixnum)(4)]=v15;
       }
      }
     }
L15:;
     v11end = (cl_fixnum)(0);
L12:;
     {
      cl_object v12;
      v12 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, v1stream) /*  SLIDING-WINDOW-STREAM-BUFFER */;
      ecl_aset_unsafe(v12,v11end,v10);
     }
     {
      cl_object v12;
      v12 = ecl_make_integer((v11end)+1);
      {
       cl_object v13;
       v13 = v1stream;
       (v13)->instance.slots[(cl_fixnum)(2)]=v12;
      }
     }
    }
   }
   v9i = (v9i)+1;
L7:;
   if (!((v9i)<(v5length))){
    goto L31;
   }
   goto L6;
L31:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
static cl_object L5447sliding_window_stream_copy_bytes_va(cl_narg narg, cl_object v10stream, cl_object v11distance, cl_object v12length, ...)
{
 return L5447sliding_window_stream_copy_bytes(v10stream, v11distance, v12length);
}
/* function definition for MAKE-BIT-STREAM                                    */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5448make_bit_stream(cl_narg narg, ...)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 cl_object v1;
 cl_object v2;
 cl_object v3;
 cl_object v4;
 ecl_va_list args; ecl_va_start(args,narg,narg,0);
 {
  cl_object keyvars[8];
  cl_parse_key(args,4,L5448make_bit_streamkeys,keyvars,NULL,FALSE);
  ecl_va_end(args);
  v1 = keyvars[0];
  if (Null(keyvars[5])) {
   v2 = ecl_make_int8_t(0);
  } else {
   v2 = keyvars[1];
  }
  if (Null(keyvars[6])) {
   v3 = ecl_make_int8_t(0);
  } else {
   v3 = keyvars[2];
  }
  if (Null(keyvars[7])) {
   v4 = ecl_make_int8_t(0);
  } else {
   v4 = keyvars[3];
  }
 }
 {
  cl_fixnum v5;
  v5 = (cl_fixnum)(0);
  if (!(ECL_FIXNUMP(v4))){
   goto L8;
  }
  v5 = ecl_fixnum(v4);
  if (!((v5)<=((cl_fixnum)(255)))){
   goto L13;
  }
  if ((v5)>=((cl_fixnum)(0))) {
   goto L4;
  }
  goto L5;
L13:;
  goto L5;
L8:;
  goto L5;
 }
L5:;
 si_structure_type_error(v4, VV[62], VV[58], VV[63]);
L4:;
 {
  cl_fixnum v5;
  v5 = (cl_fixnum)(0);
  if (!(ECL_FIXNUMP(v3))){
   goto L19;
  }
  v5 = ecl_fixnum(v3);
  if (!((v5)<=(536870911))){
   goto L24;
  }
  if ((v5)>=((cl_fixnum)(0))) {
   goto L15;
  }
  goto L16;
L24:;
  goto L16;
L19:;
  goto L16;
 }
L16:;
 si_structure_type_error(v3, VV[64], VV[58], VV[65]);
L15:;
 if (ECL_FIXNUMP(v2)) {
  goto L26;
 }
 si_structure_type_error(v2, ECL_SYM("FIXNUM",374), VV[58], VV[66]);
L26:;
 if (cl_streamp(v1)!=ECL_NIL) {
  goto L28;
 }
 si_structure_type_error(v1, ECL_SYM("STREAM",802), VV[58], ECL_SYM("STREAM",802));
L28:;
 value0 = si_make_structure(5, VV[67], v1, v2, v3, v4);
 return value0;
}
/* local function LAMBDA147                                                   */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object LC5449__lambda147(cl_object v1, cl_object v2si__x)
{
 cl_object T0, T1, T2, T3;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 {
  cl_object v3;
  cl_object v4;
  v3 = cl_gensym(0);
  v4 = cl_gensym(0);
  T0 = cl_list(2, ECL_SYM("QUOTE",682), VV[58]);
  T1 = cl_list(6, ECL_SYM("COMPARE-AND-SWAP-STRUCTURE",1527), v2si__x, T0, ecl_make_int8_t(3), v3, v4);
  T2 = cl_list(2, ECL_SYM("QUOTE",682), VV[58]);
  T3 = cl_list(4, ECL_SYM("STRUCTURE-REF",1178), v2si__x, T2, ecl_make_int8_t(3));
  cl_env_copy->nvalues = 6;
  cl_env_copy->values[5] = T3;
  cl_env_copy->values[4] = T1;
  cl_env_copy->values[3] = v4;
  cl_env_copy->values[2] = v3;
  cl_env_copy->values[1] = ECL_NIL;
  cl_env_copy->values[0] = ECL_NIL;
  return cl_env_copy->values[0];
 }
}
static cl_object LC5449__lambda147_va(cl_narg narg, cl_object v5, cl_object v6si__x, ...)
{
 return LC5449__lambda147(v5, v6si__x);
}
/* local function LAMBDA152                                                   */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object LC5450__lambda152(cl_object v1, cl_object v2si__x)
{
 cl_object T0, T1, T2, T3;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 {
  cl_object v3;
  cl_object v4;
  v3 = cl_gensym(0);
  v4 = cl_gensym(0);
  T0 = cl_list(2, ECL_SYM("QUOTE",682), VV[58]);
  T1 = cl_list(6, ECL_SYM("COMPARE-AND-SWAP-STRUCTURE",1527), v2si__x, T0, ecl_make_int8_t(2), v3, v4);
  T2 = cl_list(2, ECL_SYM("QUOTE",682), VV[58]);
  T3 = cl_list(4, ECL_SYM("STRUCTURE-REF",1178), v2si__x, T2, ecl_make_int8_t(2));
  cl_env_copy->nvalues = 6;
  cl_env_copy->values[5] = T3;
  cl_env_copy->values[4] = T1;
  cl_env_copy->values[3] = v4;
  cl_env_copy->values[2] = v3;
  cl_env_copy->values[1] = ECL_NIL;
  cl_env_copy->values[0] = ECL_NIL;
  return cl_env_copy->values[0];
 }
}
static cl_object LC5450__lambda152_va(cl_narg narg, cl_object v5, cl_object v6si__x, ...)
{
 return LC5450__lambda152(v5, v6si__x);
}
/* local function LAMBDA157                                                   */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object LC5451__lambda157(cl_object v1, cl_object v2si__x)
{
 cl_object T0, T1, T2, T3;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 {
  cl_object v3;
  cl_object v4;
  v3 = cl_gensym(0);
  v4 = cl_gensym(0);
  T0 = cl_list(2, ECL_SYM("QUOTE",682), VV[58]);
  T1 = cl_list(6, ECL_SYM("COMPARE-AND-SWAP-STRUCTURE",1527), v2si__x, T0, ecl_make_int8_t(1), v3, v4);
  T2 = cl_list(2, ECL_SYM("QUOTE",682), VV[58]);
  T3 = cl_list(4, ECL_SYM("STRUCTURE-REF",1178), v2si__x, T2, ecl_make_int8_t(1));
  cl_env_copy->nvalues = 6;
  cl_env_copy->values[5] = T3;
  cl_env_copy->values[4] = T1;
  cl_env_copy->values[3] = v4;
  cl_env_copy->values[2] = v3;
  cl_env_copy->values[1] = ECL_NIL;
  cl_env_copy->values[0] = ECL_NIL;
  return cl_env_copy->values[0];
 }
}
static cl_object LC5451__lambda157_va(cl_narg narg, cl_object v5, cl_object v6si__x, ...)
{
 return LC5451__lambda157(v5, v6si__x);
}
/* function definition for BIT-STREAM-GET-BYTE                                */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5452bit_stream_get_byte(cl_object v1stream)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 T0 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1stream) /*  BIT-STREAM-STREAM */;
 value0 = cl_read_byte(1, T0);
 return value0;
}
static cl_object L5452bit_stream_get_byte_va(cl_narg narg, cl_object v2stream, ...)
{
 return L5452bit_stream_get_byte(v2stream);
}
/* function definition for BIT-STREAM-READ-BITS                               */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5453bit_stream_read_bits(cl_object v1stream, cl_object v2bits)
{
 cl_object T0, T1, T2, T3, T4;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
L3:;
 T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1stream) /*  BIT-STREAM-BIT-COUNT */;
 if (ecl_lower(T0,v2bits)) {
  goto L5;
 }
 goto L4;
L5:;
 {
  cl_object v3;
  T0 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1stream) /*  BIT-STREAM-BITS */;
  T2 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1stream) /*  BIT-STREAM-STREAM */;
  T1 = cl_read_byte(1, T2);
  T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1stream) /*  BIT-STREAM-BIT-COUNT */;
  T3 = cl_ash(T1, T2);
  v3 = ecl_boole(ECL_BOOLIOR,(T0),(T3));
  {
   cl_object v4;
   v4 = v1stream;
   (v4)->instance.slots[(cl_fixnum)(2)]=v3;
  }
 }
 {
  cl_object v3;
  T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1stream) /*  BIT-STREAM-BIT-COUNT */;
  v3 = ecl_plus(T0,ecl_make_int8_t(8));
  {
   cl_object v4;
   v4 = v1stream;
   (v4)->instance.slots[(cl_fixnum)(3)]=v3;
  }
 }
 goto L3;
L4:;
 T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1stream) /*  BIT-STREAM-BIT-COUNT */;
 if (!(ecl_number_equalp(T0,v2bits))){
  goto L15;
 }
 {
  cl_object v3;
  v3 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1stream) /*  BIT-STREAM-BITS */;
  {
   cl_object v4;
   v4 = ecl_make_int8_t(0);
   {
    cl_object v5;
    v5 = v1stream;
    (v5)->instance.slots[(cl_fixnum)(2)]=v4;
   }
  }
  {
   cl_object v4;
   v4 = ecl_make_int8_t(0);
   {
    cl_object v5;
    v5 = v1stream;
    (v5)->instance.slots[(cl_fixnum)(3)]=v4;
   }
  }
  value0 = v3;
  cl_env_copy->nvalues = 1;
  return value0;
 }
L15:;
 {
  cl_object v4;
  {
   cl_object v5;
   {
    cl_object v6;
    v6 = v2bits;
    {
     cl_object v7;
     v7 = ecl_make_int8_t(0);
     if (!(ECL_FIXNUMP(v6)||ECL_BIGNUMP(v6))){
      goto L31;
     }
     v7 = v6;
     T0 = ecl_make_bool(ecl_greatereq(v7,ecl_make_int8_t(0)));
     goto L28;
L31:;
     T0 = ECL_NIL;
     goto L28;
    }
L28:;
    if (ecl_unlikely(!((T0)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v6);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v5 = v6;
   }
   T0 = cl_ash(ecl_make_int8_t(-1), v5);
   T1 = ecl_boole(ECL_BOOLXOR,(T0),ecl_make_fixnum(-1));
   T2 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1stream) /*  BIT-STREAM-BITS */;
   T3 = ecl_negate(ecl_make_int8_t(0));
   T4 = cl_ash(T2, T3);
   v4 = ecl_boole(ECL_BOOLAND,(T1),(T4));
  }
  {
   cl_object v5;
   T0 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1stream) /*  BIT-STREAM-BITS */;
   T1 = ecl_negate(v2bits);
   v5 = cl_ash(T0, T1);
   {
    cl_object v6;
    v6 = v1stream;
    (v6)->instance.slots[(cl_fixnum)(2)]=v5;
   }
  }
  {
   cl_object v5;
   T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1stream) /*  BIT-STREAM-BIT-COUNT */;
   v5 = ecl_minus(T0,v2bits);
   {
    cl_object v6;
    v6 = v1stream;
    (v6)->instance.slots[(cl_fixnum)(3)]=v5;
   }
  }
  value0 = v4;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L5453bit_stream_read_bits_va(cl_narg narg, cl_object v5stream, cl_object v6bits, ...)
{
 return L5453bit_stream_read_bits(v5stream, v6bits);
}
/* function definition for BIT-STREAM-COPY-BLOCK                              */
/* optimize speed 3, debug 0, space 0, safety 0                               */
static cl_object L5454bit_stream_copy_block(cl_object v1stream, cl_object v2out_stream)
{
 cl_object T0, T1, T2, T3, T4, T5;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 {
  cl_object v3;
  v3 = ecl_make_int8_t(0);
  {
   cl_object v4;
   v4 = v1stream;
   (v4)->instance.slots[(cl_fixnum)(2)]=v3;
  }
 }
 {
  cl_object v3;
  v3 = ecl_make_int8_t(0);
  {
   cl_object v4;
   v4 = v1stream;
   (v4)->instance.slots[(cl_fixnum)(3)]=v3;
  }
 }
 {
  cl_object v3len;
  cl_object v4nlen;
  T1 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1stream) /*  BIT-STREAM-STREAM */;
  T0 = cl_read_byte(1, T1);
  T2 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1stream) /*  BIT-STREAM-STREAM */;
  T1 = cl_read_byte(1, T2);
  T2 = ecl_ash(T1,(cl_fixnum)(8));
  v3len = ecl_boole(ECL_BOOLIOR,(T0),(T2));
  T1 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1stream) /*  BIT-STREAM-STREAM */;
  T0 = cl_read_byte(1, T1);
  T2 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1stream) /*  BIT-STREAM-STREAM */;
  T1 = cl_read_byte(1, T2);
  T2 = ecl_ash(T1,(cl_fixnum)(8));
  T3 = ecl_boole(ECL_BOOLIOR,(T0),(T2));
  T4 = ecl_boole(ECL_BOOLXOR,(T3),ecl_make_fixnum(-1));
  T5 = cl_ash(T4, ecl_make_int8_t(0));
  v4nlen = ecl_boole(ECL_BOOLAND,(ecl_make_fixnum(65535)),(T5));
  if (ecl_number_equalp(v3len,v4nlen)) {
   goto L14;
  }
  T0 = cl_list(2, v3len, v4nlen);
  cl_error(5, VV[2], ECL_SYM("FORMAT-CONTROL",1272), VV[82], ECL_SYM("FORMAT-ARGUMENTS",1271), T0);
L14:;
  {
   cl_object v5i;
   v5i = ecl_make_int8_t(0);
   goto L18;
L17:;
   {
    uint8_t v6;
    T0 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1stream) /*  BIT-STREAM-STREAM */;
    v6 = ecl_fixnum(cl_read_byte(1, T0));
    {
     cl_fixnum v7end;
     v7end = ecl_fixnum((cl_env_copy->function=(VV[46]->symbol.gfdef))->cfun.entry(1, v2out_stream) /*  SLIDING-WINDOW-STREAM-BUFFER-END */);
     if ((v7end)<(ecl_fixnum(ECL_SYM_VAL(cl_env_copy,VV[27])))) {
      goto L23;
     }
     T0 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, v2out_stream) /*  SLIDING-WINDOW-STREAM-BUFFER */;
     T1 = (cl_env_copy->function=(VV[49]->symbol.gfdef))->cfun.entry(1, v2out_stream) /*  SLIDING-WINDOW-STREAM-STREAM */;
     cl_write_sequence(2, T0, T1);
     {
      cl_object v8;
      v8 = (cl_env_copy->function=(VV[45]->symbol.gfdef))->cfun.entry(1, v2out_stream) /*  SLIDING-WINDOW-STREAM-CHECKSUM */;
      if (!((v8)==(VV[51]))){
       goto L28;
      }
      {
       cl_object v9;
       T0 = (cl_env_copy->function=(VV[42]->symbol.gfdef))->cfun.entry(1, v2out_stream) /*  SLIDING-WINDOW-STREAM-CHECKSUM-VALUE */;
       T1 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, v2out_stream) /*  SLIDING-WINDOW-STREAM-BUFFER */;
       v9 = L5439update_adler32_checksum(T0, T1, ECL_SYM_VAL(cl_env_copy,VV[27]));
       {
        cl_object v10;
        v10 = v2out_stream;
        (v10)->instance.slots[(cl_fixnum)(4)]=v9;
        goto L26;
       }
      }
L28:;
      if (!((v8)==(VV[52]))){
       goto L26;
      }
      {
       cl_object v11;
       T0 = (cl_env_copy->function=(VV[42]->symbol.gfdef))->cfun.entry(1, v2out_stream) /*  SLIDING-WINDOW-STREAM-CHECKSUM-VALUE */;
       T1 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, v2out_stream) /*  SLIDING-WINDOW-STREAM-BUFFER */;
       v11 = L5441update_crc32_checksum(T0, T1, ECL_SYM_VAL(cl_env_copy,VV[27]));
       {
        cl_object v12;
        v12 = v2out_stream;
        (v12)->instance.slots[(cl_fixnum)(4)]=v11;
       }
      }
     }
L26:;
     v7end = (cl_fixnum)(0);
L23:;
     {
      cl_object v8;
      v8 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, v2out_stream) /*  SLIDING-WINDOW-STREAM-BUFFER */;
      ecl_aset_unsafe(v8,v7end,ecl_make_uint8_t(v6));
     }
     {
      cl_object v8;
      v8 = ecl_make_integer((v7end)+1);
      {
       cl_object v9;
       v9 = v2out_stream;
       (v9)->instance.slots[(cl_fixnum)(2)]=v8;
      }
     }
    }
   }
   v5i = ecl_one_plus(v5i);
L18:;
   if (!(ecl_lower(v5i,v3len))){
    goto L42;
   }
   goto L17;
L42:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
static cl_object L5454bit_stream_copy_block_va(cl_narg narg, cl_object v6stream, cl_object v7out_stream, ...)
{
 return L5454bit_stream_copy_block(v6stream, v7out_stream);
}
/* function definition for MAKE-DECODE-TREE                                   */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5455make_decode_tree(cl_narg narg, ...)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 cl_object v1;
 cl_object v2;
 ecl_va_list args; ecl_va_start(args,narg,narg,0);
 {
  cl_object keyvars[4];
  cl_parse_key(args,2,L5455make_decode_treekeys,keyvars,NULL,FALSE);
  ecl_va_end(args);
  if (Null(keyvars[2])) {
   T0 = si_make_vector(ECL_SYM("INTEGER64",1376), ecl_make_int8_t(16), ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_int8_t(0));
   v1 = si_fill_array_with_elt(T0, ecl_make_int8_t(0), ecl_make_int8_t(0), ECL_NIL);
  } else {
   v1 = keyvars[0];
  }
  if (Null(keyvars[3])) {
   T0 = si_make_vector(ECL_SYM("INTEGER64",1376), ecl_make_int8_t(16), ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_int8_t(0));
   v2 = si_fill_array_with_elt(T0, ecl_make_int8_t(0), ecl_make_int8_t(0), ECL_NIL);
  } else {
   v2 = keyvars[1];
  }
 }
 if (cl_typep(2, v2, VV[88])!=ECL_NIL) {
  goto L3;
 }
 si_structure_type_error(v2, VV[88], VV[84], VV[89]);
L3:;
 if (cl_typep(2, v1, VV[88])!=ECL_NIL) {
  goto L5;
 }
 si_structure_type_error(v1, VV[88], VV[84], VV[90]);
L5:;
 value0 = si_make_structure(3, VV[91], v1, v2);
 return value0;
}
/* local function LAMBDA273                                                   */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object LC5456__lambda273(cl_object v1, cl_object v2si__x)
{
 cl_object T0, T1, T2, T3;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 {
  cl_object v3;
  cl_object v4;
  v3 = cl_gensym(0);
  v4 = cl_gensym(0);
  T0 = cl_list(2, ECL_SYM("QUOTE",682), VV[84]);
  T1 = cl_list(6, ECL_SYM("COMPARE-AND-SWAP-STRUCTURE",1527), v2si__x, T0, ecl_make_int8_t(1), v3, v4);
  T2 = cl_list(2, ECL_SYM("QUOTE",682), VV[84]);
  T3 = cl_list(4, ECL_SYM("STRUCTURE-REF",1178), v2si__x, T2, ecl_make_int8_t(1));
  cl_env_copy->nvalues = 6;
  cl_env_copy->values[5] = T3;
  cl_env_copy->values[4] = T1;
  cl_env_copy->values[3] = v4;
  cl_env_copy->values[2] = v3;
  cl_env_copy->values[1] = ECL_NIL;
  cl_env_copy->values[0] = ECL_NIL;
  return cl_env_copy->values[0];
 }
}
static cl_object LC5456__lambda273_va(cl_narg narg, cl_object v5, cl_object v6si__x, ...)
{
 return LC5456__lambda273(v5, v6si__x);
}
/* function definition for MAKE-HUFFMAN-DECODE-TREE                           */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5457make_huffman_decode_tree(cl_object v1code_lengths)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 {
  cl_object v2max_length;
  cl_object v3next_code;
  cl_object v4code_symbols;
  cl_object v5length_count;
  T0 = (ECL_SYM("MAX",553)->symbol.gfdef);
  v2max_length = cl_reduce(4, T0, v1code_lengths, VV[97], ecl_make_int8_t(0));
  {
   cl_object v6;
   v6 = ecl_one_plus(v2max_length);
   T0 = si_make_pure_array(ECL_SYM("INTEGER64",1376), v6, ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_int8_t(0));
   v3next_code = si_fill_array_with_elt(T0, ecl_make_int8_t(0), ecl_make_int8_t(0), ECL_NIL);
  }
  {
   cl_object v6;
   v6 = ecl_make_fixnum(ecl_length(v1code_lengths));
   T0 = si_make_pure_array(ECL_SYM("INTEGER64",1376), v6, ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_int8_t(0));
   v4code_symbols = si_fill_array_with_elt(T0, ecl_make_int8_t(0), ecl_make_int8_t(0), ECL_NIL);
  }
  {
   cl_object v6;
   v6 = ecl_one_plus(v2max_length);
   T0 = si_make_pure_array(ECL_SYM("INTEGER64",1376), v6, ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_int8_t(0));
   v5length_count = si_fill_array_with_elt(T0, ecl_make_int8_t(0), ecl_make_int8_t(0), ECL_NIL);
  }
  {
   cl_object v6index;
   v6index = ecl_make_int8_t(1);
   {
    cl_object v7code;
    v7code = ECL_NIL;
    {
     cl_object v8length;
     cl_fixnum v9;
     cl_fixnum v10;
     v8length = ECL_NIL;
     v9 = (cl_fixnum)(0);
     v10 = (cl_fixnum)(0);
     v10 = (v1code_lengths)->vector.fillp;
L19:;
     if (!((v9)>=(v10))){
      goto L23;
     }
     goto L20;
L23:;
     v8length = ecl_aref_unsafe(v1code_lengths,v9);
     v9 = (v9)+1;
     {
      cl_object v11;
      T0 = ecl_make_int64_t((v5length_count)->vector.self.i64[ecl_fixnum(v8length)]);
      v11 = ecl_plus(T0,ecl_make_int8_t(1));
      (v5length_count)->vector.self.i64[ecl_fixnum(v8length)]= ecl_to_long(v11);
     }
     goto L19;
L20:;
     (v5length_count)->array.self.fix[(cl_fixnum)(0)]= (cl_fixnum)(0);
    }
    if (!(ecl_greater(v6index,v2max_length))){
     goto L34;
    }
    goto L14;
L34:;
    v7code = ecl_make_int8_t(0);
L13:;
    (v3next_code)->vector.self.i64[ecl_fixnum(v6index)]= ecl_to_long(v7code);
    v6index = ecl_one_plus(v6index);
    if (!(ecl_greater(v6index,v2max_length))){
     goto L41;
    }
    goto L14;
L41:;
    T1 = ecl_one_minus(v6index);
    T0 = ecl_make_int64_t((v5length_count)->vector.self.i64[ecl_fixnum(T1)]);
    v7code = ecl_plus(v7code,T0);
    goto L13;
L14:;
   }
  }
  {
   cl_object v6length;
   cl_fixnum v7;
   cl_fixnum v8;
   v6length = ECL_NIL;
   v7 = (cl_fixnum)(0);
   v8 = (cl_fixnum)(0);
   {
    cl_object v9index;
    v9index = ecl_make_int8_t(0);
    v8 = (v1code_lengths)->vector.fillp;
    if (!((v7)>=(v8))){
     goto L56;
    }
    goto L53;
L56:;
    v6length = ecl_aref_unsafe(v1code_lengths,v7);
    v7 = (v7)+1;
L52:;
    if (ecl_zerop(v6length)) {
     goto L62;
    }
    T0 = ecl_make_int64_t((v3next_code)->vector.self.i64[ecl_fixnum(v6length)]);
    (v4code_symbols)->vector.self.i64[ecl_fixnum(T0)]= ecl_to_long(v9index);
    {
     cl_object v10;
     T0 = ecl_make_int64_t((v3next_code)->vector.self.i64[ecl_fixnum(v6length)]);
     v10 = ecl_plus(T0,ecl_make_int8_t(1));
     (v3next_code)->vector.self.i64[ecl_fixnum(v6length)]= ecl_to_long(v10);
    }
L62:;
    if (!((v7)>=(v8))){
     goto L68;
    }
    goto L53;
L68:;
    v6length = ecl_aref_unsafe(v1code_lengths,v7);
    v7 = (v7)+1;
    v9index = ecl_one_plus(v9index);
    goto L52;
L53:;
   }
  }
  value0 = L5455make_decode_tree(4, VV[100], v5length_count, VV[101], v4code_symbols);
  return value0;
 }
}
static cl_object L5457make_huffman_decode_tree_va(cl_narg narg, cl_object v6code_lengths, ...)
{
 return L5457make_huffman_decode_tree(v6code_lengths);
}
/* function definition for READ-HUFFMAN-CODE                                  */
/* optimize speed 3, debug 0, space 0, safety 0                               */
static cl_object L5458read_huffman_code(cl_object v1bit_stream, cl_object v2decode_tree)
{
 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;
L1:;
 {
  cl_object v3length_count;
  v3length_count = (cl_env_copy->function=(VV[95]->symbol.gfdef))->cfun.entry(1, v2decode_tree) /*  DECODE-TREE-LENGTH-COUNT */;
  {
   cl_object v4code_symbols;
   v4code_symbols = (cl_env_copy->function=(VV[93]->symbol.gfdef))->cfun.entry(1, v2decode_tree) /*  DECODE-TREE-CODE-SYMBOLS */;
   {
    cl_fixnum v5code;
    v5code = (cl_fixnum)(0);
    {
     cl_fixnum v6index;
     v6index = (cl_fixnum)(0);
     {
      cl_fixnum v7first;
      v7first = (cl_fixnum)(0);
      {
       cl_fixnum v8;
       cl_fixnum v9length;
       v8 = (v3length_count)->vector.fillp;
       v9length = (cl_fixnum)(1);
       {
        cl_object v10count;
        v10count = ECL_NIL;
        {
         cl_object v11;
         v11 = ECL_NIL;
L16:;
         T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
         if (ecl_lower(T0,ecl_make_int8_t(1))) {
          goto L18;
         }
         goto L17;
L18:;
         {
          cl_object v12;
          T0 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T2 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-STREAM */;
          T1 = cl_read_byte(1, T2);
          T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          T3 = cl_ash(T1, T2);
          v12 = ecl_boole(ECL_BOOLIOR,(T0),(T3));
          {
          cl_object v13;
          v13 = v1bit_stream;
          (v13)->instance.slots[(cl_fixnum)(2)]=v12;
          }
         }
         {
          cl_object v12;
          T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          v12 = ecl_plus(T0,ecl_make_int8_t(8));
          {
          cl_object v13;
          v13 = v1bit_stream;
          (v13)->instance.slots[(cl_fixnum)(3)]=v12;
          }
         }
         goto L16;
L17:;
         T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
         if (!(ecl_number_equalp(T0,ecl_make_int8_t(1)))){
          goto L28;
         }
         {
          cl_object v12;
          v12 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          {
          cl_object v13;
          v13 = ecl_make_int8_t(0);
          {
          cl_object v14;
          v14 = v1bit_stream;
          (v14)->instance.slots[(cl_fixnum)(2)]=v13;
          }
          }
          {
          cl_object v13;
          v13 = ecl_make_int8_t(0);
          {
          cl_object v14;
          v14 = v1bit_stream;
          (v14)->instance.slots[(cl_fixnum)(3)]=v13;
          }
          }
          v5code = ecl_fixnum(v12);
          goto L14;
         }
L28:;
         {
          cl_object v13;
          {
          cl_object v14;
          {
          cl_object v15;
          v15 = ecl_make_int8_t(1);
          {
          cl_object v16;
          v16 = ecl_make_int8_t(0);
          if (!(ECL_FIXNUMP(v15)||ECL_BIGNUMP(v15))){
          goto L44;
          }
          v16 = v15;
          T0 = ecl_make_bool(ecl_greatereq(v16,ecl_make_int8_t(0)));
          goto L41;
L44:;
          T0 = ECL_NIL;
          goto L41;
          }
L41:;
          if (ecl_unlikely(!((T0)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v15);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          v14 = v15;
          }
          T0 = cl_ash(ecl_make_int8_t(-1), v14);
          T1 = ecl_boole(ECL_BOOLXOR,(T0),ecl_make_fixnum(-1));
          T2 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T3 = ecl_negate(ecl_make_int8_t(0));
          T4 = cl_ash(T2, T3);
          v13 = ecl_boole(ECL_BOOLAND,(T1),(T4));
          }
          {
          cl_object v14;
          T0 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T1 = ecl_negate(ecl_make_int8_t(1));
          v14 = cl_ash(T0, T1);
          {
          cl_object v15;
          v15 = v1bit_stream;
          (v15)->instance.slots[(cl_fixnum)(2)]=v14;
          }
          }
          {
          cl_object v14;
          T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          v14 = ecl_minus(T0,ecl_make_int8_t(1));
          {
          cl_object v15;
          v15 = v1bit_stream;
          (v15)->instance.slots[(cl_fixnum)(3)]=v14;
          }
          }
          v5code = ecl_fixnum(v13);
         }
L14:;
         v6index = (cl_fixnum)(0);
         v7first = (cl_fixnum)(0);
L11:;
         if (!((v9length)>=(v8))){
          goto L58;
         }
         goto L12;
L58:;
         v10count = ecl_make_int64_t((v3length_count)->vector.self.i64[v9length]);
         T0 = ecl_plus(ecl_make_fixnum(v7first),v10count);
         if (!((v5code)<(ecl_fixnum(T0)))){
          goto L65;
         }
         T0 = ecl_minus(ecl_make_fixnum(v5code),ecl_make_fixnum(v7first));
         T1 = ecl_plus(ecl_make_fixnum(v6index),T0);
         v11 = ecl_make_int64_t((v4code_symbols)->vector.self.i64[ecl_fixnum(T1)]);
         goto L64;
L65:;
         v11 = ECL_NIL;
L64:;
         if (Null(v11)){
          goto L62;
         }
         value0 = v11;
         cl_env_copy->nvalues = 1;
         return value0;
L62:;
         T0 = ecl_times(ecl_make_fixnum(v5code),ecl_make_int8_t(2));
L71:;
         T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
         if (ecl_lower(T2,ecl_make_int8_t(1))) {
          goto L73;
         }
         goto L72;
L73:;
         {
          cl_object v12;
          T2 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T4 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-STREAM */;
          T3 = cl_read_byte(1, T4);
          T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          T5 = cl_ash(T3, T4);
          v12 = ecl_boole(ECL_BOOLIOR,(T2),(T5));
          {
          cl_object v13;
          v13 = v1bit_stream;
          (v13)->instance.slots[(cl_fixnum)(2)]=v12;
          }
         }
         {
          cl_object v12;
          T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          v12 = ecl_plus(T2,ecl_make_int8_t(8));
          {
          cl_object v13;
          v13 = v1bit_stream;
          (v13)->instance.slots[(cl_fixnum)(3)]=v12;
          }
         }
         goto L71;
L72:;
         T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
         if (!(ecl_number_equalp(T2,ecl_make_int8_t(1)))){
          goto L83;
         }
         {
          cl_object v12;
          v12 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          {
          cl_object v13;
          v13 = ecl_make_int8_t(0);
          {
          cl_object v14;
          v14 = v1bit_stream;
          (v14)->instance.slots[(cl_fixnum)(2)]=v13;
          }
          }
          {
          cl_object v13;
          v13 = ecl_make_int8_t(0);
          {
          cl_object v14;
          v14 = v1bit_stream;
          (v14)->instance.slots[(cl_fixnum)(3)]=v13;
          }
          }
          T1 = v12;
          goto L69;
         }
L83:;
         {
          cl_object v13;
          {
          cl_object v14;
          {
          cl_object v15;
          v15 = ecl_make_int8_t(1);
          {
          cl_object v16;
          v16 = ecl_make_int8_t(0);
          if (!(ECL_FIXNUMP(v15)||ECL_BIGNUMP(v15))){
          goto L99;
          }
          v16 = v15;
          T2 = ecl_make_bool(ecl_greatereq(v16,ecl_make_int8_t(0)));
          goto L96;
L99:;
          T2 = ECL_NIL;
          goto L96;
          }
L96:;
          if (ecl_unlikely(!((T2)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v15);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          v14 = v15;
          }
          T2 = cl_ash(ecl_make_int8_t(-1), v14);
          T3 = ecl_boole(ECL_BOOLXOR,(T2),ecl_make_fixnum(-1));
          T4 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T5 = ecl_negate(ecl_make_int8_t(0));
          T6 = cl_ash(T4, T5);
          v13 = ecl_boole(ECL_BOOLAND,(T3),(T6));
          }
          {
          cl_object v14;
          T2 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T3 = ecl_negate(ecl_make_int8_t(1));
          v14 = cl_ash(T2, T3);
          {
          cl_object v15;
          v15 = v1bit_stream;
          (v15)->instance.slots[(cl_fixnum)(2)]=v14;
          }
          }
          {
          cl_object v14;
          T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          v14 = ecl_minus(T2,ecl_make_int8_t(1));
          {
          cl_object v15;
          v15 = v1bit_stream;
          (v15)->instance.slots[(cl_fixnum)(3)]=v14;
          }
          }
          T1 = v13;
         }
L69:;
         v5code = ecl_fixnum(ecl_plus(T0,T1));
         v6index = ecl_fixnum(ecl_plus(ecl_make_fixnum(v6index),v10count));
         T0 = ecl_plus(ecl_make_fixnum(v7first),v10count);
         v7first = ecl_fixnum(ecl_times(T0,ecl_make_int8_t(2)));
         v9length = (v9length)+1;
         goto L11;
L12:;
         T0 = ecl_list1(ecl_make_fixnum(v5code));
         cl_error(5, VV[2], ECL_SYM("FORMAT-CONTROL",1272), VV[104], ECL_SYM("FORMAT-ARGUMENTS",1271), T0);
         value0 = ECL_NIL;
         cl_env_copy->nvalues = 1;
         return value0;
        }
       }
      }
     }
    }
   }
  }
 }
}
static cl_object L5458read_huffman_code_va(cl_narg narg, cl_object v12bit_stream, cl_object v13decode_tree, ...)
{
 return L5458read_huffman_code(v12bit_stream, v13decode_tree);
}
/* function definition for DECODE-CODE-LENGTH-ENTRIES                         */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5459decode_code_length_entries(cl_object v1bit_stream, cl_object v2count, cl_object v3decode_tree)
{
 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;
L1:;
 {
  cl_object v4;
  cl_object v5index;
  T0 = si_make_pure_array(ECL_SYM("INTEGER64",1376), v2count, ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_int8_t(0));
  v4 = si_fill_array_with_elt(T0, ecl_make_int8_t(0), ecl_make_int8_t(0), ECL_NIL);
  v5index = ecl_make_int8_t(0);
  goto L6;
L5:;
  {
   cl_object v6code;
   {
    cl_object v7length_count;
    v7length_count = (cl_env_copy->function=(VV[95]->symbol.gfdef))->cfun.entry(1, v3decode_tree) /*  DECODE-TREE-LENGTH-COUNT */;
    {
     cl_object v8code_symbols;
     v8code_symbols = (cl_env_copy->function=(VV[93]->symbol.gfdef))->cfun.entry(1, v3decode_tree) /*  DECODE-TREE-CODE-SYMBOLS */;
     {
      cl_fixnum v9code;
      v9code = (cl_fixnum)(0);
      {
       cl_fixnum v10index;
       v10index = (cl_fixnum)(0);
       {
        cl_fixnum v11first;
        v11first = (cl_fixnum)(0);
        {
         cl_fixnum v12;
         cl_fixnum v13length;
         v12 = (v7length_count)->vector.fillp;
         v13length = (cl_fixnum)(1);
         {
          cl_object v14count;
          v14count = ECL_NIL;
          {
          cl_object v15;
          v15 = ECL_NIL;
L24:;
          T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          if (ecl_lower(T0,ecl_make_int8_t(1))) {
          goto L26;
          }
          goto L25;
L26:;
          {
          cl_object v16;
          T0 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T2 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-STREAM */;
          T1 = cl_read_byte(1, T2);
          T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          T3 = cl_ash(T1, T2);
          v16 = ecl_boole(ECL_BOOLIOR,(T0),(T3));
          {
          cl_object v17;
          v17 = v1bit_stream;
          (v17)->instance.slots[(cl_fixnum)(2)]=v16;
          }
          }
          {
          cl_object v16;
          T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          v16 = ecl_plus(T0,ecl_make_int8_t(8));
          {
          cl_object v17;
          v17 = v1bit_stream;
          (v17)->instance.slots[(cl_fixnum)(3)]=v16;
          }
          }
          goto L24;
L25:;
          T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          if (!(ecl_number_equalp(T0,ecl_make_int8_t(1)))){
          goto L36;
          }
          {
          cl_object v16;
          v16 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          {
          cl_object v17;
          v17 = ecl_make_int8_t(0);
          {
          cl_object v18;
          v18 = v1bit_stream;
          (v18)->instance.slots[(cl_fixnum)(2)]=v17;
          }
          }
          {
          cl_object v17;
          v17 = ecl_make_int8_t(0);
          {
          cl_object v18;
          v18 = v1bit_stream;
          (v18)->instance.slots[(cl_fixnum)(3)]=v17;
          }
          }
          v9code = ecl_fixnum(v16);
          goto L22;
          }
L36:;
          {
          cl_object v17;
          {
          cl_object v18;
          {
          cl_object v19;
          v19 = ecl_make_int8_t(1);
          {
          cl_object v20;
          v20 = ecl_make_int8_t(0);
          if (!(ECL_FIXNUMP(v19)||ECL_BIGNUMP(v19))){
          goto L52;
          }
          v20 = v19;
          T0 = ecl_make_bool(ecl_greatereq(v20,ecl_make_int8_t(0)));
          goto L49;
L52:;
          T0 = ECL_NIL;
          goto L49;
          }
L49:;
          if (ecl_unlikely(!((T0)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v19);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          v18 = v19;
          }
          T0 = cl_ash(ecl_make_int8_t(-1), v18);
          T1 = ecl_boole(ECL_BOOLXOR,(T0),ecl_make_fixnum(-1));
          T2 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T3 = ecl_negate(ecl_make_int8_t(0));
          T4 = cl_ash(T2, T3);
          v17 = ecl_boole(ECL_BOOLAND,(T1),(T4));
          }
          {
          cl_object v18;
          T0 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T1 = ecl_negate(ecl_make_int8_t(1));
          v18 = cl_ash(T0, T1);
          {
          cl_object v19;
          v19 = v1bit_stream;
          (v19)->instance.slots[(cl_fixnum)(2)]=v18;
          }
          }
          {
          cl_object v18;
          T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          v18 = ecl_minus(T0,ecl_make_int8_t(1));
          {
          cl_object v19;
          v19 = v1bit_stream;
          (v19)->instance.slots[(cl_fixnum)(3)]=v18;
          }
          }
          v9code = ecl_fixnum(v17);
          }
L22:;
          v10index = (cl_fixnum)(0);
          v11first = (cl_fixnum)(0);
L19:;
          if (!((v13length)>=(v12))){
          goto L66;
          }
          goto L20;
L66:;
          v14count = ecl_make_int64_t((v7length_count)->vector.self.i64[v13length]);
          T0 = ecl_plus(ecl_make_fixnum(v11first),v14count);
          if (!((v9code)<(ecl_fixnum(T0)))){
          goto L73;
          }
          T0 = ecl_minus(ecl_make_fixnum(v9code),ecl_make_fixnum(v11first));
          T1 = ecl_plus(ecl_make_fixnum(v10index),T0);
          v15 = ecl_make_int64_t((v8code_symbols)->vector.self.i64[ecl_fixnum(T1)]);
          goto L72;
L73:;
          v15 = ECL_NIL;
L72:;
          if (Null(v15)){
          goto L70;
          }
          v6code = v15;
          goto L9;
L70:;
          T0 = ecl_times(ecl_make_fixnum(v9code),ecl_make_int8_t(2));
L79:;
          T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          if (ecl_lower(T2,ecl_make_int8_t(1))) {
          goto L81;
          }
          goto L80;
L81:;
          {
          cl_object v16;
          T2 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T4 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-STREAM */;
          T3 = cl_read_byte(1, T4);
          T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          T5 = cl_ash(T3, T4);
          v16 = ecl_boole(ECL_BOOLIOR,(T2),(T5));
          {
          cl_object v17;
          v17 = v1bit_stream;
          (v17)->instance.slots[(cl_fixnum)(2)]=v16;
          }
          }
          {
          cl_object v16;
          T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          v16 = ecl_plus(T2,ecl_make_int8_t(8));
          {
          cl_object v17;
          v17 = v1bit_stream;
          (v17)->instance.slots[(cl_fixnum)(3)]=v16;
          }
          }
          goto L79;
L80:;
          T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          if (!(ecl_number_equalp(T2,ecl_make_int8_t(1)))){
          goto L91;
          }
          {
          cl_object v16;
          v16 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          {
          cl_object v17;
          v17 = ecl_make_int8_t(0);
          {
          cl_object v18;
          v18 = v1bit_stream;
          (v18)->instance.slots[(cl_fixnum)(2)]=v17;
          }
          }
          {
          cl_object v17;
          v17 = ecl_make_int8_t(0);
          {
          cl_object v18;
          v18 = v1bit_stream;
          (v18)->instance.slots[(cl_fixnum)(3)]=v17;
          }
          }
          T1 = v16;
          goto L77;
          }
L91:;
          {
          cl_object v17;
          {
          cl_object v18;
          {
          cl_object v19;
          v19 = ecl_make_int8_t(1);
          {
          cl_object v20;
          v20 = ecl_make_int8_t(0);
          if (!(ECL_FIXNUMP(v19)||ECL_BIGNUMP(v19))){
          goto L107;
          }
          v20 = v19;
          T2 = ecl_make_bool(ecl_greatereq(v20,ecl_make_int8_t(0)));
          goto L104;
L107:;
          T2 = ECL_NIL;
          goto L104;
          }
L104:;
          if (ecl_unlikely(!((T2)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v19);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          v18 = v19;
          }
          T2 = cl_ash(ecl_make_int8_t(-1), v18);
          T3 = ecl_boole(ECL_BOOLXOR,(T2),ecl_make_fixnum(-1));
          T4 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T5 = ecl_negate(ecl_make_int8_t(0));
          T6 = cl_ash(T4, T5);
          v17 = ecl_boole(ECL_BOOLAND,(T3),(T6));
          }
          {
          cl_object v18;
          T2 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T3 = ecl_negate(ecl_make_int8_t(1));
          v18 = cl_ash(T2, T3);
          {
          cl_object v19;
          v19 = v1bit_stream;
          (v19)->instance.slots[(cl_fixnum)(2)]=v18;
          }
          }
          {
          cl_object v18;
          T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          v18 = ecl_minus(T2,ecl_make_int8_t(1));
          {
          cl_object v19;
          v19 = v1bit_stream;
          (v19)->instance.slots[(cl_fixnum)(3)]=v18;
          }
          }
          T1 = v17;
          }
L77:;
          v9code = ecl_fixnum(ecl_plus(T0,T1));
          v10index = ecl_fixnum(ecl_plus(ecl_make_fixnum(v10index),v14count));
          T0 = ecl_plus(ecl_make_fixnum(v11first),v14count);
          v11first = ecl_fixnum(ecl_times(T0,ecl_make_int8_t(2)));
          v13length = (v13length)+1;
          goto L19;
L20:;
          T0 = ecl_list1(ecl_make_fixnum(v9code));
          cl_error(5, VV[2], ECL_SYM("FORMAT-CONTROL",1272), VV[104], ECL_SYM("FORMAT-ARGUMENTS",1271), T0);
          v6code = ECL_NIL;
          }
         }
        }
       }
      }
     }
    }
   }
L9:;
   {
    cl_object v7;
    cl_object v8;
    v7 = v6code;
    v8 = VV[110];
    if (Null(ecl_memql(v7,v8))){
     goto L125;
    }
   }
   (v4)->vector.self.i64[ecl_fixnum(v5index)]= ecl_to_long(v6code);
   v5index = ecl_plus(v5index,ecl_make_int8_t(1));
   goto L8;
L125:;
   if (!((v6code)==(ecl_make_int8_t(16)))){
    goto L131;
   }
   {
    cl_object v7length;
L136:;
    T1 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
    if (ecl_lower(T1,ecl_make_int8_t(2))) {
     goto L138;
    }
    goto L137;
L138:;
    {
     cl_object v8;
     T1 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
     T3 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-STREAM */;
     T2 = cl_read_byte(1, T3);
     T3 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
     T4 = cl_ash(T2, T3);
     v8 = ecl_boole(ECL_BOOLIOR,(T1),(T4));
     {
      cl_object v9;
      v9 = v1bit_stream;
      (v9)->instance.slots[(cl_fixnum)(2)]=v8;
     }
    }
    {
     cl_object v8;
     T1 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
     v8 = ecl_plus(T1,ecl_make_int8_t(8));
     {
      cl_object v9;
      v9 = v1bit_stream;
      (v9)->instance.slots[(cl_fixnum)(3)]=v8;
     }
    }
    goto L136;
L137:;
    T1 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
    if (!(ecl_number_equalp(T1,ecl_make_int8_t(2)))){
     goto L148;
    }
    {
     cl_object v8;
     v8 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
     {
      cl_object v9;
      v9 = ecl_make_int8_t(0);
      {
       cl_object v10;
       v10 = v1bit_stream;
       (v10)->instance.slots[(cl_fixnum)(2)]=v9;
      }
     }
     {
      cl_object v9;
      v9 = ecl_make_int8_t(0);
      {
       cl_object v10;
       v10 = v1bit_stream;
       (v10)->instance.slots[(cl_fixnum)(3)]=v9;
      }
     }
     T0 = v8;
     goto L134;
    }
L148:;
    {
     cl_object v9;
     {
      cl_object v10;
      {
       cl_object v11;
       v11 = ecl_make_int8_t(2);
       {
        cl_object v12;
        v12 = ecl_make_int8_t(0);
        if (!(ECL_FIXNUMP(v11)||ECL_BIGNUMP(v11))){
         goto L164;
        }
        v12 = v11;
        T1 = ecl_make_bool(ecl_greatereq(v12,ecl_make_int8_t(0)));
        goto L161;
L164:;
        T1 = ECL_NIL;
        goto L161;
       }
L161:;
       if (ecl_unlikely(!((T1)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v11);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v10 = v11;
      }
      T1 = cl_ash(ecl_make_int8_t(-1), v10);
      T2 = ecl_boole(ECL_BOOLXOR,(T1),ecl_make_fixnum(-1));
      T3 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
      T4 = ecl_negate(ecl_make_int8_t(0));
      T5 = cl_ash(T3, T4);
      v9 = ecl_boole(ECL_BOOLAND,(T2),(T5));
     }
     {
      cl_object v10;
      T1 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
      T2 = ecl_negate(ecl_make_int8_t(2));
      v10 = cl_ash(T1, T2);
      {
       cl_object v11;
       v11 = v1bit_stream;
       (v11)->instance.slots[(cl_fixnum)(2)]=v10;
      }
     }
     {
      cl_object v10;
      T1 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
      v10 = ecl_minus(T1,ecl_make_int8_t(2));
      {
       cl_object v11;
       v11 = v1bit_stream;
       (v11)->instance.slots[(cl_fixnum)(3)]=v10;
      }
     }
     T0 = v9;
    }
L134:;
    v7length = ecl_plus(ecl_make_int8_t(3),T0);
    {
     cl_object v8i;
     v8i = ecl_make_int8_t(0);
     goto L177;
L176:;
     T0 = ecl_plus(v5index,v8i);
     T2 = ecl_one_minus(v5index);
     T1 = ecl_make_int64_t((v4)->vector.self.i64[ecl_fixnum(T2)]);
     (v4)->vector.self.i64[ecl_fixnum(T0)]= ecl_to_long(T1);
     v8i = ecl_one_plus(v8i);
L177:;
     if (!(ecl_lower(v8i,v7length))){
      goto L183;
     }
     goto L176;
L183:;
    }
    v5index = ecl_plus(v5index,v7length);
    goto L8;
   }
L131:;
   if (!((v6code)==(ecl_make_int8_t(17)))){
    goto L186;
   }
   {
    cl_object v8length;
L191:;
    T1 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
    if (ecl_lower(T1,ecl_make_int8_t(3))) {
     goto L193;
    }
    goto L192;
L193:;
    {
     cl_object v9;
     T1 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
     T3 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-STREAM */;
     T2 = cl_read_byte(1, T3);
     T3 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
     T4 = cl_ash(T2, T3);
     v9 = ecl_boole(ECL_BOOLIOR,(T1),(T4));
     {
      cl_object v10;
      v10 = v1bit_stream;
      (v10)->instance.slots[(cl_fixnum)(2)]=v9;
     }
    }
    {
     cl_object v9;
     T1 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
     v9 = ecl_plus(T1,ecl_make_int8_t(8));
     {
      cl_object v10;
      v10 = v1bit_stream;
      (v10)->instance.slots[(cl_fixnum)(3)]=v9;
     }
    }
    goto L191;
L192:;
    T1 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
    if (!(ecl_number_equalp(T1,ecl_make_int8_t(3)))){
     goto L203;
    }
    {
     cl_object v9;
     v9 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
     {
      cl_object v10;
      v10 = ecl_make_int8_t(0);
      {
       cl_object v11;
       v11 = v1bit_stream;
       (v11)->instance.slots[(cl_fixnum)(2)]=v10;
      }
     }
     {
      cl_object v10;
      v10 = ecl_make_int8_t(0);
      {
       cl_object v11;
       v11 = v1bit_stream;
       (v11)->instance.slots[(cl_fixnum)(3)]=v10;
      }
     }
     T0 = v9;
     goto L189;
    }
L203:;
    {
     cl_object v10;
     {
      cl_object v11;
      {
       cl_object v12;
       v12 = ecl_make_int8_t(3);
       {
        cl_object v13;
        v13 = ecl_make_int8_t(0);
        if (!(ECL_FIXNUMP(v12)||ECL_BIGNUMP(v12))){
         goto L219;
        }
        v13 = v12;
        T1 = ecl_make_bool(ecl_greatereq(v13,ecl_make_int8_t(0)));
        goto L216;
L219:;
        T1 = ECL_NIL;
        goto L216;
       }
L216:;
       if (ecl_unlikely(!((T1)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v12);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v11 = v12;
      }
      T1 = cl_ash(ecl_make_int8_t(-1), v11);
      T2 = ecl_boole(ECL_BOOLXOR,(T1),ecl_make_fixnum(-1));
      T3 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
      T4 = ecl_negate(ecl_make_int8_t(0));
      T5 = cl_ash(T3, T4);
      v10 = ecl_boole(ECL_BOOLAND,(T2),(T5));
     }
     {
      cl_object v11;
      T1 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
      T2 = ecl_negate(ecl_make_int8_t(3));
      v11 = cl_ash(T1, T2);
      {
       cl_object v12;
       v12 = v1bit_stream;
       (v12)->instance.slots[(cl_fixnum)(2)]=v11;
      }
     }
     {
      cl_object v11;
      T1 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
      v11 = ecl_minus(T1,ecl_make_int8_t(3));
      {
       cl_object v12;
       v12 = v1bit_stream;
       (v12)->instance.slots[(cl_fixnum)(3)]=v11;
      }
     }
     T0 = v10;
    }
L189:;
    v8length = ecl_plus(ecl_make_int8_t(3),T0);
    {
     cl_object v9i;
     v9i = ecl_make_int8_t(0);
     goto L232;
L231:;
     T0 = ecl_plus(v5index,v9i);
     (v4)->array.self.fix[ecl_fixnum(T0)]= (cl_fixnum)(0);
     v9i = ecl_one_plus(v9i);
L232:;
     if (!(ecl_lower(v9i,v8length))){
      goto L237;
     }
     goto L231;
L237:;
    }
    v5index = ecl_plus(v5index,v8length);
    goto L8;
   }
L186:;
   if (!((v6code)==(ecl_make_int8_t(18)))){
    goto L240;
   }
   {
    cl_object v9length;
L245:;
    T1 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
    if (ecl_lower(T1,ecl_make_int8_t(7))) {
     goto L247;
    }
    goto L246;
L247:;
    {
     cl_object v10;
     T1 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
     T3 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-STREAM */;
     T2 = cl_read_byte(1, T3);
     T3 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
     T4 = cl_ash(T2, T3);
     v10 = ecl_boole(ECL_BOOLIOR,(T1),(T4));
     {
      cl_object v11;
      v11 = v1bit_stream;
      (v11)->instance.slots[(cl_fixnum)(2)]=v10;
     }
    }
    {
     cl_object v10;
     T1 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
     v10 = ecl_plus(T1,ecl_make_int8_t(8));
     {
      cl_object v11;
      v11 = v1bit_stream;
      (v11)->instance.slots[(cl_fixnum)(3)]=v10;
     }
    }
    goto L245;
L246:;
    T1 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
    if (!(ecl_number_equalp(T1,ecl_make_int8_t(7)))){
     goto L257;
    }
    {
     cl_object v10;
     v10 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
     {
      cl_object v11;
      v11 = ecl_make_int8_t(0);
      {
       cl_object v12;
       v12 = v1bit_stream;
       (v12)->instance.slots[(cl_fixnum)(2)]=v11;
      }
     }
     {
      cl_object v11;
      v11 = ecl_make_int8_t(0);
      {
       cl_object v12;
       v12 = v1bit_stream;
       (v12)->instance.slots[(cl_fixnum)(3)]=v11;
      }
     }
     T0 = v10;
     goto L243;
    }
L257:;
    {
     cl_object v11;
     {
      cl_object v12;
      {
       cl_object v13;
       v13 = ecl_make_int8_t(7);
       {
        cl_object v14;
        v14 = ecl_make_int8_t(0);
        if (!(ECL_FIXNUMP(v13)||ECL_BIGNUMP(v13))){
         goto L273;
        }
        v14 = v13;
        T1 = ecl_make_bool(ecl_greatereq(v14,ecl_make_int8_t(0)));
        goto L270;
L273:;
        T1 = ECL_NIL;
        goto L270;
       }
L270:;
       if (ecl_unlikely(!((T1)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v13);
       value0 = ECL_NIL;
       cl_env_copy->nvalues = 0;
       v12 = v13;
      }
      T1 = cl_ash(ecl_make_int8_t(-1), v12);
      T2 = ecl_boole(ECL_BOOLXOR,(T1),ecl_make_fixnum(-1));
      T3 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
      T4 = ecl_negate(ecl_make_int8_t(0));
      T5 = cl_ash(T3, T4);
      v11 = ecl_boole(ECL_BOOLAND,(T2),(T5));
     }
     {
      cl_object v12;
      T1 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
      T2 = ecl_negate(ecl_make_int8_t(7));
      v12 = cl_ash(T1, T2);
      {
       cl_object v13;
       v13 = v1bit_stream;
       (v13)->instance.slots[(cl_fixnum)(2)]=v12;
      }
     }
     {
      cl_object v12;
      T1 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
      v12 = ecl_minus(T1,ecl_make_int8_t(7));
      {
       cl_object v13;
       v13 = v1bit_stream;
       (v13)->instance.slots[(cl_fixnum)(3)]=v12;
      }
     }
     T0 = v11;
    }
L243:;
    v9length = ecl_plus(ecl_make_int8_t(11),T0);
    {
     cl_object v10i;
     v10i = ecl_make_int8_t(0);
     goto L286;
L285:;
     T0 = ecl_plus(v5index,v10i);
     (v4)->array.self.fix[ecl_fixnum(T0)]= (cl_fixnum)(0);
     v10i = ecl_one_plus(v10i);
L286:;
     if (!(ecl_lower(v10i,v9length))){
      goto L291;
     }
     goto L285;
L291:;
    }
    v5index = ecl_plus(v5index,v9length);
    goto L8;
   }
L240:;
   si_ecase_error(v6code, VV[111]);
  }
L8:;
L6:;
  if (ecl_greatereq(v5index,v2count)) {
   goto L294;
  }
  goto L5;
L294:;
  value0 = v4;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L5459decode_code_length_entries_va(cl_narg narg, cl_object v6bit_stream, cl_object v7count, cl_object v8decode_tree, ...)
{
 return L5459decode_code_length_entries(v6bit_stream, v7count, v8decode_tree);
}
/* function definition for DECODE-HUFFMAN-TABLES                              */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5460decode_huffman_tables(cl_object v1bit_stream)
{
 cl_object T0, T1, T2, T3, T4, T5;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 {
  cl_object v2hlit;
  cl_object v3hdist;
  cl_object v4hclen;
L4:;
  T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
  if (ecl_lower(T0,ecl_make_int8_t(5))) {
   goto L6;
  }
  goto L5;
L6:;
  {
   cl_object v5;
   T0 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
   T2 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-STREAM */;
   T1 = cl_read_byte(1, T2);
   T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
   T3 = cl_ash(T1, T2);
   v5 = ecl_boole(ECL_BOOLIOR,(T0),(T3));
   {
    cl_object v6;
    v6 = v1bit_stream;
    (v6)->instance.slots[(cl_fixnum)(2)]=v5;
   }
  }
  {
   cl_object v5;
   T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
   v5 = ecl_plus(T0,ecl_make_int8_t(8));
   {
    cl_object v6;
    v6 = v1bit_stream;
    (v6)->instance.slots[(cl_fixnum)(3)]=v5;
   }
  }
  goto L4;
L5:;
  T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
  if (!(ecl_number_equalp(T0,ecl_make_int8_t(5)))){
   goto L16;
  }
  {
   cl_object v5;
   v5 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
   {
    cl_object v6;
    v6 = ecl_make_int8_t(0);
    {
     cl_object v7;
     v7 = v1bit_stream;
     (v7)->instance.slots[(cl_fixnum)(2)]=v6;
    }
   }
   {
    cl_object v6;
    v6 = ecl_make_int8_t(0);
    {
     cl_object v7;
     v7 = v1bit_stream;
     (v7)->instance.slots[(cl_fixnum)(3)]=v6;
    }
   }
   v2hlit = v5;
   goto L2;
  }
L16:;
  {
   cl_object v6;
   {
    cl_object v7;
    {
     cl_object v8;
     v8 = ecl_make_int8_t(5);
     {
      cl_object v9;
      v9 = ecl_make_int8_t(0);
      if (!(ECL_FIXNUMP(v8)||ECL_BIGNUMP(v8))){
       goto L32;
      }
      v9 = v8;
      T0 = ecl_make_bool(ecl_greatereq(v9,ecl_make_int8_t(0)));
      goto L29;
L32:;
      T0 = ECL_NIL;
      goto L29;
     }
L29:;
     if (ecl_unlikely(!((T0)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v7 = v8;
    }
    T0 = cl_ash(ecl_make_int8_t(-1), v7);
    T1 = ecl_boole(ECL_BOOLXOR,(T0),ecl_make_fixnum(-1));
    T2 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
    T3 = ecl_negate(ecl_make_int8_t(0));
    T4 = cl_ash(T2, T3);
    v6 = ecl_boole(ECL_BOOLAND,(T1),(T4));
   }
   {
    cl_object v7;
    T0 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
    T1 = ecl_negate(ecl_make_int8_t(5));
    v7 = cl_ash(T0, T1);
    {
     cl_object v8;
     v8 = v1bit_stream;
     (v8)->instance.slots[(cl_fixnum)(2)]=v7;
    }
   }
   {
    cl_object v7;
    T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
    v7 = ecl_minus(T0,ecl_make_int8_t(5));
    {
     cl_object v8;
     v8 = v1bit_stream;
     (v8)->instance.slots[(cl_fixnum)(3)]=v7;
    }
   }
   v2hlit = v6;
  }
L2:;
L44:;
  T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
  if (ecl_lower(T0,ecl_make_int8_t(5))) {
   goto L46;
  }
  goto L45;
L46:;
  {
   cl_object v5;
   T0 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
   T2 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-STREAM */;
   T1 = cl_read_byte(1, T2);
   T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
   T3 = cl_ash(T1, T2);
   v5 = ecl_boole(ECL_BOOLIOR,(T0),(T3));
   {
    cl_object v6;
    v6 = v1bit_stream;
    (v6)->instance.slots[(cl_fixnum)(2)]=v5;
   }
  }
  {
   cl_object v5;
   T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
   v5 = ecl_plus(T0,ecl_make_int8_t(8));
   {
    cl_object v6;
    v6 = v1bit_stream;
    (v6)->instance.slots[(cl_fixnum)(3)]=v5;
   }
  }
  goto L44;
L45:;
  T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
  if (!(ecl_number_equalp(T0,ecl_make_int8_t(5)))){
   goto L56;
  }
  {
   cl_object v5;
   v5 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
   {
    cl_object v6;
    v6 = ecl_make_int8_t(0);
    {
     cl_object v7;
     v7 = v1bit_stream;
     (v7)->instance.slots[(cl_fixnum)(2)]=v6;
    }
   }
   {
    cl_object v6;
    v6 = ecl_make_int8_t(0);
    {
     cl_object v7;
     v7 = v1bit_stream;
     (v7)->instance.slots[(cl_fixnum)(3)]=v6;
    }
   }
   v3hdist = v5;
   goto L42;
  }
L56:;
  {
   cl_object v6;
   {
    cl_object v7;
    {
     cl_object v8;
     v8 = ecl_make_int8_t(5);
     {
      cl_object v9;
      v9 = ecl_make_int8_t(0);
      if (!(ECL_FIXNUMP(v8)||ECL_BIGNUMP(v8))){
       goto L72;
      }
      v9 = v8;
      T0 = ecl_make_bool(ecl_greatereq(v9,ecl_make_int8_t(0)));
      goto L69;
L72:;
      T0 = ECL_NIL;
      goto L69;
     }
L69:;
     if (ecl_unlikely(!((T0)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v7 = v8;
    }
    T0 = cl_ash(ecl_make_int8_t(-1), v7);
    T1 = ecl_boole(ECL_BOOLXOR,(T0),ecl_make_fixnum(-1));
    T2 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
    T3 = ecl_negate(ecl_make_int8_t(0));
    T4 = cl_ash(T2, T3);
    v6 = ecl_boole(ECL_BOOLAND,(T1),(T4));
   }
   {
    cl_object v7;
    T0 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
    T1 = ecl_negate(ecl_make_int8_t(5));
    v7 = cl_ash(T0, T1);
    {
     cl_object v8;
     v8 = v1bit_stream;
     (v8)->instance.slots[(cl_fixnum)(2)]=v7;
    }
   }
   {
    cl_object v7;
    T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
    v7 = ecl_minus(T0,ecl_make_int8_t(5));
    {
     cl_object v8;
     v8 = v1bit_stream;
     (v8)->instance.slots[(cl_fixnum)(3)]=v7;
    }
   }
   v3hdist = v6;
  }
L42:;
L84:;
  T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
  if (ecl_lower(T0,ecl_make_int8_t(4))) {
   goto L86;
  }
  goto L85;
L86:;
  {
   cl_object v5;
   T0 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
   T2 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-STREAM */;
   T1 = cl_read_byte(1, T2);
   T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
   T3 = cl_ash(T1, T2);
   v5 = ecl_boole(ECL_BOOLIOR,(T0),(T3));
   {
    cl_object v6;
    v6 = v1bit_stream;
    (v6)->instance.slots[(cl_fixnum)(2)]=v5;
   }
  }
  {
   cl_object v5;
   T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
   v5 = ecl_plus(T0,ecl_make_int8_t(8));
   {
    cl_object v6;
    v6 = v1bit_stream;
    (v6)->instance.slots[(cl_fixnum)(3)]=v5;
   }
  }
  goto L84;
L85:;
  T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
  if (!(ecl_number_equalp(T0,ecl_make_int8_t(4)))){
   goto L96;
  }
  {
   cl_object v5;
   v5 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
   {
    cl_object v6;
    v6 = ecl_make_int8_t(0);
    {
     cl_object v7;
     v7 = v1bit_stream;
     (v7)->instance.slots[(cl_fixnum)(2)]=v6;
    }
   }
   {
    cl_object v6;
    v6 = ecl_make_int8_t(0);
    {
     cl_object v7;
     v7 = v1bit_stream;
     (v7)->instance.slots[(cl_fixnum)(3)]=v6;
    }
   }
   v4hclen = v5;
   goto L82;
  }
L96:;
  {
   cl_object v6;
   {
    cl_object v7;
    {
     cl_object v8;
     v8 = ecl_make_int8_t(4);
     {
      cl_object v9;
      v9 = ecl_make_int8_t(0);
      if (!(ECL_FIXNUMP(v8)||ECL_BIGNUMP(v8))){
       goto L112;
      }
      v9 = v8;
      T0 = ecl_make_bool(ecl_greatereq(v9,ecl_make_int8_t(0)));
      goto L109;
L112:;
      T0 = ECL_NIL;
      goto L109;
     }
L109:;
     if (ecl_unlikely(!((T0)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v7 = v8;
    }
    T0 = cl_ash(ecl_make_int8_t(-1), v7);
    T1 = ecl_boole(ECL_BOOLXOR,(T0),ecl_make_fixnum(-1));
    T2 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
    T3 = ecl_negate(ecl_make_int8_t(0));
    T4 = cl_ash(T2, T3);
    v6 = ecl_boole(ECL_BOOLAND,(T1),(T4));
   }
   {
    cl_object v7;
    T0 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
    T1 = ecl_negate(ecl_make_int8_t(4));
    v7 = cl_ash(T0, T1);
    {
     cl_object v8;
     v8 = v1bit_stream;
     (v8)->instance.slots[(cl_fixnum)(2)]=v7;
    }
   }
   {
    cl_object v7;
    T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
    v7 = ecl_minus(T0,ecl_make_int8_t(4));
    {
     cl_object v8;
     v8 = v1bit_stream;
     (v8)->instance.slots[(cl_fixnum)(3)]=v7;
    }
   }
   v4hclen = v6;
  }
L82:;
  {
   cl_object v5cl_decode_tree;
   {
    cl_object v6code_lengths;
    T0 = si_make_vector(ECL_SYM("BYTE8",1368), ecl_make_int8_t(19), ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_int8_t(0));
    v6code_lengths = si_fill_array_with_elt(T0, ecl_make_int8_t(0), ecl_make_int8_t(0), ECL_NIL);
    {
     cl_object v7;
     cl_object v8index;
     v7 = ecl_plus(v4hclen,ecl_make_int8_t(4));
     v8index = ecl_make_int8_t(0);
     {
      cl_object v9code_length;
      v9code_length = ECL_NIL;
      {
       cl_object v10code_index;
       v10code_index = ECL_NIL;
L128:;
       if (!(ecl_greatereq(v8index,v7))){
        goto L130;
       }
       goto L129;
L130:;
L135:;
       T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
       if (ecl_lower(T0,ecl_make_int8_t(3))) {
        goto L137;
       }
       goto L136;
L137:;
       {
        cl_object v11;
        T0 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
        T2 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-STREAM */;
        T1 = cl_read_byte(1, T2);
        T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
        T3 = cl_ash(T1, T2);
        v11 = ecl_boole(ECL_BOOLIOR,(T0),(T3));
        {
         cl_object v12;
         v12 = v1bit_stream;
         (v12)->instance.slots[(cl_fixnum)(2)]=v11;
        }
       }
       {
        cl_object v11;
        T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
        v11 = ecl_plus(T0,ecl_make_int8_t(8));
        {
         cl_object v12;
         v12 = v1bit_stream;
         (v12)->instance.slots[(cl_fixnum)(3)]=v11;
        }
       }
       goto L135;
L136:;
       T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
       if (!(ecl_number_equalp(T0,ecl_make_int8_t(3)))){
        goto L147;
       }
       {
        cl_object v11;
        v11 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
        {
         cl_object v12;
         v12 = ecl_make_int8_t(0);
         {
          cl_object v13;
          v13 = v1bit_stream;
          (v13)->instance.slots[(cl_fixnum)(2)]=v12;
         }
        }
        {
         cl_object v12;
         v12 = ecl_make_int8_t(0);
         {
          cl_object v13;
          v13 = v1bit_stream;
          (v13)->instance.slots[(cl_fixnum)(3)]=v12;
         }
        }
        v9code_length = v11;
        goto L133;
       }
L147:;
       {
        cl_object v12;
        {
         cl_object v13;
         {
          cl_object v14;
          v14 = ecl_make_int8_t(3);
          {
          cl_object v15;
          v15 = ecl_make_int8_t(0);
          if (!(ECL_FIXNUMP(v14)||ECL_BIGNUMP(v14))){
          goto L163;
          }
          v15 = v14;
          T0 = ecl_make_bool(ecl_greatereq(v15,ecl_make_int8_t(0)));
          goto L160;
L163:;
          T0 = ECL_NIL;
          goto L160;
          }
L160:;
          if (ecl_unlikely(!((T0)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v14);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          v13 = v14;
         }
         T0 = cl_ash(ecl_make_int8_t(-1), v13);
         T1 = ecl_boole(ECL_BOOLXOR,(T0),ecl_make_fixnum(-1));
         T2 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
         T3 = ecl_negate(ecl_make_int8_t(0));
         T4 = cl_ash(T2, T3);
         v12 = ecl_boole(ECL_BOOLAND,(T1),(T4));
        }
        {
         cl_object v13;
         T0 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
         T1 = ecl_negate(ecl_make_int8_t(3));
         v13 = cl_ash(T0, T1);
         {
          cl_object v14;
          v14 = v1bit_stream;
          (v14)->instance.slots[(cl_fixnum)(2)]=v13;
         }
        }
        {
         cl_object v13;
         T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
         v13 = ecl_minus(T0,ecl_make_int8_t(3));
         {
          cl_object v14;
          v14 = v1bit_stream;
          (v14)->instance.slots[(cl_fixnum)(3)]=v13;
         }
        }
        v9code_length = v12;
       }
L133:;
       {
        cl_object v11;
        v11 = ECL_SYM_VAL(cl_env_copy,VV[108]);
        v10code_index = ecl_aref_unsafe(v11,ecl_fixnum(v8index));
       }
       (v6code_lengths)->vector.self.b8[ecl_fixnum(v10code_index)]= ecl_fixnum(v9code_length);
       v8index = ecl_one_plus(v8index);
       goto L128;
L129:;
       v5cl_decode_tree = L5457make_huffman_decode_tree(v6code_lengths);
       goto L122;
      }
     }
    }
   }
L122:;
   {
    cl_object v6entries;
    T0 = ecl_plus(v2hlit,ecl_make_fixnum(257));
    T1 = ecl_plus(T0,v3hdist);
    T2 = ecl_plus(T1,ecl_make_int8_t(1));
    v6entries = L5459decode_code_length_entries(v1bit_stream, T2, v5cl_decode_tree);
    T0 = ecl_plus(v2hlit,ecl_make_fixnum(257));
    T1 = cl_subseq(3, v6entries, ecl_make_int8_t(0), T0);
    T2 = L5457make_huffman_decode_tree(T1);
    T3 = ecl_plus(v2hlit,ecl_make_fixnum(257));
    T4 = cl_subseq(2, v6entries, T3);
    T5 = L5457make_huffman_decode_tree(T4);
    cl_env_copy->nvalues = 2;
    cl_env_copy->values[1] = T5;
    cl_env_copy->values[0] = T2;
    return cl_env_copy->values[0];
   }
  }
 }
}
static cl_object L5460decode_huffman_tables_va(cl_narg narg, cl_object v7bit_stream, ...)
{
 return L5460decode_huffman_tables(v7bit_stream);
}
/* function definition for DECODE-LENGTH-ENTRY                                */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5461decode_length_entry(cl_object v1symbol, cl_object v2bit_stream)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 if (!(ecl_lowereq(v1symbol,ecl_make_fixnum(264)))){
  goto L2;
 }
 value0 = ecl_minus(v1symbol,ecl_make_uint8_t(254));
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 if (!(ecl_lowereq(v1symbol,ecl_make_fixnum(268)))){
  goto L4;
 }
 T0 = ecl_minus(v1symbol,ecl_make_fixnum(265));
 T1 = ecl_times(T0,ecl_make_int8_t(2));
 T2 = ecl_plus(ecl_make_int8_t(11),T1);
L8:;
 T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
 if (ecl_lower(T4,ecl_make_int8_t(1))) {
  goto L10;
 }
 goto L9;
L10:;
 {
  cl_object v3;
  T4 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BITS */;
  T6 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-STREAM */;
  T5 = cl_read_byte(1, T6);
  T6 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
  T7 = cl_ash(T5, T6);
  v3 = ecl_boole(ECL_BOOLIOR,(T4),(T7));
  {
   cl_object v4;
   v4 = v2bit_stream;
   (v4)->instance.slots[(cl_fixnum)(2)]=v3;
  }
 }
 {
  cl_object v3;
  T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
  v3 = ecl_plus(T4,ecl_make_int8_t(8));
  {
   cl_object v4;
   v4 = v2bit_stream;
   (v4)->instance.slots[(cl_fixnum)(3)]=v3;
  }
 }
 goto L8;
L9:;
 T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
 if (!(ecl_number_equalp(T4,ecl_make_int8_t(1)))){
  goto L20;
 }
 {
  cl_object v3;
  v3 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BITS */;
  {
   cl_object v4;
   v4 = ecl_make_int8_t(0);
   {
    cl_object v5;
    v5 = v2bit_stream;
    (v5)->instance.slots[(cl_fixnum)(2)]=v4;
   }
  }
  {
   cl_object v4;
   v4 = ecl_make_int8_t(0);
   {
    cl_object v5;
    v5 = v2bit_stream;
    (v5)->instance.slots[(cl_fixnum)(3)]=v4;
   }
  }
  T3 = v3;
  goto L6;
 }
L20:;
 {
  cl_object v4;
  {
   cl_object v5;
   {
    cl_object v6;
    v6 = ecl_make_int8_t(1);
    {
     cl_object v7;
     v7 = ecl_make_int8_t(0);
     if (!(ECL_FIXNUMP(v6)||ECL_BIGNUMP(v6))){
      goto L36;
     }
     v7 = v6;
     T4 = ecl_make_bool(ecl_greatereq(v7,ecl_make_int8_t(0)));
     goto L33;
L36:;
     T4 = ECL_NIL;
     goto L33;
    }
L33:;
    if (ecl_unlikely(!((T4)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v6);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v5 = v6;
   }
   T4 = cl_ash(ecl_make_int8_t(-1), v5);
   T5 = ecl_boole(ECL_BOOLXOR,(T4),ecl_make_fixnum(-1));
   T6 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BITS */;
   T7 = ecl_negate(ecl_make_int8_t(0));
   T8 = cl_ash(T6, T7);
   v4 = ecl_boole(ECL_BOOLAND,(T5),(T8));
  }
  {
   cl_object v5;
   T4 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BITS */;
   T5 = ecl_negate(ecl_make_int8_t(1));
   v5 = cl_ash(T4, T5);
   {
    cl_object v6;
    v6 = v2bit_stream;
    (v6)->instance.slots[(cl_fixnum)(2)]=v5;
   }
  }
  {
   cl_object v5;
   T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
   v5 = ecl_minus(T4,ecl_make_int8_t(1));
   {
    cl_object v6;
    v6 = v2bit_stream;
    (v6)->instance.slots[(cl_fixnum)(3)]=v5;
   }
  }
  T3 = v4;
 }
L6:;
 value0 = ecl_plus(T2,T3);
 cl_env_copy->nvalues = 1;
 return value0;
L4:;
 if (!(ecl_lowereq(v1symbol,ecl_make_fixnum(272)))){
  goto L46;
 }
 T0 = ecl_minus(v1symbol,ecl_make_fixnum(269));
 T1 = ecl_times(T0,ecl_make_int8_t(4));
 T2 = ecl_plus(ecl_make_int8_t(19),T1);
L50:;
 T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
 if (ecl_lower(T4,ecl_make_int8_t(2))) {
  goto L52;
 }
 goto L51;
L52:;
 {
  cl_object v3;
  T4 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BITS */;
  T6 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-STREAM */;
  T5 = cl_read_byte(1, T6);
  T6 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
  T7 = cl_ash(T5, T6);
  v3 = ecl_boole(ECL_BOOLIOR,(T4),(T7));
  {
   cl_object v4;
   v4 = v2bit_stream;
   (v4)->instance.slots[(cl_fixnum)(2)]=v3;
  }
 }
 {
  cl_object v3;
  T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
  v3 = ecl_plus(T4,ecl_make_int8_t(8));
  {
   cl_object v4;
   v4 = v2bit_stream;
   (v4)->instance.slots[(cl_fixnum)(3)]=v3;
  }
 }
 goto L50;
L51:;
 T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
 if (!(ecl_number_equalp(T4,ecl_make_int8_t(2)))){
  goto L62;
 }
 {
  cl_object v3;
  v3 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BITS */;
  {
   cl_object v4;
   v4 = ecl_make_int8_t(0);
   {
    cl_object v5;
    v5 = v2bit_stream;
    (v5)->instance.slots[(cl_fixnum)(2)]=v4;
   }
  }
  {
   cl_object v4;
   v4 = ecl_make_int8_t(0);
   {
    cl_object v5;
    v5 = v2bit_stream;
    (v5)->instance.slots[(cl_fixnum)(3)]=v4;
   }
  }
  T3 = v3;
  goto L48;
 }
L62:;
 {
  cl_object v4;
  {
   cl_object v5;
   {
    cl_object v6;
    v6 = ecl_make_int8_t(2);
    {
     cl_object v7;
     v7 = ecl_make_int8_t(0);
     if (!(ECL_FIXNUMP(v6)||ECL_BIGNUMP(v6))){
      goto L78;
     }
     v7 = v6;
     T4 = ecl_make_bool(ecl_greatereq(v7,ecl_make_int8_t(0)));
     goto L75;
L78:;
     T4 = ECL_NIL;
     goto L75;
    }
L75:;
    if (ecl_unlikely(!((T4)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v6);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v5 = v6;
   }
   T4 = cl_ash(ecl_make_int8_t(-1), v5);
   T5 = ecl_boole(ECL_BOOLXOR,(T4),ecl_make_fixnum(-1));
   T6 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BITS */;
   T7 = ecl_negate(ecl_make_int8_t(0));
   T8 = cl_ash(T6, T7);
   v4 = ecl_boole(ECL_BOOLAND,(T5),(T8));
  }
  {
   cl_object v5;
   T4 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BITS */;
   T5 = ecl_negate(ecl_make_int8_t(2));
   v5 = cl_ash(T4, T5);
   {
    cl_object v6;
    v6 = v2bit_stream;
    (v6)->instance.slots[(cl_fixnum)(2)]=v5;
   }
  }
  {
   cl_object v5;
   T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
   v5 = ecl_minus(T4,ecl_make_int8_t(2));
   {
    cl_object v6;
    v6 = v2bit_stream;
    (v6)->instance.slots[(cl_fixnum)(3)]=v5;
   }
  }
  T3 = v4;
 }
L48:;
 value0 = ecl_plus(T2,T3);
 cl_env_copy->nvalues = 1;
 return value0;
L46:;
 if (!(ecl_lowereq(v1symbol,ecl_make_fixnum(276)))){
  goto L88;
 }
 T0 = ecl_minus(v1symbol,ecl_make_fixnum(273));
 T1 = ecl_times(T0,ecl_make_int8_t(8));
 T2 = ecl_plus(ecl_make_int8_t(35),T1);
L92:;
 T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
 if (ecl_lower(T4,ecl_make_int8_t(3))) {
  goto L94;
 }
 goto L93;
L94:;
 {
  cl_object v3;
  T4 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BITS */;
  T6 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-STREAM */;
  T5 = cl_read_byte(1, T6);
  T6 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
  T7 = cl_ash(T5, T6);
  v3 = ecl_boole(ECL_BOOLIOR,(T4),(T7));
  {
   cl_object v4;
   v4 = v2bit_stream;
   (v4)->instance.slots[(cl_fixnum)(2)]=v3;
  }
 }
 {
  cl_object v3;
  T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
  v3 = ecl_plus(T4,ecl_make_int8_t(8));
  {
   cl_object v4;
   v4 = v2bit_stream;
   (v4)->instance.slots[(cl_fixnum)(3)]=v3;
  }
 }
 goto L92;
L93:;
 T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
 if (!(ecl_number_equalp(T4,ecl_make_int8_t(3)))){
  goto L104;
 }
 {
  cl_object v3;
  v3 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BITS */;
  {
   cl_object v4;
   v4 = ecl_make_int8_t(0);
   {
    cl_object v5;
    v5 = v2bit_stream;
    (v5)->instance.slots[(cl_fixnum)(2)]=v4;
   }
  }
  {
   cl_object v4;
   v4 = ecl_make_int8_t(0);
   {
    cl_object v5;
    v5 = v2bit_stream;
    (v5)->instance.slots[(cl_fixnum)(3)]=v4;
   }
  }
  T3 = v3;
  goto L90;
 }
L104:;
 {
  cl_object v4;
  {
   cl_object v5;
   {
    cl_object v6;
    v6 = ecl_make_int8_t(3);
    {
     cl_object v7;
     v7 = ecl_make_int8_t(0);
     if (!(ECL_FIXNUMP(v6)||ECL_BIGNUMP(v6))){
      goto L120;
     }
     v7 = v6;
     T4 = ecl_make_bool(ecl_greatereq(v7,ecl_make_int8_t(0)));
     goto L117;
L120:;
     T4 = ECL_NIL;
     goto L117;
    }
L117:;
    if (ecl_unlikely(!((T4)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v6);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v5 = v6;
   }
   T4 = cl_ash(ecl_make_int8_t(-1), v5);
   T5 = ecl_boole(ECL_BOOLXOR,(T4),ecl_make_fixnum(-1));
   T6 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BITS */;
   T7 = ecl_negate(ecl_make_int8_t(0));
   T8 = cl_ash(T6, T7);
   v4 = ecl_boole(ECL_BOOLAND,(T5),(T8));
  }
  {
   cl_object v5;
   T4 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BITS */;
   T5 = ecl_negate(ecl_make_int8_t(3));
   v5 = cl_ash(T4, T5);
   {
    cl_object v6;
    v6 = v2bit_stream;
    (v6)->instance.slots[(cl_fixnum)(2)]=v5;
   }
  }
  {
   cl_object v5;
   T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
   v5 = ecl_minus(T4,ecl_make_int8_t(3));
   {
    cl_object v6;
    v6 = v2bit_stream;
    (v6)->instance.slots[(cl_fixnum)(3)]=v5;
   }
  }
  T3 = v4;
 }
L90:;
 value0 = ecl_plus(T2,T3);
 cl_env_copy->nvalues = 1;
 return value0;
L88:;
 if (!(ecl_lowereq(v1symbol,ecl_make_fixnum(280)))){
  goto L130;
 }
 T0 = ecl_minus(v1symbol,ecl_make_fixnum(277));
 T1 = ecl_times(T0,ecl_make_int8_t(16));
 T2 = ecl_plus(ecl_make_int8_t(67),T1);
L134:;
 T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
 if (ecl_lower(T4,ecl_make_int8_t(4))) {
  goto L136;
 }
 goto L135;
L136:;
 {
  cl_object v3;
  T4 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BITS */;
  T6 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-STREAM */;
  T5 = cl_read_byte(1, T6);
  T6 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
  T7 = cl_ash(T5, T6);
  v3 = ecl_boole(ECL_BOOLIOR,(T4),(T7));
  {
   cl_object v4;
   v4 = v2bit_stream;
   (v4)->instance.slots[(cl_fixnum)(2)]=v3;
  }
 }
 {
  cl_object v3;
  T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
  v3 = ecl_plus(T4,ecl_make_int8_t(8));
  {
   cl_object v4;
   v4 = v2bit_stream;
   (v4)->instance.slots[(cl_fixnum)(3)]=v3;
  }
 }
 goto L134;
L135:;
 T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
 if (!(ecl_number_equalp(T4,ecl_make_int8_t(4)))){
  goto L146;
 }
 {
  cl_object v3;
  v3 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BITS */;
  {
   cl_object v4;
   v4 = ecl_make_int8_t(0);
   {
    cl_object v5;
    v5 = v2bit_stream;
    (v5)->instance.slots[(cl_fixnum)(2)]=v4;
   }
  }
  {
   cl_object v4;
   v4 = ecl_make_int8_t(0);
   {
    cl_object v5;
    v5 = v2bit_stream;
    (v5)->instance.slots[(cl_fixnum)(3)]=v4;
   }
  }
  T3 = v3;
  goto L132;
 }
L146:;
 {
  cl_object v4;
  {
   cl_object v5;
   {
    cl_object v6;
    v6 = ecl_make_int8_t(4);
    {
     cl_object v7;
     v7 = ecl_make_int8_t(0);
     if (!(ECL_FIXNUMP(v6)||ECL_BIGNUMP(v6))){
      goto L162;
     }
     v7 = v6;
     T4 = ecl_make_bool(ecl_greatereq(v7,ecl_make_int8_t(0)));
     goto L159;
L162:;
     T4 = ECL_NIL;
     goto L159;
    }
L159:;
    if (ecl_unlikely(!((T4)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v6);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v5 = v6;
   }
   T4 = cl_ash(ecl_make_int8_t(-1), v5);
   T5 = ecl_boole(ECL_BOOLXOR,(T4),ecl_make_fixnum(-1));
   T6 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BITS */;
   T7 = ecl_negate(ecl_make_int8_t(0));
   T8 = cl_ash(T6, T7);
   v4 = ecl_boole(ECL_BOOLAND,(T5),(T8));
  }
  {
   cl_object v5;
   T4 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BITS */;
   T5 = ecl_negate(ecl_make_int8_t(4));
   v5 = cl_ash(T4, T5);
   {
    cl_object v6;
    v6 = v2bit_stream;
    (v6)->instance.slots[(cl_fixnum)(2)]=v5;
   }
  }
  {
   cl_object v5;
   T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
   v5 = ecl_minus(T4,ecl_make_int8_t(4));
   {
    cl_object v6;
    v6 = v2bit_stream;
    (v6)->instance.slots[(cl_fixnum)(3)]=v5;
   }
  }
  T3 = v4;
 }
L132:;
 value0 = ecl_plus(T2,T3);
 cl_env_copy->nvalues = 1;
 return value0;
L130:;
 if (!(ecl_lowereq(v1symbol,ecl_make_fixnum(284)))){
  goto L172;
 }
 T0 = ecl_minus(v1symbol,ecl_make_fixnum(281));
 T1 = ecl_times(T0,ecl_make_int8_t(32));
 T2 = ecl_plus(ecl_make_uint8_t(131),T1);
L176:;
 T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
 if (ecl_lower(T4,ecl_make_int8_t(5))) {
  goto L178;
 }
 goto L177;
L178:;
 {
  cl_object v3;
  T4 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BITS */;
  T6 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-STREAM */;
  T5 = cl_read_byte(1, T6);
  T6 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
  T7 = cl_ash(T5, T6);
  v3 = ecl_boole(ECL_BOOLIOR,(T4),(T7));
  {
   cl_object v4;
   v4 = v2bit_stream;
   (v4)->instance.slots[(cl_fixnum)(2)]=v3;
  }
 }
 {
  cl_object v3;
  T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
  v3 = ecl_plus(T4,ecl_make_int8_t(8));
  {
   cl_object v4;
   v4 = v2bit_stream;
   (v4)->instance.slots[(cl_fixnum)(3)]=v3;
  }
 }
 goto L176;
L177:;
 T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
 if (!(ecl_number_equalp(T4,ecl_make_int8_t(5)))){
  goto L188;
 }
 {
  cl_object v3;
  v3 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BITS */;
  {
   cl_object v4;
   v4 = ecl_make_int8_t(0);
   {
    cl_object v5;
    v5 = v2bit_stream;
    (v5)->instance.slots[(cl_fixnum)(2)]=v4;
   }
  }
  {
   cl_object v4;
   v4 = ecl_make_int8_t(0);
   {
    cl_object v5;
    v5 = v2bit_stream;
    (v5)->instance.slots[(cl_fixnum)(3)]=v4;
   }
  }
  T3 = v3;
  goto L174;
 }
L188:;
 {
  cl_object v4;
  {
   cl_object v5;
   {
    cl_object v6;
    v6 = ecl_make_int8_t(5);
    {
     cl_object v7;
     v7 = ecl_make_int8_t(0);
     if (!(ECL_FIXNUMP(v6)||ECL_BIGNUMP(v6))){
      goto L204;
     }
     v7 = v6;
     T4 = ecl_make_bool(ecl_greatereq(v7,ecl_make_int8_t(0)));
     goto L201;
L204:;
     T4 = ECL_NIL;
     goto L201;
    }
L201:;
    if (ecl_unlikely(!((T4)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v6);
    value0 = ECL_NIL;
    cl_env_copy->nvalues = 0;
    v5 = v6;
   }
   T4 = cl_ash(ecl_make_int8_t(-1), v5);
   T5 = ecl_boole(ECL_BOOLXOR,(T4),ecl_make_fixnum(-1));
   T6 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BITS */;
   T7 = ecl_negate(ecl_make_int8_t(0));
   T8 = cl_ash(T6, T7);
   v4 = ecl_boole(ECL_BOOLAND,(T5),(T8));
  }
  {
   cl_object v5;
   T4 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BITS */;
   T5 = ecl_negate(ecl_make_int8_t(5));
   v5 = cl_ash(T4, T5);
   {
    cl_object v6;
    v6 = v2bit_stream;
    (v6)->instance.slots[(cl_fixnum)(2)]=v5;
   }
  }
  {
   cl_object v5;
   T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
   v5 = ecl_minus(T4,ecl_make_int8_t(5));
   {
    cl_object v6;
    v6 = v2bit_stream;
    (v6)->instance.slots[(cl_fixnum)(3)]=v5;
   }
  }
  T3 = v4;
 }
L174:;
 value0 = ecl_plus(T2,T3);
 cl_env_copy->nvalues = 1;
 return value0;
L172:;
 if (!(ecl_number_equalp(v1symbol,ecl_make_fixnum(285)))){
  goto L214;
 }
 value0 = ecl_make_fixnum(258);
 cl_env_copy->nvalues = 1;
 return value0;
L214:;
 T0 = ecl_list1(v1symbol);
 value0 = cl_error(5, VV[2], ECL_SYM("FORMAT-CONTROL",1272), VV[116], ECL_SYM("FORMAT-ARGUMENTS",1271), T0);
 return value0;
}
static cl_object L5461decode_length_entry_va(cl_narg narg, cl_object v3symbol, cl_object v4bit_stream, ...)
{
 return L5461decode_length_entry(v3symbol, v4bit_stream);
}
/* function definition for DECODE-DISTANCE-ENTRY                              */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5462decode_distance_entry(cl_object v1symbol, cl_object v2bit_stream)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 if (!(ecl_lowereq(v1symbol,ecl_make_int8_t(3)))){
  goto L2;
 }
 value0 = ecl_one_plus(v1symbol);
 cl_env_copy->nvalues = 1;
 return value0;
L2:;
 {
  cl_object v3;                                   /*  ORDER                   */
  cl_object v4;                                   /*  OFFSET                  */
  value0 = ecl_truncate2(v1symbol,ecl_make_int8_t(2));
  {
   v3 = value0;
   v4 = cl_env_copy->values[1];
  }
  {
   cl_object v5extra_bits;
   cl_object v6factor;
   v5extra_bits = ecl_one_minus(v3);
   v6factor = cl_ash(ecl_make_int8_t(1), v5extra_bits);
   T0 = cl_ash(ecl_make_int8_t(1), v3);
   T1 = ecl_one_plus(T0);
   T2 = ecl_times(v4,v6factor);
   T3 = ecl_plus(T1,T2);
L9:;
   T5 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
   if (ecl_lower(T5,v5extra_bits)) {
    goto L11;
   }
   goto L10;
L11:;
   {
    cl_object v7;
    T5 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BITS */;
    T7 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-STREAM */;
    T6 = cl_read_byte(1, T7);
    T7 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
    T8 = cl_ash(T6, T7);
    v7 = ecl_boole(ECL_BOOLIOR,(T5),(T8));
    {
     cl_object v8;
     v8 = v2bit_stream;
     (v8)->instance.slots[(cl_fixnum)(2)]=v7;
    }
   }
   {
    cl_object v7;
    T5 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
    v7 = ecl_plus(T5,ecl_make_int8_t(8));
    {
     cl_object v8;
     v8 = v2bit_stream;
     (v8)->instance.slots[(cl_fixnum)(3)]=v7;
    }
   }
   goto L9;
L10:;
   T5 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
   if (!(ecl_number_equalp(T5,v5extra_bits))){
    goto L21;
   }
   {
    cl_object v7;
    v7 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BITS */;
    {
     cl_object v8;
     v8 = ecl_make_int8_t(0);
     {
      cl_object v9;
      v9 = v2bit_stream;
      (v9)->instance.slots[(cl_fixnum)(2)]=v8;
     }
    }
    {
     cl_object v8;
     v8 = ecl_make_int8_t(0);
     {
      cl_object v9;
      v9 = v2bit_stream;
      (v9)->instance.slots[(cl_fixnum)(3)]=v8;
     }
    }
    T4 = v7;
    goto L7;
   }
L21:;
   {
    cl_object v8;
    {
     cl_object v9;
     {
      cl_object v10;
      v10 = v5extra_bits;
      {
       cl_object v11;
       v11 = ecl_make_int8_t(0);
       if (!(ECL_FIXNUMP(v10)||ECL_BIGNUMP(v10))){
        goto L37;
       }
       v11 = v10;
       T5 = ecl_make_bool(ecl_greatereq(v11,ecl_make_int8_t(0)));
       goto L34;
L37:;
       T5 = ECL_NIL;
       goto L34;
      }
L34:;
      if (ecl_unlikely(!((T5)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v10);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v9 = v10;
     }
     T5 = cl_ash(ecl_make_int8_t(-1), v9);
     T6 = ecl_boole(ECL_BOOLXOR,(T5),ecl_make_fixnum(-1));
     T7 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BITS */;
     T8 = ecl_negate(ecl_make_int8_t(0));
     T9 = cl_ash(T7, T8);
     v8 = ecl_boole(ECL_BOOLAND,(T6),(T9));
    }
    {
     cl_object v9;
     T5 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BITS */;
     T6 = ecl_negate(v5extra_bits);
     v9 = cl_ash(T5, T6);
     {
      cl_object v10;
      v10 = v2bit_stream;
      (v10)->instance.slots[(cl_fixnum)(2)]=v9;
     }
    }
    {
     cl_object v9;
     T5 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v2bit_stream) /*  BIT-STREAM-BIT-COUNT */;
     v9 = ecl_minus(T5,v5extra_bits);
     {
      cl_object v10;
      v10 = v2bit_stream;
      (v10)->instance.slots[(cl_fixnum)(3)]=v9;
     }
    }
    T4 = v8;
   }
L7:;
   value0 = ecl_plus(T3,T4);
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
static cl_object L5462decode_distance_entry_va(cl_narg narg, cl_object v3symbol, cl_object v4bit_stream, ...)
{
 return L5462decode_distance_entry(v3symbol, v4bit_stream);
}
/* function definition for DECODE-HUFFMAN-BLOCK                               */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5463decode_huffman_block(cl_object v1bit_stream, cl_object v2window_stream, cl_object v3lit_decode_tree, cl_object v4dist_decode_tree)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 {
  cl_object v5symbol;
  {
   cl_object v6length_count;
   v6length_count = (cl_env_copy->function=(VV[95]->symbol.gfdef))->cfun.entry(1, v3lit_decode_tree) /*  DECODE-TREE-LENGTH-COUNT */;
   {
    cl_object v7code_symbols;
    v7code_symbols = (cl_env_copy->function=(VV[93]->symbol.gfdef))->cfun.entry(1, v3lit_decode_tree) /*  DECODE-TREE-CODE-SYMBOLS */;
    {
     cl_fixnum v8code;
     v8code = (cl_fixnum)(0);
     {
      cl_fixnum v9index;
      v9index = (cl_fixnum)(0);
      {
       cl_fixnum v10first;
       v10first = (cl_fixnum)(0);
       {
        cl_fixnum v11;
        cl_fixnum v12length;
        v11 = (v6length_count)->vector.fillp;
        v12length = (cl_fixnum)(1);
        {
         cl_object v13count;
         v13count = ECL_NIL;
         {
          cl_object v14;
          v14 = ECL_NIL;
L17:;
          T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          if (ecl_lower(T0,ecl_make_int8_t(1))) {
          goto L19;
          }
          goto L18;
L19:;
          {
          cl_object v15;
          T0 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T2 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-STREAM */;
          T1 = cl_read_byte(1, T2);
          T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          T3 = cl_ash(T1, T2);
          v15 = ecl_boole(ECL_BOOLIOR,(T0),(T3));
          {
          cl_object v16;
          v16 = v1bit_stream;
          (v16)->instance.slots[(cl_fixnum)(2)]=v15;
          }
          }
          {
          cl_object v15;
          T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          v15 = ecl_plus(T0,ecl_make_int8_t(8));
          {
          cl_object v16;
          v16 = v1bit_stream;
          (v16)->instance.slots[(cl_fixnum)(3)]=v15;
          }
          }
          goto L17;
L18:;
          T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          if (!(ecl_number_equalp(T0,ecl_make_int8_t(1)))){
          goto L29;
          }
          {
          cl_object v15;
          v15 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          {
          cl_object v16;
          v16 = ecl_make_int8_t(0);
          {
          cl_object v17;
          v17 = v1bit_stream;
          (v17)->instance.slots[(cl_fixnum)(2)]=v16;
          }
          }
          {
          cl_object v16;
          v16 = ecl_make_int8_t(0);
          {
          cl_object v17;
          v17 = v1bit_stream;
          (v17)->instance.slots[(cl_fixnum)(3)]=v16;
          }
          }
          v8code = ecl_fixnum(v15);
          goto L15;
          }
L29:;
          {
          cl_object v16;
          {
          cl_object v17;
          {
          cl_object v18;
          v18 = ecl_make_int8_t(1);
          {
          cl_object v19;
          v19 = ecl_make_int8_t(0);
          if (!(ECL_FIXNUMP(v18)||ECL_BIGNUMP(v18))){
          goto L45;
          }
          v19 = v18;
          T0 = ecl_make_bool(ecl_greatereq(v19,ecl_make_int8_t(0)));
          goto L42;
L45:;
          T0 = ECL_NIL;
          goto L42;
          }
L42:;
          if (ecl_unlikely(!((T0)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v18);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          v17 = v18;
          }
          T0 = cl_ash(ecl_make_int8_t(-1), v17);
          T1 = ecl_boole(ECL_BOOLXOR,(T0),ecl_make_fixnum(-1));
          T2 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T3 = ecl_negate(ecl_make_int8_t(0));
          T4 = cl_ash(T2, T3);
          v16 = ecl_boole(ECL_BOOLAND,(T1),(T4));
          }
          {
          cl_object v17;
          T0 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T1 = ecl_negate(ecl_make_int8_t(1));
          v17 = cl_ash(T0, T1);
          {
          cl_object v18;
          v18 = v1bit_stream;
          (v18)->instance.slots[(cl_fixnum)(2)]=v17;
          }
          }
          {
          cl_object v17;
          T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          v17 = ecl_minus(T0,ecl_make_int8_t(1));
          {
          cl_object v18;
          v18 = v1bit_stream;
          (v18)->instance.slots[(cl_fixnum)(3)]=v17;
          }
          }
          v8code = ecl_fixnum(v16);
          }
L15:;
          v9index = (cl_fixnum)(0);
          v10first = (cl_fixnum)(0);
L12:;
          if (!((v12length)>=(v11))){
          goto L59;
          }
          goto L13;
L59:;
          v13count = ecl_make_int64_t((v6length_count)->vector.self.i64[v12length]);
          T0 = ecl_plus(ecl_make_fixnum(v10first),v13count);
          if (!((v8code)<(ecl_fixnum(T0)))){
          goto L66;
          }
          T0 = ecl_minus(ecl_make_fixnum(v8code),ecl_make_fixnum(v10first));
          T1 = ecl_plus(ecl_make_fixnum(v9index),T0);
          v14 = ecl_aref_unsafe(v7code_symbols,ecl_fixnum(T1));
          goto L65;
L66:;
          v14 = ECL_NIL;
L65:;
          if (Null(v14)){
          goto L63;
          }
          v5symbol = v14;
          goto L2;
L63:;
          T0 = ecl_times(ecl_make_fixnum(v8code),ecl_make_int8_t(2));
L72:;
          T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          if (ecl_lower(T2,ecl_make_int8_t(1))) {
          goto L74;
          }
          goto L73;
L74:;
          {
          cl_object v15;
          T2 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T4 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-STREAM */;
          T3 = cl_read_byte(1, T4);
          T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          T5 = cl_ash(T3, T4);
          v15 = ecl_boole(ECL_BOOLIOR,(T2),(T5));
          {
          cl_object v16;
          v16 = v1bit_stream;
          (v16)->instance.slots[(cl_fixnum)(2)]=v15;
          }
          }
          {
          cl_object v15;
          T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          v15 = ecl_plus(T2,ecl_make_int8_t(8));
          {
          cl_object v16;
          v16 = v1bit_stream;
          (v16)->instance.slots[(cl_fixnum)(3)]=v15;
          }
          }
          goto L72;
L73:;
          T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          if (!(ecl_number_equalp(T2,ecl_make_int8_t(1)))){
          goto L84;
          }
          {
          cl_object v15;
          v15 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          {
          cl_object v16;
          v16 = ecl_make_int8_t(0);
          {
          cl_object v17;
          v17 = v1bit_stream;
          (v17)->instance.slots[(cl_fixnum)(2)]=v16;
          }
          }
          {
          cl_object v16;
          v16 = ecl_make_int8_t(0);
          {
          cl_object v17;
          v17 = v1bit_stream;
          (v17)->instance.slots[(cl_fixnum)(3)]=v16;
          }
          }
          T1 = v15;
          goto L70;
          }
L84:;
          {
          cl_object v16;
          {
          cl_object v17;
          {
          cl_object v18;
          v18 = ecl_make_int8_t(1);
          {
          cl_object v19;
          v19 = ecl_make_int8_t(0);
          if (!(ECL_FIXNUMP(v18)||ECL_BIGNUMP(v18))){
          goto L100;
          }
          v19 = v18;
          T2 = ecl_make_bool(ecl_greatereq(v19,ecl_make_int8_t(0)));
          goto L97;
L100:;
          T2 = ECL_NIL;
          goto L97;
          }
L97:;
          if (ecl_unlikely(!((T2)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v18);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          v17 = v18;
          }
          T2 = cl_ash(ecl_make_int8_t(-1), v17);
          T3 = ecl_boole(ECL_BOOLXOR,(T2),ecl_make_fixnum(-1));
          T4 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T5 = ecl_negate(ecl_make_int8_t(0));
          T6 = cl_ash(T4, T5);
          v16 = ecl_boole(ECL_BOOLAND,(T3),(T6));
          }
          {
          cl_object v17;
          T2 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T3 = ecl_negate(ecl_make_int8_t(1));
          v17 = cl_ash(T2, T3);
          {
          cl_object v18;
          v18 = v1bit_stream;
          (v18)->instance.slots[(cl_fixnum)(2)]=v17;
          }
          }
          {
          cl_object v17;
          T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          v17 = ecl_minus(T2,ecl_make_int8_t(1));
          {
          cl_object v18;
          v18 = v1bit_stream;
          (v18)->instance.slots[(cl_fixnum)(3)]=v17;
          }
          }
          T1 = v16;
          }
L70:;
          v8code = ecl_fixnum(ecl_plus(T0,T1));
          v9index = ecl_fixnum(ecl_plus(ecl_make_fixnum(v9index),v13count));
          T0 = ecl_plus(ecl_make_fixnum(v10first),v13count);
          v10first = ecl_fixnum(ecl_times(T0,ecl_make_int8_t(2)));
          v12length = (v12length)+1;
          goto L12;
L13:;
          T0 = ecl_list1(ecl_make_fixnum(v8code));
          cl_error(5, VV[2], ECL_SYM("FORMAT-CONTROL",1272), VV[104], ECL_SYM("FORMAT-ARGUMENTS",1271), T0);
          v5symbol = ECL_NIL;
         }
        }
       }
      }
     }
    }
   }
  }
L2:;
  goto L120;
L119:;
  if (!(ecl_lowereq(v5symbol,ecl_make_uint8_t(255)))){
   goto L123;
  }
  {
   cl_fixnum v6end;
   v6end = ecl_fixnum((cl_env_copy->function=(VV[46]->symbol.gfdef))->cfun.entry(1, v2window_stream) /*  SLIDING-WINDOW-STREAM-BUFFER-END */);
   if ((v6end)<(ecl_fixnum(ECL_SYM_VAL(cl_env_copy,VV[27])))) {
    goto L126;
   }
   T0 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, v2window_stream) /*  SLIDING-WINDOW-STREAM-BUFFER */;
   T1 = (cl_env_copy->function=(VV[49]->symbol.gfdef))->cfun.entry(1, v2window_stream) /*  SLIDING-WINDOW-STREAM-STREAM */;
   cl_write_sequence(2, T0, T1);
   {
    cl_object v7;
    v7 = (cl_env_copy->function=(VV[45]->symbol.gfdef))->cfun.entry(1, v2window_stream) /*  SLIDING-WINDOW-STREAM-CHECKSUM */;
    if (!((v7)==(VV[51]))){
     goto L131;
    }
    {
     cl_object v8;
     T0 = (cl_env_copy->function=(VV[42]->symbol.gfdef))->cfun.entry(1, v2window_stream) /*  SLIDING-WINDOW-STREAM-CHECKSUM-VALUE */;
     T1 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, v2window_stream) /*  SLIDING-WINDOW-STREAM-BUFFER */;
     v8 = L5439update_adler32_checksum(T0, T1, ECL_SYM_VAL(cl_env_copy,VV[27]));
     {
      cl_object v9;
      v9 = v2window_stream;
      (v9)->instance.slots[(cl_fixnum)(4)]=v8;
      goto L129;
     }
    }
L131:;
    if (!((v7)==(VV[52]))){
     goto L129;
    }
    {
     cl_object v10;
     T0 = (cl_env_copy->function=(VV[42]->symbol.gfdef))->cfun.entry(1, v2window_stream) /*  SLIDING-WINDOW-STREAM-CHECKSUM-VALUE */;
     T1 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, v2window_stream) /*  SLIDING-WINDOW-STREAM-BUFFER */;
     v10 = L5441update_crc32_checksum(T0, T1, ECL_SYM_VAL(cl_env_copy,VV[27]));
     {
      cl_object v11;
      v11 = v2window_stream;
      (v11)->instance.slots[(cl_fixnum)(4)]=v10;
     }
    }
   }
L129:;
   v6end = (cl_fixnum)(0);
L126:;
   {
    cl_object v7;
    v7 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, v2window_stream) /*  SLIDING-WINDOW-STREAM-BUFFER */;
    ecl_aset_unsafe(v7,v6end,v5symbol);
   }
   {
    cl_object v7;
    v7 = ecl_make_integer((v6end)+1);
    {
     cl_object v8;
     v8 = v2window_stream;
     (v8)->instance.slots[(cl_fixnum)(2)]=v7;
     goto L122;
    }
   }
  }
L123:;
  {
   cl_object v9;
   cl_object v10;
   if (!(ecl_lowereq(v5symbol,ecl_make_fixnum(264)))){
    goto L144;
   }
   v9 = ecl_minus(v5symbol,ecl_make_uint8_t(254));
   goto L143;
L144:;
   if (!(ecl_lowereq(v5symbol,ecl_make_fixnum(268)))){
    goto L146;
   }
   T0 = ecl_minus(v5symbol,ecl_make_fixnum(265));
   T1 = ecl_times(T0,ecl_make_int8_t(2));
   T2 = ecl_plus(ecl_make_int8_t(11),T1);
L150:;
   T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
   if (ecl_lower(T4,ecl_make_int8_t(1))) {
    goto L152;
   }
   goto L151;
L152:;
   {
    cl_object v11;
    T4 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
    T6 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-STREAM */;
    T5 = cl_read_byte(1, T6);
    T6 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
    T7 = cl_ash(T5, T6);
    v11 = ecl_boole(ECL_BOOLIOR,(T4),(T7));
    {
     cl_object v12;
     v12 = v1bit_stream;
     (v12)->instance.slots[(cl_fixnum)(2)]=v11;
    }
   }
   {
    cl_object v11;
    T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
    v11 = ecl_plus(T4,ecl_make_int8_t(8));
    {
     cl_object v12;
     v12 = v1bit_stream;
     (v12)->instance.slots[(cl_fixnum)(3)]=v11;
    }
   }
   goto L150;
L151:;
   T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
   if (!(ecl_number_equalp(T4,ecl_make_int8_t(1)))){
    goto L162;
   }
   {
    cl_object v11;
    v11 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
    {
     cl_object v12;
     v12 = ecl_make_int8_t(0);
     {
      cl_object v13;
      v13 = v1bit_stream;
      (v13)->instance.slots[(cl_fixnum)(2)]=v12;
     }
    }
    {
     cl_object v12;
     v12 = ecl_make_int8_t(0);
     {
      cl_object v13;
      v13 = v1bit_stream;
      (v13)->instance.slots[(cl_fixnum)(3)]=v12;
     }
    }
    T3 = v11;
    goto L148;
   }
L162:;
   {
    cl_object v12;
    {
     cl_object v13;
     {
      cl_object v14;
      v14 = ecl_make_int8_t(1);
      {
       cl_object v15;
       v15 = ecl_make_int8_t(0);
       if (!(ECL_FIXNUMP(v14)||ECL_BIGNUMP(v14))){
        goto L178;
       }
       v15 = v14;
       T4 = ecl_make_bool(ecl_greatereq(v15,ecl_make_int8_t(0)));
       goto L175;
L178:;
       T4 = ECL_NIL;
       goto L175;
      }
L175:;
      if (ecl_unlikely(!((T4)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v14);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v13 = v14;
     }
     T4 = cl_ash(ecl_make_int8_t(-1), v13);
     T5 = ecl_boole(ECL_BOOLXOR,(T4),ecl_make_fixnum(-1));
     T6 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
     T7 = ecl_negate(ecl_make_int8_t(0));
     T8 = cl_ash(T6, T7);
     v12 = ecl_boole(ECL_BOOLAND,(T5),(T8));
    }
    {
     cl_object v13;
     T4 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
     T5 = ecl_negate(ecl_make_int8_t(1));
     v13 = cl_ash(T4, T5);
     {
      cl_object v14;
      v14 = v1bit_stream;
      (v14)->instance.slots[(cl_fixnum)(2)]=v13;
     }
    }
    {
     cl_object v13;
     T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
     v13 = ecl_minus(T4,ecl_make_int8_t(1));
     {
      cl_object v14;
      v14 = v1bit_stream;
      (v14)->instance.slots[(cl_fixnum)(3)]=v13;
     }
    }
    T3 = v12;
   }
L148:;
   v9 = ecl_plus(T2,T3);
   goto L143;
L146:;
   if (!(ecl_lowereq(v5symbol,ecl_make_fixnum(272)))){
    goto L188;
   }
   T0 = ecl_minus(v5symbol,ecl_make_fixnum(269));
   T1 = ecl_times(T0,ecl_make_int8_t(4));
   T2 = ecl_plus(ecl_make_int8_t(19),T1);
L192:;
   T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
   if (ecl_lower(T4,ecl_make_int8_t(2))) {
    goto L194;
   }
   goto L193;
L194:;
   {
    cl_object v11;
    T4 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
    T6 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-STREAM */;
    T5 = cl_read_byte(1, T6);
    T6 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
    T7 = cl_ash(T5, T6);
    v11 = ecl_boole(ECL_BOOLIOR,(T4),(T7));
    {
     cl_object v12;
     v12 = v1bit_stream;
     (v12)->instance.slots[(cl_fixnum)(2)]=v11;
    }
   }
   {
    cl_object v11;
    T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
    v11 = ecl_plus(T4,ecl_make_int8_t(8));
    {
     cl_object v12;
     v12 = v1bit_stream;
     (v12)->instance.slots[(cl_fixnum)(3)]=v11;
    }
   }
   goto L192;
L193:;
   T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
   if (!(ecl_number_equalp(T4,ecl_make_int8_t(2)))){
    goto L204;
   }
   {
    cl_object v11;
    v11 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
    {
     cl_object v12;
     v12 = ecl_make_int8_t(0);
     {
      cl_object v13;
      v13 = v1bit_stream;
      (v13)->instance.slots[(cl_fixnum)(2)]=v12;
     }
    }
    {
     cl_object v12;
     v12 = ecl_make_int8_t(0);
     {
      cl_object v13;
      v13 = v1bit_stream;
      (v13)->instance.slots[(cl_fixnum)(3)]=v12;
     }
    }
    T3 = v11;
    goto L190;
   }
L204:;
   {
    cl_object v12;
    {
     cl_object v13;
     {
      cl_object v14;
      v14 = ecl_make_int8_t(2);
      {
       cl_object v15;
       v15 = ecl_make_int8_t(0);
       if (!(ECL_FIXNUMP(v14)||ECL_BIGNUMP(v14))){
        goto L220;
       }
       v15 = v14;
       T4 = ecl_make_bool(ecl_greatereq(v15,ecl_make_int8_t(0)));
       goto L217;
L220:;
       T4 = ECL_NIL;
       goto L217;
      }
L217:;
      if (ecl_unlikely(!((T4)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v14);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v13 = v14;
     }
     T4 = cl_ash(ecl_make_int8_t(-1), v13);
     T5 = ecl_boole(ECL_BOOLXOR,(T4),ecl_make_fixnum(-1));
     T6 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
     T7 = ecl_negate(ecl_make_int8_t(0));
     T8 = cl_ash(T6, T7);
     v12 = ecl_boole(ECL_BOOLAND,(T5),(T8));
    }
    {
     cl_object v13;
     T4 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
     T5 = ecl_negate(ecl_make_int8_t(2));
     v13 = cl_ash(T4, T5);
     {
      cl_object v14;
      v14 = v1bit_stream;
      (v14)->instance.slots[(cl_fixnum)(2)]=v13;
     }
    }
    {
     cl_object v13;
     T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
     v13 = ecl_minus(T4,ecl_make_int8_t(2));
     {
      cl_object v14;
      v14 = v1bit_stream;
      (v14)->instance.slots[(cl_fixnum)(3)]=v13;
     }
    }
    T3 = v12;
   }
L190:;
   v9 = ecl_plus(T2,T3);
   goto L143;
L188:;
   if (!(ecl_lowereq(v5symbol,ecl_make_fixnum(276)))){
    goto L230;
   }
   T0 = ecl_minus(v5symbol,ecl_make_fixnum(273));
   T1 = ecl_times(T0,ecl_make_int8_t(8));
   T2 = ecl_plus(ecl_make_int8_t(35),T1);
L234:;
   T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
   if (ecl_lower(T4,ecl_make_int8_t(3))) {
    goto L236;
   }
   goto L235;
L236:;
   {
    cl_object v11;
    T4 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
    T6 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-STREAM */;
    T5 = cl_read_byte(1, T6);
    T6 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
    T7 = cl_ash(T5, T6);
    v11 = ecl_boole(ECL_BOOLIOR,(T4),(T7));
    {
     cl_object v12;
     v12 = v1bit_stream;
     (v12)->instance.slots[(cl_fixnum)(2)]=v11;
    }
   }
   {
    cl_object v11;
    T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
    v11 = ecl_plus(T4,ecl_make_int8_t(8));
    {
     cl_object v12;
     v12 = v1bit_stream;
     (v12)->instance.slots[(cl_fixnum)(3)]=v11;
    }
   }
   goto L234;
L235:;
   T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
   if (!(ecl_number_equalp(T4,ecl_make_int8_t(3)))){
    goto L246;
   }
   {
    cl_object v11;
    v11 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
    {
     cl_object v12;
     v12 = ecl_make_int8_t(0);
     {
      cl_object v13;
      v13 = v1bit_stream;
      (v13)->instance.slots[(cl_fixnum)(2)]=v12;
     }
    }
    {
     cl_object v12;
     v12 = ecl_make_int8_t(0);
     {
      cl_object v13;
      v13 = v1bit_stream;
      (v13)->instance.slots[(cl_fixnum)(3)]=v12;
     }
    }
    T3 = v11;
    goto L232;
   }
L246:;
   {
    cl_object v12;
    {
     cl_object v13;
     {
      cl_object v14;
      v14 = ecl_make_int8_t(3);
      {
       cl_object v15;
       v15 = ecl_make_int8_t(0);
       if (!(ECL_FIXNUMP(v14)||ECL_BIGNUMP(v14))){
        goto L262;
       }
       v15 = v14;
       T4 = ecl_make_bool(ecl_greatereq(v15,ecl_make_int8_t(0)));
       goto L259;
L262:;
       T4 = ECL_NIL;
       goto L259;
      }
L259:;
      if (ecl_unlikely(!((T4)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v14);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v13 = v14;
     }
     T4 = cl_ash(ecl_make_int8_t(-1), v13);
     T5 = ecl_boole(ECL_BOOLXOR,(T4),ecl_make_fixnum(-1));
     T6 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
     T7 = ecl_negate(ecl_make_int8_t(0));
     T8 = cl_ash(T6, T7);
     v12 = ecl_boole(ECL_BOOLAND,(T5),(T8));
    }
    {
     cl_object v13;
     T4 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
     T5 = ecl_negate(ecl_make_int8_t(3));
     v13 = cl_ash(T4, T5);
     {
      cl_object v14;
      v14 = v1bit_stream;
      (v14)->instance.slots[(cl_fixnum)(2)]=v13;
     }
    }
    {
     cl_object v13;
     T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
     v13 = ecl_minus(T4,ecl_make_int8_t(3));
     {
      cl_object v14;
      v14 = v1bit_stream;
      (v14)->instance.slots[(cl_fixnum)(3)]=v13;
     }
    }
    T3 = v12;
   }
L232:;
   v9 = ecl_plus(T2,T3);
   goto L143;
L230:;
   if (!(ecl_lowereq(v5symbol,ecl_make_fixnum(280)))){
    goto L272;
   }
   T0 = ecl_minus(v5symbol,ecl_make_fixnum(277));
   T1 = ecl_times(T0,ecl_make_int8_t(16));
   T2 = ecl_plus(ecl_make_int8_t(67),T1);
L276:;
   T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
   if (ecl_lower(T4,ecl_make_int8_t(4))) {
    goto L278;
   }
   goto L277;
L278:;
   {
    cl_object v11;
    T4 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
    T6 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-STREAM */;
    T5 = cl_read_byte(1, T6);
    T6 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
    T7 = cl_ash(T5, T6);
    v11 = ecl_boole(ECL_BOOLIOR,(T4),(T7));
    {
     cl_object v12;
     v12 = v1bit_stream;
     (v12)->instance.slots[(cl_fixnum)(2)]=v11;
    }
   }
   {
    cl_object v11;
    T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
    v11 = ecl_plus(T4,ecl_make_int8_t(8));
    {
     cl_object v12;
     v12 = v1bit_stream;
     (v12)->instance.slots[(cl_fixnum)(3)]=v11;
    }
   }
   goto L276;
L277:;
   T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
   if (!(ecl_number_equalp(T4,ecl_make_int8_t(4)))){
    goto L288;
   }
   {
    cl_object v11;
    v11 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
    {
     cl_object v12;
     v12 = ecl_make_int8_t(0);
     {
      cl_object v13;
      v13 = v1bit_stream;
      (v13)->instance.slots[(cl_fixnum)(2)]=v12;
     }
    }
    {
     cl_object v12;
     v12 = ecl_make_int8_t(0);
     {
      cl_object v13;
      v13 = v1bit_stream;
      (v13)->instance.slots[(cl_fixnum)(3)]=v12;
     }
    }
    T3 = v11;
    goto L274;
   }
L288:;
   {
    cl_object v12;
    {
     cl_object v13;
     {
      cl_object v14;
      v14 = ecl_make_int8_t(4);
      {
       cl_object v15;
       v15 = ecl_make_int8_t(0);
       if (!(ECL_FIXNUMP(v14)||ECL_BIGNUMP(v14))){
        goto L304;
       }
       v15 = v14;
       T4 = ecl_make_bool(ecl_greatereq(v15,ecl_make_int8_t(0)));
       goto L301;
L304:;
       T4 = ECL_NIL;
       goto L301;
      }
L301:;
      if (ecl_unlikely(!((T4)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v14);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v13 = v14;
     }
     T4 = cl_ash(ecl_make_int8_t(-1), v13);
     T5 = ecl_boole(ECL_BOOLXOR,(T4),ecl_make_fixnum(-1));
     T6 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
     T7 = ecl_negate(ecl_make_int8_t(0));
     T8 = cl_ash(T6, T7);
     v12 = ecl_boole(ECL_BOOLAND,(T5),(T8));
    }
    {
     cl_object v13;
     T4 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
     T5 = ecl_negate(ecl_make_int8_t(4));
     v13 = cl_ash(T4, T5);
     {
      cl_object v14;
      v14 = v1bit_stream;
      (v14)->instance.slots[(cl_fixnum)(2)]=v13;
     }
    }
    {
     cl_object v13;
     T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
     v13 = ecl_minus(T4,ecl_make_int8_t(4));
     {
      cl_object v14;
      v14 = v1bit_stream;
      (v14)->instance.slots[(cl_fixnum)(3)]=v13;
     }
    }
    T3 = v12;
   }
L274:;
   v9 = ecl_plus(T2,T3);
   goto L143;
L272:;
   if (!(ecl_lowereq(v5symbol,ecl_make_fixnum(284)))){
    goto L314;
   }
   T0 = ecl_minus(v5symbol,ecl_make_fixnum(281));
   T1 = ecl_times(T0,ecl_make_int8_t(32));
   T2 = ecl_plus(ecl_make_uint8_t(131),T1);
L318:;
   T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
   if (ecl_lower(T4,ecl_make_int8_t(5))) {
    goto L320;
   }
   goto L319;
L320:;
   {
    cl_object v11;
    T4 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
    T6 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-STREAM */;
    T5 = cl_read_byte(1, T6);
    T6 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
    T7 = cl_ash(T5, T6);
    v11 = ecl_boole(ECL_BOOLIOR,(T4),(T7));
    {
     cl_object v12;
     v12 = v1bit_stream;
     (v12)->instance.slots[(cl_fixnum)(2)]=v11;
    }
   }
   {
    cl_object v11;
    T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
    v11 = ecl_plus(T4,ecl_make_int8_t(8));
    {
     cl_object v12;
     v12 = v1bit_stream;
     (v12)->instance.slots[(cl_fixnum)(3)]=v11;
    }
   }
   goto L318;
L319:;
   T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
   if (!(ecl_number_equalp(T4,ecl_make_int8_t(5)))){
    goto L330;
   }
   {
    cl_object v11;
    v11 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
    {
     cl_object v12;
     v12 = ecl_make_int8_t(0);
     {
      cl_object v13;
      v13 = v1bit_stream;
      (v13)->instance.slots[(cl_fixnum)(2)]=v12;
     }
    }
    {
     cl_object v12;
     v12 = ecl_make_int8_t(0);
     {
      cl_object v13;
      v13 = v1bit_stream;
      (v13)->instance.slots[(cl_fixnum)(3)]=v12;
     }
    }
    T3 = v11;
    goto L316;
   }
L330:;
   {
    cl_object v12;
    {
     cl_object v13;
     {
      cl_object v14;
      v14 = ecl_make_int8_t(5);
      {
       cl_object v15;
       v15 = ecl_make_int8_t(0);
       if (!(ECL_FIXNUMP(v14)||ECL_BIGNUMP(v14))){
        goto L346;
       }
       v15 = v14;
       T4 = ecl_make_bool(ecl_greatereq(v15,ecl_make_int8_t(0)));
       goto L343;
L346:;
       T4 = ECL_NIL;
       goto L343;
      }
L343:;
      if (ecl_unlikely(!((T4)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v14);
      value0 = ECL_NIL;
      cl_env_copy->nvalues = 0;
      v13 = v14;
     }
     T4 = cl_ash(ecl_make_int8_t(-1), v13);
     T5 = ecl_boole(ECL_BOOLXOR,(T4),ecl_make_fixnum(-1));
     T6 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
     T7 = ecl_negate(ecl_make_int8_t(0));
     T8 = cl_ash(T6, T7);
     v12 = ecl_boole(ECL_BOOLAND,(T5),(T8));
    }
    {
     cl_object v13;
     T4 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
     T5 = ecl_negate(ecl_make_int8_t(5));
     v13 = cl_ash(T4, T5);
     {
      cl_object v14;
      v14 = v1bit_stream;
      (v14)->instance.slots[(cl_fixnum)(2)]=v13;
     }
    }
    {
     cl_object v13;
     T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
     v13 = ecl_minus(T4,ecl_make_int8_t(5));
     {
      cl_object v14;
      v14 = v1bit_stream;
      (v14)->instance.slots[(cl_fixnum)(3)]=v13;
     }
    }
    T3 = v12;
   }
L316:;
   v9 = ecl_plus(T2,T3);
   goto L143;
L314:;
   if (!(ecl_number_equalp(v5symbol,ecl_make_fixnum(285)))){
    goto L356;
   }
   v9 = ecl_make_fixnum(258);
   goto L143;
L356:;
   T0 = ecl_list1(v5symbol);
   v9 = cl_error(5, VV[2], ECL_SYM("FORMAT-CONTROL",1272), VV[116], ECL_SYM("FORMAT-ARGUMENTS",1271), T0);
L143:;
   {
    cl_object v11;
    {
     cl_object v12length_count;
     v12length_count = (cl_env_copy->function=(VV[95]->symbol.gfdef))->cfun.entry(1, v4dist_decode_tree) /*  DECODE-TREE-LENGTH-COUNT */;
     {
      cl_object v13code_symbols;
      v13code_symbols = (cl_env_copy->function=(VV[93]->symbol.gfdef))->cfun.entry(1, v4dist_decode_tree) /*  DECODE-TREE-CODE-SYMBOLS */;
      {
       cl_fixnum v14code;
       v14code = (cl_fixnum)(0);
       {
        cl_fixnum v15index;
        v15index = (cl_fixnum)(0);
        {
         cl_fixnum v16first;
         v16first = (cl_fixnum)(0);
         {
          cl_fixnum v17;
          cl_fixnum v18length;
          v17 = (v12length_count)->vector.fillp;
          v18length = (cl_fixnum)(1);
          {
          cl_object v19count;
          v19count = ECL_NIL;
          {
          cl_object v20;
          v20 = ECL_NIL;
L374:;
          T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          if (ecl_lower(T0,ecl_make_int8_t(1))) {
          goto L376;
          }
          goto L375;
L376:;
          {
          cl_object v21;
          T0 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T1 = L5452bit_stream_get_byte(v1bit_stream);
          T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          T3 = cl_ash(T1, T2);
          v21 = ecl_boole(ECL_BOOLIOR,(T0),(T3));
          {
          cl_object v22;
          v22 = v1bit_stream;
          (v22)->instance.slots[(cl_fixnum)(2)]=v21;
          }
          }
          {
          cl_object v21;
          T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          v21 = ecl_plus(T0,ecl_make_int8_t(8));
          {
          cl_object v22;
          v22 = v1bit_stream;
          (v22)->instance.slots[(cl_fixnum)(3)]=v21;
          }
          }
          goto L374;
L375:;
          T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          if (!(ecl_number_equalp(T0,ecl_make_int8_t(1)))){
          goto L385;
          }
          {
          cl_object v21;
          v21 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          {
          cl_object v22;
          v22 = ecl_make_int8_t(0);
          {
          cl_object v23;
          v23 = v1bit_stream;
          (v23)->instance.slots[(cl_fixnum)(2)]=v22;
          }
          }
          {
          cl_object v22;
          v22 = ecl_make_int8_t(0);
          {
          cl_object v23;
          v23 = v1bit_stream;
          (v23)->instance.slots[(cl_fixnum)(3)]=v22;
          }
          }
          v14code = ecl_fixnum(v21);
          goto L372;
          }
L385:;
          {
          cl_object v22;
          {
          cl_object v23;
          {
          cl_object v24;
          v24 = ecl_make_int8_t(1);
          {
          cl_object v25;
          v25 = ecl_make_int8_t(0);
          if (!(ECL_FIXNUMP(v24)||ECL_BIGNUMP(v24))){
          goto L401;
          }
          v25 = v24;
          T0 = ecl_make_bool(ecl_greatereq(v25,ecl_make_int8_t(0)));
          goto L398;
L401:;
          T0 = ECL_NIL;
          goto L398;
          }
L398:;
          if (ecl_unlikely(!((T0)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v24);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          v23 = v24;
          }
          T0 = cl_ash(ecl_make_int8_t(-1), v23);
          T1 = ecl_boole(ECL_BOOLXOR,(T0),ecl_make_fixnum(-1));
          T2 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T3 = ecl_negate(ecl_make_int8_t(0));
          T4 = cl_ash(T2, T3);
          v22 = ecl_boole(ECL_BOOLAND,(T1),(T4));
          }
          {
          cl_object v23;
          T0 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T1 = ecl_negate(ecl_make_int8_t(1));
          v23 = cl_ash(T0, T1);
          {
          cl_object v24;
          v24 = v1bit_stream;
          (v24)->instance.slots[(cl_fixnum)(2)]=v23;
          }
          }
          {
          cl_object v23;
          T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          v23 = ecl_minus(T0,ecl_make_int8_t(1));
          {
          cl_object v24;
          v24 = v1bit_stream;
          (v24)->instance.slots[(cl_fixnum)(3)]=v23;
          }
          }
          v14code = ecl_fixnum(v22);
          }
L372:;
          v15index = (cl_fixnum)(0);
          v16first = (cl_fixnum)(0);
L369:;
          if (!((v18length)>=(v17))){
          goto L415;
          }
          goto L370;
L415:;
          v19count = ecl_make_int64_t((v12length_count)->vector.self.i64[v18length]);
          T0 = ecl_plus(ecl_make_fixnum(v16first),v19count);
          if (!((v14code)<(ecl_fixnum(T0)))){
          goto L422;
          }
          T0 = ecl_minus(ecl_make_fixnum(v14code),ecl_make_fixnum(v16first));
          T1 = ecl_plus(ecl_make_fixnum(v15index),T0);
          v20 = ecl_make_int64_t((v13code_symbols)->vector.self.i64[ecl_fixnum(T1)]);
          goto L421;
L422:;
          v20 = ECL_NIL;
L421:;
          if (Null(v20)){
          goto L419;
          }
          v11 = v20;
          goto L359;
L419:;
          T0 = ecl_times(ecl_make_fixnum(v14code),ecl_make_int8_t(2));
L428:;
          T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          if (ecl_lower(T2,ecl_make_int8_t(1))) {
          goto L430;
          }
          goto L429;
L430:;
          {
          cl_object v21;
          T2 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T3 = L5452bit_stream_get_byte(v1bit_stream);
          T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          T5 = cl_ash(T3, T4);
          v21 = ecl_boole(ECL_BOOLIOR,(T2),(T5));
          {
          cl_object v22;
          v22 = v1bit_stream;
          (v22)->instance.slots[(cl_fixnum)(2)]=v21;
          }
          }
          {
          cl_object v21;
          T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          v21 = ecl_plus(T2,ecl_make_int8_t(8));
          {
          cl_object v22;
          v22 = v1bit_stream;
          (v22)->instance.slots[(cl_fixnum)(3)]=v21;
          }
          }
          goto L428;
L429:;
          T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          if (!(ecl_number_equalp(T2,ecl_make_int8_t(1)))){
          goto L439;
          }
          {
          cl_object v21;
          v21 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          {
          cl_object v22;
          v22 = ecl_make_int8_t(0);
          {
          cl_object v23;
          v23 = v1bit_stream;
          (v23)->instance.slots[(cl_fixnum)(2)]=v22;
          }
          }
          {
          cl_object v22;
          v22 = ecl_make_int8_t(0);
          {
          cl_object v23;
          v23 = v1bit_stream;
          (v23)->instance.slots[(cl_fixnum)(3)]=v22;
          }
          }
          T1 = v21;
          goto L426;
          }
L439:;
          {
          cl_object v22;
          {
          cl_object v23;
          {
          cl_object v24;
          v24 = ecl_make_int8_t(1);
          {
          cl_object v25;
          v25 = ecl_make_int8_t(0);
          if (!(ECL_FIXNUMP(v24)||ECL_BIGNUMP(v24))){
          goto L455;
          }
          v25 = v24;
          T2 = ecl_make_bool(ecl_greatereq(v25,ecl_make_int8_t(0)));
          goto L452;
L455:;
          T2 = ECL_NIL;
          goto L452;
          }
L452:;
          if (ecl_unlikely(!((T2)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v24);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          v23 = v24;
          }
          T2 = cl_ash(ecl_make_int8_t(-1), v23);
          T3 = ecl_boole(ECL_BOOLXOR,(T2),ecl_make_fixnum(-1));
          T4 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T5 = ecl_negate(ecl_make_int8_t(0));
          T6 = cl_ash(T4, T5);
          v22 = ecl_boole(ECL_BOOLAND,(T3),(T6));
          }
          {
          cl_object v23;
          T2 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T3 = ecl_negate(ecl_make_int8_t(1));
          v23 = cl_ash(T2, T3);
          {
          cl_object v24;
          v24 = v1bit_stream;
          (v24)->instance.slots[(cl_fixnum)(2)]=v23;
          }
          }
          {
          cl_object v23;
          T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          v23 = ecl_minus(T2,ecl_make_int8_t(1));
          {
          cl_object v24;
          v24 = v1bit_stream;
          (v24)->instance.slots[(cl_fixnum)(3)]=v23;
          }
          }
          T1 = v22;
          }
L426:;
          v14code = ecl_fixnum(ecl_plus(T0,T1));
          v15index = ecl_fixnum(ecl_plus(ecl_make_fixnum(v15index),v19count));
          T0 = ecl_plus(ecl_make_fixnum(v16first),v19count);
          v16first = ecl_fixnum(ecl_times(T0,ecl_make_int8_t(2)));
          v18length = (v18length)+1;
          goto L369;
L370:;
          T0 = ecl_list1(ecl_make_fixnum(v14code));
          cl_error(5, VV[2], ECL_SYM("FORMAT-CONTROL",1272), VV[104], ECL_SYM("FORMAT-ARGUMENTS",1271), T0);
          v11 = ECL_NIL;
          }
          }
         }
        }
       }
      }
     }
    }
L359:;
    if (!(ecl_lowereq(v11,ecl_make_int8_t(3)))){
     goto L473;
    }
    v10 = ecl_one_plus(v11);
    goto L358;
L473:;
    {
     cl_object v12;                               /*  ORDER                   */
     cl_object v13;                               /*  OFFSET                  */
     value0 = ecl_truncate2(v11,ecl_make_int8_t(2));
     {
      v12 = value0;
      v13 = cl_env_copy->values[1];
     }
     {
      cl_object v14extra_bits;
      cl_object v15factor;
      v14extra_bits = ecl_one_minus(v12);
      v15factor = cl_ash(ecl_make_int8_t(1), v14extra_bits);
      T0 = cl_ash(ecl_make_int8_t(1), v12);
      T1 = ecl_one_plus(T0);
      T2 = ecl_times(v13,v15factor);
      T3 = ecl_plus(T1,T2);
L480:;
      T5 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
      if (ecl_lower(T5,v14extra_bits)) {
       goto L482;
      }
      goto L481;
L482:;
      {
       cl_object v16;
       T5 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
       T7 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-STREAM */;
       T6 = cl_read_byte(1, T7);
       T7 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
       T8 = cl_ash(T6, T7);
       v16 = ecl_boole(ECL_BOOLIOR,(T5),(T8));
       {
        cl_object v17;
        v17 = v1bit_stream;
        (v17)->instance.slots[(cl_fixnum)(2)]=v16;
       }
      }
      {
       cl_object v16;
       T5 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
       v16 = ecl_plus(T5,ecl_make_int8_t(8));
       {
        cl_object v17;
        v17 = v1bit_stream;
        (v17)->instance.slots[(cl_fixnum)(3)]=v16;
       }
      }
      goto L480;
L481:;
      T5 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
      if (!(ecl_number_equalp(T5,v14extra_bits))){
       goto L492;
      }
      {
       cl_object v16;
       v16 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
       {
        cl_object v17;
        v17 = ecl_make_int8_t(0);
        {
         cl_object v18;
         v18 = v1bit_stream;
         (v18)->instance.slots[(cl_fixnum)(2)]=v17;
        }
       }
       {
        cl_object v17;
        v17 = ecl_make_int8_t(0);
        {
         cl_object v18;
         v18 = v1bit_stream;
         (v18)->instance.slots[(cl_fixnum)(3)]=v17;
        }
       }
       T4 = v16;
       goto L478;
      }
L492:;
      {
       cl_object v17;
       {
        cl_object v18;
        {
         cl_object v19;
         v19 = v14extra_bits;
         {
          cl_object v20;
          v20 = ecl_make_int8_t(0);
          if (!(ECL_FIXNUMP(v19)||ECL_BIGNUMP(v19))){
          goto L508;
          }
          v20 = v19;
          T5 = ecl_make_bool(ecl_greatereq(v20,ecl_make_int8_t(0)));
          goto L505;
L508:;
          T5 = ECL_NIL;
          goto L505;
         }
L505:;
         if (ecl_unlikely(!((T5)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v19);
         value0 = ECL_NIL;
         cl_env_copy->nvalues = 0;
         v18 = v19;
        }
        T5 = cl_ash(ecl_make_int8_t(-1), v18);
        T6 = ecl_boole(ECL_BOOLXOR,(T5),ecl_make_fixnum(-1));
        T7 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
        T8 = ecl_negate(ecl_make_int8_t(0));
        T9 = cl_ash(T7, T8);
        v17 = ecl_boole(ECL_BOOLAND,(T6),(T9));
       }
       {
        cl_object v18;
        T5 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
        T6 = ecl_negate(v14extra_bits);
        v18 = cl_ash(T5, T6);
        {
         cl_object v19;
         v19 = v1bit_stream;
         (v19)->instance.slots[(cl_fixnum)(2)]=v18;
        }
       }
       {
        cl_object v18;
        T5 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
        v18 = ecl_minus(T5,v14extra_bits);
        {
         cl_object v19;
         v19 = v1bit_stream;
         (v19)->instance.slots[(cl_fixnum)(3)]=v18;
        }
       }
       T4 = v17;
      }
L478:;
      v10 = ecl_plus(T3,T4);
     }
    }
   }
L358:;
   L5447sliding_window_stream_copy_bytes(v2window_stream, v10, v9);
  }
L122:;
  {
   cl_object v6length_count;
   v6length_count = (cl_env_copy->function=(VV[95]->symbol.gfdef))->cfun.entry(1, v3lit_decode_tree) /*  DECODE-TREE-LENGTH-COUNT */;
   {
    cl_object v7code_symbols;
    v7code_symbols = (cl_env_copy->function=(VV[93]->symbol.gfdef))->cfun.entry(1, v3lit_decode_tree) /*  DECODE-TREE-CODE-SYMBOLS */;
    {
     cl_fixnum v8code;
     v8code = (cl_fixnum)(0);
     {
      cl_fixnum v9index;
      v9index = (cl_fixnum)(0);
      {
       cl_fixnum v10first;
       v10first = (cl_fixnum)(0);
       {
        cl_fixnum v11;
        cl_fixnum v12length;
        v11 = (v6length_count)->vector.fillp;
        v12length = (cl_fixnum)(1);
        {
         cl_object v13count;
         v13count = ECL_NIL;
         {
          cl_object v14;
          v14 = ECL_NIL;
L534:;
          T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          if (ecl_lower(T0,ecl_make_int8_t(1))) {
          goto L536;
          }
          goto L535;
L536:;
          {
          cl_object v15;
          T0 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T2 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-STREAM */;
          T1 = cl_read_byte(1, T2);
          T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          T3 = cl_ash(T1, T2);
          v15 = ecl_boole(ECL_BOOLIOR,(T0),(T3));
          {
          cl_object v16;
          v16 = v1bit_stream;
          (v16)->instance.slots[(cl_fixnum)(2)]=v15;
          }
          }
          {
          cl_object v15;
          T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          v15 = ecl_plus(T0,ecl_make_int8_t(8));
          {
          cl_object v16;
          v16 = v1bit_stream;
          (v16)->instance.slots[(cl_fixnum)(3)]=v15;
          }
          }
          goto L534;
L535:;
          T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          if (!(ecl_number_equalp(T0,ecl_make_int8_t(1)))){
          goto L546;
          }
          {
          cl_object v15;
          v15 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          {
          cl_object v16;
          v16 = ecl_make_int8_t(0);
          {
          cl_object v17;
          v17 = v1bit_stream;
          (v17)->instance.slots[(cl_fixnum)(2)]=v16;
          }
          }
          {
          cl_object v16;
          v16 = ecl_make_int8_t(0);
          {
          cl_object v17;
          v17 = v1bit_stream;
          (v17)->instance.slots[(cl_fixnum)(3)]=v16;
          }
          }
          v8code = ecl_fixnum(v15);
          goto L532;
          }
L546:;
          {
          cl_object v16;
          {
          cl_object v17;
          {
          cl_object v18;
          v18 = ecl_make_int8_t(1);
          {
          cl_object v19;
          v19 = ecl_make_int8_t(0);
          if (!(ECL_FIXNUMP(v18)||ECL_BIGNUMP(v18))){
          goto L562;
          }
          v19 = v18;
          T0 = ecl_make_bool(ecl_greatereq(v19,ecl_make_int8_t(0)));
          goto L559;
L562:;
          T0 = ECL_NIL;
          goto L559;
          }
L559:;
          if (ecl_unlikely(!((T0)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v18);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          v17 = v18;
          }
          T0 = cl_ash(ecl_make_int8_t(-1), v17);
          T1 = ecl_boole(ECL_BOOLXOR,(T0),ecl_make_fixnum(-1));
          T2 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T3 = ecl_negate(ecl_make_int8_t(0));
          T4 = cl_ash(T2, T3);
          v16 = ecl_boole(ECL_BOOLAND,(T1),(T4));
          }
          {
          cl_object v17;
          T0 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T1 = ecl_negate(ecl_make_int8_t(1));
          v17 = cl_ash(T0, T1);
          {
          cl_object v18;
          v18 = v1bit_stream;
          (v18)->instance.slots[(cl_fixnum)(2)]=v17;
          }
          }
          {
          cl_object v17;
          T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          v17 = ecl_minus(T0,ecl_make_int8_t(1));
          {
          cl_object v18;
          v18 = v1bit_stream;
          (v18)->instance.slots[(cl_fixnum)(3)]=v17;
          }
          }
          v8code = ecl_fixnum(v16);
          }
L532:;
          v9index = (cl_fixnum)(0);
          v10first = (cl_fixnum)(0);
L529:;
          if (!((v12length)>=(v11))){
          goto L576;
          }
          goto L530;
L576:;
          v13count = ecl_make_int64_t((v6length_count)->vector.self.i64[v12length]);
          T0 = ecl_plus(ecl_make_fixnum(v10first),v13count);
          if (!((v8code)<(ecl_fixnum(T0)))){
          goto L583;
          }
          T0 = ecl_minus(ecl_make_fixnum(v8code),ecl_make_fixnum(v10first));
          T1 = ecl_plus(ecl_make_fixnum(v9index),T0);
          v14 = ecl_make_int64_t((v7code_symbols)->vector.self.i64[ecl_fixnum(T1)]);
          goto L582;
L583:;
          v14 = ECL_NIL;
L582:;
          if (Null(v14)){
          goto L580;
          }
          v5symbol = v14;
          goto L519;
L580:;
          T0 = ecl_times(ecl_make_fixnum(v8code),ecl_make_int8_t(2));
L589:;
          T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          if (ecl_lower(T2,ecl_make_int8_t(1))) {
          goto L591;
          }
          goto L590;
L591:;
          {
          cl_object v15;
          T2 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T4 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-STREAM */;
          T3 = cl_read_byte(1, T4);
          T4 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          T5 = cl_ash(T3, T4);
          v15 = ecl_boole(ECL_BOOLIOR,(T2),(T5));
          {
          cl_object v16;
          v16 = v1bit_stream;
          (v16)->instance.slots[(cl_fixnum)(2)]=v15;
          }
          }
          {
          cl_object v15;
          T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          v15 = ecl_plus(T2,ecl_make_int8_t(8));
          {
          cl_object v16;
          v16 = v1bit_stream;
          (v16)->instance.slots[(cl_fixnum)(3)]=v15;
          }
          }
          goto L589;
L590:;
          T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          if (!(ecl_number_equalp(T2,ecl_make_int8_t(1)))){
          goto L601;
          }
          {
          cl_object v15;
          v15 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          {
          cl_object v16;
          v16 = ecl_make_int8_t(0);
          {
          cl_object v17;
          v17 = v1bit_stream;
          (v17)->instance.slots[(cl_fixnum)(2)]=v16;
          }
          }
          {
          cl_object v16;
          v16 = ecl_make_int8_t(0);
          {
          cl_object v17;
          v17 = v1bit_stream;
          (v17)->instance.slots[(cl_fixnum)(3)]=v16;
          }
          }
          T1 = v15;
          goto L587;
          }
L601:;
          {
          cl_object v16;
          {
          cl_object v17;
          {
          cl_object v18;
          v18 = ecl_make_int8_t(1);
          {
          cl_object v19;
          v19 = ecl_make_int8_t(0);
          if (!(ECL_FIXNUMP(v18)||ECL_BIGNUMP(v18))){
          goto L617;
          }
          v19 = v18;
          T2 = ecl_make_bool(ecl_greatereq(v19,ecl_make_int8_t(0)));
          goto L614;
L617:;
          T2 = ECL_NIL;
          goto L614;
          }
L614:;
          if (ecl_unlikely(!((T2)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v18);
          value0 = ECL_NIL;
          cl_env_copy->nvalues = 0;
          v17 = v18;
          }
          T2 = cl_ash(ecl_make_int8_t(-1), v17);
          T3 = ecl_boole(ECL_BOOLXOR,(T2),ecl_make_fixnum(-1));
          T4 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T5 = ecl_negate(ecl_make_int8_t(0));
          T6 = cl_ash(T4, T5);
          v16 = ecl_boole(ECL_BOOLAND,(T3),(T6));
          }
          {
          cl_object v17;
          T2 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
          T3 = ecl_negate(ecl_make_int8_t(1));
          v17 = cl_ash(T2, T3);
          {
          cl_object v18;
          v18 = v1bit_stream;
          (v18)->instance.slots[(cl_fixnum)(2)]=v17;
          }
          }
          {
          cl_object v17;
          T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
          v17 = ecl_minus(T2,ecl_make_int8_t(1));
          {
          cl_object v18;
          v18 = v1bit_stream;
          (v18)->instance.slots[(cl_fixnum)(3)]=v17;
          }
          }
          T1 = v16;
          }
L587:;
          v8code = ecl_fixnum(ecl_plus(T0,T1));
          v9index = ecl_fixnum(ecl_plus(ecl_make_fixnum(v9index),v13count));
          T0 = ecl_plus(ecl_make_fixnum(v10first),v13count);
          v10first = ecl_fixnum(ecl_times(T0,ecl_make_int8_t(2)));
          v12length = (v12length)+1;
          goto L529;
L530:;
          T0 = ecl_list1(ecl_make_fixnum(v8code));
          cl_error(5, VV[2], ECL_SYM("FORMAT-CONTROL",1272), VV[104], ECL_SYM("FORMAT-ARGUMENTS",1271), T0);
          v5symbol = ECL_NIL;
         }
        }
       }
      }
     }
    }
   }
  }
L519:;
L120:;
  if (ecl_number_equalp(v5symbol,ecl_make_fixnum(256))) {
   goto L635;
  }
  goto L119;
L635:;
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L5463decode_huffman_block_va(cl_narg narg, cl_object v6bit_stream, cl_object v7window_stream, cl_object v8lit_decode_tree, cl_object v9dist_decode_tree, ...)
{
 return L5463decode_huffman_block(v6bit_stream, v7window_stream, v8lit_decode_tree, v9dist_decode_tree);
}
/* function definition for DECODE-BLOCK                                       */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5464decode_block(cl_object v1bit_stream, cl_object v2window_stream)
{
 cl_object T0, T1, T2, T3, T4, T5;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 {
  cl_object v3finalp;
  cl_object v4type;
L5:;
  T1 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
  if (ecl_lower(T1,ecl_make_int8_t(1))) {
   goto L7;
  }
  goto L6;
L7:;
  {
   cl_object v5;
   T1 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
   T3 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-STREAM */;
   T2 = cl_read_byte(1, T3);
   T3 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
   T4 = cl_ash(T2, T3);
   v5 = ecl_boole(ECL_BOOLIOR,(T1),(T4));
   {
    cl_object v6;
    v6 = v1bit_stream;
    (v6)->instance.slots[(cl_fixnum)(2)]=v5;
   }
  }
  {
   cl_object v5;
   T1 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
   v5 = ecl_plus(T1,ecl_make_int8_t(8));
   {
    cl_object v6;
    v6 = v1bit_stream;
    (v6)->instance.slots[(cl_fixnum)(3)]=v5;
   }
  }
  goto L5;
L6:;
  T1 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
  if (!(ecl_number_equalp(T1,ecl_make_int8_t(1)))){
   goto L17;
  }
  {
   cl_object v5;
   v5 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
   {
    cl_object v6;
    v6 = ecl_make_int8_t(0);
    {
     cl_object v7;
     v7 = v1bit_stream;
     (v7)->instance.slots[(cl_fixnum)(2)]=v6;
    }
   }
   {
    cl_object v6;
    v6 = ecl_make_int8_t(0);
    {
     cl_object v7;
     v7 = v1bit_stream;
     (v7)->instance.slots[(cl_fixnum)(3)]=v6;
    }
   }
   T0 = v5;
   goto L3;
  }
L17:;
  {
   cl_object v6;
   {
    cl_object v7;
    {
     cl_object v8;
     v8 = ecl_make_int8_t(1);
     {
      cl_object v9;
      v9 = ecl_make_int8_t(0);
      if (!(ECL_FIXNUMP(v8)||ECL_BIGNUMP(v8))){
       goto L33;
      }
      v9 = v8;
      T1 = ecl_make_bool(ecl_greatereq(v9,ecl_make_int8_t(0)));
      goto L30;
L33:;
      T1 = ECL_NIL;
      goto L30;
     }
L30:;
     if (ecl_unlikely(!((T1)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v7 = v8;
    }
    T1 = cl_ash(ecl_make_int8_t(-1), v7);
    T2 = ecl_boole(ECL_BOOLXOR,(T1),ecl_make_fixnum(-1));
    T3 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
    T4 = ecl_negate(ecl_make_int8_t(0));
    T5 = cl_ash(T3, T4);
    v6 = ecl_boole(ECL_BOOLAND,(T2),(T5));
   }
   {
    cl_object v7;
    T1 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
    T2 = ecl_negate(ecl_make_int8_t(1));
    v7 = cl_ash(T1, T2);
    {
     cl_object v8;
     v8 = v1bit_stream;
     (v8)->instance.slots[(cl_fixnum)(2)]=v7;
    }
   }
   {
    cl_object v7;
    T1 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
    v7 = ecl_minus(T1,ecl_make_int8_t(1));
    {
     cl_object v8;
     v8 = v1bit_stream;
     (v8)->instance.slots[(cl_fixnum)(3)]=v7;
    }
   }
   T0 = v6;
  }
L3:;
  {
   bool v5;
   v5 = ecl_zerop(T0);
   v3finalp = (v5)?ECL_NIL:ECL_T;
  }
L45:;
  T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
  if (ecl_lower(T0,ecl_make_int8_t(2))) {
   goto L47;
  }
  goto L46;
L47:;
  {
   cl_object v5;
   T0 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
   T2 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-STREAM */;
   T1 = cl_read_byte(1, T2);
   T2 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
   T3 = cl_ash(T1, T2);
   v5 = ecl_boole(ECL_BOOLIOR,(T0),(T3));
   {
    cl_object v6;
    v6 = v1bit_stream;
    (v6)->instance.slots[(cl_fixnum)(2)]=v5;
   }
  }
  {
   cl_object v5;
   T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
   v5 = ecl_plus(T0,ecl_make_int8_t(8));
   {
    cl_object v6;
    v6 = v1bit_stream;
    (v6)->instance.slots[(cl_fixnum)(3)]=v5;
   }
  }
  goto L45;
L46:;
  T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
  if (!(ecl_number_equalp(T0,ecl_make_int8_t(2)))){
   goto L57;
  }
  {
   cl_object v5;
   v5 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
   {
    cl_object v6;
    v6 = ecl_make_int8_t(0);
    {
     cl_object v7;
     v7 = v1bit_stream;
     (v7)->instance.slots[(cl_fixnum)(2)]=v6;
    }
   }
   {
    cl_object v6;
    v6 = ecl_make_int8_t(0);
    {
     cl_object v7;
     v7 = v1bit_stream;
     (v7)->instance.slots[(cl_fixnum)(3)]=v6;
    }
   }
   v4type = v5;
   goto L43;
  }
L57:;
  {
   cl_object v6;
   {
    cl_object v7;
    {
     cl_object v8;
     v8 = ecl_make_int8_t(2);
     {
      cl_object v9;
      v9 = ecl_make_int8_t(0);
      if (!(ECL_FIXNUMP(v8)||ECL_BIGNUMP(v8))){
       goto L73;
      }
      v9 = v8;
      T0 = ecl_make_bool(ecl_greatereq(v9,ecl_make_int8_t(0)));
      goto L70;
L73:;
      T0 = ECL_NIL;
      goto L70;
     }
L70:;
     if (ecl_unlikely(!((T0)!=ECL_NIL)))
         FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",889),v8);
     value0 = ECL_NIL;
     cl_env_copy->nvalues = 0;
     v7 = v8;
    }
    T0 = cl_ash(ecl_make_int8_t(-1), v7);
    T1 = ecl_boole(ECL_BOOLXOR,(T0),ecl_make_fixnum(-1));
    T2 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
    T3 = ecl_negate(ecl_make_int8_t(0));
    T4 = cl_ash(T2, T3);
    v6 = ecl_boole(ECL_BOOLAND,(T1),(T4));
   }
   {
    cl_object v7;
    T0 = (cl_env_copy->function=(VV[71]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BITS */;
    T1 = ecl_negate(ecl_make_int8_t(2));
    v7 = cl_ash(T0, T1);
    {
     cl_object v8;
     v8 = v1bit_stream;
     (v8)->instance.slots[(cl_fixnum)(2)]=v7;
    }
   }
   {
    cl_object v7;
    T0 = (cl_env_copy->function=(VV[69]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-BIT-COUNT */;
    v7 = ecl_minus(T0,ecl_make_int8_t(2));
    {
     cl_object v8;
     v8 = v1bit_stream;
     (v8)->instance.slots[(cl_fixnum)(3)]=v7;
    }
   }
   v4type = v6;
  }
L43:;
  if (!((v4type)==(ecl_make_int8_t(0)))){
   goto L84;
  }
  {
   cl_object v5;
   v5 = ecl_make_int8_t(0);
   {
    cl_object v6;
    v6 = v1bit_stream;
    (v6)->instance.slots[(cl_fixnum)(2)]=v5;
   }
  }
  {
   cl_object v5;
   v5 = ecl_make_int8_t(0);
   {
    cl_object v6;
    v6 = v1bit_stream;
    (v6)->instance.slots[(cl_fixnum)(3)]=v5;
   }
  }
  {
   cl_object v5len;
   cl_object v6nlen;
   T1 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-STREAM */;
   T0 = cl_read_byte(1, T1);
   T2 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-STREAM */;
   T1 = cl_read_byte(1, T2);
   T2 = ecl_ash(T1,(cl_fixnum)(8));
   v5len = ecl_boole(ECL_BOOLIOR,(T0),(T2));
   T1 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-STREAM */;
   T0 = cl_read_byte(1, T1);
   T2 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-STREAM */;
   T1 = cl_read_byte(1, T2);
   T2 = ecl_ash(T1,(cl_fixnum)(8));
   T3 = ecl_boole(ECL_BOOLIOR,(T0),(T2));
   T4 = ecl_boole(ECL_BOOLXOR,(T3),ecl_make_fixnum(-1));
   T5 = cl_ash(T4, ecl_make_int8_t(0));
   v6nlen = ecl_boole(ECL_BOOLAND,(ecl_make_fixnum(65535)),(T5));
   if (ecl_number_equalp(v5len,v6nlen)) {
    goto L98;
   }
   T0 = cl_list(2, v5len, v6nlen);
   cl_error(5, VV[2], ECL_SYM("FORMAT-CONTROL",1272), VV[82], ECL_SYM("FORMAT-ARGUMENTS",1271), T0);
L98:;
   {
    cl_object v7i;
    v7i = ecl_make_int8_t(0);
    goto L102;
L101:;
    {
     uint8_t v8;
     T0 = (cl_env_copy->function=(VV[75]->symbol.gfdef))->cfun.entry(1, v1bit_stream) /*  BIT-STREAM-STREAM */;
     v8 = ecl_fixnum(cl_read_byte(1, T0));
     {
      cl_fixnum v9end;
      v9end = ecl_fixnum((cl_env_copy->function=(VV[46]->symbol.gfdef))->cfun.entry(1, v2window_stream) /*  SLIDING-WINDOW-STREAM-BUFFER-END */);
      if ((v9end)<(ecl_fixnum(ECL_SYM_VAL(cl_env_copy,VV[27])))) {
       goto L107;
      }
      T0 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, v2window_stream) /*  SLIDING-WINDOW-STREAM-BUFFER */;
      T1 = (cl_env_copy->function=(VV[49]->symbol.gfdef))->cfun.entry(1, v2window_stream) /*  SLIDING-WINDOW-STREAM-STREAM */;
      cl_write_sequence(2, T0, T1);
      {
       cl_object v10;
       v10 = (cl_env_copy->function=(VV[45]->symbol.gfdef))->cfun.entry(1, v2window_stream) /*  SLIDING-WINDOW-STREAM-CHECKSUM */;
       if (!((v10)==(VV[51]))){
        goto L112;
       }
       {
        cl_object v11;
        T0 = (cl_env_copy->function=(VV[42]->symbol.gfdef))->cfun.entry(1, v2window_stream) /*  SLIDING-WINDOW-STREAM-CHECKSUM-VALUE */;
        T1 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, v2window_stream) /*  SLIDING-WINDOW-STREAM-BUFFER */;
        v11 = L5439update_adler32_checksum(T0, T1, ECL_SYM_VAL(cl_env_copy,VV[27]));
        {
         cl_object v12;
         v12 = v2window_stream;
         (v12)->instance.slots[(cl_fixnum)(4)]=v11;
         goto L110;
        }
       }
L112:;
       if (!((v10)==(VV[52]))){
        goto L110;
       }
       {
        cl_object v13;
        T0 = (cl_env_copy->function=(VV[42]->symbol.gfdef))->cfun.entry(1, v2window_stream) /*  SLIDING-WINDOW-STREAM-CHECKSUM-VALUE */;
        T1 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, v2window_stream) /*  SLIDING-WINDOW-STREAM-BUFFER */;
        v13 = L5441update_crc32_checksum(T0, T1, ECL_SYM_VAL(cl_env_copy,VV[27]));
        {
         cl_object v14;
         v14 = v2window_stream;
         (v14)->instance.slots[(cl_fixnum)(4)]=v13;
        }
       }
      }
L110:;
      v9end = (cl_fixnum)(0);
L107:;
      {
       cl_object v10;
       v10 = (cl_env_copy->function=(VV[48]->symbol.gfdef))->cfun.entry(1, v2window_stream) /*  SLIDING-WINDOW-STREAM-BUFFER */;
       ecl_aset_unsafe(v10,v9end,ecl_make_uint8_t(v8));
      }
      {
       cl_object v10;
       v10 = ecl_make_integer((v9end)+1);
       {
        cl_object v11;
        v11 = v2window_stream;
        (v11)->instance.slots[(cl_fixnum)(2)]=v10;
       }
      }
     }
    }
    v7i = ecl_one_plus(v7i);
L102:;
    if (!(ecl_lower(v7i,v5len))){
     goto L126;
    }
    goto L101;
L126:;
    goto L83;
   }
  }
L84:;
  if (!((v4type)==(ecl_make_int8_t(1)))){
   goto L128;
  }
  L5463decode_huffman_block(v1bit_stream, v2window_stream, ECL_SYM_VAL(cl_env_copy,VV[106]), ECL_SYM_VAL(cl_env_copy,VV[107]));
  goto L83;
L128:;
  if (!((v4type)==(ecl_make_int8_t(2)))){
   goto L130;
  }
  {
   cl_object v8;                                  /*  LIT-DECODE-TREE         */
   cl_object v9;                                  /*  DIST-DECODE-TREE        */
   value0 = L5460decode_huffman_tables(v1bit_stream);
   {
    const int v10 = cl_env_copy->nvalues;
    v8 = value0;
    cl_object v11;
    v11 = (v10<=1)? ECL_NIL : cl_env_copy->values[1];
    v9 = v11;
   }
   L5463decode_huffman_block(v1bit_stream, v2window_stream, v8, v9);
   goto L83;
  }
L130:;
  if (!((v4type)==(ecl_make_int8_t(3)))){
   goto L133;
  }
  T0 = ecl_list1(v4type);
  cl_error(5, VV[2], ECL_SYM("FORMAT-CONTROL",1272), VV[123], ECL_SYM("FORMAT-ARGUMENTS",1271), T0);
  goto L83;
L133:;
  si_ecase_error(v4type, VV[124]);
L83:;
  value0 = Null(v3finalp)?ECL_T:ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L5464decode_block_va(cl_narg narg, cl_object v5bit_stream, cl_object v6window_stream, ...)
{
 return L5464decode_block(v5bit_stream, v6window_stream);
}
/* function definition for PARSE-ZLIB-HEADER                                  */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5465parse_zlib_header(cl_object v1input_stream)
{
 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;
L1:;
 {
  cl_object v2;
  cl_object v3;
  v2 = cl_read_byte(1, v1input_stream);
  v3 = cl_read_byte(1, v1input_stream);
  T0 = ecl_times(v2,ecl_make_fixnum(256));
  T1 = ecl_plus(T0,v3);
  T2 = (ecl_floor2(T1,ecl_make_int8_t(31)),cl_env_copy->values[1]);
  if (ecl_zerop(T2)) {
   goto L4;
  }
  T0 = cl_list(2, v2, v3);
  cl_error(5, VV[6], ECL_SYM("FORMAT-CONTROL",1272), VV[127], ECL_SYM("FORMAT-ARGUMENTS",1271), T0);
L4:;
  {
   cl_object v4dict;
   T1 = cl_ash(ecl_make_int8_t(-1), ecl_make_int8_t(1));
   T2 = ecl_boole(ECL_BOOLXOR,(T1),ecl_make_fixnum(-1));
   T3 = ecl_negate(ecl_make_int8_t(5));
   T4 = cl_ash(v3, T3);
   T0 = ecl_boole(ECL_BOOLAND,(T2),(T4));
   if (ecl_zerop(T0)) {
    goto L7;
   }
   v4dict = L5466parse_zlib_checksum(v1input_stream);
   goto L6;
L7:;
   v4dict = ECL_NIL;
L6:;
   T1 = cl_ash(ecl_make_int8_t(-1), ecl_make_int8_t(4));
   T2 = ecl_boole(ECL_BOOLXOR,(T1),ecl_make_fixnum(-1));
   T3 = ecl_negate(ecl_make_int8_t(0));
   T4 = cl_ash(v2, T3);
   T0 = ecl_boole(ECL_BOOLAND,(T2),(T4));
   T2 = cl_ash(ecl_make_int8_t(-1), ecl_make_int8_t(4));
   T3 = ecl_boole(ECL_BOOLXOR,(T2),ecl_make_fixnum(-1));
   T4 = ecl_negate(ecl_make_int8_t(4));
   T5 = cl_ash(v2, T4);
   T1 = ecl_boole(ECL_BOOLAND,(T3),(T5));
   T3 = cl_ash(ecl_make_int8_t(-1), ecl_make_int8_t(2));
   T4 = ecl_boole(ECL_BOOLXOR,(T3),ecl_make_fixnum(-1));
   T5 = ecl_negate(ecl_make_int8_t(6));
   T6 = cl_ash(v3, T5);
   T2 = ecl_boole(ECL_BOOLAND,(T4),(T6));
   cl_env_copy->nvalues = 4;
   cl_env_copy->values[3] = T2;
   cl_env_copy->values[2] = v4dict;
   cl_env_copy->values[1] = T1;
   cl_env_copy->values[0] = T0;
   return cl_env_copy->values[0];
  }
 }
}
static cl_object L5465parse_zlib_header_va(cl_narg narg, cl_object v5input_stream, ...)
{
 return L5465parse_zlib_header(v5input_stream);
}
/* function definition for PARSE-ZLIB-CHECKSUM                                */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5466parse_zlib_checksum(cl_object v1input_stream)
{
 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;
L1:;
 T0 = cl_read_byte(1, v1input_stream);
 T1 = ecl_times(T0,ecl_make_fixnum(256));
 T2 = ecl_times(T1,ecl_make_fixnum(256));
 T3 = ecl_times(T2,ecl_make_fixnum(256));
 T4 = cl_read_byte(1, v1input_stream);
 T5 = ecl_times(T4,ecl_make_fixnum(256));
 T6 = ecl_times(T5,ecl_make_fixnum(256));
 T7 = ecl_plus(T3,T6);
 T8 = cl_read_byte(1, v1input_stream);
 T9 = ecl_times(T8,ecl_make_fixnum(256));
 T10 = ecl_plus(T7,T9);
 T11 = cl_read_byte(1, v1input_stream);
 value0 = ecl_plus(T10,T11);
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L5466parse_zlib_checksum_va(cl_narg narg, cl_object v2input_stream, ...)
{
 return L5466parse_zlib_checksum(v2input_stream);
}
/* function definition for PARSE-ZLIB-FOOTER                                  */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5467parse_zlib_footer(cl_object v1input_stream)
{
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 value0 = L5466parse_zlib_checksum(v1input_stream);
 return value0;
}
static cl_object L5467parse_zlib_footer_va(cl_narg narg, cl_object v2input_stream, ...)
{
 return L5467parse_zlib_footer(v2input_stream);
}
/* function definition for PARSE-GZIP-HEADER                                  */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5468parse_gzip_header(cl_object v1input_stream)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 {
  cl_object v2;
  cl_object v3;
  cl_object v4;
  cl_object v5;
  v2 = cl_read_byte(1, v1input_stream);
  v3 = cl_read_byte(1, v1input_stream);
  v4 = cl_read_byte(1, v1input_stream);
  v5 = cl_read_byte(1, v1input_stream);
  if (!(ecl_number_equalp(v2,ECL_SYM_VAL(cl_env_copy,VV[133])))){
   goto L9;
  }
  if (ecl_number_equalp(v3,ECL_SYM_VAL(cl_env_copy,VV[134]))) {
   goto L6;
  }
  goto L7;
L9:;
  goto L7;
L7:;
  T0 = cl_list(4, ECL_SYM_VAL(cl_env_copy,VV[133]), ECL_SYM_VAL(cl_env_copy,VV[134]), v2, v3);
  cl_error(5, VV[10], ECL_SYM("FORMAT-CONTROL",1272), VV[136], ECL_SYM("FORMAT-ARGUMENTS",1271), T0);
L6:;
  if (ecl_number_equalp(v4,ecl_make_int8_t(8))) {
   goto L11;
  }
  T0 = ecl_list1(v4);
  cl_error(5, VV[10], ECL_SYM("FORMAT-CONTROL",1272), VV[137], ECL_SYM("FORMAT-ARGUMENTS",1271), T0);
L11:;
  T1 = cl_ash(ecl_make_int8_t(-1), ecl_make_int8_t(3));
  T2 = ecl_boole(ECL_BOOLXOR,(T1),ecl_make_fixnum(-1));
  T3 = ecl_negate(ecl_make_int8_t(5));
  T4 = cl_ash(v5, T3);
  T0 = ecl_boole(ECL_BOOLAND,(T2),(T4));
  if (ecl_zerop(T0)) {
   goto L13;
  }
  T0 = ecl_list1(v5);
  cl_error(5, VV[10], ECL_SYM("FORMAT-CONTROL",1272), VV[138], ECL_SYM("FORMAT-ARGUMENTS",1271), T0);
L13:;
  T1 = cl_ash(ecl_make_int8_t(-1), ecl_make_int8_t(1));
  T2 = ecl_boole(ECL_BOOLXOR,(T1),ecl_make_fixnum(-1));
  T3 = ecl_negate(ecl_make_int8_t(0));
  T4 = cl_ash(v5, T3);
  T0 = ecl_boole(ECL_BOOLAND,(T2),(T4));
  {
   bool v6;
   v6 = ecl_number_equalp(ecl_make_int8_t(1),T0);
   T1 = L5469parse_gzip_mtime(v1input_stream);
   T2 = cl_read_byte(1, v1input_stream);
   T3 = cl_read_byte(1, v1input_stream);
   T6 = cl_ash(ecl_make_int8_t(-1), ecl_make_int8_t(1));
   T7 = ecl_boole(ECL_BOOLXOR,(T6),ecl_make_fixnum(-1));
   T8 = ecl_negate(ecl_make_int8_t(2));
   T9 = cl_ash(v5, T8);
   T5 = ecl_boole(ECL_BOOLAND,(T7),(T9));
   if (ecl_zerop(T5)) {
    goto L18;
   }
   T4 = L5470parse_gzip_extra(v1input_stream);
   goto L17;
L18:;
   T4 = ECL_NIL;
L17:;
   T7 = cl_ash(ecl_make_int8_t(-1), ecl_make_int8_t(1));
   T8 = ecl_boole(ECL_BOOLXOR,(T7),ecl_make_fixnum(-1));
   T9 = ecl_negate(ecl_make_int8_t(3));
   T10 = cl_ash(v5, T9);
   T6 = ecl_boole(ECL_BOOLAND,(T8),(T10));
   if (ecl_zerop(T6)) {
    goto L22;
   }
   T5 = L5471parse_gzip_string(v1input_stream);
   goto L21;
L22:;
   T5 = ECL_NIL;
L21:;
   T8 = cl_ash(ecl_make_int8_t(-1), ecl_make_int8_t(1));
   T9 = ecl_boole(ECL_BOOLXOR,(T8),ecl_make_fixnum(-1));
   T10 = ecl_negate(ecl_make_int8_t(4));
   T11 = cl_ash(v5, T10);
   T7 = ecl_boole(ECL_BOOLAND,(T9),(T11));
   if (ecl_zerop(T7)) {
    goto L26;
   }
   T6 = L5471parse_gzip_string(v1input_stream);
   goto L25;
L26:;
   T6 = ECL_NIL;
L25:;
   T9 = cl_ash(ecl_make_int8_t(-1), ecl_make_int8_t(1));
   T10 = ecl_boole(ECL_BOOLXOR,(T9),ecl_make_fixnum(-1));
   T11 = ecl_negate(ecl_make_int8_t(1));
   T12 = cl_ash(v5, T11);
   T8 = ecl_boole(ECL_BOOLAND,(T10),(T12));
   if (ecl_zerop(T8)) {
    goto L30;
   }
   T8 = cl_read_byte(1, v1input_stream);
   T9 = cl_read_byte(2, v1input_stream, ecl_make_fixnum(256));
   T7 = ecl_plus(T8,T9);
   goto L29;
L30:;
   T7 = ECL_NIL;
L29:;
   cl_env_copy->nvalues = 9;
   cl_env_copy->values[8] = T7;
   cl_env_copy->values[7] = T6;
   cl_env_copy->values[6] = T5;
   cl_env_copy->values[5] = T4;
   cl_env_copy->values[4] = T3;
   cl_env_copy->values[3] = T2;
   cl_env_copy->values[2] = T1;
   cl_env_copy->values[1] = ecl_make_bool(v6);
   cl_env_copy->values[0] = v4;
   return cl_env_copy->values[0];
  }
 }
}
static cl_object L5468parse_gzip_header_va(cl_narg narg, cl_object v6input_stream, ...)
{
 return L5468parse_gzip_header(v6input_stream);
}
/* function definition for PARSE-GZIP-MTIME                                   */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5469parse_gzip_mtime(cl_object v1input_stream)
{
 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;
L1:;
 {
  cl_object v2time;
  T0 = cl_read_byte(1, v1input_stream);
  T1 = cl_read_byte(1, v1input_stream);
  T2 = ecl_times(T1,ecl_make_fixnum(256));
  T3 = ecl_plus(T0,T2);
  T4 = cl_read_byte(1, v1input_stream);
  T5 = ecl_times(T4,ecl_make_fixnum(256));
  T6 = ecl_times(T5,ecl_make_fixnum(256));
  T7 = ecl_plus(T3,T6);
  T8 = cl_read_byte(1, v1input_stream);
  T9 = ecl_times(T8,ecl_make_fixnum(256));
  T10 = ecl_times(T9,ecl_make_fixnum(256));
  T11 = ecl_times(T10,ecl_make_fixnum(256));
  v2time = ecl_plus(T7,T11);
  if (!(ecl_zerop(v2time))){
   goto L3;
  }
  value0 = ECL_NIL;
  cl_env_copy->nvalues = 1;
  return value0;
L3:;
  value0 = ecl_plus(v2time,ecl_make_fixnum(2208988800));
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L5469parse_gzip_mtime_va(cl_narg narg, cl_object v3input_stream, ...)
{
 return L5469parse_gzip_mtime(v3input_stream);
}
/* function definition for PARSE-GZIP-EXTRA                                   */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5470parse_gzip_extra(cl_object v1input_stream)
{
 cl_object T0, T1, T2;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 {
  cl_object v2length;
  cl_object v3result;
  T0 = cl_read_byte(1, v1input_stream);
  T1 = cl_read_byte(1, v1input_stream);
  T2 = ecl_times(T1,ecl_make_fixnum(256));
  v2length = ecl_plus(T0,T2);
  v3result = si_make_pure_array(ECL_SYM("BYTE8",1368), v2length, ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_int8_t(0));
  cl_read_sequence(2, v3result, v1input_stream);
  value0 = v3result;
  cl_env_copy->nvalues = 1;
  return value0;
 }
}
static cl_object L5470parse_gzip_extra_va(cl_narg narg, cl_object v4input_stream, ...)
{
 return L5470parse_gzip_extra(v4input_stream);
}
/* function definition for PARSE-GZIP-STRING                                  */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5471parse_gzip_string(cl_object volatile v1input_stream)
{
 cl_object volatile env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
L1:;
 {
  volatile cl_object v2string;
  v2string = cl_make_string_output_stream(0);
  {
   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 {
    {
     cl_object v3value;
     v3value = ECL_NIL;
L6:;
     v3value = cl_read_byte(1, v1input_stream);
     if (!(ecl_zerop(v3value))){
      goto L10;
     }
     goto L7;
L10:;
     {
      ecl_character v4;
      v4 = ecl_fixnum(v3value);
      cl_write_char(2, ECL_CODE_CHAR(v4), v2string);
     }
     goto L6;
L7:;
    }
    cl_env_copy->values[0] = cl_get_output_stream_string(v2string);
    }
   }
   ecl_frs_pop(cl_env_copy);
   ecl_stack_frame_push_values(_ecl_inner_frame);
   cl_close(1, v2string);
   ecl_stack_frame_pop_values(_ecl_inner_frame);
   if (unwinding) ecl_unwind(cl_env_copy,next_fr);
   ecl_stack_frame_close(_ecl_inner_frame);
   return cl_env_copy->values[0];
  }
 }
}
static cl_object L5471parse_gzip_string_va(cl_narg narg, cl_object v3input_stream, ...)
{
 return L5471parse_gzip_string(v3input_stream);
}
/* function definition for PARSE-GZIP-CHECKSUM                                */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5472parse_gzip_checksum(cl_object v1input_stream)
{
 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;
L1:;
 T0 = cl_read_byte(1, v1input_stream);
 T1 = cl_read_byte(1, v1input_stream);
 T2 = ecl_times(T1,ecl_make_fixnum(256));
 T3 = ecl_plus(T0,T2);
 T4 = cl_read_byte(1, v1input_stream);
 T5 = ecl_times(T4,ecl_make_fixnum(256));
 T6 = ecl_times(T5,ecl_make_fixnum(256));
 T7 = ecl_plus(T3,T6);
 T8 = cl_read_byte(1, v1input_stream);
 T9 = ecl_times(T8,ecl_make_fixnum(256));
 T10 = ecl_times(T9,ecl_make_fixnum(256));
 T11 = ecl_times(T10,ecl_make_fixnum(256));
 value0 = ecl_plus(T7,T11);
 cl_env_copy->nvalues = 1;
 return value0;
}
static cl_object L5472parse_gzip_checksum_va(cl_narg narg, cl_object v2input_stream, ...)
{
 return L5472parse_gzip_checksum(v2input_stream);
}
/* function definition for PARSE-GZIP-FOOTER                                  */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5473parse_gzip_footer(cl_object v1input_stream)
{
 cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 T0 = L5472parse_gzip_checksum(v1input_stream);
 T1 = cl_read_byte(1, v1input_stream);
 T2 = cl_read_byte(1, v1input_stream);
 T3 = ecl_times(T2,ecl_make_fixnum(256));
 T4 = ecl_plus(T1,T3);
 T5 = cl_read_byte(1, v1input_stream);
 T6 = ecl_times(T5,ecl_make_fixnum(256));
 T7 = ecl_times(T6,ecl_make_fixnum(256));
 T8 = ecl_plus(T4,T7);
 T9 = cl_read_byte(1, v1input_stream);
 T10 = ecl_times(T9,ecl_make_fixnum(256));
 T11 = ecl_times(T10,ecl_make_fixnum(256));
 T12 = ecl_times(T11,ecl_make_fixnum(256));
 T13 = ecl_plus(T8,T12);
 cl_env_copy->nvalues = 2;
 cl_env_copy->values[1] = T13;
 cl_env_copy->values[0] = T0;
 return cl_env_copy->values[0];
}
static cl_object L5473parse_gzip_footer_va(cl_narg narg, cl_object v2input_stream, ...)
{
 return L5473parse_gzip_footer(v2input_stream);
}
/* function definition for INFLATE-STREAM                                     */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5474inflate_stream(cl_narg narg, cl_object v1input_stream, cl_object v2output_stream, ...)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 cl_object v3checksum;
 ecl_va_list args; ecl_va_start(args,v2output_stream,narg,2);
 {
  cl_object keyvars[2];
  cl_parse_key(args,1,L5474inflate_streamkeys,keyvars,NULL,FALSE);
  ecl_va_end(args);
  v3checksum = keyvars[0];
 }
 {
  cl_object v4window_stream;
  if (!((v3checksum)==(ECL_NIL))){
   goto L3;
  }
  T0 = ecl_make_int8_t(0);
  goto L2;
L3:;
  if (!((v3checksum)==(VV[52]))){
   goto L6;
  }
  T0 = ecl_make_int8_t(0);
  goto L2;
L6:;
  if (!((v3checksum)==(VV[51]))){
   goto L8;
  }
  T0 = ecl_make_int8_t(1);
  goto L2;
L8:;
  T0 = si_ecase_error(v3checksum, VV[154]);
L2:;
  v4window_stream = L5442make_sliding_window_stream(6, ECL_SYM("STREAM",1350), v2output_stream, VV[151], v3checksum, VV[152], T0);
  {
   cl_object v5bit_stream;
   v5bit_stream = L5448make_bit_stream(2, ECL_SYM("STREAM",1350), v1input_stream);
L11:;
   if (L5464decode_block(v5bit_stream, v4window_stream)!=ECL_NIL) {
    goto L13;
   }
   goto L12;
L13:;
   goto L11;
L12:;
   L5446sliding_window_stream_flush(v4window_stream);
   if (Null(v3checksum)){
    goto L16;
   }
   value0 = (cl_env_copy->function=(VV[42]->symbol.gfdef))->cfun.entry(1, v4window_stream) /*  SLIDING-WINDOW-STREAM-CHECKSUM-VALUE */;
   return value0;
L16:;
   value0 = ECL_NIL;
   cl_env_copy->nvalues = 1;
   return value0;
  }
 }
}
/* function definition for INFLATE-ZLIB-STREAM                                */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5475inflate_zlib_stream(cl_narg narg, cl_object v1input_stream, cl_object v2output_stream, ...)
{
 cl_object T0, T1, T2, T3;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 cl_object v3check_checksum;
 ecl_va_list args; ecl_va_start(args,v2output_stream,narg,2);
 {
  cl_object keyvars[2];
  cl_parse_key(args,1,L5475inflate_zlib_streamkeys,keyvars,NULL,FALSE);
  ecl_va_end(args);
  v3check_checksum = keyvars[0];
 }
 {
  cl_object v4;                                   /*  CM                      */
  cl_object v5;                                   /*  CINFO                   */
  cl_object v6;                                   /*  DICTID                  */
  cl_object v7;                                   /*  FLEVEL                  */
  value0 = L5465parse_zlib_header(v1input_stream);
  {
   const int v8 = cl_env_copy->nvalues;
   v4 = value0;
   cl_object v9;
   v9 = (v8<=1)? ECL_NIL : cl_env_copy->values[1];
   v5 = v9;
   v9 = (v8<=2)? ECL_NIL : cl_env_copy->values[2];
   v6 = v9;
   v9 = (v8<=3)? ECL_NIL : cl_env_copy->values[3];
   v7 = v9;
  }
  if (ecl_number_equalp(v4,ecl_make_int8_t(8))) {
   goto L2;
  }
  T0 = ecl_list1(v4);
  cl_error(5, VV[6], ECL_SYM("FORMAT-CONTROL",1272), VV[157], ECL_SYM("FORMAT-ARGUMENTS",1271), T0);
L2:;
  if (ecl_lowereq(v5,ecl_make_int8_t(7))) {
   goto L4;
  }
  T0 = ecl_plus(ecl_make_int8_t(8),v5);
  T1 = ecl_plus(ecl_make_int8_t(8),v5);
  T2 = ecl_expt(ecl_make_int8_t(2),T1);
  T3 = cl_list(2, T0, T2);
  cl_error(5, VV[6], ECL_SYM("FORMAT-CONTROL",1272), VV[158], ECL_SYM("FORMAT-ARGUMENTS",1271), T3);
L4:;
  if (v6==ECL_NIL) {
   goto L6;
  }
  T0 = ecl_list1(v6);
  cl_error(5, VV[6], ECL_SYM("FORMAT-CONTROL",1272), VV[159], ECL_SYM("FORMAT-ARGUMENTS",1271), T0);
L6:;
  {
   cl_object v8;
   cl_object v9;
   if (Null(v3check_checksum)){
    goto L10;
   }
   T0 = VV[51];
   goto L9;
L10:;
   T0 = ECL_NIL;
L9:;
   v8 = L5474inflate_stream(4, v1input_stream, v2output_stream, VV[151], T0);
   v9 = L5467parse_zlib_footer(v1input_stream);
   if (Null(v3check_checksum)){
    goto L13;
   }
   if (ecl_number_equalp(v9,v8)) {
    goto L13;
   }
   T0 = cl_list(2, v9, v8);
   cl_error(5, VV[6], ECL_SYM("FORMAT-CONTROL",1272), VV[160], ECL_SYM("FORMAT-ARGUMENTS",1271), T0);
L13:;
   cl_env_copy->nvalues = 2;
   cl_env_copy->values[1] = v7;
   cl_env_copy->values[0] = v9;
   return cl_env_copy->values[0];
  }
 }
}
/* function definition for INFLATE-GZIP-STREAM                                */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5476inflate_gzip_stream(cl_narg narg, cl_object v1input_stream, cl_object v2output_stream, ...)
{
 cl_object T0;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
 cl_object v3check_checksum;
 ecl_va_list args; ecl_va_start(args,v2output_stream,narg,2);
 {
  cl_object keyvars[2];
  cl_parse_key(args,1,L5476inflate_gzip_streamkeys,keyvars,NULL,FALSE);
  ecl_va_end(args);
  v3check_checksum = keyvars[0];
 }
 {
  cl_object v4;                                   /*  CM                      */
  cl_object v5;                                   /*  MTIME                   */
  cl_object v6;                                   /*  FNAME                   */
  cl_object v7;                                   /*  FCOMMENT                */
  value0 = L5468parse_gzip_header(v1input_stream);
  {
   const int v8 = cl_env_copy->nvalues;
   v4 = value0;
   cl_object v9;
   v9 = (v8<=2)? ECL_NIL : cl_env_copy->values[2];
   v5 = v9;
   v9 = (v8<=6)? ECL_NIL : cl_env_copy->values[6];
   v6 = v9;
   v9 = (v8<=7)? ECL_NIL : cl_env_copy->values[7];
   v7 = v9;
  }
  if (ecl_number_equalp(v4,ecl_make_int8_t(8))) {
   goto L2;
  }
  T0 = ecl_list1(v4);
  cl_error(5, VV[10], ECL_SYM("FORMAT-CONTROL",1272), VV[157], ECL_SYM("FORMAT-ARGUMENTS",1271), T0);
L2:;
  {
   cl_object v8;
   cl_object v9;
   if (Null(v3check_checksum)){
    goto L6;
   }
   T0 = VV[52];
   goto L5;
L6:;
   T0 = ECL_NIL;
L5:;
   v8 = L5474inflate_stream(4, v1input_stream, v2output_stream, VV[151], T0);
   v9 = L5473parse_gzip_footer(v1input_stream);
   if (Null(v3check_checksum)){
    goto L9;
   }
   if (ecl_number_equalp(v9,v8)) {
    goto L9;
   }
   T0 = cl_list(2, v9, v8);
   cl_error(5, VV[10], ECL_SYM("FORMAT-CONTROL",1272), VV[160], ECL_SYM("FORMAT-ARGUMENTS",1271), T0);
L9:;
   cl_env_copy->nvalues = 4;
   cl_env_copy->values[3] = v7;
   cl_env_copy->values[2] = v5;
   cl_env_copy->values[1] = v6;
   cl_env_copy->values[0] = v9;
   return cl_env_copy->values[0];
  }
 }
}
/* function definition for GUNZIP                                             */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object L5477gunzip(cl_object volatile v1input_file, cl_object volatile v2output_file)
{
 cl_object volatile env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object volatile value0;
L1:;
 {
  volatile cl_object v3input;
  v3input = cl_open(3, v1input_file, ECL_SYM("ELEMENT-TYPE",1255), VV[62]);
  {
   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);
     {
      volatile cl_object v4output;
      v4output = cl_open(7, v2output_file, ECL_SYM("DIRECTION",1249), ECL_SYM("OUTPUT",1319), ECL_SYM("IF-EXISTS",1279), ECL_SYM("SUPERSEDE",1351), ECL_SYM("ELEMENT-TYPE",1255), VV[62]);
      {
       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_env_copy->values[0] = L5476inflate_gzip_stream(2, v3input, v4output);
         ecl_stack_frame_push_values(_ecl_inner_frame);
         if (Null(v4output)){
          goto L9;
         }
         cl_close(1, v4output);
L9:;
         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(v4output)){
        goto L11;
       }
       cl_close(3, v4output, ECL_SYM("ABORT",1225), ECL_T);
L11:;
       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_stack_frame_push_values(_ecl_inner_frame);
     if (Null(v3input)){
      goto L13;
     }
     cl_close(1, v3input);
L13:;
     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(v3input)){
    goto L15;
   }
   cl_close(3, v3input, ECL_SYM("ABORT",1225), ECL_T);
L15:;
   ecl_stack_frame_pop_values(_ecl_inner_frame);
   if (unwinding) ecl_unwind(cl_env_copy,next_fr);
   ecl_stack_frame_close(_ecl_inner_frame);
  }
 }
 value0 = cl_probe_file(v2output_file);
 return value0;
}
static cl_object L5477gunzip_va(cl_narg narg, cl_object v3input_file, cl_object v4output_file, ...)
{
 return L5477gunzip(v3input_file, v4output_file);
}
/* local function LAMBDA2                                                     */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object LC5433__lambda2(cl_object v1c, cl_object v2s)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 {
  cl_object v3;
  v3 = ECL_SYM_VAL(cl_env_copy,ECL_SYM("+IO-SYNTAX-PROGV-LIST+",1805));
  {
   cl_object v5, v6; cl_index v4;
   v5 = ECL_CONS_CAR(v3);
   v6 = ECL_CONS_CDR(v3);
   v4 = ecl_progv(cl_env_copy, v5, v6);
   ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-READABLY*",59),ECL_NIL); /*  *PRINT-READABLY* */
   T0 = (cl_env_copy->function=(ECL_SYM("SIMPLE-CONDITION-FORMAT-CONTROL",771)->symbol.gfdef))->cfun.entry(1, v1c) /*  SIMPLE-CONDITION-FORMAT-CONTROL */;
   T1 = (cl_env_copy->function=(ECL_SYM("SIMPLE-CONDITION-FORMAT-ARGUMENTS",772)->symbol.gfdef))->cfun.entry(1, v1c) /*  SIMPLE-CONDITION-FORMAT-ARGUMENTS */;
   value0 = cl_format(4, v2s, VV[5], T0, T1);
   ecl_bds_unwind(cl_env_copy,v4);
   return value0;
  }
 }
}
static cl_object LC5433__lambda2_va(cl_narg narg, cl_object v4c, cl_object v5s, ...)
{
 return LC5433__lambda2(v4c, v5s);
}
/* local function LAMBDA6                                                     */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object LC5435__lambda6(cl_object v1c, cl_object v2s)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 {
  cl_object v3;
  v3 = ECL_SYM_VAL(cl_env_copy,ECL_SYM("+IO-SYNTAX-PROGV-LIST+",1805));
  {
   cl_object v5, v6; cl_index v4;
   v5 = ECL_CONS_CAR(v3);
   v6 = ECL_CONS_CDR(v3);
   v4 = ecl_progv(cl_env_copy, v5, v6);
   ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-READABLY*",59),ECL_NIL); /*  *PRINT-READABLY* */
   T0 = (cl_env_copy->function=(ECL_SYM("SIMPLE-CONDITION-FORMAT-CONTROL",771)->symbol.gfdef))->cfun.entry(1, v1c) /*  SIMPLE-CONDITION-FORMAT-CONTROL */;
   T1 = (cl_env_copy->function=(ECL_SYM("SIMPLE-CONDITION-FORMAT-ARGUMENTS",772)->symbol.gfdef))->cfun.entry(1, v1c) /*  SIMPLE-CONDITION-FORMAT-ARGUMENTS */;
   value0 = cl_format(4, v2s, VV[9], T0, T1);
   ecl_bds_unwind(cl_env_copy,v4);
   return value0;
  }
 }
}
static cl_object LC5435__lambda6_va(cl_narg narg, cl_object v4c, cl_object v5s, ...)
{
 return LC5435__lambda6(v4c, v5s);
}
/* local function LAMBDA10                                                    */
/* optimize speed 3, debug 1, space 1, safety 0                               */
static cl_object LC5437__lambda10(cl_object v1c, cl_object v2s)
{
 cl_object T0, T1;
 cl_object env0 = ECL_NIL;
 const cl_env_ptr cl_env_copy = ecl_process_env();
 cl_object value0;
L1:;
 {
  cl_object v3;
  v3 = ECL_SYM_VAL(cl_env_copy,ECL_SYM("+IO-SYNTAX-PROGV-LIST+",1805));
  {
   cl_object v5, v6; cl_index v4;
   v5 = ECL_CONS_CAR(v3);
   v6 = ECL_CONS_CDR(v3);
   v4 = ecl_progv(cl_env_copy, v5, v6);
   ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-READABLY*",59),ECL_NIL); /*  *PRINT-READABLY* */
   T0 = (cl_env_copy->function=(ECL_SYM("SIMPLE-CONDITION-FORMAT-CONTROL",771)->symbol.gfdef))->cfun.entry(1, v1c) /*  SIMPLE-CONDITION-FORMAT-CONTROL */;
   T1 = (cl_env_copy->function=(ECL_SYM("SIMPLE-CONDITION-FORMAT-ARGUMENTS",772)->symbol.gfdef))->cfun.entry(1, v1c) /*  SIMPLE-CONDITION-FORMAT-ARGUMENTS */;
   value0 = cl_format(4, v2s, VV[9], T0, T1);
   ecl_bds_unwind(cl_env_copy,v4);
   return value0;
  }
 }
}
static cl_object LC5437__lambda10_va(cl_narg narg, cl_object v4c, cl_object v5s, ...)
{
 return LC5437__lambda10(v4c, v5s);
}
#include "ext/deflate.data"
#ifdef __cplusplus
extern "C"
#endif

ECL_DLLEXPORT void _ecl4N1I9dXpmctk9_RmZ1M881(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("EXT:DEFLATE;DEFLATE.LISP.NEWEST",-1);
 return;}
 #ifdef ECL_DYNAMIC_VV
 VV = Cblock->cblock.data;
 #endif
 Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecl4N1I9dXpmctk9_RmZ1M881@";
 VVtemp = Cblock->cblock.temp_data;
 ECL_DEFINE_SETF_FUNCTIONS
 {
  cl_object T0, T1, T2, T3, T4, T5;
  cl_object volatile env0 = ECL_NIL;
/* MAKE-LOAD-FORMs                                                            */
/* TOP-LEVEL-FORMs                                                            */
  (cl_env_copy->function=(VV[0]->symbol.gfdef))->cfun.entry(12, VVtemp[0], ECL_NIL, ECL_NIL, ECL_NIL, VVtemp[1], ECL_NIL, ECL_NIL, ECL_NIL, VVtemp[2], ECL_NIL, ECL_NIL, ECL_NIL) /*  DODEFPACKAGE */;
  si_select_package(VVtemp[0]);
  (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",669), VVtemp[3]) /*  MAPC */;
  clos_load_defclass(VV[1], VVtemp[4], ECL_NIL, ECL_NIL);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC5434__lambda0_va,ECL_NIL,Cblock,0);
   T0 = v1;
  }
  T1 = cl_listX(3, ECL_SYM("INITFUNCTION",1001), T0, VVtemp[6]);
  T2 = ecl_list1(T1);
  clos_load_defclass(VV[2], VVtemp[5], T2, ECL_NIL);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC5436__lambda4_va,ECL_NIL,Cblock,0);
   T0 = v1;
  }
  T1 = cl_listX(3, ECL_SYM("INITFUNCTION",1001), T0, VVtemp[7]);
  T2 = ecl_list1(T1);
  clos_load_defclass(VV[6], VVtemp[5], T2, ECL_NIL);
  {
   cl_object volatile v1;
   v1 = ecl_make_cfun_va((cl_objectfn)LC5438__lambda8_va,ECL_NIL,Cblock,0);
   T0 = v1;
  }
  T1 = cl_listX(3, ECL_SYM("INITFUNCTION",1001), T0, VVtemp[7]);
  T2 = ecl_list1(T1);
  clos_load_defclass(VV[10], VVtemp[5], T2, ECL_NIL);
  si_Xmake_constant(VV[13], ecl_make_int8_t(1));
  si_Xmake_constant(VV[14], ecl_make_fixnum(65521));
  (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",669), VVtemp[8]) /*  MAPC */;
  ecl_cmp_defun(VV[167]);                         /*  UPDATE-ADLER32-CHECKSUM */
  si_Xmake_constant(VV[19], ecl_make_int8_t(0));
  si_Xmake_constant(VV[20], ecl_make_fixnum(3988292384));
  (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",669), VVtemp[9]) /*  MAPC */;
  ecl_cmp_defun(VV[168]);                         /*  GENERATE-CRC32-TABLE    */
  (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",669), VVtemp[10]) /*  MAPC */;
  VV[25]=L5440generate_crc32_table();
  ecl_cmp_defun(VV[169]);                         /*  UPDATE-CRC32-CHECKSUM   */
  si_Xmake_constant(VV[27], ecl_make_fixnum(32768));
  si_define_structure(VV[29], _ecl_static_0, ECL_NIL, ECL_NIL, VVtemp[11], VVtemp[12], VV[30], ECL_NIL, ECL_NIL, ECL_NIL, VVtemp[13], ecl_make_int8_t(5), ECL_NIL, ECL_NIL, VV[31]);
  VV[40]=cl_find_class(1, VV[29]);
  ecl_cmp_defun(VV[170]);                         /*  MAKE-SLIDING-WINDOW-STREAM */
  {
   cl_object v1package;
   v1package = cl_symbol_package(VV[42]);
   if (Null(v1package)){
    goto L63;
   }
   if (Null(si_package_locked_p(v1package))){
    goto L63;
   }
   if (!(ECL_SYM_VAL(cl_env_copy,ECL_SYM("*IGNORE-PACKAGE-LOCKS*",1128))==ECL_NIL)){
    goto L63;
   }
   si_signal_simple_error(6, ECL_SYM("PACKAGE-ERROR",620), VVtemp[14], VVtemp[15], VVtemp[16], ECL_SYM("PACKAGE",1321), v1package);
  }
L63:;
  {
   cl_object volatile v2;
   v2 = ecl_make_cfun_va((cl_objectfn)LC5443__lambda83_va,ECL_NIL,Cblock,2);
   T0 = v2;
  }
  si_put_sysprop(VV[42], VV[43], T0);
  (cl_env_copy->function=(ECL_SYM("REMCAS",1535)->symbol.gfdef))->cfun.entry(1, VV[45]) /*  REMCAS */;
  {
   cl_object v2package;
   v2package = cl_symbol_package(VV[46]);
   if (Null(v2package)){
    goto L72;
   }
   if (Null(si_package_locked_p(v2package))){
    goto L72;
   }
   if (!(ECL_SYM_VAL(cl_env_copy,ECL_SYM("*IGNORE-PACKAGE-LOCKS*",1128))==ECL_NIL)){
    goto L72;
   }
   si_signal_simple_error(6, ECL_SYM("PACKAGE-ERROR",620), VVtemp[14], VVtemp[15], VVtemp[17], ECL_SYM("PACKAGE",1321), v2package);
  }
L72:;
  {
   cl_object volatile v3;
   v3 = ecl_make_cfun_va((cl_objectfn)LC5444__lambda88_va,ECL_NIL,Cblock,2);
   T0 = v3;
  }
  si_put_sysprop(VV[46], VV[43], T0);
  (cl_env_copy->function=(ECL_SYM("REMCAS",1535)->symbol.gfdef))->cfun.entry(1, VV[48]) /*  REMCAS */;
  (cl_env_copy->function=(ECL_SYM("REMCAS",1535)->symbol.gfdef))->cfun.entry(1, VV[49]) /*  REMCAS */;
  (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",669), VVtemp[18]) /*  MAPC */;
  ecl_cmp_defun(VV[171]);                         /*  SLIDING-WINDOW-STREAM-WRITE-BYTE */
  si_put_sysprop(VV[50], ECL_SYM("INLINE",436), VVtemp[19]);
  ecl_cmp_defun(VV[172]);                         /*  SLIDING-WINDOW-STREAM-FLUSH */
  ecl_cmp_defun(VV[173]);                         /*  SLIDING-WINDOW-STREAM-COPY-BYTES */
  si_define_structure(VV[58], _ecl_static_1, ECL_NIL, ECL_NIL, VVtemp[20], VVtemp[21], VV[59], ECL_NIL, ECL_NIL, ECL_NIL, VVtemp[22], ecl_make_int8_t(4), ECL_NIL, ECL_NIL, VV[60]);
  VV[67]=cl_find_class(1, VV[58]);
  ecl_cmp_defun(VV[174]);                         /*  MAKE-BIT-STREAM         */
  {
   cl_object v3package;
   v3package = cl_symbol_package(VV[69]);
   if (Null(v3package)){
    goto L101;
   }
   if (Null(si_package_locked_p(v3package))){
    goto L101;
   }
   if (!(ECL_SYM_VAL(cl_env_copy,ECL_SYM("*IGNORE-PACKAGE-LOCKS*",1128))==ECL_NIL)){
    goto L101;
   }
   si_signal_simple_error(6, ECL_SYM("PACKAGE-ERROR",620), VVtemp[14], VVtemp[15], VVtemp[23], ECL_SYM("PACKAGE",1321), v3package);
  }
L101:;
  {
   cl_object volatile v4;
   v4 = ecl_make_cfun_va((cl_objectfn)LC5449__lambda147_va,ECL_NIL,Cblock,2);
   T0 = v4;
  }
  si_put_sysprop(VV[69], VV[43], T0);
  {
   cl_object v4package;
   v4package = cl_symbol_package(VV[71]);
   if (Null(v4package)){
    goto L109;
   }
   if (Null(si_package_locked_p(v4package))){
    goto L109;
   }
   if (!(ECL_SYM_VAL(cl_env_copy,ECL_SYM("*IGNORE-PACKAGE-LOCKS*",1128))==ECL_NIL)){
    goto L109;
   }
   si_signal_simple_error(6, ECL_SYM("PACKAGE-ERROR",620), VVtemp[14], VVtemp[15], VVtemp[24], ECL_SYM("PACKAGE",1321), v4package);
  }
L109:;
  {
   cl_object volatile v5;
   v5 = ecl_make_cfun_va((cl_objectfn)LC5450__lambda152_va,ECL_NIL,Cblock,2);
   T0 = v5;
  }
  si_put_sysprop(VV[71], VV[43], T0);
  {
   cl_object v5package;
   v5package = cl_symbol_package(VV[73]);
   if (Null(v5package)){
    goto L117;
   }
   if (Null(si_package_locked_p(v5package))){
    goto L117;
   }
   if (!(ECL_SYM_VAL(cl_env_copy,ECL_SYM("*IGNORE-PACKAGE-LOCKS*",1128))==ECL_NIL)){
    goto L117;
   }
   si_signal_simple_error(6, ECL_SYM("PACKAGE-ERROR",620), VVtemp[14], VVtemp[15], VVtemp[25], ECL_SYM("PACKAGE",1321), v5package);
  }
L117:;
  {
   cl_object volatile v6;
   v6 = ecl_make_cfun_va((cl_objectfn)LC5451__lambda157_va,ECL_NIL,Cblock,2);
   T0 = v6;
  }
  si_put_sysprop(VV[73], VV[43], T0);
  (cl_env_copy->function=(ECL_SYM("REMCAS",1535)->symbol.gfdef))->cfun.entry(1, VV[75]) /*  REMCAS */;
  (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",669), VVtemp[26]) /*  MAPC */;
  ecl_cmp_defun(VV[175]);                         /*  BIT-STREAM-GET-BYTE     */
  si_put_sysprop(VV[76], ECL_SYM("INLINE",436), VVtemp[27]);
  (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",669), VVtemp[28]) /*  MAPC */;
  ecl_cmp_defun(VV[176]);                         /*  BIT-STREAM-READ-BITS    */
  si_put_sysprop(VV[78], ECL_SYM("INLINE",436), VVtemp[29]);
  (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",669), VVtemp[30]) /*  MAPC */;
  ecl_cmp_defun(VV[177]);                         /*  BIT-STREAM-COPY-BLOCK   */
  si_put_sysprop(VV[81], ECL_SYM("INLINE",436), VVtemp[31]);
  si_define_structure(VV[84], _ecl_static_2, ECL_NIL, ECL_NIL, VVtemp[32], VVtemp[33], VV[85], ECL_NIL, ECL_NIL, ECL_NIL, VVtemp[34], ecl_make_int8_t(2), ECL_NIL, ECL_NIL, VV[86]);
  VV[91]=cl_find_class(1, VV[84]);
  ecl_cmp_defun(VV[178]);                         /*  MAKE-DECODE-TREE        */
  {
   cl_object v6package;
   v6package = cl_symbol_package(VV[93]);
   if (Null(v6package)){
    goto L149;
   }
   if (Null(si_package_locked_p(v6package))){
    goto L149;
   }
   if (!(ECL_SYM_VAL(cl_env_copy,ECL_SYM("*IGNORE-PACKAGE-LOCKS*",1128))==ECL_NIL)){
    goto L149;
   }
   si_signal_simple_error(6, ECL_SYM("PACKAGE-ERROR",620), VVtemp[14], VVtemp[15], VVtemp[35], ECL_SYM("PACKAGE",1321), v6package);
  }
L149:;
  {
   cl_object volatile v7;
   v7 = ecl_make_cfun_va((cl_objectfn)LC5456__lambda273_va,ECL_NIL,Cblock,2);
   T0 = v7;
  }
  si_put_sysprop(VV[93], VV[43], T0);
  (cl_env_copy->function=(ECL_SYM("REMCAS",1535)->symbol.gfdef))->cfun.entry(1, VV[95]) /*  REMCAS */;
  ecl_cmp_defun(VV[179]);                         /*  MAKE-HUFFMAN-DECODE-TREE */
  (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",669), VVtemp[36]) /*  MAPC */;
  ecl_cmp_defun(VV[180]);                         /*  READ-HUFFMAN-CODE       */
  si_put_sysprop(VV[103], ECL_SYM("INLINE",436), VVtemp[37]);
  si_Xmake_special(VV[106]);
  T0 = cl_make_sequence(4, ECL_SYM("VECTOR",902), ecl_make_uint8_t(144), ECL_SYM("INITIAL-ELEMENT",1286), ecl_make_int8_t(8));
  T1 = cl_make_sequence(4, ECL_SYM("VECTOR",902), ecl_make_int8_t(112), ECL_SYM("INITIAL-ELEMENT",1286), ecl_make_int8_t(9));
  T2 = cl_make_sequence(4, ECL_SYM("VECTOR",902), ecl_make_int8_t(24), ECL_SYM("INITIAL-ELEMENT",1286), ecl_make_int8_t(7));
  T3 = cl_make_sequence(4, ECL_SYM("VECTOR",902), ecl_make_int8_t(8), ECL_SYM("INITIAL-ELEMENT",1286), ecl_make_int8_t(8));
  T4 = cl_concatenate(5, ECL_SYM("VECTOR",902), T0, T1, T2, T3);
  T5 = L5457make_huffman_decode_tree(T4);
  ECL_SETQ(cl_env_copy,VV[106],T5);
  si_Xmake_special(VV[107]);
  T0 = cl_make_sequence(4, ECL_SYM("VECTOR",902), ecl_make_int8_t(32), ECL_SYM("INITIAL-ELEMENT",1286), ecl_make_int8_t(5));
  T1 = L5457make_huffman_decode_tree(T0);
  ECL_SETQ(cl_env_copy,VV[107],T1);
  si_Xmake_special(VV[108]);
  T0 = VVtemp[38];
  ECL_SETQ(cl_env_copy,VV[108],T0);
  ecl_cmp_defun(VV[181]);                         /*  DECODE-CODE-LENGTH-ENTRIES */
  ecl_cmp_defun(VV[182]);                         /*  DECODE-HUFFMAN-TABLES   */
  (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",669), VVtemp[39]) /*  MAPC */;
  ecl_cmp_defun(VV[183]);                         /*  DECODE-LENGTH-ENTRY     */
  si_put_sysprop(VV[115], ECL_SYM("INLINE",436), VVtemp[40]);
  (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",669), VVtemp[41]) /*  MAPC */;
  ecl_cmp_defun(VV[184]);                         /*  DECODE-DISTANCE-ENTRY   */
  si_put_sysprop(VV[118], ECL_SYM("INLINE",436), VVtemp[42]);
  ecl_cmp_defun(VV[185]);                         /*  DECODE-HUFFMAN-BLOCK    */
  ecl_cmp_defun(VV[186]);                         /*  DECODE-BLOCK            */
  ecl_cmp_defun(VV[187]);                         /*  PARSE-ZLIB-HEADER       */
  ecl_cmp_defun(VV[188]);                         /*  PARSE-ZLIB-CHECKSUM     */
  ecl_cmp_defun(VV[189]);                         /*  PARSE-ZLIB-FOOTER       */
  si_Xmake_constant(VV[133], ecl_make_int8_t(31));
  si_Xmake_constant(VV[134], ecl_make_uint8_t(139));
  ecl_cmp_defun(VV[190]);                         /*  PARSE-GZIP-HEADER       */
  ecl_cmp_defun(VV[191]);                         /*  PARSE-GZIP-MTIME        */
  ecl_cmp_defun(VV[192]);                         /*  PARSE-GZIP-EXTRA        */
  ecl_cmp_defun(VV[193]);                         /*  PARSE-GZIP-STRING       */
  ecl_cmp_defun(VV[194]);                         /*  PARSE-GZIP-CHECKSUM     */
  ecl_cmp_defun(VV[195]);                         /*  PARSE-GZIP-FOOTER       */
  ecl_cmp_defun(VV[196]);                         /*  INFLATE-STREAM          */
  ecl_cmp_defun(VV[197]);                         /*  INFLATE-ZLIB-STREAM     */
  ecl_cmp_defun(VV[198]);                         /*  INFLATE-GZIP-STREAM     */
  ecl_cmp_defun(VV[199]);                         /*  GUNZIP                  */
  cl_provide(VV[166]);
 }
}
