///|
let delta_palette : FixedArray[Int32] = [
  0, 0, 0, 4, 4, 4, 11, 0, 0, 0, 0, -13, 0, -12, 0, -10, -10, -10, -18, -18, -18,
  -27, -27, -27, -18, -18, 0, 0, 0, -32, -32, 0, 0, -37, -37, -37, 0, -32, -32, 24,
  24, 45, 50, 50, 50, -45, -24, -24, -24, -45, -45, 0, -24, -24, -34, -34, 0, -24,
  0, -24, -45, -45, -24, 64, 64, 64, -32, 0, -32, 0, -32, 0, -32, 0, 32, -24, -45,
  -24, 45, 24, 45, 24, -24, -45, -45, -24, 24, 80, 80, 80, 64, 0, 0, 0, 0, -64, 0,
  -64, -64, -24, -24, 45, 96, 96, 96, 64, 64, 0, 45, -24, -24, 34, -34, 0, 112, 112,
  112, 24, -45, -45, 45, 45, -24, 0, -32, 32, 24, -24, 45, 0, 96, 96, 45, -24, 24,
  24, -45, -24, -24, -45, 24, 0, -64, 0, 96, 0, 0, 128, 128, 128, 64, 0, 64, 144,
  144, 144, 96, 96, 0, -36, -36, 36, 45, -24, -45, 45, -45, -24, 0, 0, -96, 0, 128,
  128, 0, 96, 0, 45, 24, -45, -128, 0, 0, 24, -45, 24, -45, 24, -45, 64, 0, -64,
  64, -64, -64, 96, 0, 96, 45, -45, 24, 24, 45, -45, 64, 64, -64, 128, 128, 0, 0,
  0, -128, -24, 45, -45,
]

///|
fn Palette::inverse_inner(
  self : Palette,
  palette : @grid.SubGrid[Int32],
  targets : Array[@grid.SubGrid[Int32]],
  bit_depth : Int32,
) -> Unit {
  let nb_deltas = self.nb_deltas
  let nb_colors = self.nb_colours
  let index_grid = targets[0]
  let width = index_grid.width
  let height = index_grid.height
  let is_simple = for y in 0..= nb_colors {
        ok = false
        break
      }
    }
    if !ok {
      break false
    }
  } nobreak {
    true
  }
  if is_simple {
    return inverse_simple(palette, targets)
  }
  let need_delta : Array[(Int32, Int32)] = []
  let channels = targets.length()
  guard channels == palette.height else {
    abort("assertion failed: palette channel count")
  }
  // `(1i32 << bit_depth) - 1` and `1i32 << bit_depth.saturating_sub(3)`
  let max_value = (1 << (bit_depth & 31)) - 1
  let delta_shift = if bit_depth > 8 {
    (if bit_depth < 24 { bit_depth } else { 24 }) - 8
  } else {
    0
  }
  let base_offset = 1 << (if bit_depth > 3 { bit_depth - 3 } else { 0 })
  for y in 0..= 0 && index < nb_colors {
        for c in 0..= nb_colors {
        let index = index - nb_colors
        if index < 64 {
          for c in 0..> ((2 * c) & 31)) % 4 * max_value / 4 + base_offset,
            )
          }
        } else {
          let mut index = index - 64
          for c in 0..= 3 {
            targets[c].set(x, y, 0)
            continue
          }
          let index = -(index + 1)
          let index = index % 143
          let mut temp_sample = delta_palette[((index + 1) >> 1) * 3 + c]
          if (index & 1) == 0 {
            temp_sample = -temp_sample
          }
          if bit_depth > 8 {
            temp_sample = temp_sample << delta_shift
          }
          targets[c].set(x, y, temp_sample)
        }
      }
    }
  }
  if need_delta.is_empty() {
    return
  }
  let d_pred = self.d_pred
  let wp_header = if d_pred == SelfCorrecting { self.wp_header } else { None }
  let predictor = PredictorState::new()
  for grid in targets {
    predictor.reset(width, [], wp_header)
    let mut idx = 0
    let buf = grid.buf
    let mut done = false
    for y in 0..= need_delta.length() {
            done = true
            break
          }
        }
        predictor.record(sample_value)
      }
      if done {
        break
      }
    }
  }
}

///|
fn inverse_simple(
  palette : @grid.SubGrid[Int32],
  targets : Array[@grid.SubGrid[Int32]],
) -> Unit {
  let index_grid = targets[0]
  let height = index_grid.height
  let width = index_grid.width
  let channels = targets.length()
  guard channels == palette.height else {
    abort("assertion failed: palette channel count")
  }
  let ibuf = index_grid.buf
  let pbuf = palette.buf
  for c in 1..