nx_nxgguf.nx source

1// nxgguf.nx -- Nishi sovereign tensor weight format. 2// 3// Replaces HuggingFace safetensors / GGUF with content-addressed, 4// memory-mapped, dedupable weight blocks. Single-binary deploy of 5// any model; instant cold-load via mmap; LoRAs share base weights 6// at the storage layer. 7// 8// Format overview: 9// 10// [magic 4] = "NXGF" 11// [version 4] = u32 LE, currently 1 12// [tensor_count 8] = u64 LE, total tensors 13// [metadata_offset 8] = u64 LE, offset to metadata block 14// [metadata_length 8] = u64 LE, byte length of metadata 15// [block_table_offset 8] = u64 LE, offset to block dir 16// [block_table_length 8] = u64 LE, byte length of block dir 17// [data_offset 8] = u64 LE, where weight bytes start 18// [reserved 16] = zeros 19// = 64 bytes total header 20// 21// metadata block: protobuf-encoded TensorRegistry 22// repeated TensorEntry { 23// string name = 1; // "model.layers.0.attn.q.weight" 24// repeated int64 shape = 2; // [512, 512] 25// int32 dtype = 3; // 0=fp32 1=fp16 2=bf16 3=fp8 4=int8 5=int4 26// string block_hash = 4; // sha256 of the tensor's bytes 27// int64 byte_length = 5; // raw byte count 28// } 29// 30// block table: array of BlockDescriptor 31// bytes hash (32) // sha256 32// uint64 file_offset ( 8) // where in file 33// uint64 byte_length ( 8) 34// uint32 ref_count ( 4) // # tensors pointing here 35// uint32 reserved ( 4) 36// = 56 bytes per block descriptor 37// 38// data section: concatenated raw weight bytes; tensor reads 39// `block.byte_length` bytes starting at `block.file_offset`. 40// 41// Dedup mechanism: if two tensors have the same content, they share 42// one BlockDescriptor (block_hash matches). ref_count tracks usage. 43// LoRAs typically share 95%+ of base model weights this way. 44// 45// mmap path: caller mmaps the entire file, then nxgguf_open() walks 46// the header and metadata in-place. Tensor reads return pointers 47// into the mmap region -- zero-copy load. 48 49// nx_safety_envelope: 50// intended_use: AUTO_APPLIED -- primitive-specific tuning queued 51// sil_target: SIL1 52// evidence: [bulk_applied_2026-05-16, see-file-comment-for-detail] 53// verdict: NOT_YET_EVALUATED 54 55import "nx_syscalls.nx" 56 57// === constants === 58 59// "NXGF" stored little-endian: bytes 'N'(0x4E),'X'(0x58),'G'(0x47),'F'(0x46) 60// → u32 value with 'F' as MSB, 'N' as LSB = 0x4647_584E 61const NXGGUF_MAGIC: i64 = 0x4647584E 62const NXGGUF_VERSION: i64 = 1 63const NXGGUF_HEADER_BYTES: i64 = 64 64const NXGGUF_BLOCK_DESC_BYTES: i64 = 56 65 66// dtype enum (matches GGUF's dtype IDs where overlapping) 67const DTYPE_FP32: i64 = 0 68const DTYPE_FP16: i64 = 1 69const DTYPE_BF16: i64 = 2 70const DTYPE_FP8: i64 = 3 // E4M3 71const DTYPE_INT8: i64 = 4 72const DTYPE_INT4: i64 = 5 // group-quantized 73const DTYPE_INT2: i64 = 6 // for BitNet b1.58 + similar 74const DTYPE_TERN: i64 = 7 // ternary {-1, 0, 1} packed 75 76// element size in bits (for memory accounting) 77func dtype_bits(dt: i64) -> i64 { 78 if dt == DTYPE_FP32 { return 32 } 79 if dt == DTYPE_FP16 { return 16 } 80 if dt == DTYPE_BF16 { return 16 } 81 if dt == DTYPE_FP8 { return 8 } 82 if dt == DTYPE_INT8 { return 8 } 83 if dt == DTYPE_INT4 { return 4 } 84 if dt == DTYPE_INT2 { return 2 } 85 if dt == DTYPE_TERN { return 2 } // 1.58 bits effective, stored 2 86 return 32 87} 88 89// === in-memory representation === 90 91struct NxgFile { 92 base: *u8, // mmap'd file start 93 length: i64, // mmap'd byte length 94 tensor_count: i64, 95 metadata_off: i64, 96 metadata_len: i64, 97 block_table_off: i64, 98 block_table_len: i64, 99 data_off: i64, 100} 101 102struct NxgTensor { 103 file: *NxgFile, // back-pointer to owner 104 name_off: i64, // offset into metadata block where name lives 105 name_len: i64, // bytes 106 rank: i64, // number of dims 107 shape: *i64, // pointer into metadata where dims live 108 dtype: i64, 109 block_hash_off: i64, // offset into metadata where 32-byte hash lives 110 byte_length: i64, 111 data_ptr: *u8, // resolved pointer into mmap region; null until resolved 112} 113 114struct NxgBlockDesc { 115 hash_off: i64, // offset into block table where 32-byte hash lives 116 file_offset: i64, // where the block's bytes are in the file 117 byte_length: i64, 118 ref_count: i64, 119} 120 121// === reader === 122 123// Decode little-endian u64 at `buf[off..off+8]`. 124func read_u64_le(buf: *u8, off: i64) -> i64 { 125 var v: i64 = 0 126 var i: i64 = 7 127 while i >= 0 { 128 v = (v << 8) | buf[off + i] 129 i = i - 1 130 } 131 return v 132} 133 134func read_u32_le(buf: *u8, off: i64) -> i64 { 135 var v: i64 = 0 136 var i: i64 = 3 137 while i >= 0 { 138 v = (v << 8) | buf[off + i] 139 i = i - 1 140 } 141 return v 142} 143 144// Open an NXGF file from mmap'd bytes. Returns 0 on success; 145// negative on error. Validates magic + version + sanity-checks 146// offsets fit within the file. 147func nxgguf_open(file: *NxgFile, base: *u8, length: i64) -> i64 { 148 if length < NXGGUF_HEADER_BYTES { return -1 } 149 let magic: i64 = read_u32_le(base, 0) 150 if magic != NXGGUF_MAGIC { return -2 } 151 let version: i64 = read_u32_le(base, 4) 152 if version != NXGGUF_VERSION { return -3 } 153 154 file.base = base 155 file.length = length 156 file.tensor_count = read_u64_le(base, 8) 157 file.metadata_off = read_u64_le(base, 16) 158 file.metadata_len = read_u64_le(base, 24) 159 file.block_table_off = read_u64_le(base, 32) 160 file.block_table_len = read_u64_le(base, 40) 161 file.data_off = read_u64_le(base, 48) 162 163 // Bounds check. 164 if file.metadata_off + file.metadata_len > length { return -4 } 165 if file.block_table_off + file.block_table_len > length { return -5 } 166 if file.data_off > length { return -6 } 167 return 0 168} 169 170// Total weight bytes -- sum across all unique blocks. Used for VRAM 171// accounting before committing the model to GPU. 172func nxgguf_total_bytes(file: *NxgFile) -> i64 { 173 let n_blocks: i64 = file.block_table_len / NXGGUF_BLOCK_DESC_BYTES 174 var total: i64 = 0 175 var i: i64 = 0 176 while i < n_blocks { 177 let off: i64 = file.block_table_off + i * NXGGUF_BLOCK_DESC_BYTES 178 let len: i64 = read_u64_le(file.base, off + 40) 179 total = total + len 180 i = i + 1 181 } 182 return total 183} 184 185// Number of unique blocks (vs total tensors). Lower = better dedup. 186func nxgguf_unique_blocks(file: *NxgFile) -> i64 { 187 return file.block_table_len / NXGGUF_BLOCK_DESC_BYTES 188} 189 190// === content-addressed block hashing ================================= 191// 192// sha256 of a tensor's raw bytes is the block_hash. Two tensors 193// with identical content -> identical hash -> share one 194// BlockDescriptor. This is what makes LoRAs near-free at the 195// storage layer (95%+ of base weights typically share with the 196// base model). 197 198import "nx_sha256.nx" 199const NXGGUF_MAGIC_8192: i64 = 8192 200const NXGGUF_MAGIC_1024: i64 = 1024 201const NXGGUF_MAGIC_65536: i64 = 65536 202 203// Compute sha256(bytes[0..len]) into out (32 bytes). 204func nxgguf_hash_block(bytes: *u8, len: i64, out: *u8) -> i64 { 205 let ctx_raw: *u8 = sys_mmap(128) 206 let ctx: *Sha256 = ctx_raw as *Sha256 207 sha256_init(ctx) 208 sha256_update(ctx, bytes, len) 209 sha256_final(ctx, out) 210 return 0 211} 212 213// Compare two 32-byte sha256 hashes. Returns 0 if equal, 1 if 214// different. Constant-time (sha256 outputs aren't secret but 215// dedup speed matters). 216func nxgguf_hash_eq(a: *u8, b: *u8) -> i64 { 217 var i: i64 = 0 218 var diff: i64 = 0 219 while i < 32 { 220 if a[i] != b[i] { diff = 1 } 221 i = i + 1 222 } 223 if diff == 1 { return 1 } 224 return 0 225} 226 227// Look up a block by its hash in the file's block table. Returns 228// the block index (>= 0) on hit, or -1 on miss. O(N) scan; for 229// production use a hash-keyed index (later phase, ~80 LoC). 230func nxgguf_find_block(file: *NxgFile, target_hash: *u8) -> i64 { 231 let n_blocks: i64 = file.block_table_len / NXGGUF_BLOCK_DESC_BYTES 232 var i: i64 = 0 233 while i < n_blocks { 234 let desc_off: i64 = file.block_table_off + i * NXGGUF_BLOCK_DESC_BYTES 235 let block_hash_ptr: *u8 = (file.base as i64 + desc_off) as *u8 236 if nxgguf_hash_eq(block_hash_ptr, target_hash) == 0 { 237 return i 238 } 239 i = i + 1 240 } 241 return -1 242} 243 244// === write side ====================================================== 245// 246// Build an nxgguf file in memory from an array of tensor entries. 247// Caller supplies tensor metadata + raw bytes; encoder hashes each 248// tensor's content, dedupes, packs the format. 249// 250// Usage: 251// let w: *NxgWriter = nxgguf_writer_new(out_buf, out_cap) 252// for each tensor: 253// nxgguf_writer_add(w, name, name_len, rank, shape, dtype, 254// data, byte_length) 255// let total: i64 = nxgguf_writer_finalize(w) 256// sys_write(fd, out_buf, total) 257// 258// The writer maintains an in-memory block table for dedup. Every 259// tensor's content is sha256'd; matching hashes share one 260// BlockDescriptor (ref_count++). 261 262const NXG_MAX_BLOCKS: i64 = 4096 263const NXG_MAX_TENSORS: i64 = 4096 264 265struct NxgWriter { 266 out: *u8, 267 out_cap: i64, 268 n_blocks: i64, 269 n_tensors: i64, 270 block_hashes: *u8, 271 block_lens: *i64, 272 block_data: *u8, 273 block_offs: *i64, 274 block_data_pos: i64, 275 tensor_names: *u8, 276 tensor_ranks: *i64, 277 tensor_shapes: *i64, 278 tensor_dtypes: *i64, 279 tensor_blocks: *i64, 280} 281 282func nxgguf_writer_new(out_buf: *u8, out_cap: i64) -> *NxgWriter { 283 let w_raw: *u8 = sys_mmap(128) 284 let w: *NxgWriter = w_raw as *NxgWriter 285 w.out = out_buf 286 w.out_cap = out_cap 287 w.n_blocks = 0 288 w.n_tensors = 0 289 w.block_hashes = sys_mmap(NXG_MAX_BLOCKS * 32 + 64) 290 w.block_lens = sys_mmap(NXG_MAX_BLOCKS * 8 + 64) as *i64 291 w.block_data = sys_mmap(out_cap) 292 w.block_offs = sys_mmap(NXG_MAX_BLOCKS * 8 + 64) as *i64 293 w.block_data_pos = 0 294 w.tensor_names = sys_mmap(NXG_MAX_TENSORS * 256 + 64) 295 w.tensor_ranks = sys_mmap(NXG_MAX_TENSORS * 8 + 64) as *i64 296 w.tensor_shapes = sys_mmap(NXG_MAX_TENSORS * 8 * 8 + 64) as *i64 297 w.tensor_dtypes = sys_mmap(NXG_MAX_TENSORS * 8 + 64) as *i64 298 w.tensor_blocks = sys_mmap(NXG_MAX_TENSORS * 8 + 64) as *i64 299 return w 300} 301 302// Look up a hash in the writer's block table. Returns block index 303// or -1 if not present. 304func nxgguf_writer_find_block(w: *NxgWriter, target_hash: *u8) -> i64 { 305 var i: i64 = 0 306 while i < w.n_blocks { 307 let h_off: i64 = i * 32 308 let bh: *u8 = (w.block_hashes as i64 + h_off) as *u8 309 if nxgguf_hash_eq(bh, target_hash) == 0 { return i } 310 i = i + 1 311 } 312 return -1 313} 314 315// Add a tensor to the writer. Hashes the data; dedupes against 316// existing blocks; appends a new BlockDescriptor + bytes if novel. 317// Returns 0 on success, -1 on capacity overflow. 318func nxgguf_writer_add(w: *NxgWriter, 319 name: *u8, name_len: i64, 320 rank: i64, shape: *i64, dtype: i64, 321 data: *u8, byte_length: i64) -> i64 { 322 if w.n_tensors >= NXG_MAX_TENSORS { return -1 } 323 324 let hash_buf: *u8 = sys_mmap(64) 325 nxgguf_hash_block(data, byte_length, hash_buf) 326 327 var block_idx: i64 = nxgguf_writer_find_block(w, hash_buf) 328 if block_idx < 0 { 329 if w.n_blocks >= NXG_MAX_BLOCKS { return -1 } 330 block_idx = w.n_blocks 331 let h_off: i64 = block_idx * 32 332 var k: i64 = 0 333 while k < 32 { 334 let dst: *u8 = (w.block_hashes as i64 + h_off + k) as *u8 335 *dst = hash_buf[k] 336 k = k + 1 337 } 338 w.block_lens[block_idx] = byte_length 339 var bi: i64 = 0 340 while bi < byte_length { 341 let dst: *u8 = (w.block_data as i64 + w.block_data_pos + bi) as *u8 342 *dst = data[bi] 343 bi = bi + 1 344 } 345 w.block_offs[block_idx] = w.block_data_pos 346 w.block_data_pos = w.block_data_pos + byte_length 347 w.n_blocks = w.n_blocks + 1 348 } 349 350 let t_idx: i64 = w.n_tensors 351 let name_off: i64 = t_idx * 256 352 var k: i64 = 0 353 while k < name_len { 354 let dst: *u8 = (w.tensor_names as i64 + name_off + k) as *u8 355 *dst = name[k] 356 k = k + 1 357 } 358 let term: *u8 = (w.tensor_names as i64 + name_off + name_len) as *u8 359 *term = 0 360 w.tensor_ranks[t_idx] = rank 361 let shape_off: i64 = t_idx * 8 362 var d: i64 = 0 363 while d < rank { 364 if d >= 8 { return -1 } 365 w.tensor_shapes[shape_off + d] = shape[d] 366 d = d + 1 367 } 368 w.tensor_dtypes[t_idx] = dtype 369 w.tensor_blocks[t_idx] = block_idx 370 w.n_tensors = t_idx + 1 371 return 0 372} 373 374// Encode a u64 little-endian into out[off..off+8]. 375func write_u64_le(out: *u8, off: i64, v: i64) -> i64 { 376 out[off + 0] = v & 0xFF 377 out[off + 1] = (v >> 8) & 0xFF 378 out[off + 2] = (v >> 16) & 0xFF 379 out[off + 3] = (v >> 24) & 0xFF 380 out[off + 4] = (v >> 32) & 0xFF 381 out[off + 5] = (v >> 40) & 0xFF 382 out[off + 6] = (v >> 48) & 0xFF 383 out[off + 7] = (v >> 56) & 0xFF 384 return 0 385} 386 387// Finalize: emit header + block table + data section. Skips the 388// metadata block for v0.0.1 (protobuf encoder is a future commit). 389// Returns total bytes written. 390func nxgguf_writer_finalize(w: *NxgWriter) -> i64 { 391 let header_bytes: i64 = NXGGUF_HEADER_BYTES 392 let block_table_bytes: i64 = w.n_blocks * NXGGUF_BLOCK_DESC_BYTES 393 let data_off: i64 = header_bytes + block_table_bytes 394 let total: i64 = data_off + w.block_data_pos 395 if total > w.out_cap { return -1 } 396 397 w.out[0] = 0x4E // 'N' 398 w.out[1] = 0x58 // 'X' 399 w.out[2] = 0x47 // 'G' 400 w.out[3] = 0x46 // 'F' 401 w.out[4] = 1; w.out[5] = 0; w.out[6] = 0; w.out[7] = 0 402 write_u64_le(w.out, 8, w.n_tensors) 403 write_u64_le(w.out, 16, header_bytes) // metadata_off 404 write_u64_le(w.out, 24, 0) // metadata_len 405 write_u64_le(w.out, 32, header_bytes) // block_table_off 406 write_u64_le(w.out, 40, block_table_bytes) 407 write_u64_le(w.out, 48, data_off) 408 var i: i64 = 56 409 while i < 64 { w.out[i] = 0; i = i + 1 } 410 411 var b: i64 = 0 412 while b < w.n_blocks { 413 let desc_off: i64 = header_bytes + b * NXGGUF_BLOCK_DESC_BYTES 414 var k: i64 = 0 415 while k < 32 { 416 let src: *u8 = (w.block_hashes as i64 + b * 32 + k) as *u8 417 w.out[desc_off + k] = *src 418 k = k + 1 419 } 420 write_u64_le(w.out, desc_off + 32, data_off + w.block_offs[b]) 421 write_u64_le(w.out, desc_off + 40, w.block_lens[b]) 422 write_u64_le(w.out, desc_off + 48, 0) 423 b = b + 1 424 } 425 426 var di: i64 = 0 427 while di < w.block_data_pos { 428 let src: *u8 = (w.block_data as i64 + di) as *u8 429 w.out[data_off + di] = *src 430 di = di + 1 431 } 432 return total 433} 434 435// === self-test === 436 437// Construct a 4-tensor fixture in memory + verify open/total-bytes 438// round-trip. No file I/O so this runs anywhere. 439func main() -> i64 { 440 let buf: *u8 = sys_mmap(NXGGUF_MAGIC_8192) 441 442 // header: "NXGF" magic bytes 443 buf[0] = 0x4E // 'N' 444 buf[1] = 0x58 // 'X' 445 buf[2] = 0x47 // 'G' 446 buf[3] = 0x46 // 'F' 447 // version = 1, little-endian u32 448 buf[4] = 1; buf[5] = 0; buf[6] = 0; buf[7] = 0 449 // tensor_count = 4 450 buf[8] = 4; buf[9] = 0; buf[10] = 0; buf[11] = 0 451 buf[12] = 0; buf[13] = 0; buf[14] = 0; buf[15] = 0 452 // metadata_off = 64, metadata_len = 0 (no metadata in this fixture) 453 buf[16] = 64; buf[17] = 0; buf[18] = 0; buf[19] = 0 454 buf[20] = 0; buf[21] = 0; buf[22] = 0; buf[23] = 0 455 buf[24] = 0; buf[25] = 0; buf[26] = 0; buf[27] = 0 456 buf[28] = 0; buf[29] = 0; buf[30] = 0; buf[31] = 0 457 // block_table_off = 64, block_table_len = 56 (one block) 458 buf[32] = 64; buf[33] = 0; buf[34] = 0; buf[35] = 0 459 buf[36] = 0; buf[37] = 0; buf[38] = 0; buf[39] = 0 460 buf[40] = 56; buf[41] = 0; buf[42] = 0; buf[43] = 0 461 buf[44] = 0; buf[45] = 0; buf[46] = 0; buf[47] = 0 462 // data_off = 120 463 buf[48] = 120; buf[49] = 0; buf[50] = 0; buf[51] = 0 464 buf[52] = 0; buf[53] = 0; buf[54] = 0; buf[55] = 0 465 // reserved 466 buf[56] = 0; buf[57] = 0; buf[58] = 0; buf[59] = 0 467 buf[60] = 0; buf[61] = 0; buf[62] = 0; buf[63] = 0 468 469 // block descriptor at offset 64: byte_length = 1024 at offset 64+40 = 104 470 buf[104] = 0; buf[105] = 4; buf[106] = 0; buf[107] = 0 // NXGGUF_MAGIC_1024 LE 471 buf[108] = 0; buf[109] = 0; buf[110] = 0; buf[111] = 0 472 473 let file: *NxgFile = sys_mmap(64) as *NxgFile 474 let rc: i64 = nxgguf_open(file, buf, NXGGUF_MAGIC_8192) 475 if rc != 0 { return __syscall(93, 100 + (0 - rc), 0, 0, 0, 0, 0) } 476 if file.tensor_count != 4 { return __syscall(93, 50, 0, 0, 0, 0, 0) } 477 if file.data_off != 120 { return __syscall(93, 51, 0, 0, 0, 0, 0) } 478 if nxgguf_total_bytes(file) != NXGGUF_MAGIC_1024 { 479 return __syscall(93, 52, 0, 0, 0, 0, 0) 480 } 481 if nxgguf_unique_blocks(file) != 1 { 482 return __syscall(93, 53, 0, 0, 0, 0, 0) 483 } 484 485 // Hash-equality + dedup self-test: 486 // Two identical 32-byte buffers -> same sha256 -> hash_eq returns 0. 487 let hash_a: *u8 = sys_mmap(64) 488 let hash_b: *u8 = sys_mmap(64) 489 let payload: *u8 = sys_mmap(128) 490 var ki: i64 = 0 491 while ki < 64 { payload[ki] = ki & 0xFF; ki = ki + 1 } 492 nxgguf_hash_block(payload, 64, hash_a) 493 nxgguf_hash_block(payload, 64, hash_b) 494 if nxgguf_hash_eq(hash_a, hash_b) != 0 { 495 return __syscall(93, 60, 0, 0, 0, 0, 0) 496 } 497 // Modify one byte of payload, re-hash -> different. 498 payload[0] = payload[0] ^ 1 499 nxgguf_hash_block(payload, 64, hash_b) 500 if nxgguf_hash_eq(hash_a, hash_b) != 1 { 501 return __syscall(93, 61, 0, 0, 0, 0, 0) 502 } 503 504 // Writer round-trip: build a 3-tensor file where two tensors 505 // share content (dedup test), then re-read it. 506 let wbuf: *u8 = sys_mmap(NXGGUF_MAGIC_65536) 507 let w: *NxgWriter = nxgguf_writer_new(wbuf, NXGGUF_MAGIC_65536) 508 509 // Tensor data: 64 bytes of distinct + 64 bytes that match 510 // tensor 0 + 32 bytes of distinct. 511 let t0_data: *u8 = sys_mmap(64); var ti: i64 = 0 512 while ti < 64 { t0_data[ti] = ti & 0xFF; ti = ti + 1 } 513 let t1_data: *u8 = sys_mmap(64); ti = 0 514 while ti < 64 { t1_data[ti] = ti & 0xFF; ti = ti + 1 } // identical to t0 515 let t2_data: *u8 = sys_mmap(32); ti = 0 516 while ti < 32 { t2_data[ti] = (ti + 100) & 0xFF; ti = ti + 1 } 517 518 let shape_raw: *u8 = sys_mmap(64); let shape_p: *i64 = shape_raw as *i64 519 shape_p[0] = 8; shape_p[1] = 8 520 521 nxgguf_writer_add(w, "tensor.0" as *u8, 8, 2, shape_p, DTYPE_INT8, t0_data, 64) 522 nxgguf_writer_add(w, "tensor.1" as *u8, 8, 2, shape_p, DTYPE_INT8, t1_data, 64) 523 let shape2_raw: *u8 = sys_mmap(64); let shape2_p: *i64 = shape2_raw as *i64 524 shape2_p[0] = 32 525 nxgguf_writer_add(w, "tensor.2" as *u8, 8, 1, shape2_p, DTYPE_INT8, t2_data, 32) 526 527 let total: i64 = nxgguf_writer_finalize(w) 528 if total <= 0 { return __syscall(93, 70, 0, 0, 0, 0, 0) } 529 530 // Round-trip verify: open + check counts. Dedup means 3 531 // tensors share 2 unique blocks. 532 let rd_file: *NxgFile = sys_mmap(64) as *NxgFile 533 let rrc: i64 = nxgguf_open(rd_file, wbuf, total) 534 if rrc != 0 { return __syscall(93, 71, 0, 0, 0, 0, 0) } 535 if rd_file.tensor_count != 3 { return __syscall(93, 72, 0, 0, 0, 0, 0) } 536 if nxgguf_unique_blocks(rd_file) != 2 { 537 return __syscall(93, 73, 0, 0, 0, 0, 0) 538 } 539 if nxgguf_total_bytes(rd_file) != 96 { // 64 + 32 = 96 (deduped) 540 return __syscall(93, 74, 0, 0, 0, 0, 0) 541 } 542 543 return __syscall(93, 42, 0, 0, 0, 0, 0) 544}