///|
priv struct CompressionTracker {
  mut val : Int
  mut position : Int
  output : StringBuilder
  get_char_from_int : (Int) -> String
}

///|
fn CompressionTracker::get_char_from_int(
  self : CompressionTracker,
  code : Int,
) -> String {
  (self.get_char_from_int)(code)
}

///|
fn CompressionTracker::write_bit(
  self : CompressionTracker,
  bits_per_char : Int,
  value : Int,
) -> Unit {
  self.val = (self.val << 1) | (value & 1)
  if self.position == bits_per_char - 1 {
    self.position = 0
    self.output.write_string(self.get_char_from_int(self.val))
    self.val = 0
  } else {
    self.position += 1
  }
}

///|
fn CompressionTracker::write_bits_lsb(
  self : CompressionTracker,
  bits_per_char : Int,
  bit_count : Int,
  value : Int,
) -> Unit {
  let mut current = value
  for _ in 0..> 1
  }
}

///|
fn CompressionTracker::write_literal(
  self : CompressionTracker,
  bits_per_char : Int,
  code_unit : Int,
  num_bits : Int,
) -> Unit {
  if code_unit < 256 {
    for _ in 0.. String,
) -> String {
  let dictionary = {}
  let set_to_create = Set::new()
  let mut w = ""
  let mut enlarge_in = 2
  let mut dict_size = 3
  let mut num_bits = 2
  let data = {
    val: 0,
    position: 0,
    output: StringBuilder::new(),
    get_char_from_int,
  }

  fn decr_enlarge_in() {
    enlarge_in = enlarge_in - 1
    if enlarge_in == 0 {
      enlarge_in = 1 << num_bits
      num_bits = num_bits + 1
    }
  }

  for idx in 0..