void compress( int init_bits, OutputStream outs ) throws IOException
      {
      int fcode;
      int i /* = 0 */;
      int c;
      int ent;
      int disp;
      int hsize_reg;
      int hshift;

      // Set up the globals:  g_init_bits - initial number of bits
      g_init_bits = init_bits;

      // Set up the necessary values
      clear_flg = false;
      n_bits = g_init_bits;
      maxcode = MAXCODE( n_bits );

      ClearCode = 1 << ( init_bits - 1 );
      EOFCode = ClearCode + 1;
      free_ent = ClearCode + 2;

      char_init();

      ent = nextPixel();

      hshift = 0;
      for ( fcode = hsize; fcode < 65536; fcode *= 2 )
          ++hshift;
      hshift = 8 - hshift;                        // set hash code range bound

      hsize_reg = hsize;
      cl_hash( hsize_reg );        // clear hash table

      output( ClearCode, outs );

      outer_loop:
      while ( (c = nextPixel()) != EOF )
          {
          fcode = ( c << maxbits ) + ent;
          i = ( c << hshift ) ^ ent;                // xor hashing

          if ( htab[i] == fcode )
              {
              ent = codetab[i];
              continue;
              }
          else if ( htab[i] >= 0 )        // non-empty slot
              {
              disp = hsize_reg - i;        // secondary hash (after G. Knott)
              if ( i == 0 )
                  disp = 1;
              do
                  {
                  if ( (i -= disp) < 0 )
                      i += hsize_reg;

                  if ( htab[i] == fcode )
                      {
                      ent = codetab[i];
                      continue outer_loop;
                      }
                  }
              while ( htab[i] >= 0 );
              }
          output( ent, outs );
          ent = c;
          if ( free_ent < maxmaxcode )
              {
              codetab[i] = free_ent++;        // code -> hashtable
              htab[i] = fcode;
              }
          else
              cl_block( outs );
          }
      // Put out the final code.
      output( ent, outs );
      output( EOFCode, outs );
      }