attempt to divide by zero

let c = Content::read(&mut BufReader::new(File::open(&path)?))?;
println!("{mode}: Content::read ok, {} tensors, alignment {:?}", c.tensor_infos.len(), c.metadata.get("general.alignment").map(Value::to_u32));
let model = ModelWeights::from_gguf(c, &mut f, &dev)?; // then one forward on "What is Rust?"

--- align32
align32: Content::read ok, 272 tensors, alignment Some(Ok(32))
first generated token 66 "R"
exit=0
--- align0

thread 'main' (3975114) panicked at ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/candle-core-0.11.0/src/quantized/gguf_file.rs:560:43:
attempt to divide by zero
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
exit=101
--- trunc
trunc: Content::read ok, 272 tensors, alignment None
Error: tensor needs 2304 bytes at offset 144809056, only 0 remaining in file
exit=1

        let position = reader.stream_position()?;
        let alignment = match metadata.get("general.alignment") {
            Some(Value::U8(v)) => *v as u64,
            Some(Value::U16(v)) => *v as u64,
            Some(Value::U32(v)) => *v as u64,
            Some(Value::I8(v)) if *v >= 0 => *v as u64,
            Some(Value::I16(v)) if *v >= 0 => *v as u64,
            Some(Value::I32(v)) if *v >= 0 => *v as u64,
            _ => DEFAULT_ALIGNMENT,
        };
        let tensor_data_offset = position.div_ceil(alignment) * alignment;

        let tensor_start = tensor_data_offset.saturating_add(self.offset);
        let file_size = reader.seek(std::io::SeekFrom::End(0))?;
        let remaining = file_size.saturating_sub(tensor_start);
        if size_in_bytes as u64 > remaining {
            crate::bail!(
                "tensor needs {size_in_bytes} bytes at offset {tensor_start}, only {remaining} remaining in file"
            )
        }

/// Reject what Content::read lets through: alignment 0 (it panics) and tensors past the end.
fn checked(path: &str) -> anyhow::Result<Content> {
  let content = std::panic::catch_unwind(|| read_header(path))
    .map_err(|_| anyhow::anyhow!("{path}: Content::read panicked (general.alignment = 0?)"))??;
  let file_len = std::fs::metadata(path)?.len();
  let mut infos: Vec<_> = content.tensor_infos.iter().collect();
  infos.sort_by_key(|(_, info)| info.offset);
  for (name, info) in infos {
    let bytes = (info.shape.elem_count() / info.ggml_dtype.block_size() * info.ggml_dtype.type_size()) as u64;
    let end = content.tensor_data_offset + info.offset + bytes;
    anyhow::ensure!(end <= file_len, "{path}: tensor {name} ends at {end}, file has {file_len} bytes");
  }
  Ok(content)
}

q8: ok, first generated token 66 "R"
align32: ok, first generated token 66 "R"

thread 'main' (4003453) panicked at ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/candle-core-0.11.0/src/quantized/gguf_file.rs:560:43:
attempt to divide by zero
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
align0: Err(~/exp-candle/pb-pit/gguf/align0.gguf: Content::read panicked (general.alignment = 0?))
trunc: Err(~/exp-candle/pb-pit/gguf/trunc.gguf: tensor blk.26.ffn_gate.weight ends at 105279328, file has 104857600 bytes)