docs: function zip_ct_tally(
      dist, // distance of matched string
      lc) { // match length-MIN_MATCH or unmatched char (if dist==0)
      zip_l_buf[zip_last_lit++] = lc;
      if (dist == 0) {
          // lc is the unmatched char
          zip_dyn_ltree[lc].fc++;
      } else {
          // Here, lc is the match length - MIN_MATCH
          dist--; // dist = match distance - 1
          //      Assert((ush)dist < (ush)MAX_DIST &&
          //       (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
          //       (ush)D_CODE(dist) < (ush)D_CODES,  "ct_tally: bad match");
  
          zip_dyn_ltree[zip_length_code[lc] + zip_LITERALS + 1].fc++;
          zip_dyn_dtree[zip_D_CODE(dist)].fc++;
  
          zip_d_buf[zip_last_dist++] = dist;
          zip_flags |= zip_flag_bit;
      }
      zip_flag_bit <<= 1;
  
      // Output the flags if they fill a byte
      if ((zip_last_lit & 7) == 0) {
          zip_flag_buf[zip_last_flags++] = zip_flags;
          zip_flags = 0;
          zip_flag_bit = 1;
      }
      // Try to guess if it is profitable to stop the current block here
      if (zip_compr_level > 2 && (zip_last_lit & 0xfff) == 0) {
          // Compute an upper bound for the compressed length
          var out_length = zip_last_lit * 8;
          var in_length = zip_strstart - zip_block_start;
          var dcode;
  
          for (dcode = 0; dcode < zip_D_CODES; dcode++) {
              out_length += zip_dyn_dtree[dcode].fc * (5 + zip_extra_dbits[dcode]);
          }
          out_length >>= 3;
          //      Trace((stderr,"\nlast_lit %u, last_dist %u, in %ld, out ~%ld(%ld%%) ",
          //       encoder->last_lit, encoder->last_dist, in_length, out_length,
          //       100L - out_length*100L/in_length));
          if (zip_last_dist < parseInt(zip_last_lit / 2) &&
              out_length < parseInt(in_length / 2))
              return true;
      }
      return (zip_last_lit == zip_LIT_BUFSIZE - 1 ||
          zip_last_dist == zip_DIST_BUFSIZE);
      /* We avoid equality with LIT_BUFSIZE because of wraparound at 64K
       * on 16 bit machines and because stored blocks are restricted to
       * 64K-1 bytes.
       */
  }