func.decl import("input") @require(%condition: i32, %diagnostic: buffer)

func.decl import("input") @encode(%text: buffer, %flags: i32, %capacity: i64) -> (buffer, i64)

func.decl import("json") @members(%json: buffer) -> (buffer, i32, i64)

func.decl import("json") @members_range(%json: buffer, %offset: i64, %length: i64) -> (buffer, i32, i64)

func.decl import("json") @compact(%text: buffer) -> (buffer)

func.decl import("json") @unescape(%source: buffer, %offset: i64, %length: i64, %target: buffer, %target_offset: i64) -> (i64)

func.decl import("tools") @parse_xml(%schemas: buffer, %response: buffer, %truncated: i64) -> (buffer)

func.decl import("runner") @execute_5(%stage: i32, %b0: hal.buffer, %b1: hal.buffer, %b2: hal.buffer, %b3: hal.buffer, %b4: hal.buffer) -> (i64)

func.decl import("runner") @execute_7(%stage: i32, %b0: hal.buffer, %b1: hal.buffer, %b2: hal.buffer, %b3: hal.buffer, %b4: hal.buffer, %b5: hal.buffer, %b6: hal.buffer) -> (i64)

func.decl import("runner") @execute_4(%stage: i32, %b0: hal.buffer, %b1: hal.buffer, %b2: hal.buffer, %b3: hal.buffer) -> (i64)

func.decl import("runner") @execute_6(%stage: i32, %b0: hal.buffer, %b1: hal.buffer, %b2: hal.buffer, %b3: hal.buffer, %b4: hal.buffer, %b5: hal.buffer) -> (i64)

func.decl import("runner") @feedback(%slot: i32, %source: hal.buffer, %offset: i64, %length: i64) -> (i64)

global.rodata.def @name = bytes("496e7465726e536369656e63652f536167652d41312e35")

global.rodata.def @empty = bytes("")

global.rodata.def @no_tools = bytes("5b5d")

global.rodata.def @assistant = bytes("617373697374616e74")

global.rodata.def @user = bytes("75736572")

global.rodata.def @system = bytes("73797374656d")

global.rodata.def @tool_role = bytes("746f6f6c")

// "role", "content", "messages", "enable_thinking", "chat_template_kwargs", "reasoning_effort", "none"
global.rodata.def @role_key = bytes("726f6c65")

global.rodata.def @content_key = bytes("636f6e74656e74")

global.rodata.def @messages_key = bytes("6d65737361676573")

global.rodata.def @thinking_key = bytes("656e61626c655f7468696e6b696e67")

global.rodata.def @kwargs_key = bytes("636861745f74656d706c6174655f6b7761726773")

global.rodata.def @effort_key = bytes("726561736f6e696e675f6566666f7274")

global.rodata.def @effort_none = bytes("6e6f6e65")

global.rodata.def @newline = bytes("0a")

// "unsupported message: roles are system/user/assistant/tool, content is text (no images)"
global.rodata.def @invalid = bytes("756e737570706f72746564206d6573736167653a20726f6c6573206172652073797374656d2f757365722f617373697374616e742f746f6f6c2c20636f6e74656e74206973207465787420286e6f20696d6167657329")

// "llm requires pooled epochs without MTP"
global.rodata.def @unsupported = bytes("6c6c6d20726571756972657320706f6f6c65642065706f63687320776974686f7574204d5450")

// "input exceeds the available context size"
global.rodata.def @overflow = bytes("696e70757420657863656564732074686520617661696c61626c6520636f6e746578742073697a65")

func.def @check(%condition: i1) {
  %value = scalar.extui %condition : i1 to i32
  %error = global.load @invalid : buffer
  func.call @require(%value, %error) : (i32, buffer)
  func.return
}

func.def @equal(%a: buffer, %b: buffer) -> (i1) {
  %a_length = buffer.length %a
  %b_length = buffer.length %b
  %same_length = index.cmp eq, %a_length, %b_length : offset
  %same = scf.if %same_length -> (i1) {
    %c0 = index.constant 0 : offset
    %compared = buffer.compare %a[%c0], %b[%c0], %a_length
    %c0_i32 = scalar.constant 0 : i32
    %matches = scalar.cmpi eq, %compared, %c0_i32 : i32
    scf.yield %matches : i1
  } else {
    %false = scalar.constant false : i1
    scf.yield %false : i1
  }
  func.return %same : i1
}

func.def @join(%a: buffer, %b: buffer) -> (buffer) {
  %c0 = index.constant 0 : offset
  %a_length = buffer.length %a
  %b_length = buffer.length %b
  %length = index.add %a_length, %b_length : offset
  %output = buffer.alloca<private> align(1) %length : buffer
  buffer.copy %a[%c0], %output[%c0], %a_length
  buffer.copy %b[%c0], %output[%a_length], %b_length
  func.return %output : buffer
}

func.def @join4(%a: buffer, %b: buffer, %c: buffer, %d: buffer) -> (buffer) {
  %ab = func.call @join(%a, %b) : (buffer, buffer) -> (buffer)
  %cd = func.call @join(%c, %d) : (buffer, buffer) -> (buffer)
  %all = func.call @join(%ab, %cd) : (buffer, buffer) -> (buffer)
  func.return %all : buffer
}

func.def inline @tool_append(%output: buffer, %position: offset, %text: buffer) -> (offset) {
  %c0 = index.constant 0 : offset
  %length = buffer.length %text
  buffer.copy %text[%c0], %output[%position], %length
  %end = index.add %position, %length : offset
  func.return %end : offset
}

// Copy of text[begin, end).
func.def inline @slice(%text: buffer, %begin: offset, %end: offset) -> (buffer) {
  %c0 = index.constant 0 : offset
  %size = index.sub %end, %begin : offset
  %result = buffer.alloca<private> align(1) %size : buffer
  buffer.copy %text[%begin], %result[%c0], %size
  func.return %result : buffer
}

func.def @json_range(%text: buffer, %begin: i64, %length: i64) -> (buffer) {
  %bounded_begin = scalar.assume %begin [range(%begin, 0, 9223372036854775807)] : i64
  %bounded_length = scalar.assume %length [range(%length, 0, 9223372036854775807)] : i64
  %start = index.cast %bounded_begin : i64 to offset
  %size = index.cast %bounded_length : i64 to offset
  %c0 = index.constant 0 : offset
  %result = buffer.alloca<private> align(1) %size : buffer
  buffer.copy %text[%start], %result[%c0], %size
  func.return %result : buffer
}

// Decodes a JSON string range (without quotes).
func.def @json_key(%source: buffer, %begin: i64, %length: i64) -> (buffer) {
  %c0_i64 = scalar.constant 0 : i64
  %bounded_length = scalar.assume %length [range(%length, 0, 9223372036854775807)] : i64
  %size = index.cast %bounded_length : i64 to offset
  %storage = buffer.alloca<private> align(1) %size : buffer
  %decoded_length = func.call @unescape(%source, %begin, %length, %storage, %c0_i64) : (buffer, i64, i64, buffer, i64) -> (i64)
  %result = func.call @json_range(%storage, %c0_i64, %decoded_length) : (buffer, i64, i64) -> (buffer)
  func.return %result : buffer
}

func.def inline @text_is_space(%text: buffer, %position: offset) -> (i1) {
  %byte = buffer.load.i8.u %text[%position]
  %space = scalar.constant 32 : i32
  %tab = scalar.constant 9 : i32
  %carriage_return = scalar.constant 13 : i32
  %is_space = scalar.cmpi eq, %byte, %space : i32
  %after_tab = scalar.cmpi uge, %byte, %tab : i32
  %before_return = scalar.cmpi ule, %byte, %carriage_return : i32
  %control = scalar.andi %after_tab, %before_return : i1
  %result = scalar.ori %is_space, %control : i1
  func.return %result : i1
}

// First position >= %from where %marker starts and fits before %end; %end if none.
func.def inline @find(%text: buffer, %from: offset, %end: offset, %marker: buffer) -> (offset) {
  %c0 = index.constant 0 : offset
  %c1 = index.constant 1 : offset
  %zero = scalar.constant 0 : i32
  %false = scalar.constant false : i1
  %marker_length = buffer.length %marker
  %found = scf.while(%position = %from : offset) -> (offset) {
    %stop = index.add %position, %marker_length : offset
    %fits = index.cmp ule, %stop, %end : offset
    %continue = scf.if %fits -> (i1) {
      %compared = buffer.compare %text[%position], %marker[%c0], %marker_length
      %differs = scalar.cmpi ne, %compared, %zero : i32
      scf.yield %differs : i1
    } else {
      scf.yield %false : i1
    }
    scf.condition %continue, %position : i1, offset
  } do(%position: offset) {
    %next = index.add %position, %c1 : offset
    scf.yield %next : offset
  }
  %stop = index.add %found, %marker_length : offset
  %hit = index.cmp ule, %stop, %end : offset
  %result = scf.select %hit, %found, %end : offset
  func.return %result : offset
}

func.def inline @skip_space(%text: buffer, %from: offset, %end: offset) -> (offset) {
  %c1 = index.constant 1 : offset
  %false = scalar.constant false : i1
  %result = scf.while(%position = %from : offset) -> (offset) {
    %inside = index.cmp ult, %position, %end : offset
    %space = scf.if %inside -> (i1) {
      %value = func.call @text_is_space(%text, %position) : (buffer, offset) -> (i1)
      scf.yield %value : i1
    } else {
      scf.yield %false : i1
    }
    scf.condition %space, %position : i1, offset
  } do(%position: offset) {
    %next = index.add %position, %c1 : offset
    scf.yield %next : offset
  }
  func.return %result : offset
}

// End of trailing whitespace trimming: largest e in [begin, end] with text[e-1] not space.
func.def inline @trim_end(%text: buffer, %begin: offset, %end: offset) -> (offset) {
  %c1 = index.constant 1 : offset
  %false = scalar.constant false : i1
  %result = scf.while(%position = %end : offset) -> (offset) {
    %more = index.cmp ugt, %position, %begin : offset
    %space = scf.if %more -> (i1) {
      %last = index.sub %position, %c1 : offset
      %value = func.call @text_is_space(%text, %last) : (buffer, offset) -> (i1)
      scf.yield %value : i1
    } else {
      scf.yield %false : i1
    }
    scf.condition %space, %position : i1, offset
  } do(%position: offset) {
    %next = index.sub %position, %c1 : offset
    scf.yield %next : offset
  }
  func.return %result : offset
}

func.def inline @trim(%text: buffer) -> (buffer) {
  %c0 = index.constant 0 : offset
  %length = buffer.length %text
  %begin = func.call @skip_space(%text, %c0, %length) : (buffer, offset, offset) -> (offset)
  %end = func.call @trim_end(%text, %begin, %length) : (buffer, offset, offset) -> (offset)
  %result = func.call @slice(%text, %begin, %end) : (buffer, offset, offset) -> (buffer)
  func.return %result : buffer
}

func.def inline @byte_is(%text: buffer, %position: offset, %end: offset, %value: i32) -> (i1) {
  %inside = index.cmp ult, %position, %end : offset
  %result = scf.if %inside -> (i1) {
    %byte = buffer.load.i8.u %text[%position]
    %same = scalar.cmpi eq, %byte, %value : i32
    scf.yield %same : i1
  } else {
    %false = scalar.constant false : i1
    scf.yield %false : i1
  }
  func.return %result : i1
}

func.def public @model_name() -> (buffer) {
  %name = global.load @name : buffer
  func.return %name : buffer
}

func.decl import("json") @parse_i64(%source: buffer, %offset: i64, %length: i64) -> (i64)

func.decl import("json") @parse_f64(%source: buffer, %offset: i64, %length: i64) -> (f64)

// Sampling record (16 bytes): temperature f32, top_p f32, top_k i32, seed i32.
// temperature 0 is greedy (the default); top_k 0 means "up to 64 candidates".
global.rodata.def @temperature_key = bytes("74656d7065726174757265")

global.rodata.def @top_p_key = bytes("746f705f70")

global.rodata.def @top_k_key = bytes("746f705f6b")

global.rodata.def @seed_key = bytes("73656564")

func.def public @request_defaults(%options: buffer) -> (buffer) {
  %origin = index.constant 0 : offset
  %bytes = index.constant 16 : offset
  %record = buffer.alloca<private> align(4) %bytes : buffer
  %view = buffer.view %record[%origin] : buffer -> view<4xi32>
  %c0_i32 = scalar.constant 0 : i32
  %temperature = scalar.constant 0.0 : f32
  %top_p = scalar.constant 1.0 : f32
  %top_k = scalar.constant 0 : i32
  %temperature_bits = scalar.bitcast %temperature : f32 to i32
  %top_p_bits = scalar.bitcast %top_p : f32 to i32
  view.store %temperature_bits, %view[0] : i32, view<4xi32>
  view.store %top_p_bits, %view[1] : i32, view<4xi32>
  view.store %top_k, %view[2] : i32, view<4xi32>
  view.store %c0_i32, %view[3] : i32, view<4xi32>
  func.return %record : buffer
}

// OpenAI-style temperature / top_p / top_k / seed (numbers; null keeps the default).
// Without a seed each request draws from its own nonce.
func.def public @request_options(%defaults: buffer, %request: buffer, %nonce: i64) -> (buffer) {
  %origin = index.constant 0 : offset
  %c0 = index.constant 0 : index
  %c1 = index.constant 1 : index
  %bytes = index.constant 16 : offset
  %record = buffer.alloca<private> align(4) %bytes : buffer
  buffer.copy %defaults[%origin], %record[%origin], %bytes
  %view = buffer.view %record[%origin] : buffer -> view<4xi32>
  %nonce32 = scalar.trunci %nonce : i64 to i32
  view.store %nonce32, %view[3] : i32, view<4xi32>
  %fields, %type, %count = func.call @members(%request) : (buffer) -> (buffer, i32, i64)
  %bounded_count = scalar.assume %count [range(%count, 0, 2147483647)] : i64
  %extent = index.cast %bounded_count : i64 to index
  %records = buffer.view %fields[%origin] : buffer -> view<[%extent]x5xi64>
  %number = scalar.constant 1 : i64
  %temperature_key = global.load @temperature_key : buffer
  %top_p_key = global.load @top_p_key : buffer
  %top_k_key = global.load @top_k_key : buffer
  %seed_key = global.load @seed_key : buffer
  scf.for %i = [%c0 to %extent step %c1] {
    %key_begin = view.load %records[%i, 0] : view<[%extent]x5xi64> -> i64
    %key_length = view.load %records[%i, 1] : view<[%extent]x5xi64> -> i64
    %value_begin = view.load %records[%i, 2] : view<[%extent]x5xi64> -> i64
    %value_length = view.load %records[%i, 3] : view<[%extent]x5xi64> -> i64
    %value_type = view.load %records[%i, 4] : view<[%extent]x5xi64> -> i64
    %is_number = scalar.cmpi eq, %value_type, %number : i64
    scf.if %is_number {
      %key = func.call @json_key(%request, %key_begin, %key_length) : (buffer, i64, i64) -> (buffer)
      %is_temperature = func.call @equal(%key, %temperature_key) : (buffer, buffer) -> (i1)
      %is_top_p = func.call @equal(%key, %top_p_key) : (buffer, buffer) -> (i1)
      %is_top_k = func.call @equal(%key, %top_k_key) : (buffer, buffer) -> (i1)
      %is_seed = func.call @equal(%key, %seed_key) : (buffer, buffer) -> (i1)
      %is_float = scalar.ori %is_temperature, %is_top_p : i1
      scf.if %is_float {
        %value64 = func.call @parse_f64(%request, %value_begin, %value_length) : (buffer, i64, i64) -> (f64)
        %value = scalar.fptrunc %value64 : f64 to f32
        %bits = scalar.bitcast %value : f32 to i32
        scf.if %is_temperature {
          view.store %bits, %view[0] : i32, view<4xi32>
        } else {
          view.store %bits, %view[1] : i32, view<4xi32>
        }
      }
      %is_integer = scalar.ori %is_top_k, %is_seed : i1
      scf.if %is_integer {
        %value64 = func.call @parse_i64(%request, %value_begin, %value_length) : (buffer, i64, i64) -> (i64)
        %value = scalar.trunci %value64 : i64 to i32
        scf.if %is_top_k {
          view.store %value, %view[2] : i32, view<4xi32>
        } else {
          view.store %value, %view[3] : i32, view<4xi32>
        }
      }
    }
  }
  func.return %record : buffer
}

// Sampling records follow the 640-byte control header, one per resident row.
func.def public @bind_request(%state: buffer, %row: i32, %options: buffer) {
  %origin = index.constant 0 : offset
  %header = index.constant 2048 : offset
  %record_bytes = index.constant 16 : offset
  %bounded_row = scalar.assume %row [range(%row, 0, 1048575)] : i32
  %row_index = index.cast %bounded_row : i32 to index
  %relative = index.scale %row_index, %record_bytes : index, offset -> offset
  %at = index.add %header, %relative : offset
  %end = index.add %at, %record_bytes : offset
  %length = buffer.length %state
  %fits = index.cmp ule, %end, %length : offset
  %options_length = buffer.length %options
  %complete = index.cmp uge, %options_length, %record_bytes : offset
  %store = scalar.andi %fits, %complete : i1
  scf.if %store {
    buffer.copy %options[%origin], %state[%at], %record_bytes
  }
  func.return
}

// (reasoning supported, selectable efforts bitmap, default effort):
// efforts none=0 ... high=4; a toggleable thinking model offers none|high.
func.def public @chat_reasoning() -> (i32, i32, i32) {
  %supported = scalar.constant 1 : i32
  %efforts = scalar.constant 17 : i32
  %default = scalar.constant 4 : i32
  func.return %supported, %efforts, %default : i32, i32, i32
}

func.def public @chat_image_limits() -> (i64, i64, i64, i64, i64) {
  %maximum_count = scalar.constant 4 : i64
  %compressed_bytes = scalar.constant 67108864 : i64
  %width = scalar.constant 4096 : i64
  %height = scalar.constant 4096 : i64
  %pixels = scalar.constant 16777216 : i64
  func.return %maximum_count, %compressed_bytes, %width, %height, %pixels : i64, i64, i64, i64, i64
}

// Chat template, from the config "chat" block (build.py fills these):
// {"bos": "", "system_prefix": "<|im_start|>system\n", "suffix": "<|im_end|>\n", "user_prefix": "<|im_start|>user\n", "assistant_prefix": "<|im_start|>assistant\n", "default_system": "", "trim_content": true, "think_open": "<think>\n", "think_close": "\n</think>\n\n", "history_think": "always", "history_think_scope": "after_last_query", "generation_prompt": "<|im_start|>assistant\n<think>\n", "gener
global.rodata.def @system_prefix = bytes("3c7c696d5f73746172747c3e73797374656d0a")

global.rodata.def @user_prefix = bytes("3c7c696d5f73746172747c3e757365720a")

global.rodata.def @assistant_prefix = bytes("3c7c696d5f73746172747c3e617373697374616e740a")

global.rodata.def @message_suffix = bytes("3c7c696d5f656e647c3e0a")
global.rodata.def @history_suffix = bytes("3c7c696d5f656e647c3e")

global.rodata.def @think_open = bytes("3c7468696e6b3e0a")

global.rodata.def @think_close = bytes("0a3c2f7468696e6b3e0a0a")

global.rodata.def @generation_think = bytes("3c7c696d5f73746172747c3e617373697374616e740a3c7468696e6b3e0a")

global.rodata.def @generation_plain = bytes("3c7c696d5f73746172747c3e617373697374616e740a3c7468696e6b3e0a0a3c2f7468696e6b3e0a0a")

global.rodata.def @default_system = bytes("")

global.rodata.def @bos = bytes("")

global.rodata.def @tools_prefix = bytes("2320546f6f6c730a0a596f7520686176652061636365737320746f2074686520666f6c6c6f77696e672066756e6374696f6e733a0a0a3c746f6f6c733e")

global.rodata.def @tools_suffix = bytes("0a3c2f746f6f6c733e0a0a496620796f752063686f6f736520746f2063616c6c20612066756e6374696f6e204f4e4c59207265706c7920696e2074686520666f6c6c6f77696e6720666f726d61742077697468204e4f207375666669783a0a0a3c746f6f6c5f63616c6c3e0a3c66756e6374696f6e3d6578616d706c655f66756e6374696f6e5f6e616d653e0a3c706172616d657465723d6578616d706c655f706172616d657465725f313e0a76616c75655f310a3c2f706172616d657465723e0a3c706172616d657465723d6578616d706c655f706172616d657465725f323e0a54686973206973207468652076616c756520666f7220746865207365636f6e6420706172616d657465720a746861742063616e207370616e0a6d756c7469706c65206c696e65730a3c2f706172616d657465723e0a3c2f66756e6374696f6e3e0a3c2f746f6f6c5f63616c6c3e0a0a3c494d504f5254414e543e0a52656d696e6465723a0a2d2046756e6374696f6e2063616c6c73204d55535420666f6c6c6f77207468652073706563696669656420666f726d61743a20616e20696e6e6572203c66756e6374696f6e3d2e2e2e3e3c2f66756e6374696f6e3e20626c6f636b206d757374206265206e65737465642077697468696e203c746f6f6c5f63616c6c3e3c2f746f6f6c5f63616c6c3e20584d4c20746167730a2d20526571756972656420706172616d6574657273204d555354206265207370656369666965640a2d20596f75206d61792070726f76696465206f7074696f6e616c20726561736f6e696e6720666f7220796f75722066756e6374696f6e2063616c6c20696e206e61747572616c206c616e6775616765204245464f5245207468652066756e6374696f6e2063616c6c2c20627574204e4f542061667465720a2d204966207468657265206973206e6f2066756e6374696f6e2063616c6c20617661696c61626c652c20616e7377657220746865207175657374696f6e206c696b65206e6f726d616c207769746820796f75722063757272656e74206b6e6f776c6564676520616e6420646f206e6f742074656c6c2074686520757365722061626f75742066756e6374696f6e2063616c6c730a3c2f494d504f5254414e543e")

global.rodata.def @tool_line_prefix = bytes("0a")

// Printed between consecutive tools only (LFM2: ", ").
global.rodata.def @tool_separator = bytes("")

// Pythonic calls (LFM2): the whole call list is wrapped in CALLS_OPEN ... CALLS_CLOSE
// (empty for the other formats); CALL_END ends the list in generated text.
global.rodata.def @calls_open = bytes("")

global.rodata.def @calls_close = bytes("")
// Stop token the model emits to end a turn when the template renders that same token next
// (GLM-style: <|observation|> after calls, <|user|> after an answer). It stays in the KV row, so the
// published history must contain it too, or the next turn duplicates it.
global.rodata.def @stop_after_calls = bytes("")
global.rodata.def @stop_after_answer = bytes("")

global.rodata.def @call_end = bytes("")

global.rodata.def @tools_system_separator = bytes("0a0a")

global.rodata.def @tool_turn_prefix = bytes("3c7c696d5f73746172747c3e75736572")

global.rodata.def @tool_item_prefix = bytes("0a3c746f6f6c5f726573706f6e73653e0a")

global.rodata.def @tool_item_suffix = bytes("0a3c2f746f6f6c5f726573706f6e73653e")

global.rodata.def @tool_turn_suffix = bytes("3c7c696d5f656e647c3e0a")

global.rodata.def @content_call_separator = bytes("0a0a")

global.rodata.def @call_separator = bytes("0a")

// The tools JSON array as the template prints it: each tool object (or its
// "function" member when TOOLS_FUNCTION_ONLY), one per line.
global.rodata.def @function_key = bytes("66756e6374696f6e")

func.def @tool_printed(%tool: buffer) -> (buffer) {
  %only = scalar.constant false : i1
  %result = scf.if %only -> (buffer) {
    %origin = index.constant 0 : offset
    %c0 = index.constant 0 : index
    %c1 = index.constant 1 : index
    %fields, %type, %count = func.call @members(%tool) : (buffer) -> (buffer, i32, i64)
    %bounded_count = scalar.assume %count [range(%count, 0, 2147483647)] : i64
    %extent = index.cast %bounded_count : i64 to index
    %records = buffer.view %fields[%origin] : buffer -> view<[%extent]x5xi64>
    %function_key = global.load @function_key : buffer
    %selected = scf.for %i = [%c0 to %extent step %c1](%current = %tool : buffer) -> (buffer) {
      %key_origin = view.load %records[%i, 0] : view<[%extent]x5xi64> -> i64
      %key_length = view.load %records[%i, 1] : view<[%extent]x5xi64> -> i64
      %key = func.call @json_key(%tool, %key_origin, %key_length) : (buffer, i64, i64) -> (buffer)
      %is_function = func.call @equal(%key, %function_key) : (buffer, buffer) -> (i1)
      %next = scf.if %is_function -> (buffer) {
        %value_origin = view.load %records[%i, 2] : view<[%extent]x5xi64> -> i64
        %value_length = view.load %records[%i, 3] : view<[%extent]x5xi64> -> i64
        %value = func.call @json_range(%tool, %value_origin, %value_length) : (buffer, i64, i64) -> (buffer)
        scf.yield %value : buffer
      } else {
        scf.yield %current : buffer
      }
      scf.yield %next : buffer
    }
    scf.yield %selected : buffer
  } else {
    scf.yield %tool : buffer
  }
  func.return %result : buffer
}

func.def @tools_body(%tools: buffer, %tool_fields: buffer, %tool_count: i64) -> (buffer) {
  %origin = index.constant 0 : offset
  %c0 = index.constant 0 : index
  %c1 = index.constant 1 : index
  %count = scalar.assume %tool_count [range(%tool_count, 1, 4096)] : i64
  %extent = index.cast %count : i64 to index
  %records = buffer.view %tool_fields[%origin] : buffer -> view<[%extent]x5xi64>
  %prefix = global.load @tools_prefix : buffer
  %suffix = global.load @tools_suffix : buffer
  %newline = global.load @tool_line_prefix : buffer
  %between = global.load @tool_separator : buffer
  %none = global.load @empty : buffer
  %body = scf.for %i = [%c0 to %extent step %c1](%text = %prefix : buffer) -> (buffer) {
    %value_origin = view.load %records[%i, 2] : view<[%extent]x5xi64> -> i64
    %value_length = view.load %records[%i, 3] : view<[%extent]x5xi64> -> i64
    %value = func.call @json_range(%tools, %value_origin, %value_length) : (buffer, i64, i64) -> (buffer)
    %printed = func.call @tool_printed(%value) : (buffer) -> (buffer)
    %later = index.cmp ne, %i, %c0 : index
    %gap = scf.select %later, %between, %none : buffer
    %line = func.call @join4(%gap, %newline, %printed, %none) : (buffer, buffer, buffer, buffer) -> (buffer)
    %next = func.call @join(%text, %line) : (buffer, buffer) -> (buffer)
    scf.yield %next : buffer
  }
  %result = func.call @join(%body, %suffix) : (buffer, buffer) -> (buffer)
  func.return %result : buffer
}

// Returns (found, value range begin, length, type) of %key in the object at
// %text[begin, begin + length).
func.def @json_lookup(%text: buffer, %begin: i64, %length: i64, %key: buffer) -> (i1, i64, i64, i64) {
  %origin = index.constant 0 : offset
  %c0 = index.constant 0 : index
  %c1 = index.constant 1 : index
  %zero64 = scalar.constant 0 : i64
  %false = scalar.constant false : i1
  %fields, %type, %count = func.call @members_range(%text, %begin, %length) : (buffer, i64, i64) -> (buffer, i32, i64)
  %object = scalar.constant 2 : i32
  %is_object = scalar.cmpi eq, %type, %object : i32
  %usable_count = scf.select %is_object, %count, %zero64 : i64
  %bounded_count = scalar.assume %usable_count [range(%usable_count, 0, 2147483647)] : i64
  %extent = index.cast %bounded_count : i64 to index
  %records = buffer.view %fields[%origin] : buffer -> view<[%extent]x5xi64>
  %found, %value_begin, %value_length, %value_type = scf.for %i = [%c0 to %extent step %c1](%f = %false : i1, %b = %zero64 : i64, %l = %zero64 : i64, %t = %zero64 : i64) -> (i1, i64, i64, i64) {
    %key_origin = view.load %records[%i, 0] : view<[%extent]x5xi64> -> i64
    %key_length = view.load %records[%i, 1] : view<[%extent]x5xi64> -> i64
    %name = func.call @json_key(%text, %key_origin, %key_length) : (buffer, i64, i64) -> (buffer)
    %match = func.call @equal(%name, %key) : (buffer, buffer) -> (i1)
    %vb = view.load %records[%i, 2] : view<[%extent]x5xi64> -> i64
    %vl = view.load %records[%i, 3] : view<[%extent]x5xi64> -> i64
    %vt = view.load %records[%i, 4] : view<[%extent]x5xi64> -> i64
    %nf = scalar.ori %f, %match : i1
    %nb = scf.select %match, %vb, %b : i64
    %nl = scf.select %match, %vl, %l : i64
    %nt = scf.select %match, %vt, %t : i64
    scf.yield %nf, %nb, %nl, %nt : i1, i64, i64, i64
  }
  func.return %found, %value_begin, %value_length, %value_type : i1, i64, i64, i64
}

// Thinking selection from a value: true/false, or a reasoning_effort string.
func.def @thinking_value(%request: buffer, %found: i1, %begin: i64, %length: i64, %type: i64, %effort: i1, %current: i1) -> (i1) {
  %result = scf.if %found -> (i1) {
    %selected = scf.if %effort -> (i1) {
      %value = func.call @json_key(%request, %begin, %length) : (buffer, i64, i64) -> (buffer)
      %none = global.load @effort_none : buffer
      %is_none = func.call @equal(%value, %none) : (buffer, buffer) -> (i1)
      %false = scalar.constant false : i1
      %on = scalar.cmpi eq, %is_none, %false : i1
      scf.yield %on : i1
    } else {
      %true_type = scalar.constant 4 : i64
      %on = scalar.cmpi eq, %type, %true_type : i64
      scf.yield %on : i1
    }
    scf.yield %selected : i1
  } else {
    scf.yield %current : i1
  }
  func.return %result : i1
}

// 1 + index of the last "user" message in the request's messages array (0: none).
func.def @last_user(%request: buffer, %begin: i64, %length: i64) -> (i64) {
  %origin = index.constant 0 : offset
  %c0 = index.constant 0 : index
  %c1 = index.constant 1 : index
  %zero64 = scalar.constant 0 : i64
  %one64 = scalar.constant 1 : i64
  %elements, %type, %count = func.call @members_range(%request, %begin, %length) : (buffer, i64, i64) -> (buffer, i32, i64)
  %bounded_count = scalar.assume %count [range(%count, 0, 2147483647)] : i64
  %extent = index.cast %bounded_count : i64 to index
  %records = buffer.view %elements[%origin] : buffer -> view<[%extent]x5xi64>
  %role_key = global.load @role_key : buffer
  %user_role = global.load @user : buffer
  %object_type = scalar.constant 2 : i64
  %result = scf.for %i = [%c0 to %extent step %c1](%last = %zero64 : i64) -> (i64) {
    %mb = view.load %records[%i, 2] : view<[%extent]x5xi64> -> i64
    %ml = view.load %records[%i, 3] : view<[%extent]x5xi64> -> i64
    %mt = view.load %records[%i, 4] : view<[%extent]x5xi64> -> i64
    %is_object = scalar.cmpi eq, %mt, %object_type : i64
    %next = scf.if %is_object -> (i64) {
      %fr, %br, %lr, %tr = func.call @json_lookup(%request, %mb, %ml, %role_key) : (buffer, i64, i64, buffer) -> (i1, i64, i64, i64)
      %role = func.call @json_key(%request, %br, %lr) : (buffer, i64, i64) -> (buffer)
      %is_user = func.call @equal(%role, %user_role) : (buffer, buffer) -> (i1)
      %index = index.cast %i : index to i64
      %ordinal = scalar.addi %index, %one64 : i64
      %value = scf.select %is_user, %ordinal, %last : i64
      scf.yield %value : i64
    } else {
      scf.yield %last : i64
    }
    scf.yield %next : i64
  }
  func.return %result : i64
}

// State bits carried through chat_message (opaque to the host):
//   0-1 previous role (0 none, 1 user, 2 assistant, 3 tool)
//   2   the first system message was already rendered by chat_begin
//   4   thinking enabled for the generation prompt
//   8+  1 + index of the last user message (0: none); reasoning is rendered
//       only after it when HISTORY_THINK_AFTER_QUERY (Qwen-style templates)
// chat_begin renders the system block whenever tools are present or the
// template has a default system prompt, merging the first system message's
// text in the template's order.
func.def public @chat_begin(%request: buffer, %tools: buffer) -> (buffer, i64) {
  %origin = index.constant 0 : offset
  %zero64 = scalar.constant 0 : i64
  %four64 = scalar.constant 4 : i64
  %sixteen64 = scalar.constant 16 : i64
  %false = scalar.constant false : i1
  %empty = global.load @empty : buffer
  %request_bytes = buffer.length %request
  %request_length = index.cast %request_bytes : offset to i64
  // Thinking: default, then enable_thinking, chat_template_kwargs.enable_thinking, reasoning_effort.
  %toggle = scalar.constant true : i1
  %think_default = scalar.constant true : i1
  %thinking_key = global.load @thinking_key : buffer
  %kwargs_key = global.load @kwargs_key : buffer
  %effort_key = global.load @effort_key : buffer
  %f1, %b1, %l1, %t1 = func.call @json_lookup(%request, %zero64, %request_length, %thinking_key) : (buffer, i64, i64, buffer) -> (i1, i64, i64, i64)
  %think1 = func.call @thinking_value(%request, %f1, %b1, %l1, %t1, %false, %think_default) : (buffer, i1, i64, i64, i64, i1, i1) -> (i1)
  %fk, %bk, %lk, %tk = func.call @json_lookup(%request, %zero64, %request_length, %kwargs_key) : (buffer, i64, i64, buffer) -> (i1, i64, i64, i64)
  %think2 = scf.if %fk -> (i1) {
    %f2, %b2, %l2, %t2 = func.call @json_lookup(%request, %bk, %lk, %thinking_key) : (buffer, i64, i64, buffer) -> (i1, i64, i64, i64)
    %value = func.call @thinking_value(%request, %f2, %b2, %l2, %t2, %false, %think1) : (buffer, i1, i64, i64, i64, i1, i1) -> (i1)
    scf.yield %value : i1
  } else {
    scf.yield %think1 : i1
  }
  %fe, %be, %le, %te = func.call @json_lookup(%request, %zero64, %request_length, %effort_key) : (buffer, i64, i64, buffer) -> (i1, i64, i64, i64)
  %string_type = scalar.constant 0 : i64
  %effort_string = scalar.cmpi eq, %te, %string_type : i64
  %use_effort = scalar.andi %fe, %effort_string : i1
  %true = scalar.constant true : i1
  %think3 = func.call @thinking_value(%request, %use_effort, %be, %le, %te, %true, %think2) : (buffer, i1, i64, i64, i64, i1, i1) -> (i1)
  %thinking = scf.select %toggle, %think3, %think_default : i1
  // First message: is it a system message with plain text content?
  %messages_key = global.load @messages_key : buffer
  %fm, %bm, %lm, %tm = func.call @json_lookup(%request, %zero64, %request_length, %messages_key) : (buffer, i64, i64, buffer) -> (i1, i64, i64, i64)
  %array_type = scalar.constant 3 : i64
  %is_array = scalar.cmpi eq, %tm, %array_type : i64
  %has_messages = scalar.andi %fm, %is_array : i1
  %first_system, %system_text = scf.if %has_messages -> (i1, buffer) {
    %elements, %etype, %ecount = func.call @members_range(%request, %bm, %lm) : (buffer, i64, i64) -> (buffer, i32, i64)
    %nonempty = scalar.cmpi ne, %ecount, %zero64 : i64
    %fs, %text = scf.if %nonempty -> (i1, buffer) {
      %records = buffer.view %elements[%origin] : buffer -> view<1x5xi64>
      %mb = view.load %records[0, 2] : view<1x5xi64> -> i64
      %ml = view.load %records[0, 3] : view<1x5xi64> -> i64
      %role_key = global.load @role_key : buffer
      %content_key = global.load @content_key : buffer
      %fr, %br, %lr, %tr = func.call @json_lookup(%request, %mb, %ml, %role_key) : (buffer, i64, i64, buffer) -> (i1, i64, i64, i64)
      %fc, %bc, %lc, %tc = func.call @json_lookup(%request, %mb, %ml, %content_key) : (buffer, i64, i64, buffer) -> (i1, i64, i64, i64)
      %role = func.call @json_key(%request, %br, %lr) : (buffer, i64, i64) -> (buffer)
      %system_role = global.load @system : buffer
      %is_system = func.call @equal(%role, %system_role) : (buffer, buffer) -> (i1)
      %content_string = scalar.cmpi eq, %tc, %string_type : i64
      %plain = scalar.andi %fc, %content_string : i1
      %system_plain = scalar.andi %is_system, %plain : i1
      %value = scf.if %system_plain -> (buffer) {
        %decoded = func.call @json_key(%request, %bc, %lc) : (buffer, i64, i64) -> (buffer)
        scf.yield %decoded : buffer
      } else {
        scf.yield %empty : buffer
      }
      scf.yield %system_plain, %value : i1, buffer
    } else {
      scf.yield %false, %empty : i1, buffer
    }
    scf.yield %fs, %text : i1, buffer
  } else {
    scf.yield %false, %empty : i1, buffer
  }
  %last_query = scf.if %has_messages -> (i64) {
    %value = func.call @last_user(%request, %bm, %lm) : (buffer, i64, i64) -> (i64)
    scf.yield %value : i64
  } else {
    scf.yield %zero64 : i64
  }
  %trim_content = scalar.constant true : i1
  %trimmed_system = scf.if %trim_content -> (buffer) {
    %value = func.call @trim(%system_text) : (buffer) -> (buffer)
    scf.yield %value : buffer
  } else {
    scf.yield %system_text : buffer
  }
  %default_system = global.load @default_system : buffer
  %default_length = buffer.length %default_system
  %has_default = index.cmp ne, %default_length, %origin : offset
  %not_first_system = scalar.cmpi eq, %first_system, %false : i1
  %use_default = scalar.andi %not_first_system, %has_default : i1
  %system_body = scf.select %use_default, %default_system, %trimmed_system : buffer
  %tool_fields, %tool_type, %tool_count = func.call @members(%tools) : (buffer) -> (buffer, i32, i64)
  %has_tools = scalar.cmpi ne, %tool_count, %zero64 : i64
  %system_prefix = global.load @system_prefix : buffer
  %suffix = global.load @message_suffix : buffer
  %rendered = scf.if %has_tools -> (buffer) {
    %tools_text = func.call @tools_body(%tools, %tool_fields, %tool_count) : (buffer, buffer, i64) -> (buffer)
    %body_length = buffer.length %system_body
    %has_body = index.cmp ne, %body_length, %origin : offset
    %separator_value = global.load @tools_system_separator : buffer
    %separator = scf.select %has_body, %separator_value, %empty : buffer
    %after_system = scalar.constant false : i1
    %merged = scf.if %after_system -> (buffer) {
      %value = func.call @join4(%system_body, %separator, %tools_text, %empty) : (buffer, buffer, buffer, buffer) -> (buffer)
      scf.yield %value : buffer
    } else {
      %value = func.call @join4(%tools_text, %separator, %system_body, %empty) : (buffer, buffer, buffer, buffer) -> (buffer)
      scf.yield %value : buffer
    }
    %block = func.call @join4(%system_prefix, %merged, %suffix, %empty) : (buffer, buffer, buffer, buffer) -> (buffer)
    scf.yield %block : buffer
  } else {
    %block = scf.if %use_default -> (buffer) {
      %value = func.call @join4(%system_prefix, %default_system, %suffix, %empty) : (buffer, buffer, buffer, buffer) -> (buffer)
      scf.yield %value : buffer
    } else {
      scf.yield %empty : buffer
    }
    scf.yield %block : buffer
  }
  %bos = global.load @bos : buffer
  %prefixed = func.call @join(%bos, %rendered) : (buffer, buffer) -> (buffer)
  %consumed = scalar.andi %has_tools, %first_system : i1
  %consumed_bit = scf.select %consumed, %four64, %zero64 : i64
  %thinking_bit = scf.select %thinking, %sixteen64, %zero64 : i64
  %flags = scalar.ori %consumed_bit, %thinking_bit : i64
  %shift = scalar.constant 8 : i64
  %query_bits = scalar.shli %last_query, %shift : i64
  %state = scalar.ori %flags, %query_bits : i64
  func.return %prefixed, %state : buffer, i64
}

// Text-only content parts (kind 0) are concatenated; image parts are rejected.
func.def @text_parts(%content: buffer, %parts: buffer, %part_count: i64) -> (buffer) {
  %origin = index.constant 0 : offset
  %c0 = index.constant 0 : index
  %c1 = index.constant 1 : index
  %text_kind = scalar.constant 0 : i32
  %bounded_count = scalar.assume %part_count [range(%part_count, 1, 4096)] : i64
  %count = index.cast %bounded_count : i64 to index
  %records = buffer.view %parts[%origin] : buffer -> view<[%count]x6xi32>
  %empty = global.load @empty : buffer
  %result = scf.for %i = [%c0 to %count step %c1](%text = %empty : buffer) -> (buffer) {
    %kind = view.load %records[%i, 0] : view<[%count]x6xi32> -> i32
    %is_text = scalar.cmpi eq, %kind, %text_kind : i32
    func.call @check(%is_text) : (i1)
    %source32 = view.load %records[%i, 1] : view<[%count]x6xi32> -> i32
    %length32 = view.load %records[%i, 2] : view<[%count]x6xi32> -> i32
    %source64 = scalar.extui %source32 : i32 to i64
    %length64 = scalar.extui %length32 : i32 to i64
    %piece = func.call @json_range(%content, %source64, %length64) : (buffer, i64, i64) -> (buffer)
    %next = func.call @join(%text, %piece) : (buffer, buffer) -> (buffer)
    scf.yield %next : buffer
  }
  func.return %result : buffer
}

// Renders one message. Host field bits: 1 reasoning_content, 2 tool_calls
// (assistant only), 4 tool_call_id (tool only). %calls holds the
// concatenated render_tool output of the assistant's tool calls.
func.def public @chat_message(%raw: buffer, %role: buffer, %content: buffer, %parts: buffer, %frames: buffer, %reasoning: buffer, %calls: buffer, %state: i64, %ordinal: i64, %fields: i64, %part_count: i64) -> (buffer, i64, buffer, i64) {
  %c0 = index.constant 0 : offset
  %zero64 = scalar.constant 0 : i64
  %one64 = scalar.constant 1 : i64
  %two64 = scalar.constant 2 : i64
  %three64 = scalar.constant 3 : i64
  %four64 = scalar.constant 4 : i64
  %keep_mask = scalar.constant -4 : i64
  %false = scalar.constant false : i1
  %assistant_role = global.load @assistant : buffer
  %user_role = global.load @user : buffer
  %system_role = global.load @system : buffer
  %tool_role = global.load @tool_role : buffer
  %assistant = func.call @equal(%role, %assistant_role) : (buffer, buffer) -> (i1)
  %user = func.call @equal(%role, %user_role) : (buffer, buffer) -> (i1)
  %system = func.call @equal(%role, %system_role) : (buffer, buffer) -> (i1)
  %tool = func.call @equal(%role, %tool_role) : (buffer, buffer) -> (i1)
  %ordinary = scalar.ori %user, %system : i1
  %speaker = scalar.ori %assistant, %tool : i1
  %supported = scalar.ori %ordinary, %speaker : i1
  %assistant_fields = scalar.andi %fields, %three64 : i64
  %has_assistant_fields = scalar.cmpi ne, %assistant_fields, %zero64 : i64
  %not_assistant_fields = scalar.cmpi eq, %has_assistant_fields, %false : i1
  %valid_assistant_fields = scalar.ori %assistant, %not_assistant_fields : i1
  %valid = scalar.andi %supported, %valid_assistant_fields : i1
  func.call @check(%valid) : (i1)
  %has_parts = scalar.cmpi ne, %part_count, %zero64 : i64
  %vision_none = global.load @empty : buffer
  %vision_zero = scalar.constant 0 : i64
  %raw_text, %vision_plan, %vision_count = scf.if %has_parts -> (buffer, buffer, i64) {
    %joined, %vplan, %vcount = func.call @vision_content(%content, %parts, %frames, %part_count) : (buffer, buffer, buffer, i64) -> (buffer, buffer, i64)
    scf.yield %joined, %vplan, %vcount : buffer, buffer, i64
  } else {
    scf.yield %content, %vision_none, %vision_zero : buffer, buffer, i64
  }
  %trim_content = scalar.constant true : i1
  %text = scf.if %trim_content -> (buffer) {
    %value = func.call @trim(%raw_text) : (buffer) -> (buffer)
    scf.yield %value : buffer
  } else {
    scf.yield %raw_text : buffer
  }
  %empty = global.load @empty : buffer
  %prior_role = scalar.andi %state, %three64 : i64
  %prior_tool = scalar.cmpi eq, %prior_role, %three64 : i64
  %not_tool = scalar.cmpi eq, %tool, %false : i1
  %close_tools = scalar.andi %prior_tool, %not_tool : i1
  %tool_turn_suffix = global.load @tool_turn_suffix : buffer
  %before = scf.select %close_tools, %tool_turn_suffix, %empty : buffer
  %first = scalar.cmpi eq, %ordinal, %zero64 : i64
  %consumed_bit = scalar.andi %state, %four64 : i64
  %consumed = scalar.cmpi ne, %consumed_bit, %zero64 : i64
  %first_system = scalar.andi %first, %system : i1
  %skip = scalar.andi %first_system, %consumed : i1
  %suffix = global.load @message_suffix : buffer
  %body = scf.if %skip -> (buffer) {
    scf.yield %empty : buffer
  } else {
    %rendered = scf.if %tool -> (buffer) {
      %turn = global.load @tool_turn_prefix : buffer
      %open = scf.select %prior_tool, %empty, %turn : buffer
      %item_prefix = global.load @tool_item_prefix : buffer
      %item_suffix = global.load @tool_item_suffix : buffer
      %value = func.call @join4(%open, %item_prefix, %text, %item_suffix) : (buffer, buffer, buffer, buffer) -> (buffer)
      scf.yield %value : buffer
    } else {
      %value = scf.if %assistant -> (buffer) {
        %prefix = global.load @assistant_prefix : buffer
        %thought = func.call @trim(%reasoning) : (buffer) -> (buffer)
        %thought_length = buffer.length %thought
        %has_thought = index.cmp ne, %thought_length, %c0 : offset
        %always = scalar.constant true : i1
        %wanted = scalar.ori %always, %has_thought : i1
        %shift = scalar.constant 8 : i64
        %last_query = scalar.shrui %state, %shift : i64
        %after_query = scalar.cmpi sge, %ordinal, %last_query : i64
        %scope_all = scalar.constant false : i1
        %in_scope = scalar.ori %scope_all, %after_query : i1
        %show = scalar.andi %wanted, %in_scope : i1
        %think = scf.if %show -> (buffer) {
          %open = global.load @think_open : buffer
          %close = global.load @think_close : buffer
          %block = func.call @join4(%open, %thought, %close, %empty) : (buffer, buffer, buffer, buffer) -> (buffer)
          scf.yield %block : buffer
        } else {
          scf.yield %empty : buffer
        }
        %text_length = buffer.length %text
        %has_text = index.cmp ne, %text_length, %c0 : offset
        %calls_length = buffer.length %calls
        %has_calls = index.cmp ne, %calls_length, %c0 : offset
        %separate = scalar.andi %has_text, %has_calls : i1
        %separator_value = global.load @content_call_separator : buffer
        %separator = scf.select %separate, %separator_value, %empty : buffer
        %close_value = global.load @calls_close : buffer
        %close = scf.select %has_calls, %close_value, %empty : buffer
        %head = func.call @join4(%prefix, %think, %text, %separator) : (buffer, buffer, buffer, buffer) -> (buffer)
        %message = func.call @join4(%head, %calls, %close, %suffix) : (buffer, buffer, buffer, buffer) -> (buffer)
        scf.yield %message : buffer
      } else {
        %system_prefix = global.load @system_prefix : buffer
        %user_prefix = global.load @user_prefix : buffer
        %prefix = scf.select %user, %user_prefix, %system_prefix : buffer
        %message = func.call @join4(%prefix, %text, %suffix, %empty) : (buffer, buffer, buffer, buffer) -> (buffer)
        scf.yield %message : buffer
      }
      scf.yield %value : buffer
    }
    scf.yield %rendered : buffer
  }
  %fragment = func.call @join(%before, %body) : (buffer, buffer) -> (buffer)
  %role_tool = scf.select %tool, %three64, %zero64 : i64
  %role_assistant = scf.select %assistant, %two64, %role_tool : i64
  %new_role = scf.select %user, %one64, %role_assistant : i64
  %kept = scalar.andi %state, %keep_mask : i64
  %next = scalar.ori %kept, %new_role : i64
  func.call @vision_locate(%fragment, %vision_plan, %vision_count) : (buffer, buffer, i64)
  func.return %fragment, %next, %vision_plan, %vision_count : buffer, i64, buffer, i64
}

// Output state 1 = inside the reasoning block, 0 = answer text.
func.def public @chat_end(%state: i64) -> (buffer, i64) {
  %zero64 = scalar.constant 0 : i64
  %three64 = scalar.constant 3 : i64
  %sixteen64 = scalar.constant 16 : i64
  %empty = global.load @empty : buffer
  %prior_role = scalar.andi %state, %three64 : i64
  %prior_tool = scalar.cmpi eq, %prior_role, %three64 : i64
  %tool_turn_suffix = global.load @tool_turn_suffix : buffer
  %before = scf.select %prior_tool, %tool_turn_suffix, %empty : buffer
  %thinking_bit = scalar.andi %state, %sixteen64 : i64
  %thinking = scalar.cmpi ne, %thinking_bit, %zero64 : i64
  %think_prompt = global.load @generation_think : buffer
  %plain_prompt = global.load @generation_plain : buffer
  %prompt = scf.select %thinking, %think_prompt, %plain_prompt : buffer
  %starts = scalar.constant 1 : i64
  %output_state = scf.select %thinking, %starts, %zero64 : i64
  %result = func.call @join(%before, %prompt) : (buffer, buffer) -> (buffer)
  func.return %result, %output_state : buffer, i64
}

// ---- Tool calls --------------------------------------------------------------
// CALL_FORMAT: 4 = pythonic (LFM2: <|tool_call_start|>[NAME(k='v', n=3), ...]<|tool_call_end|>)
// CALL_FORMAT: 1 = Hermes JSON (Qwen2.5/Qwen3: <tool_call>\n{"name": ..., "arguments": {...}}\n</tool_call>)
//              2 = Qwen XML (Qwen3-Coder/Qwen3.5: <tool_call>\n<function=NAME>\n<parameter=K>\nV\n</parameter>\n</function>\n</tool_call>)
//              3 = GLM (GLM-4.5+/Flint: <tool_call>NAME<arg_key>K</arg_key><arg_value>V</arg_value></tool_call>)
global.rodata.def @call_open = bytes("3c746f6f6c5f63616c6c3e")

global.rodata.def @call_close = bytes("3c2f746f6f6c5f63616c6c3e")

// '<tool_call>\n{"name": "', '", "arguments": ', '}\n</tool_call>'
global.rodata.def @hermes_open = bytes("3c746f6f6c5f63616c6c3e0a7b226e616d65223a2022")

global.rodata.def @hermes_middle = bytes("222c2022617267756d656e7473223a20")

global.rodata.def @hermes_close = bytes("7d0a3c2f746f6f6c5f63616c6c3e")

// '"name"', '"arguments"'
global.rodata.def @name_field = bytes("226e616d6522")

global.rodata.def @arguments_field = bytes("22617267756d656e747322")

// '<tool_call>\n<function=', '>\n', '<parameter=', '\n</parameter>\n', '</function>\n</tool_call>'
global.rodata.def @xml_call_open = bytes("3c746f6f6c5f63616c6c3e0a3c66756e6374696f6e3d")

global.rodata.def @xml_tag_end = bytes("3e0a")

global.rodata.def @xml_parameter_open = bytes("3c706172616d657465723d")

global.rodata.def @xml_parameter_close = bytes("0a3c2f706172616d657465723e0a")

global.rodata.def @xml_call_close = bytes("3c2f66756e6374696f6e3e0a3c2f746f6f6c5f63616c6c3e")

// '<arg_key>', '</arg_key>', '<arg_value>', '</arg_value>'
global.rodata.def @key_open = bytes("3c6172675f6b65793e")

global.rodata.def @key_close = bytes("3c2f6172675f6b65793e")

global.rodata.def @value_open = bytes("3c6172675f76616c75653e")

global.rodata.def @value_close = bytes("3c2f6172675f76616c75653e")

// '{"type":"function","function":{"name":"', '","arguments":"', '"}}'
global.rodata.def @record_open = bytes("7b2274797065223a2266756e6374696f6e222c2266756e6374696f6e223a7b226e616d65223a22")

global.rodata.def @record_middle = bytes("222c22617267756d656e7473223a22")

global.rodata.def @record_close = bytes("227d7d")

// Renders one call as the template prints it; %ordinal > 0 adds the separator
// between consecutive calls. Returns the buffer and its used length.
func.def public @render_tool(%name: buffer, %arguments: buffer, %ordinal: i64) -> (buffer, i64) {
  %zero64 = scalar.constant 0 : i64
  %origin = index.constant 0 : offset
  %c0 = index.constant 0 : index
  %c1 = index.constant 1 : index
  %format = scalar.constant 2 : i32
  %hermes = scalar.constant 1 : i32
  %glm = scalar.constant 3 : i32
  %is_hermes = scalar.cmpi eq, %format, %hermes : i32
  %is_glm = scalar.cmpi eq, %format, %glm : i32
  %pythonic = scalar.constant 4 : i32
  %is_pythonic = scalar.cmpi eq, %format, %pythonic : i32
  %has_prior = scalar.cmpi ne, %ordinal, %zero64 : i64
  %separator_value = global.load @call_separator : buffer
  %empty = global.load @empty : buffer
  %separator = scf.select %has_prior, %separator_value, %empty : buffer
  %result = scf.if %is_hermes -> (buffer) {
    // Arguments are printed as the client sent them (the template prints a
    // string argument verbatim), so generated calls round-trip byte-exactly.
    %open = global.load @hermes_open : buffer
    %middle = global.load @hermes_middle : buffer
    %close = global.load @hermes_close : buffer
    %head = func.call @join4(%separator, %open, %name, %middle) : (buffer, buffer, buffer, buffer) -> (buffer)
    %value = func.call @join4(%head, %arguments, %close, %empty) : (buffer, buffer, buffer, buffer) -> (buffer)
    scf.yield %value : buffer
  } else {
   %other = scf.if %is_pythonic -> (buffer) {
    // NAME(k=v, ...); the first call opens the list (CALLS_OPEN), chat_message and
    // complete_text close it (CALLS_CLOSE).
    %list_open = global.load @calls_open : buffer
    %opener = scf.select %has_prior, %separator_value, %list_open : buffer
    %py_compacted = func.call @compact(%arguments) : (buffer) -> (buffer)
    %py_members, %py_type, %py_count = func.call @members(%py_compacted) : (buffer) -> (buffer, i32, i64)
    %py_object = scalar.constant 2 : i32
    %py_is_object = scalar.cmpi eq, %py_type, %py_object : i32
    func.call @check(%py_is_object) : (i1)
    %py_bounded = scalar.assume %py_count [range(%py_count, 0, 33554431)] : i64
    %py_extent = index.cast %py_bounded : i64 to index
    %py_fields = buffer.view %py_members[%origin] : buffer -> view<[%py_extent]x5xi64>
    %paren_open = global.load @py_open_paren : buffer
    %paren_close = global.load @py_close_paren : buffer
    %equals = global.load @py_equals : buffer
    %comma_space = global.load @py_comma_space : buffer
    %object_type = scalar.constant 2 : i64
    %array_type = scalar.constant 3 : i64
    %py_head = func.call @join4(%opener, %name, %paren_open, %empty) : (buffer, buffer, buffer, buffer) -> (buffer)
    %py_body = scf.for %i = [%c0 to %py_extent step %c1](%text = %py_head : buffer) -> (buffer) {
      %key_begin = view.load %py_fields[%i, 0] : view<[%py_extent]x5xi64> -> i64
      %key_length = view.load %py_fields[%i, 1] : view<[%py_extent]x5xi64> -> i64
      %value_begin = view.load %py_fields[%i, 2] : view<[%py_extent]x5xi64> -> i64
      %value_length = view.load %py_fields[%i, 3] : view<[%py_extent]x5xi64> -> i64
      %value_type = view.load %py_fields[%i, 4] : view<[%py_extent]x5xi64> -> i64
      %key = func.call @json_key(%py_compacted, %key_begin, %key_length) : (buffer, i64, i64) -> (buffer)
      %is_string = scalar.cmpi eq, %value_type, %zero64 : i64
      %value = scf.if %is_string -> (buffer) {
        %decoded = func.call @json_key(%py_compacted, %value_begin, %value_length) : (buffer, i64, i64) -> (buffer)
        %quoted = func.call @py_quote(%decoded) : (buffer) -> (buffer)
        scf.yield %quoted : buffer
      } else {
        %raw = func.call @json_range(%py_compacted, %value_begin, %value_length) : (buffer, i64, i64) -> (buffer)
        %is_object = scalar.cmpi eq, %value_type, %object_type : i64
        %is_array = scalar.cmpi eq, %value_type, %array_type : i64
        %container = scalar.ori %is_object, %is_array : i1
        %printed = scf.if %container -> (buffer) {
          %spaced = func.call @json_spaced(%raw) : (buffer) -> (buffer)
          scf.yield %spaced : buffer
        } else {
          %literal = func.call @py_literal(%raw) : (buffer) -> (buffer)
          scf.yield %literal : buffer
        }
        scf.yield %printed : buffer
      }
      %later = index.cmp ne, %i, %c0 : index
      %lead = scf.select %later, %comma_space, %empty : buffer
      %opened = func.call @join4(%text, %lead, %key, %equals) : (buffer, buffer, buffer, buffer) -> (buffer)
      %next = func.call @join(%opened, %value) : (buffer, buffer) -> (buffer)
      scf.yield %next : buffer
    }
    %py_call_text = func.call @join(%py_body, %paren_close) : (buffer, buffer) -> (buffer)
    scf.yield %py_call_text : buffer
   } else {
    // Clients may reserialize arguments; compact keeps the history key stable.
    %compacted = func.call @compact(%arguments) : (buffer) -> (buffer)
    %members, %type, %count = func.call @members(%compacted) : (buffer) -> (buffer, i32, i64)
    %object = scalar.constant 2 : i32
    %is_object = scalar.cmpi eq, %type, %object : i32
    func.call @check(%is_object) : (i1)
    %bounded_count = scalar.assume %count [range(%count, 0, 33554431)] : i64
    %extent = index.cast %bounded_count : i64 to index
    %fields = buffer.view %members[%origin] : buffer -> view<[%extent]x5xi64>
    %xml_open = global.load @xml_call_open : buffer
    %tag_end = global.load @xml_tag_end : buffer
    %xml_key = global.load @xml_parameter_open : buffer
    %xml_value_close = global.load @xml_parameter_close : buffer
    %xml_close = global.load @xml_call_close : buffer
    %glm_open = global.load @call_open : buffer
    %glm_close = global.load @call_close : buffer
    %glm_key = global.load @key_open : buffer
    %glm_key_close = global.load @key_close : buffer
    %glm_value = global.load @value_open : buffer
    %glm_value_close = global.load @value_close : buffer
    %call_open = scf.select %is_glm, %glm_open, %xml_open : buffer
    %name_end = scf.select %is_glm, %empty, %tag_end : buffer
    %key_open = scf.select %is_glm, %glm_key, %xml_key : buffer
    %glm_key_end = func.call @join(%glm_key_close, %glm_value) : (buffer, buffer) -> (buffer)
    %key_end = scf.select %is_glm, %glm_key_end, %tag_end : buffer
    %value_end = scf.select %is_glm, %glm_value_close, %xml_value_close : buffer
    %call_close = scf.select %is_glm, %glm_close, %xml_close : buffer
    %head = func.call @join4(%separator, %call_open, %name, %name_end) : (buffer, buffer, buffer, buffer) -> (buffer)
    %body = scf.for %i = [%c0 to %extent step %c1](%text = %head : buffer) -> (buffer) {
      %key_begin = view.load %fields[%i, 0] : view<[%extent]x5xi64> -> i64
      %key_length = view.load %fields[%i, 1] : view<[%extent]x5xi64> -> i64
      %value_begin = view.load %fields[%i, 2] : view<[%extent]x5xi64> -> i64
      %value_length = view.load %fields[%i, 3] : view<[%extent]x5xi64> -> i64
      %value_type = view.load %fields[%i, 4] : view<[%extent]x5xi64> -> i64
      %key = func.call @json_key(%compacted, %key_begin, %key_length) : (buffer, i64, i64) -> (buffer)
      %is_string = scalar.cmpi eq, %value_type, %zero64 : i64
      %value = scf.if %is_string -> (buffer) {
        %decoded = func.call @json_key(%compacted, %value_begin, %value_length) : (buffer, i64, i64) -> (buffer)
        scf.yield %decoded : buffer
      } else {
        %raw = func.call @json_range(%compacted, %value_begin, %value_length) : (buffer, i64, i64) -> (buffer)
        scf.yield %raw : buffer
      }
      %opened = func.call @join4(%text, %key_open, %key, %key_end) : (buffer, buffer, buffer, buffer) -> (buffer)
      %next = func.call @join4(%opened, %value, %value_end, %empty) : (buffer, buffer, buffer, buffer) -> (buffer)
      scf.yield %next : buffer
    }
    %value = func.call @join(%body, %call_close) : (buffer, buffer) -> (buffer)
    scf.yield %value : buffer
   }
    scf.yield %other : buffer
  }
  %length_bytes = buffer.length %result
  %length = index.cast %length_bytes : offset to i64
  func.return %result, %length : buffer, i64
}

// Text after the last complete </tool_call> belongs to no call; like common
// OpenAI-compatible parsers, it is dropped instead of failing the turn.
func.def @through_last_call(%response: buffer) -> (buffer) {
  %origin = index.constant 0 : offset
  %close = global.load @call_close : buffer
  %close_length = buffer.length %close
  %length = buffer.length %response
  %scanned, %last = scf.while(%state = %origin : offset, %found = %origin : offset) -> (offset, offset) {
    %position = func.call @find(%response, %state, %length, %close) : (buffer, offset, offset, buffer) -> (offset)
    %hit = index.cmp ult, %position, %length : offset
    %after = index.add %position, %close_length : offset
    %next_found = scf.select %hit, %after, %found : offset
    scf.condition %hit, %after, %next_found : i1, offset, offset
  } do(%state: offset, %found: offset) {
    scf.yield %state, %found : offset, offset
  }
  %matched = index.cmp ne, %last, %origin : offset
  %result = scf.if %matched -> (buffer) {
    %prefix = func.call @slice(%response, %origin, %last) : (buffer, offset, offset) -> (buffer)
    scf.yield %prefix : buffer
  } else {
    scf.yield %response : buffer
  }
  func.return %result : buffer
}

// Appends text[begin, end) as JSON string content.
func.def @json_escape(%text: buffer, %begin: offset, %end: offset, %output: buffer, %position: offset) -> (offset) {
  %c1 = index.constant 1 : offset
  %c2 = index.constant 2 : offset
  %quote = scalar.constant 34 : i32
  %backslash = scalar.constant 92 : i32
  %newline = scalar.constant 10 : i32
  %return = scalar.constant 13 : i32
  %tab = scalar.constant 9 : i32
  %space = scalar.constant 32 : i32
  %letter_n = scalar.constant 110 : i32
  %letter_r = scalar.constant 114 : i32
  %letter_t = scalar.constant 116 : i32
  %final_in, %final_out = scf.while(%in = %begin : offset, %out = %position : offset) -> (offset, offset) {
    %more = index.cmp ult, %in, %end : offset
    scf.condition %more, %in, %out : i1, offset, offset
  } do(%in: offset, %out: offset) {
    %byte = buffer.load.i8.u %text[%in]
    %is_quote = scalar.cmpi eq, %byte, %quote : i32
    %is_backslash = scalar.cmpi eq, %byte, %backslash : i32
    %is_newline = scalar.cmpi eq, %byte, %newline : i32
    %is_return = scalar.cmpi eq, %byte, %return : i32
    %is_tab = scalar.cmpi eq, %byte, %tab : i32
    %is_control = scalar.cmpi ult, %byte, %space : i32
    %literal = scalar.ori %is_quote, %is_backslash : i1
    %letter_rt = scf.select %is_return, %letter_r, %letter_t : i32
    %letter = scf.select %is_newline, %letter_n, %letter_rt : i32
    %named_a = scalar.ori %is_newline, %is_return : i1
    %named = scalar.ori %named_a, %is_tab : i1
    %escaped = scalar.ori %literal, %named : i1
    %second = scf.select %literal, %byte, %letter : i32
    %written = scf.if %escaped -> (offset) {
      buffer.store.i8 %backslash, %output[%out]
      %next_out = index.add %out, %c1 : offset
      buffer.store.i8 %second, %output[%next_out]
      %after = index.add %out, %c2 : offset
      scf.yield %after : offset
    } else {
      // Other control bytes are invalid in JSON text; they become spaces.
      %plain = scf.select %is_control, %space, %byte : i32
      buffer.store.i8 %plain, %output[%out]
      %after = index.add %out, %c1 : offset
      scf.yield %after : offset
    }
    %next_in = index.add %in, %c1 : offset
    scf.yield %next_in, %written : offset, offset
  }
  func.return %final_out : offset
}

// End (exclusive) of the JSON string whose content starts at %from.
func.def inline @string_end(%text: buffer, %from: offset, %end: offset) -> (offset) {
  %c1 = index.constant 1 : offset
  %c2 = index.constant 2 : offset
  %quote = scalar.constant 34 : i32
  %backslash = scalar.constant 92 : i32
  %result = scf.while(%position = %from : offset) -> (offset) {
    %inside = index.cmp ult, %position, %end : offset
    %continue = scf.if %inside -> (i1) {
      %byte = buffer.load.i8.u %text[%position]
      %closing = scalar.cmpi eq, %byte, %quote : i32
      %false = scalar.constant false : i1
      %open = scalar.cmpi eq, %closing, %false : i1
      scf.yield %open : i1
    } else {
      %false = scalar.constant false : i1
      scf.yield %false : i1
    }
    scf.condition %continue, %position : i1, offset
  } do(%position: offset) {
    %byte = buffer.load.i8.u %text[%position]
    %escape = scalar.cmpi eq, %byte, %backslash : i32
    %step = scf.select %escape, %c2, %c1 : offset
    %next = index.add %position, %step : offset
    scf.yield %next : offset
  }
  %bounded = index.cmp ult, %result, %end : offset
  %final = scf.select %bounded, %result, %end : offset
  func.return %final : offset
}

// Hermes JSON calls, scanned without a JSON parser so a malformed call never
// fails the request: arguments are returned as generated (possibly invalid
// JSON) for the harness to handle. Unfinished calls are omitted.
func.def @hermes_calls(%response: buffer) -> (buffer) {
  %origin = index.constant 0 : offset
  %c1 = index.constant 1 : offset
  %c64 = index.constant 64 : offset
  %colon = scalar.constant 58 : i32
  %quote = scalar.constant 34 : i32
  %brace = scalar.constant 125 : i32
  %false = scalar.constant false : i1
  %true = scalar.constant true : i1
  %length = buffer.length %response
  %twice = index.add %length, %length : offset
  %scaled = index.add %twice, %twice : offset
  %capacity = index.add %scaled, %c64 : offset
  %output = buffer.alloca<private> align(1) %capacity : buffer
  %open_bracket = scalar.constant 91 : i32
  %close_bracket = scalar.constant 93 : i32
  %comma = scalar.constant 44 : i32
  buffer.store.i8 %open_bracket, %output[%origin]
  %call_open = global.load @call_open : buffer
  %call_close = global.load @call_close : buffer
  %open_length = buffer.length %call_open
  %close_length = buffer.length %call_close
  %name_field = global.load @name_field : buffer
  %arguments_field = global.load @arguments_field : buffer
  %name_field_length = buffer.length %name_field
  %arguments_field_length = buffer.length %arguments_field
  %record_open = global.load @record_open : buffer
  %record_middle = global.load @record_middle : buffer
  %record_close = global.load @record_close : buffer
  %final_position, %final_out, %final_first = scf.while(%position = %origin : offset, %out = %c1 : offset, %first = %true : i1) -> (offset, offset, i1) {
    %start = func.call @find(%response, %position, %length, %call_open) : (buffer, offset, offset, buffer) -> (offset)
    %has_start = index.cmp ult, %start, %length : offset
    %body_begin = index.add %start, %open_length : offset
    %body_from = scf.select %has_start, %body_begin, %length : offset
    %stop = func.call @find(%response, %body_from, %length, %call_close) : (buffer, offset, offset, buffer) -> (offset)
    %has_stop = index.cmp ult, %stop, %length : offset
    %complete = scalar.andi %has_start, %has_stop : i1
    scf.condition %complete, %position, %out, %first : i1, offset, offset, i1
  } do(%position: offset, %out: offset, %first: i1) {
    %start = func.call @find(%response, %position, %length, %call_open) : (buffer, offset, offset, buffer) -> (offset)
    %body_begin = index.add %start, %open_length : offset
    %stop = func.call @find(%response, %body_begin, %length, %call_close) : (buffer, offset, offset, buffer) -> (offset)
    // "name": "<value>"
    %name_key = func.call @find(%response, %body_begin, %stop, %name_field) : (buffer, offset, offset, buffer) -> (offset)
    %after_name_key = index.add %name_key, %name_field_length : offset
    %name_colon = func.call @skip_space(%response, %after_name_key, %stop) : (buffer, offset, offset) -> (offset)
    %has_name_colon = func.call @byte_is(%response, %name_colon, %stop, %colon) : (buffer, offset, offset, i32) -> (i1)
    %after_name_colon = index.add %name_colon, %c1 : offset
    %name_quote = func.call @skip_space(%response, %after_name_colon, %stop) : (buffer, offset, offset) -> (offset)
    %has_name_quote = func.call @byte_is(%response, %name_quote, %stop, %quote) : (buffer, offset, offset, i32) -> (i1)
    %name_begin = index.add %name_quote, %c1 : offset
    %name_end = func.call @string_end(%response, %name_begin, %stop) : (buffer, offset, offset) -> (offset)
    %name_ok_a = scalar.andi %has_name_colon, %has_name_quote : i1
    %name_closed = index.cmp ult, %name_end, %stop : offset
    %name_ok = scalar.andi %name_ok_a, %name_closed : i1
    // "arguments": <value> up to the object's closing brace.
    %arguments_key = func.call @find(%response, %body_begin, %stop, %arguments_field) : (buffer, offset, offset, buffer) -> (offset)
    %after_arguments_key = index.add %arguments_key, %arguments_field_length : offset
    %arguments_colon = func.call @skip_space(%response, %after_arguments_key, %stop) : (buffer, offset, offset) -> (offset)
    %has_arguments_colon = func.call @byte_is(%response, %arguments_colon, %stop, %colon) : (buffer, offset, offset, i32) -> (i1)
    %after_arguments_colon = index.add %arguments_colon, %c1 : offset
    %value_begin = func.call @skip_space(%response, %after_arguments_colon, %stop) : (buffer, offset, offset) -> (offset)
    %body_end = func.call @trim_end(%response, %value_begin, %stop) : (buffer, offset, offset) -> (offset)
    %last = index.sub %body_end, %c1 : offset
    %ends_object = func.call @byte_is(%response, %last, %stop, %brace) : (buffer, offset, offset, i32) -> (i1)
    %inner_end = scf.select %ends_object, %last, %body_end : offset
    %value_end = func.call @trim_end(%response, %value_begin, %inner_end) : (buffer, offset, offset) -> (offset)
    %has_value = index.cmp ult, %value_begin, %value_end : offset
    %arguments_ok_a = scalar.andi %has_arguments_colon, %has_value : i1
    %arguments_ok = scalar.andi %arguments_ok_a, %ends_object : i1
    %ok = scalar.andi %name_ok, %arguments_ok : i1
    %written, %next_first = scf.if %ok -> (offset, i1) {
      %separated = scf.if %first -> (offset) {
        scf.yield %out : offset
      } else {
        buffer.store.i8 %comma, %output[%out]
        %after = index.add %out, %c1 : offset
        scf.yield %after : offset
      }
      %after_open = func.call @tool_append(%output, %separated, %record_open) : (buffer, offset, buffer) -> (offset)
      // The name is already JSON string content.
      %name_bytes = index.sub %name_end, %name_begin : offset
      buffer.copy %response[%name_begin], %output[%after_open], %name_bytes
      %after_name = index.add %after_open, %name_bytes : offset
      %after_middle = func.call @tool_append(%output, %after_name, %record_middle) : (buffer, offset, buffer) -> (offset)
      // A string-valued "arguments" is already escaped JSON text.
      %string_value = func.call @byte_is(%response, %value_begin, %value_end, %quote) : (buffer, offset, offset, i32) -> (i1)
      %after_value = scf.if %string_value -> (offset) {
        %inner_begin = index.add %value_begin, %c1 : offset
        %inner_stop = index.sub %value_end, %c1 : offset
        %inner_bytes = index.sub %inner_stop, %inner_begin : offset
        buffer.copy %response[%inner_begin], %output[%after_middle], %inner_bytes
        %moved = index.add %after_middle, %inner_bytes : offset
        scf.yield %moved : offset
      } else {
        %moved = func.call @json_escape(%response, %value_begin, %value_end, %output, %after_middle) : (buffer, offset, offset, buffer, offset) -> (offset)
        scf.yield %moved : offset
      }
      %after_record = func.call @tool_append(%output, %after_value, %record_close) : (buffer, offset, buffer) -> (offset)
      scf.yield %after_record, %false : offset, i1
    } else {
      scf.yield %out, %first : offset, i1
    }
    %next_position = index.add %stop, %close_length : offset
    scf.yield %next_position, %written, %next_first : offset, offset, i1
  }
  buffer.store.i8 %close_bracket, %output[%final_out]
  %used = index.add %final_out, %c1 : offset
  %result = func.call @slice(%output, %origin, %used) : (buffer, offset, offset) -> (buffer)
  func.return %result : buffer
}

// GLM spelling -> the host XML grammar: <tool_call>NAME<arg_key>K</arg_key>
// <arg_value>V</arg_value></tool_call> becomes <tool_call>\n<function=NAME>\n
// <parameter=K>\nV\n</parameter>\n</function>\n</tool_call>.
func.def inline @starts_at(%text: buffer, %position: offset, %marker: buffer) -> (i1) {
  %c0 = index.constant 0 : offset
  %length = buffer.length %text
  %marker_length = buffer.length %marker
  %stop = index.add %position, %marker_length : offset
  %inside = index.cmp ule, %stop, %length : offset
  %result = scf.if %inside -> (i1) {
    %compared = buffer.compare %text[%position], %marker[%c0], %marker_length
    %zero = scalar.constant 0 : i32
    %same = scalar.cmpi eq, %compared, %zero : i32
    scf.yield %same : i1
  } else {
    %false = scalar.constant false : i1
    scf.yield %false : i1
  }
  func.return %result : i1
}

func.def @glm_calls_to_xml(%response: buffer) -> (buffer) {
  %origin = index.constant 0 : offset
  %c1 = index.constant 1 : offset
  %c64 = index.constant 64 : offset
  %false = scalar.constant false : i1
  %true = scalar.constant true : i1
  %length = buffer.length %response
  %twice = index.add %length, %length : offset
  %scaled = index.add %twice, %length : offset
  %capacity = index.add %scaled, %c64 : offset
  %output = buffer.alloca<private> align(1) %capacity : buffer
  %call_open = global.load @call_open : buffer
  %call_close = global.load @call_close : buffer
  %key_open = global.load @key_open : buffer
  %key_close = global.load @key_close : buffer
  %value_open = global.load @value_open : buffer
  %value_close = global.load @value_close : buffer
  %xml_open = global.load @xml_call_open : buffer
  %tag_end = global.load @xml_tag_end : buffer
  %xml_key = global.load @xml_parameter_open : buffer
  %xml_value_close = global.load @xml_parameter_close : buffer
  %xml_close = global.load @xml_call_close : buffer
  %end, %written, %naming = scf.while(%position = %origin : offset, %out = %origin : offset, %open = %false : i1) -> (offset, offset, i1) {
    %more = index.cmp ult, %position, %length : offset
    scf.condition %more, %position, %out, %open : i1, offset, offset, i1
  } do(%position: offset, %out: offset, %open: i1) {
    %is_call_open = func.call @starts_at(%response, %position, %call_open) : (buffer, offset, buffer) -> (i1)
    %is_call_close = func.call @starts_at(%response, %position, %call_close) : (buffer, offset, buffer) -> (i1)
    %is_key_open = func.call @starts_at(%response, %position, %key_open) : (buffer, offset, buffer) -> (i1)
    %is_key_close = func.call @starts_at(%response, %position, %key_close) : (buffer, offset, buffer) -> (i1)
    %is_value_open = func.call @starts_at(%response, %position, %value_open) : (buffer, offset, buffer) -> (i1)
    %is_value_close = func.call @starts_at(%response, %position, %value_close) : (buffer, offset, buffer) -> (i1)
    // A function name is closed before its first parameter or the call end.
    %closes_name_a = scalar.ori %is_call_close, %is_key_open : i1
    %closes_name = scalar.andi %closes_name_a, %open : i1
    %named = scf.if %closes_name -> (offset) {
      %after = func.call @tool_append(%output, %out, %tag_end) : (buffer, offset, buffer) -> (offset)
      scf.yield %after : offset
    } else {
      scf.yield %out : offset
    }
    %p, %o, %n = scf.if %is_call_open -> (offset, offset, i1) {
      %after = func.call @tool_append(%output, %named, %xml_open) : (buffer, offset, buffer) -> (offset)
      %skip = buffer.length %call_open
      %next = index.add %position, %skip : offset
      scf.yield %next, %after, %true : offset, offset, i1
    } else {
      %p1, %o1, %n1 = scf.if %is_call_close -> (offset, offset, i1) {
        %after = func.call @tool_append(%output, %named, %xml_close) : (buffer, offset, buffer) -> (offset)
        %skip = buffer.length %call_close
        %next = index.add %position, %skip : offset
        scf.yield %next, %after, %false : offset, offset, i1
      } else {
        %p2, %o2, %n2 = scf.if %is_key_open -> (offset, offset, i1) {
          %after = func.call @tool_append(%output, %named, %xml_key) : (buffer, offset, buffer) -> (offset)
          %skip = buffer.length %key_open
          %next = index.add %position, %skip : offset
          scf.yield %next, %after, %false : offset, offset, i1
        } else {
          %p3, %o3, %n3 = scf.if %is_key_close -> (offset, offset, i1) {
            %after = func.call @tool_append(%output, %out, %tag_end) : (buffer, offset, buffer) -> (offset)
            %skip = buffer.length %key_close
            %next = index.add %position, %skip : offset
            scf.yield %next, %after, %open : offset, offset, i1
          } else {
            %p4, %o4, %n4 = scf.if %is_value_open -> (offset, offset, i1) {
              %skip = buffer.length %value_open
              %next = index.add %position, %skip : offset
              scf.yield %next, %out, %open : offset, offset, i1
            } else {
              %p5, %o5, %n5 = scf.if %is_value_close -> (offset, offset, i1) {
                %after = func.call @tool_append(%output, %out, %xml_value_close) : (buffer, offset, buffer) -> (offset)
                %skip = buffer.length %value_close
                %next = index.add %position, %skip : offset
                scf.yield %next, %after, %open : offset, offset, i1
              } else {
                // Ordinary byte: names drop whitespace, everything else copies.
                %space = func.call @text_is_space(%response, %position) : (buffer, offset) -> (i1)
                %drop = scalar.andi %space, %open : i1
                %next = index.add %position, %c1 : offset
                %after = scf.if %drop -> (offset) {
                  scf.yield %out : offset
                } else {
                  buffer.copy %response[%position], %output[%out], %c1
                  %moved = index.add %out, %c1 : offset
                  scf.yield %moved : offset
                }
                scf.yield %next, %after, %open : offset, offset, i1
              }
              scf.yield %p5, %o5, %n5 : offset, offset, i1
            }
            scf.yield %p4, %o4, %n4 : offset, offset, i1
          }
          scf.yield %p3, %o3, %n3 : offset, offset, i1
        }
        scf.yield %p2, %o2, %n2 : offset, offset, i1
      }
      scf.yield %p1, %o1, %n1 : offset, offset, i1
    }
    scf.yield %p, %o, %n : offset, offset, i1
  }
  %result = func.call @slice(%output, %origin, %written) : (buffer, offset, offset) -> (buffer)
  func.return %result : buffer
}

// ---- Pythonic calls (LFM2) ---------------------------------------------------
// History: NAME(k=v, ...) with strings single-quoted (\\ \' \n \r escaped), lists and
// objects as tojson (", " / ": " separators), true/false/null as True/False/None,
// numbers as sent. Output: the list between CALLS_OPEN and CALL_END becomes
// OpenAI records; string literals become JSON strings, True/False/None become
// true/false/null, everything else (numbers, JSON lists/objects) is copied.
// A call without its closing parenthesis (truncated or malformed) is dropped.
global.rodata.def @py_open_paren = bytes("28")

global.rodata.def @py_close_paren = bytes("29")

global.rodata.def @py_equals = bytes("3d")

global.rodata.def @py_comma_space = bytes("2c20")

global.rodata.def @json_true = bytes("74727565")

global.rodata.def @json_false = bytes("66616c7365")

global.rodata.def @json_null = bytes("6e756c6c")

global.rodata.def @py_true = bytes("54727565")

global.rodata.def @py_false = bytes("46616c7365")

global.rodata.def @py_none = bytes("4e6f6e65")

// A JSON scalar's text as Python's str() prints it: true/false/null as True/False/None, anything else unchanged.
func.def @py_literal(%raw: buffer) -> (buffer) {
  %json_true = global.load @json_true : buffer
  %json_false = global.load @json_false : buffer
  %json_null = global.load @json_null : buffer
  %py_true = global.load @py_true : buffer
  %py_false = global.load @py_false : buffer
  %py_none = global.load @py_none : buffer
  %is_true = func.call @equal(%raw, %json_true) : (buffer, buffer) -> (i1)
  %is_false = func.call @equal(%raw, %json_false) : (buffer, buffer) -> (i1)
  %is_null = func.call @equal(%raw, %json_null) : (buffer, buffer) -> (i1)
  %v1 = scf.select %is_true, %py_true, %raw : buffer
  %v2 = scf.select %is_false, %py_false, %v1 : buffer
  %v3 = scf.select %is_null, %py_none, %v2 : buffer
  func.return %v3 : buffer
}

// '": '
global.rodata.def @key_value_gap = bytes("223a20")

func.def inline @name_byte(%b: i32) -> (i1) {
  %c48 = scalar.constant 48 : i32
  %c57 = scalar.constant 57 : i32
  %c65 = scalar.constant 65 : i32
  %c90 = scalar.constant 90 : i32
  %c97 = scalar.constant 97 : i32
  %c122 = scalar.constant 122 : i32
  %c95 = scalar.constant 95 : i32
  %c46 = scalar.constant 46 : i32
  %c45 = scalar.constant 45 : i32
  %ge_digit = scalar.cmpi uge, %b, %c48 : i32
  %le_digit = scalar.cmpi ule, %b, %c57 : i32
  %digit = scalar.andi %ge_digit, %le_digit : i1
  %ge_upper = scalar.cmpi uge, %b, %c65 : i32
  %le_upper = scalar.cmpi ule, %b, %c90 : i32
  %upper = scalar.andi %ge_upper, %le_upper : i1
  %ge_lower = scalar.cmpi uge, %b, %c97 : i32
  %le_lower = scalar.cmpi ule, %b, %c122 : i32
  %lower = scalar.andi %ge_lower, %le_lower : i1
  %under = scalar.cmpi eq, %b, %c95 : i32
  %dot = scalar.cmpi eq, %b, %c46 : i32
  %dash = scalar.cmpi eq, %b, %c45 : i32
  %a = scalar.ori %digit, %upper : i1
  %b1 = scalar.ori %a, %lower : i1
  %b2 = scalar.ori %b1, %under : i1
  %b3 = scalar.ori %b2, %dot : i1
  %result = scalar.ori %b3, %dash : i1
  func.return %result : i1
}

// Python repr-style single-quoted literal, as the template's format_arg_value prints it.
func.def @py_quote(%text: buffer) -> (buffer) {
  %c0 = index.constant 0 : offset
  %c1 = index.constant 1 : offset
  %c2 = index.constant 2 : offset
  %quote = scalar.constant 39 : i32
  %backslash = scalar.constant 92 : i32
  %newline = scalar.constant 10 : i32
  %return = scalar.constant 13 : i32
  %letter_n = scalar.constant 110 : i32
  %letter_r = scalar.constant 114 : i32
  %length = buffer.length %text
  %twice = index.add %length, %length : offset
  %capacity = index.add %twice, %c2 : offset
  %output = buffer.alloca<private> align(1) %capacity : buffer
  buffer.store.i8 %quote, %output[%c0]
  %final_in, %final_out = scf.while(%in = %c0 : offset, %out = %c1 : offset) -> (offset, offset) {
    %more = index.cmp ult, %in, %length : offset
    scf.condition %more, %in, %out : i1, offset, offset
  } do(%in: offset, %out: offset) {
    %byte = buffer.load.i8.u %text[%in]
    %is_quote = scalar.cmpi eq, %byte, %quote : i32
    %is_backslash = scalar.cmpi eq, %byte, %backslash : i32
    %is_newline = scalar.cmpi eq, %byte, %newline : i32
    %is_return = scalar.cmpi eq, %byte, %return : i32
    %literal = scalar.ori %is_quote, %is_backslash : i1
    %named = scalar.ori %is_newline, %is_return : i1
    %escaped = scalar.ori %literal, %named : i1
    %letter = scf.select %is_newline, %letter_n, %letter_r : i32
    %second = scf.select %literal, %byte, %letter : i32
    %written = scf.if %escaped -> (offset) {
      buffer.store.i8 %backslash, %output[%out]
      %next_out = index.add %out, %c1 : offset
      buffer.store.i8 %second, %output[%next_out]
      %after = index.add %out, %c2 : offset
      scf.yield %after : offset
    } else {
      buffer.store.i8 %byte, %output[%out]
      %after = index.add %out, %c1 : offset
      scf.yield %after : offset
    }
    %next_in = index.add %in, %c1 : offset
    scf.yield %next_in, %written : offset, offset
  }
  buffer.store.i8 %quote, %output[%final_out]
  %used = index.add %final_out, %c1 : offset
  %result = func.call @slice(%output, %c0, %used) : (buffer, offset, offset) -> (buffer)
  func.return %result : buffer
}

// Compact JSON -> json.dumps spacing (", " and ": " outside strings), as tojson prints it.
func.def @json_spaced(%text: buffer) -> (buffer) {
  %c0 = index.constant 0 : offset
  %c1 = index.constant 1 : offset
  %c2 = index.constant 2 : offset
  %quote = scalar.constant 34 : i32
  %backslash = scalar.constant 92 : i32
  %comma = scalar.constant 44 : i32
  %colon = scalar.constant 58 : i32
  %space = scalar.constant 32 : i32
  %false = scalar.constant false : i1
  %length = buffer.length %text
  %twice = index.add %length, %length : offset
  %capacity = index.add %twice, %c2 : offset
  %output = buffer.alloca<private> align(1) %capacity : buffer
  %final_in, %final_out, %final_inside, %final_escape = scf.while(%in = %c0 : offset, %out = %c0 : offset, %inside = %false : i1, %escape = %false : i1) -> (offset, offset, i1, i1) {
    %more = index.cmp ult, %in, %length : offset
    scf.condition %more, %in, %out, %inside, %escape : i1, offset, offset, i1, i1
  } do(%in: offset, %out: offset, %inside: i1, %escape: i1) {
    %byte = buffer.load.i8.u %text[%in]
    %is_quote = scalar.cmpi eq, %byte, %quote : i32
    %is_backslash = scalar.cmpi eq, %byte, %backslash : i32
    %is_comma = scalar.cmpi eq, %byte, %comma : i32
    %is_colon = scalar.cmpi eq, %byte, %colon : i32
    %outside = scalar.cmpi eq, %inside, %false : i1
    %plain = scalar.cmpi eq, %escape, %false : i1
    %live = scalar.andi %inside, %plain : i1
    %starts_escape = scalar.andi %live, %is_backslash : i1
    %closes = scalar.andi %live, %is_quote : i1
    %opens = scalar.andi %outside, %is_quote : i1
    %stays = scalar.cmpi eq, %closes, %false : i1
    %kept = scalar.andi %inside, %stays : i1
    %next_inside = scalar.ori %kept, %opens : i1
    %separator = scalar.ori %is_comma, %is_colon : i1
    %spaced = scalar.andi %outside, %separator : i1
    buffer.store.i8 %byte, %output[%out]
    %after = index.add %out, %c1 : offset
    %written = scf.if %spaced -> (offset) {
      buffer.store.i8 %space, %output[%after]
      %moved = index.add %after, %c1 : offset
      scf.yield %moved : offset
    } else {
      scf.yield %after : offset
    }
    %next_in = index.add %in, %c1 : offset
    scf.yield %next_in, %written, %next_inside, %starts_escape : offset, offset, i1, i1
  }
  %result = func.call @slice(%output, %c0, %final_out) : (buffer, offset, offset) -> (buffer)
  func.return %result : buffer
}

// Copies the Python string literal whose opening quote is at %begin into
// %output at %out as a JSON string. Returns (position after it, output end).
func.def @py_string(%text: buffer, %begin: offset, %end: offset, %output: buffer, %out: offset) -> (offset, offset) {
  %c0 = index.constant 0 : offset
  %c1 = index.constant 1 : offset
  %c2 = index.constant 2 : offset
  %zero = scalar.constant 0 : i32
  %dq = scalar.constant 34 : i32
  %sq = scalar.constant 39 : i32
  %bs = scalar.constant 92 : i32
  %nl = scalar.constant 10 : i32
  %cr = scalar.constant 13 : i32
  %tab = scalar.constant 9 : i32
  %space = scalar.constant 32 : i32
  %letter_n = scalar.constant 110 : i32
  %letter_r = scalar.constant 114 : i32
  %letter_t = scalar.constant 116 : i32
  %letter_b = scalar.constant 98 : i32
  %letter_f = scalar.constant 102 : i32
  %letter_u = scalar.constant 117 : i32
  %slash = scalar.constant 47 : i32
  %false = scalar.constant false : i1
  %quote = buffer.load.i8.u %text[%begin]
  buffer.store.i8 %dq, %output[%out]
  %start_out = index.add %out, %c1 : offset
  %start_in = index.add %begin, %c1 : offset
  %final_in, %final_out = scf.while(%in = %start_in : offset, %o = %start_out : offset) -> (offset, offset) {
    %more = index.cmp ult, %in, %end : offset
    %open = scf.if %more -> (i1) {
      %byte = buffer.load.i8.u %text[%in]
      %closing = scalar.cmpi eq, %byte, %quote : i32
      %not_closing = scalar.cmpi eq, %closing, %false : i1
      scf.yield %not_closing : i1
    } else {
      scf.yield %false : i1
    }
    scf.condition %open, %in, %o : i1, offset, offset
  } do(%in: offset, %o: offset) {
    %byte = buffer.load.i8.u %text[%in]
    %after = index.add %in, %c1 : offset
    %has_next = index.cmp ult, %after, %end : offset
    %n = scf.if %has_next -> (i32) {
      %value = buffer.load.i8.u %text[%after]
      scf.yield %value : i32
    } else {
      scf.yield %zero : i32
    }
    %is_bs = scalar.cmpi eq, %byte, %bs : i32
    %bs_next = scalar.andi %is_bs, %has_next : i1
    %n_dq = scalar.cmpi eq, %n, %dq : i32
    %n_bs = scalar.cmpi eq, %n, %bs : i32
    %n_n = scalar.cmpi eq, %n, %letter_n : i32
    %n_r = scalar.cmpi eq, %n, %letter_r : i32
    %n_t = scalar.cmpi eq, %n, %letter_t : i32
    %n_b = scalar.cmpi eq, %n, %letter_b : i32
    %n_f = scalar.cmpi eq, %n, %letter_f : i32
    %n_u = scalar.cmpi eq, %n, %letter_u : i32
    %n_slash = scalar.cmpi eq, %n, %slash : i32
    %n_sq = scalar.cmpi eq, %n, %sq : i32
    %k1 = scalar.ori %n_dq, %n_bs : i1
    %k2 = scalar.ori %k1, %n_n : i1
    %k3 = scalar.ori %k2, %n_r : i1
    %k4 = scalar.ori %k3, %n_t : i1
    %k5 = scalar.ori %k4, %n_b : i1
    %k6 = scalar.ori %k5, %n_f : i1
    %k7 = scalar.ori %k6, %n_u : i1
    %k8 = scalar.ori %k7, %n_slash : i1
    // \" \\ \n \r \t \b \f \u \/ are JSON escapes too; \' is a plain quote;
    // any other backslash is literal (Python keeps unknown escapes).
    %known = scalar.andi %bs_next, %k8 : i1
    %single_quote = scalar.andi %bs_next, %n_sq : i1
    %special = scalar.ori %known, %single_quote : i1
    %not_special = scalar.cmpi eq, %special, %false : i1
    %lone_bs = scalar.andi %is_bs, %not_special : i1
    %is_dq = scalar.cmpi eq, %byte, %dq : i32
    %is_nl = scalar.cmpi eq, %byte, %nl : i32
    %is_cr = scalar.cmpi eq, %byte, %cr : i32
    %is_tab = scalar.cmpi eq, %byte, %tab : i32
    %is_control = scalar.cmpi ult, %byte, %space : i32
    %e1 = scalar.ori %known, %lone_bs : i1
    %e2 = scalar.ori %e1, %is_dq : i1
    %e3 = scalar.ori %e2, %is_nl : i1
    %e4 = scalar.ori %e3, %is_cr : i1
    %escaped = scalar.ori %e4, %is_tab : i1
    %x_rt = scf.select %is_cr, %letter_r, %letter_t : i32
    %x_ws = scf.select %is_nl, %letter_n, %x_rt : i32
    %x_dq = scf.select %is_dq, %dq, %x_ws : i32
    %x_bs = scf.select %lone_bs, %bs, %x_dq : i32
    %x = scf.select %known, %n, %x_bs : i32
    %y_plain = scf.select %is_control, %space, %byte : i32
    %y = scf.select %single_quote, %sq, %y_plain : i32
    %consumed = scf.select %special, %c2, %c1 : offset
    %written = scf.if %escaped -> (offset) {
      buffer.store.i8 %bs, %output[%o]
      %o1 = index.add %o, %c1 : offset
      buffer.store.i8 %x, %output[%o1]
      %o2 = index.add %o, %c2 : offset
      scf.yield %o2 : offset
    } else {
      buffer.store.i8 %y, %output[%o]
      %o1 = index.add %o, %c1 : offset
      scf.yield %o1 : offset
    }
    %next_in = index.add %in, %consumed : offset
    scf.yield %next_in, %written : offset, offset
  }
  %closed = index.cmp ult, %final_in, %end : offset
  %skip = scf.select %closed, %c1, %c0 : offset
  %after_quote = index.add %final_in, %skip : offset
  buffer.store.i8 %dq, %output[%final_out]
  %used = index.add %final_out, %c1 : offset
  func.return %after_quote, %used : offset, offset
}

// Copies one Python argument value at %begin into %output as JSON, up to a
// ',' / ')' / ']' outside brackets. Returns (position, output end).
func.def @py_value(%text: buffer, %begin: offset, %end: offset, %output: buffer, %out: offset) -> (offset, offset) {
  %c1 = index.constant 1 : offset
  %zero64 = scalar.constant 0 : i64
  %one64 = scalar.constant 1 : i64
  %false = scalar.constant false : i1
  %comma = scalar.constant 44 : i32
  %rparen = scalar.constant 41 : i32
  %lbracket = scalar.constant 91 : i32
  %rbracket = scalar.constant 93 : i32
  %lbrace = scalar.constant 123 : i32
  %rbrace = scalar.constant 125 : i32
  %dq = scalar.constant 34 : i32
  %sq = scalar.constant 39 : i32
  %py_true = global.load @py_true : buffer
  %py_false = global.load @py_false : buffer
  %py_none = global.load @py_none : buffer
  %json_true = global.load @json_true : buffer
  %json_false = global.load @json_false : buffer
  %json_null = global.load @json_null : buffer
  %true_length = buffer.length %py_true
  %false_length = buffer.length %py_false
  %final_p, %final_o, %final_d = scf.while(%p = %begin : offset, %o = %out : offset, %d = %zero64 : i64) -> (offset, offset, i64) {
    %more = index.cmp ult, %p, %end : offset
    %go = scf.if %more -> (i1) {
      %byte = buffer.load.i8.u %text[%p]
      %top = scalar.cmpi eq, %d, %zero64 : i64
      %t1 = scalar.cmpi eq, %byte, %comma : i32
      %t2 = scalar.cmpi eq, %byte, %rparen : i32
      %t3 = scalar.cmpi eq, %byte, %rbracket : i32
      %ta = scalar.ori %t1, %t2 : i1
      %term = scalar.ori %ta, %t3 : i1
      %stop = scalar.andi %top, %term : i1
      %continue = scalar.cmpi eq, %stop, %false : i1
      scf.yield %continue : i1
    } else {
      scf.yield %false : i1
    }
    scf.condition %go, %p, %o, %d : i1, offset, offset, i64
  } do(%p: offset, %o: offset, %d: i64) {
    %byte = buffer.load.i8.u %text[%p]
    %is_dq = scalar.cmpi eq, %byte, %dq : i32
    %is_sq = scalar.cmpi eq, %byte, %sq : i32
    %is_quote = scalar.ori %is_dq, %is_sq : i1
    %is_true = func.call @starts_at(%text, %p, %py_true) : (buffer, offset, buffer) -> (i1)
    %is_false = func.call @starts_at(%text, %p, %py_false) : (buffer, offset, buffer) -> (i1)
    %is_none = func.call @starts_at(%text, %p, %py_none) : (buffer, offset, buffer) -> (i1)
    %is_lbracket = scalar.cmpi eq, %byte, %lbracket : i32
    %is_lbrace = scalar.cmpi eq, %byte, %lbrace : i32
    %is_rbracket = scalar.cmpi eq, %byte, %rbracket : i32
    %is_rbrace = scalar.cmpi eq, %byte, %rbrace : i32
    %opens = scalar.ori %is_lbracket, %is_lbrace : i1
    %closes = scalar.ori %is_rbracket, %is_rbrace : i1
    %top = scalar.cmpi eq, %d, %zero64 : i64
    %space = func.call @text_is_space(%text, %p) : (buffer, offset) -> (i1)
    %drop = scalar.andi %top, %space : i1
    %np, %no, %nd = scf.if %is_quote -> (offset, offset, i64) {
      %sp, %so = func.call @py_string(%text, %p, %end, %output, %o) : (buffer, offset, offset, buffer, offset) -> (offset, offset)
      scf.yield %sp, %so, %d : offset, offset, i64
    } else {
      %p1, %o1, %d1 = scf.if %is_true -> (offset, offset, i64) {
        %wo = func.call @tool_append(%output, %o, %json_true) : (buffer, offset, buffer) -> (offset)
        %wp = index.add %p, %true_length : offset
        scf.yield %wp, %wo, %d : offset, offset, i64
      } else {
        %p2, %o2, %d2 = scf.if %is_false -> (offset, offset, i64) {
          %wo = func.call @tool_append(%output, %o, %json_false) : (buffer, offset, buffer) -> (offset)
          %wp = index.add %p, %false_length : offset
          scf.yield %wp, %wo, %d : offset, offset, i64
        } else {
          %p3, %o3, %d3 = scf.if %is_none -> (offset, offset, i64) {
            %wo = func.call @tool_append(%output, %o, %json_null) : (buffer, offset, buffer) -> (offset)
            %wp = index.add %p, %true_length : offset
            scf.yield %wp, %wo, %d : offset, offset, i64
          } else {
            %wp = index.add %p, %c1 : offset
            %p4, %o4, %d4 = scf.if %drop -> (offset, offset, i64) {
              scf.yield %wp, %o, %d : offset, offset, i64
            } else {
              buffer.store.i8 %byte, %output[%o]
              %wo = index.add %o, %c1 : offset
              %deeper = scalar.addi %d, %one64 : i64
              %shallower = scalar.subi %d, %one64 : i64
              %da = scf.select %opens, %deeper, %d : i64
              %db = scf.select %closes, %shallower, %da : i64
              scf.yield %wp, %wo, %db : offset, offset, i64
            }
            scf.yield %p4, %o4, %d4 : offset, offset, i64
          }
          scf.yield %p3, %o3, %d3 : offset, offset, i64
        }
        scf.yield %p2, %o2, %d2 : offset, offset, i64
      }
      scf.yield %p1, %o1, %d1 : offset, offset, i64
    }
    scf.yield %np, %no, %nd : offset, offset, i64
  }
  func.return %final_p, %final_o : offset, offset
}

// One call NAME(k=v, ...) at %begin; its arguments object is written to %args.
// Returns (end, complete, name end, arguments length).
func.def @py_call(%text: buffer, %begin: offset, %end: offset, %args: buffer) -> (offset, i1, offset, offset) {
  %c0 = index.constant 0 : offset
  %c1 = index.constant 1 : offset
  %false = scalar.constant false : i1
  %true = scalar.constant true : i1
  %lparen = scalar.constant 40 : i32
  %rparen = scalar.constant 41 : i32
  %comma = scalar.constant 44 : i32
  %equals = scalar.constant 61 : i32
  %lbrace = scalar.constant 123 : i32
  %rbrace = scalar.constant 125 : i32
  %dq = scalar.constant 34 : i32
  %empty = global.load @empty : buffer
  %comma_space = global.load @py_comma_space : buffer
  %gap = global.load @key_value_gap : buffer
  %name_end = scf.while(%p = %begin : offset) -> (offset) {
    %more = index.cmp ult, %p, %end : offset
    %go = scf.if %more -> (i1) {
      %byte = buffer.load.i8.u %text[%p]
      %ok = func.call @name_byte(%byte) : (i32) -> (i1)
      scf.yield %ok : i1
    } else {
      scf.yield %false : i1
    }
    scf.condition %go, %p : i1, offset
  } do(%p: offset) {
    %next = index.add %p, %c1 : offset
    scf.yield %next : offset
  }
  %has_paren = func.call @byte_is(%text, %name_end, %end, %lparen) : (buffer, offset, offset, i32) -> (i1)
  %r_end, %r_ok, %r_length = scf.if %has_paren -> (offset, i1, offset) {
    buffer.store.i8 %lbrace, %args[%c0]
    %start = index.add %name_end, %c1 : offset
    %fp, %fa, %ffirst, %fdone, %fok = scf.while(%p = %start : offset, %a = %c1 : offset, %first = %true : i1, %done = %false : i1, %ok = %false : i1) -> (offset, offset, i1, i1, i1) {
      %more = index.cmp ult, %p, %end : offset
      %open = scalar.cmpi eq, %done, %false : i1
      %go = scalar.andi %more, %open : i1
      scf.condition %go, %p, %a, %first, %done, %ok : i1, offset, offset, i1, i1, i1
    } do(%p: offset, %a: offset, %first: i1, %done: i1, %ok: i1) {
      %q = func.call @skip_space(%text, %p, %end) : (buffer, offset, offset) -> (offset)
      %at_close = func.call @byte_is(%text, %q, %end, %rparen) : (buffer, offset, offset, i32) -> (i1)
      %at_comma = func.call @byte_is(%text, %q, %end, %comma) : (buffer, offset, offset, i32) -> (i1)
      %after_q = index.add %q, %c1 : offset
      %np, %na, %nfirst, %ndone, %nok = scf.if %at_close -> (offset, offset, i1, i1, i1) {
        scf.yield %after_q, %a, %first, %true, %true : offset, offset, i1, i1, i1
      } else {
        %p1, %a1, %f1, %d1, %k1 = scf.if %at_comma -> (offset, offset, i1, i1, i1) {
          scf.yield %after_q, %a, %first, %false, %false : offset, offset, i1, i1, i1
        } else {
          %key_stop = scf.while(%k = %q : offset) -> (offset) {
            %kmore = index.cmp ult, %k, %end : offset
            %kgo = scf.if %kmore -> (i1) {
              %byte = buffer.load.i8.u %text[%k]
              %s1 = scalar.cmpi eq, %byte, %equals : i32
              %s2 = scalar.cmpi eq, %byte, %comma : i32
              %s3 = scalar.cmpi eq, %byte, %rparen : i32
              %sa = scalar.ori %s1, %s2 : i1
              %stop = scalar.ori %sa, %s3 : i1
              %continue = scalar.cmpi eq, %stop, %false : i1
              scf.yield %continue : i1
            } else {
              scf.yield %false : i1
            }
            scf.condition %kgo, %k : i1, offset
          } do(%k: offset) {
            %knext = index.add %k, %c1 : offset
            scf.yield %knext : offset
          }
          %has_equals = func.call @byte_is(%text, %key_stop, %end, %equals) : (buffer, offset, offset, i32) -> (i1)
          %p2, %a2, %f2, %d2, %k2 = scf.if %has_equals -> (offset, offset, i1, i1, i1) {
            %key_end = func.call @trim_end(%text, %q, %key_stop) : (buffer, offset, offset) -> (offset)
            %lead = scf.select %first, %empty, %comma_space : buffer
            %w1 = func.call @tool_append(%args, %a, %lead) : (buffer, offset, buffer) -> (offset)
            buffer.store.i8 %dq, %args[%w1]
            %w2 = index.add %w1, %c1 : offset
            %w3 = func.call @json_escape(%text, %q, %key_end, %args, %w2) : (buffer, offset, offset, buffer, offset) -> (offset)
            %w4 = func.call @tool_append(%args, %w3, %gap) : (buffer, offset, buffer) -> (offset)
            %after_equals = index.add %key_stop, %c1 : offset
            %value_start = func.call @skip_space(%text, %after_equals, %end) : (buffer, offset, offset) -> (offset)
            %vp, %va = func.call @py_value(%text, %value_start, %end, %args, %w4) : (buffer, offset, offset, buffer, offset) -> (offset, offset)
            %no_value = index.cmp eq, %va, %w4 : offset
            scf.yield %vp, %va, %false, %no_value, %false : offset, offset, i1, i1, i1
          } else {
            scf.yield %key_stop, %a, %first, %true, %false : offset, offset, i1, i1, i1
          }
          scf.yield %p2, %a2, %f2, %d2, %k2 : offset, offset, i1, i1, i1
        }
        scf.yield %p1, %a1, %f1, %d1, %k1 : offset, offset, i1, i1, i1
      }
      scf.yield %np, %na, %nfirst, %ndone, %nok : offset, offset, i1, i1, i1
    }
    buffer.store.i8 %rbrace, %args[%fa]
    %length = index.add %fa, %c1 : offset
    scf.yield %fp, %fok, %length : offset, i1, offset
  } else {
    scf.yield %name_end, %false, %c0 : offset, i1, offset
  }
  func.return %r_end, %r_ok, %name_end, %r_length : offset, i1, offset, offset
}

func.def @pythonic_calls(%response: buffer) -> (buffer) {
  %origin = index.constant 0 : offset
  %c1 = index.constant 1 : offset
  %c16 = index.constant 16 : offset
  %c64 = index.constant 64 : offset
  %false = scalar.constant false : i1
  %true = scalar.constant true : i1
  %comma = scalar.constant 44 : i32
  %open_bracket = scalar.constant 91 : i32
  %close_bracket = scalar.constant 93 : i32
  %length = buffer.length %response
  %l2 = index.add %length, %length : offset
  %l4 = index.add %l2, %l2 : offset
  %l8 = index.add %l4, %l4 : offset
  %l16 = index.add %l8, %l8 : offset
  %l32 = index.add %l16, %l16 : offset
  %capacity = index.add %l32, %c64 : offset
  %args_capacity = index.add %l4, %c16 : offset
  %output = buffer.alloca<private> align(1) %capacity : buffer
  %args = buffer.alloca<private> align(1) %args_capacity : buffer
  buffer.store.i8 %open_bracket, %output[%origin]
  %marker = global.load @text_tool_marker : buffer
  %list_end = global.load @call_end : buffer
  %marker_length = buffer.length %marker
  %list_end_length = buffer.length %list_end
  %record_open = global.load @record_open : buffer
  %record_middle = global.load @record_middle : buffer
  %record_close = global.load @record_close : buffer
  %final_p, %final_o, %final_first, %final_inside = scf.while(%p = %origin : offset, %o = %c1 : offset, %first = %true : i1, %inside = %false : i1) -> (offset, offset, i1, i1) {
    %more = index.cmp ult, %p, %length : offset
    scf.condition %more, %p, %o, %first, %inside : i1, offset, offset, i1, i1
  } do(%p: offset, %o: offset, %first: i1, %inside: i1) {
    %at_open = func.call @starts_at(%response, %p, %marker) : (buffer, offset, buffer) -> (i1)
    %at_close = func.call @starts_at(%response, %p, %list_end) : (buffer, offset, buffer) -> (i1)
    %byte = buffer.load.i8.u %response[%p]
    %name = func.call @name_byte(%byte) : (i32) -> (i1)
    %begins = scalar.andi %inside, %name : i1
    %np, %no, %nfirst, %ninside = scf.if %at_open -> (offset, offset, i1, i1) {
      %skip = index.add %p, %marker_length : offset
      scf.yield %skip, %o, %first, %true : offset, offset, i1, i1
    } else {
      %p1, %o1, %f1, %in1 = scf.if %at_close -> (offset, offset, i1, i1) {
        %skip = index.add %p, %list_end_length : offset
        scf.yield %skip, %o, %first, %false : offset, offset, i1, i1
      } else {
        %p2, %o2, %f2, %in2 = scf.if %begins -> (offset, offset, i1, i1) {
          %call_end, %complete, %name_end, %args_length = func.call @py_call(%response, %p, %length, %args) : (buffer, offset, offset, buffer) -> (offset, i1, offset, offset)
          %written, %next_first = scf.if %complete -> (offset, i1) {
            %separated = scf.if %first -> (offset) {
              scf.yield %o : offset
            } else {
              buffer.store.i8 %comma, %output[%o]
              %after = index.add %o, %c1 : offset
              scf.yield %after : offset
            }
            %after_open = func.call @tool_append(%output, %separated, %record_open) : (buffer, offset, buffer) -> (offset)
            %after_name = func.call @json_escape(%response, %p, %name_end, %output, %after_open) : (buffer, offset, offset, buffer, offset) -> (offset)
            %after_middle = func.call @tool_append(%output, %after_name, %record_middle) : (buffer, offset, buffer) -> (offset)
            %after_args = func.call @json_escape(%args, %origin, %args_length, %output, %after_middle) : (buffer, offset, offset, buffer, offset) -> (offset)
            %after_record = func.call @tool_append(%output, %after_args, %record_close) : (buffer, offset, buffer) -> (offset)
            scf.yield %after_record, %false : offset, i1
          } else {
            scf.yield %o, %first : offset, i1
          }
          scf.yield %call_end, %written, %next_first, %inside : offset, offset, i1, i1
        } else {
          %step = index.add %p, %c1 : offset
          scf.yield %step, %o, %first, %inside : offset, offset, i1, i1
        }
        scf.yield %p2, %o2, %f2, %in2 : offset, offset, i1, i1
      }
      scf.yield %p1, %o1, %f1, %in1 : offset, offset, i1, i1
    }
    scf.yield %np, %no, %nfirst, %ninside : offset, offset, i1, i1
  }
  buffer.store.i8 %close_bracket, %output[%final_o]
  %used = index.add %final_o, %c1 : offset
  %result = func.call @slice(%output, %origin, %used) : (buffer, offset, offset) -> (buffer)
  func.return %result : buffer
}

// The host supplies the reserved suffix that starts at the first call marker.
// %truncated is 1 when generation hit its token limit without EOS.
func.def public @parse_tools(%schemas: buffer, %response: buffer, %truncated: i64) -> (buffer) {
  %c0 = index.constant 0 : offset
  %zero64 = scalar.constant 0 : i64
  %length = buffer.length %response
  %has_text = index.cmp ne, %length, %c0 : offset
  %schema_fields, %schema_type, %schema_count = func.call @members(%schemas) : (buffer) -> (buffer, i32, i64)
  %has_tools = scalar.cmpi ne, %schema_count, %zero64 : i64
  %parse = scalar.andi %has_text, %has_tools : i1
  %calls = scf.if %parse -> (buffer) {
    %format = scalar.constant 2 : i32
    %hermes = scalar.constant 1 : i32
    %glm = scalar.constant 3 : i32
    %is_hermes = scalar.cmpi eq, %format, %hermes : i32
    %is_glm = scalar.cmpi eq, %format, %glm : i32
    %parsed = scf.if %is_hermes -> (buffer) {
      %records = func.call @hermes_calls(%response) : (buffer) -> (buffer)
      scf.yield %records : buffer
    } else {
     %pythonic = scalar.constant 4 : i32
     %is_pythonic = scalar.cmpi eq, %format, %pythonic : i32
     %other = scf.if %is_pythonic -> (buffer) {
      %py_records = func.call @pythonic_calls(%response) : (buffer) -> (buffer)
      scf.yield %py_records : buffer
     } else {
      %complete = func.call @through_last_call(%response) : (buffer) -> (buffer)
      %xml = scf.if %is_glm -> (buffer) {
        %converted = func.call @glm_calls_to_xml(%complete) : (buffer) -> (buffer)
        scf.yield %converted : buffer
      } else {
        scf.yield %complete : buffer
      }
      %records = func.call @parse_xml(%schemas, %xml, %truncated) : (buffer, buffer, i64) -> (buffer)
      scf.yield %records : buffer
     }
     scf.yield %other : buffer
    }
    scf.yield %parsed : buffer
  } else {
    %none = global.load @no_tools : buffer
    scf.yield %none : buffer
  }
  func.return %calls : buffer
}

// The host supplies the previous raw prediction separately. On EOS it replaces
// the first assistant delimiter in this suffix; an open response consumes its
// last ordinary token before that delimiter. Full replay encodes both normally.
// Encodes the rendered conversation with special-token matching enabled.
func.def @plain_prepare_input(%text: buffer, %markers: buffer, %marker_count: i64, %format: i32, %boundary: i32, %capacity: i64) -> (buffer, i64, buffer) {
  %c0 = index.constant 0 : offset
  %c0_i32 = scalar.constant 0 : i32
  %c0_i64 = scalar.constant 0 : i64
  %c1_i64 = scalar.constant 1 : i64
  %no_markers = scalar.cmpi eq, %marker_count, %c0_i64 : i64
  func.call @check(%no_markers) : (i1)
  %probe = scalar.addi %capacity, %c1_i64 : i64
  %tokens, %count = func.call @encode(%text, %c0_i32, %probe) : (buffer, i32, i64) -> (buffer, i64)
  %fits = scalar.cmpi ule, %count, %capacity : i64
  %fits32 = scalar.extui %fits : i1 to i32
  %error = global.load @overflow : buffer
  func.call @require(%fits32, %error) : (i32, buffer)
  %spans = buffer.alloca<private> align(4) %c0 : buffer
  func.return %tokens, %count, %spans : buffer, i64, buffer
}

global.rodata.def @text_think_end = bytes("3c2f7468696e6b3e")

global.rodata.def @text_tool_marker = bytes("3c746f6f6c5f63616c6c3e")

func.def @text_until(%response: buffer, %marker: buffer, %previous: i64, %phase: i32) -> (i64) {
  %c0 = index.constant 0 : offset
  %c1 = index.constant 1 : offset
  %zero32 = scalar.constant 0 : i32
  %false = scalar.constant false : i1
  %length = buffer.length %response
  %marker_length = buffer.length %marker
  // The owner supplies the last extent returned for this growing response.
  %previous_value = scalar.assume %previous [range(%previous, 0, 9223372036854775807)] : i64
  %start = index.cast %previous_value : i64 to offset
  %streaming = scalar.cmpi eq, %phase, %zero32 : i32
  %end = scf.while(%position = %start : offset) -> (offset) {
    %has_bytes = index.cmp ult, %position, %length : offset
    %advance = scf.if %has_bytes -> (i1) {
      %remaining = index.sub %length, %position : offset
      %short = index.cmp ult, %remaining, %marker_length : offset
      %count = scf.select %short, %remaining, %marker_length : offset
      %comparison = buffer.compare %response[%position], %marker[%c0], %count
      %mismatch = scalar.cmpi ne, %comparison, %zero32 : i32
      %complete_marker = index.cmp uge, %remaining, %marker_length : offset
      %withhold = scalar.ori %streaming, %complete_marker : i1
      %release_fragment = scalar.cmpi eq, %withhold, %false : i1
      %advance = scalar.ori %mismatch, %release_fragment : i1
      scf.yield %advance : i1
    } else {
      scf.yield %false : i1
    }
    scf.condition %advance, %position : i1, offset
  } do(%position: offset) {
    %next = index.add %position, %c1 : offset
    scf.yield %next : offset
  }
  %result = index.cast %end : offset to i64
  func.return %result : i64
}

// State 1 is an open reasoning block; state 2 consumes its trailing whitespace.
// Content (state 0) stops at the call marker (without the separator, @content_until):
// the rest goes to parse_tools.
// (Adapted from hrx-loom-library program/text/qwen3_8/chat.loom.)
func.def public @output_next(%response: buffer, %previous: i64, %state: i64, %phase: i32) -> (i64, i64, i64, i64) {
  %c0_i64 = scalar.constant 0 : i64
  %c1_i64 = scalar.constant 1 : i64
  %c2_i64 = scalar.constant 2 : i64
  %origin = index.constant 0 : offset
  %step = index.constant 1 : offset
  %thinking = scalar.cmpi eq, %state, %c1_i64 : i64
  %spacing = scalar.cmpi eq, %state, %c2_i64 : i64
  %kind, %begin, %end, %next = scf.if %spacing -> (i64, i64, i64, i64) {
    %start_value = scalar.assume %previous [range(%previous, 0, 9223372036854775807)] : i64
    %start = index.cast %start_value : i64 to offset
    %length = buffer.length %response
    %false = scalar.constant false : i1
    %stop = scf.while(%position = %start : offset) -> (offset) {
      %available = index.cmp ult, %position, %length : offset
      %space = scf.if %available -> (i1) {
        %value = func.call @text_is_space(%response, %position) : (buffer, offset) -> (i1)
        scf.yield %value : i1
      } else {
        scf.yield %false : i1
      }
      scf.condition %space, %position : i1, offset
    } do(%position: offset) {
      %following = index.add %position, %step : offset
      scf.yield %following : offset
    }
    %start_text = index.cast %stop : offset to i64
    %end, %skip = func.call @content_until(%response, %start_text, %phase) : (buffer, i64, i32) -> (i64, i64)
    %has_text = scalar.cmpi ne, %end, %start_text : i64
    %next = scf.select %has_text, %c0_i64, %state : i64
    scf.yield %c1_i64, %start_text, %end, %next : i64, i64, i64, i64
  } else {
    %kind, %end, %next = scf.if %thinking -> (i64, i64, i64) {
      %marker = global.load @text_think_end : buffer
      %stop = func.call @text_until(%response, %marker, %previous, %phase) : (buffer, buffer, i64, i32) -> (i64)
      %at_marker = scalar.cmpi eq, %stop, %previous : i64
      %length_offset = buffer.length %response
      %length = index.cast %length_offset : offset to i64
      %remaining = scalar.subi %length, %stop : i64
      %marker_length_offset = buffer.length %marker
      %marker_length = index.cast %marker_length_offset : offset to i64
      %complete = scalar.cmpi uge, %remaining, %marker_length : i64
      %consume = scalar.andi %at_marker, %complete : i1
      %after = scalar.addi %stop, %marker_length : i64
      %reasoning_end = scf.select %consume, %after, %stop : i64
      %reasoning_next = scf.select %consume, %c2_i64, %state : i64
      %reasoning_kind = scf.select %consume, %c0_i64, %c2_i64 : i64
      scf.yield %reasoning_kind, %reasoning_end, %reasoning_next : i64, i64, i64
    } else {
      // The separator before a call is consumed without output (kind 0) once only it is left.
      %emit, %skip = func.call @content_until(%response, %previous, %phase) : (buffer, i64, i32) -> (i64, i64)
      %held = scalar.cmpi eq, %emit, %previous : i64
      %skips = scalar.cmpi ne, %skip, %emit : i64
      %consume = scalar.andi %held, %skips : i1
      %content_kind = scf.select %consume, %c0_i64, %c1_i64 : i64
      %content_end = scf.select %consume, %skip, %emit : i64
      scf.yield %content_kind, %content_end, %state : i64, i64, i64
    }
    scf.yield %kind, %previous, %end, %next : i64, i64, i64, i64
  }
  func.return %kind, %begin, %end, %next : i64, i64, i64, i64
}

// Content from %start: (end of the bytes to emit, end of the bytes to consume). Content stops at the
// call marker without the content/call separator the template prints between them (it renders
// content + separator + calls, so the separator is call framing: keeping it in the content doubled it
// in the next turn's rendering, and canonical history never matched the output). While streaming,
// trailing whitespace is withheld until it is known not to precede a call. No separator: unchanged.
func.def @content_until(%response: buffer, %start: i64, %phase: i32) -> (i64, i64) {
  %c0 = index.constant 0 : offset
  %c0_i64 = scalar.constant 0 : i64
  %zero32 = scalar.constant 0 : i32
  %false = scalar.constant false : i1
  %marker = global.load @text_tool_marker : buffer
  %stop = func.call @text_until(%response, %marker, %start, %phase) : (buffer, buffer, i64, i32) -> (i64)
  %separator = global.load @content_call_separator : buffer
  %separator_length_offset = buffer.length %separator
  %separator_length = index.cast %separator_length_offset : offset to i64
  %has_separator = scalar.cmpi ne, %separator_length, %c0_i64 : i64
  %length_offset = buffer.length %response
  %length = index.cast %length_offset : offset to i64
  %remaining = scalar.subi %length, %stop : i64
  %marker_length_offset = buffer.length %marker
  %marker_length = index.cast %marker_length_offset : offset to i64
  %complete = scalar.cmpi uge, %remaining, %marker_length : i64
  %inside = scalar.cmpi ult, %stop, %length : i64
  %found = scalar.andi %complete, %inside : i1
  %start_value = scalar.assume %start [range(%start, 0, 9223372036854775807)] : i64
  %start_offset = index.cast %start_value : i64 to offset
  %stop_value = scalar.assume %stop [range(%stop, 0, 9223372036854775807)] : i64
  %stop_offset = index.cast %stop_value : i64 to offset
  %run_offset = func.call @trim_end(%response, %start_offset, %stop_offset) : (buffer, offset, offset) -> (offset)
  %run = index.cast %run_offset : offset to i64
  %run_length = scalar.subi %stop, %run : i64
  %fits = scalar.cmpi uge, %run_length, %separator_length : i64
  %framed = scalar.andi %has_separator, %found : i1
  %candidate = scalar.andi %framed, %fits : i1
  %separator_begin = scalar.subi %stop, %separator_length : i64
  %matches = scf.if %candidate -> (i1) {
    %begin_value = scalar.assume %separator_begin [range(%separator_begin, 0, 9223372036854775807)] : i64
    %begin_offset = index.cast %begin_value : i64 to offset
    %order = buffer.compare %response[%begin_offset], %separator[%c0], %separator_length_offset
    %equal = scalar.cmpi eq, %order, %zero32 : i32
    scf.yield %equal : i1
  } else {
    scf.yield %false : i1
  }
  %streaming = scalar.cmpi eq, %phase, %zero32 : i32
  %unknown = scalar.cmpi eq, %found, %false : i1
  %pending = scalar.andi %streaming, %unknown : i1
  %hold = scalar.andi %has_separator, %pending : i1
  %cut = scf.select %matches, %separator_begin, %stop : i64
  %emit = scf.select %hold, %run, %cut : i64
  %skip = scf.select %matches, %stop, %emit : i64
  func.return %emit, %skip : i64, i64
}

// Canonical history of this turn, as chat_message would render it: prompt +
// [trimmed reasoning + think close] + content (trimmed when the template trims it) + [separator] + calls + suffix.
// Device state is reusable only when the generated part (without the suffix,
// which the next input appends) is byte-identical to the actual output and the
// response did not end inside reasoning. (Adapted from qwen3_8/chat.loom.)
func.def public @complete_text(%prompt: buffer, %response: buffer, %raw_content: buffer, %reasoning: buffer, %tools: buffer, %initial_state: i64, %final_state: i64) -> (buffer, i32) {
  %c0 = index.constant 0 : offset
  %c1_i64 = scalar.constant 1 : i64
  %empty = global.load @empty : buffer
  %thinking = scalar.cmpi eq, %initial_state, %c1_i64 : i64
  %prefix = scf.if %thinking -> (buffer) {
    %thought = func.call @trim(%reasoning) : (buffer) -> (buffer)
    %close = global.load @think_close : buffer
    %value = func.call @join4(%prompt, %thought, %close, %empty) : (buffer, buffer, buffer, buffer) -> (buffer)
    scf.yield %value : buffer
  } else {
    scf.yield %prompt : buffer
  }
  %trim_content = scalar.constant true : i1
  %content = scf.if %trim_content -> (buffer) {
    %value = func.call @trim(%raw_content) : (buffer) -> (buffer)
    scf.yield %value : buffer
  } else {
    scf.yield %raw_content : buffer
  }
  %content_length = buffer.length %content
  %has_content = index.cmp ne, %content_length, %c0 : offset
  %tools_length = buffer.length %tools
  %has_calls = index.cmp ne, %tools_length, %c0 : offset
  %separate = scalar.andi %has_content, %has_calls : i1
  %separator_value = global.load @content_call_separator : buffer
  %separator = scf.select %separate, %separator_value, %empty : buffer
  %suffix = global.load @message_suffix : buffer
  %close_value = global.load @calls_close : buffer
  %close = scf.select %has_calls, %close_value, %empty : buffer
  %head = func.call @join4(%prefix, %content, %separator, %tools) : (buffer, buffer, buffer, buffer) -> (buffer)
  %answer = func.call @join(%head, %close) : (buffer, buffer) -> (buffer)
  %closed = scalar.cmpi ne, %final_state, %c1_i64 : i64
  %history_suffix = global.load @history_suffix : buffer
  %turn_suffix = scf.select %closed, %history_suffix, %suffix : buffer
  %suffixed = func.call @join(%answer, %turn_suffix) : (buffer, buffer) -> (buffer)
  %stop_calls = global.load @stop_after_calls : buffer
  %stop_answer = global.load @stop_after_answer : buffer
  %stop_kind = scf.select %has_calls, %stop_calls, %stop_answer : buffer
  %stop = scf.select %closed, %stop_kind, %empty : buffer
  %result = func.call @join(%suffixed, %stop) : (buffer, buffer) -> (buffer)
  %prompt_length = buffer.length %prompt
  %answer_length = buffer.length %answer
  %generated_length = index.sub %answer_length, %prompt_length : offset
  %response_length = buffer.length %response
  %same_length = index.cmp eq, %generated_length, %response_length : offset
  %identical = scf.if %same_length -> (i1) {
    %zero32 = scalar.constant 0 : i32
    %order = buffer.compare %answer[%prompt_length], %response[%c0], %response_length
    %equal = scalar.cmpi eq, %order, %zero32 : i32
    scf.yield %equal : i1
  } else {
    %false = scalar.constant false : i1
    scf.yield %false : i1
  }
  %compatible = scalar.andi %closed, %identical : i1
  %reusable = scalar.extui %compatible : i1 to i32
  func.return %result, %reusable : buffer, i32
}

func.def public @encode_state(%bindings: buffer, %count: i32, %origins: buffer) {
  %origin = index.constant 0 : offset
  %c0 = index.constant 0 : index
  %c1 = index.constant 1 : index
  %bounded_count = scalar.assume %count [range(%count, 1, 2147483647)] : i32
  %length = index.cast %bounded_count : i32 to index
  %origin_length = buffer.length %origins
  %origin_length64 = index.cast %origin_length : offset to i64
  %stride = scalar.constant 40 : i64
  %capacity64 = scalar.divui %origin_length64, %stride : i64
  %bounded_capacity = scalar.assume %capacity64 [range(%capacity64, 1, 2147483647)] : i64
  %capacity = index.cast %bounded_capacity : i64 to index
  %records = buffer.view %bindings[%origin] : buffer -> view<[%length]x4xi64>
  %rows = buffer.view %origins[%origin] : buffer -> view<[%capacity]x5xi64>
  scf.for %i = [%c0 to %length step %c1] {
    %row64 = view.load %records[%i, 0] : view<[%length]x4xi64> -> i64
    %row_bound = scalar.assume %row64 [range(%row64, 0, 2147483646)] : i64
    %row_value = index.cast %row_bound : i64 to index
    %row = index.assume %row_value [lt(%row_value, %capacity)] : index
    %read = view.load %records[%i, 1] : view<[%length]x4xi64> -> i64
    %write = view.load %records[%i, 2] : view<[%length]x4xi64> -> i64
    %position = view.load %records[%i, 3] : view<[%length]x4xi64> -> i64
    view.store %read, %rows[%row, 0] : i64, view<[%capacity]x5xi64>
    view.store %write, %rows[%row, 1] : i64, view<[%capacity]x5xi64>
    view.store %position, %rows[%row, 3] : i64, view<[%capacity]x5xi64>
  }
  func.return
}

// Opaque output deliberately gathers the two halves of each retained hidden
// word in reverse order. Native serving preserves bytes, not tensor types.
func.def public @capture_epoch(%state: buffer, %shape: i32, %count: i32, %plan: buffer) -> (buffer) {
  %origin = index.constant 0 : offset
  %c0 = index.constant 0 : index
  %c1 = index.constant 1 : index
  %bounded = scalar.assume %count [range(%count, 1, 2147483647)] : i32
  %spans = index.cast %bounded : i32 to index
  %count64 = scalar.extui %bounded : i32 to i64
  %record_bytes = scalar.constant 48 : i64
  %bytes64 = scalar.muli %count64, %record_bytes : i64
  %bounded_bytes = scalar.assume %bytes64 [range(%bytes64, 48, 103079215056)] : i64
  %length = index.cast %bounded_bytes : i64 to offset
  %storage = buffer.alloca<private> align(8) %length : buffer
  %records = buffer.view %storage[%origin] : buffer -> view<[%spans]x2x3xi64>
  %half = scalar.constant 2 : i64
  %word = scalar.constant 4 : i64
  scf.for %i = [%c0 to %spans step %c1] {
    %span = index.cast %i : index to i64
    %low = scalar.muli %span, %word : i64
    %high = scalar.addi %low, %half : i64
    view.store %span, %records[%i, 0, 0] : i64, view<[%spans]x2x3xi64>
    view.store %high, %records[%i, 0, 1] : i64, view<[%spans]x2x3xi64>
    view.store %half, %records[%i, 0, 2] : i64, view<[%spans]x2x3xi64>
    view.store %span, %records[%i, 1, 0] : i64, view<[%spans]x2x3xi64>
    view.store %low, %records[%i, 1, 1] : i64, view<[%spans]x2x3xi64>
    view.store %half, %records[%i, 1, 2] : i64, view<[%spans]x2x3xi64>
  }
  func.return %storage : buffer
}

func.def @plan_capacity(%plan: buffer) -> (index) {
  %bytes = buffer.length %plan
  %bytes64 = index.cast %bytes : offset to i64
  %stride = scalar.constant 36 : i64
  %records = scalar.divui %bytes64, %stride : i64
  %bounded = scalar.assume %records [range(%records, 1, 2147483647)] : i64
  %capacity = index.cast %bounded : i64 to index
  func.return %capacity : index
}

func.def @encode_mixed_plan(%plan: buffer, %inputs: buffer, %record_begin: index, %span_count: i32, %input_count: i32, %packet_capacity: i32, %packet: buffer) {
  %origin = index.constant 0 : offset
  %c0 = index.constant 0 : index
  %c1 = index.constant 1 : index
  %bounded_span_count = scalar.assume %span_count [range(%span_count, 0, 2147483647)] : i32
  %span_extent = index.cast %bounded_span_count : i32 to index
  %bounded_input_count = scalar.assume %input_count [range(%input_count, 1, 524288)] : i32
  %input_extent = index.cast %bounded_input_count : i32 to index
  %bounded_packet_capacity = scalar.assume %packet_capacity [range(%packet_capacity, 1, 524288)] : i32
  %packet_extent = index.cast %bounded_packet_capacity : i32 to index
  %plan_extent = func.call @plan_capacity(%plan) : (buffer) -> (index)
  %requests = buffer.view %plan[%origin] : buffer -> view<[%plan_extent]x9xi32>
  %ids = buffer.view %inputs[%origin] : buffer -> view<[%input_extent]xi32>
  %records = buffer.view %packet[%origin] : buffer -> view<[%packet_extent]x8xi32>
  scf.for %i = [%c0 to %span_extent step %c1] {
    %request_value = index.add %record_begin, %i : index
    %request = index.assume %request_value [range(%request_value, 0, 2147483646), lt(%request_value, %plan_extent)] : index
    %input_begin32 = view.load %requests[%request, 4] : view<[%plan_extent]x9xi32> -> i32
    %input_length32 = view.load %requests[%request, 5] : view<[%plan_extent]x9xi32> -> i32
    %bounded_begin = scalar.assume %input_begin32 [range(%input_begin32, 0, 524287)] : i32
    %bounded_length = scalar.assume %input_length32 [range(%input_length32, 0, 524288)] : i32
    %input_begin = index.cast %bounded_begin : i32 to index
    %input_length = index.cast %bounded_length : i32 to index
    scf.for %j = [%c0 to %input_length step %c1] {
      %position = index.add %input_begin, %j : index
      %input_position = index.assume %position [lt(%position, %input_extent)] : index
      %packet_position = index.assume %position [lt(%position, %packet_extent)] : index
      %token = view.load %ids[%input_position] : view<[%input_extent]xi32> -> i32
      view.store %token, %records[%packet_position, 0] : i32, view<[%packet_extent]x8xi32>
    }
  }
  func.return
}

func.def @encode_mixed_media(%plan: buffer, %media_plan: buffer, %media_count: i32, %packet_capacity: i32, %packet: buffer) {
  %origin = index.constant 0 : offset
  %c0 = index.constant 0 : index
  %c1 = index.constant 1 : index
  %bounded_media_count = scalar.assume %media_count [range(%media_count, 1, 524288)] : i32
  %media_extent = index.cast %bounded_media_count : i32 to index
  %bounded_packet_capacity = scalar.assume %packet_capacity [range(%packet_capacity, 1, 524288)] : i32
  %packet_extent = index.cast %bounded_packet_capacity : i32 to index
  %plan_extent = func.call @plan_capacity(%plan) : (buffer) -> (index)
  %requests = buffer.view %plan[%origin] : buffer -> view<[%plan_extent]x9xi32>
  %media = buffer.view %media_plan[%origin] : buffer -> view<[%media_extent]x7xi32>
  %records = buffer.view %packet[%origin] : buffer -> view<[%packet_extent]x8xi32>
  scf.for %i = [%c0 to %media_extent step %c1] {
    %plan_index32 = view.load %media[%i, 0] : view<[%media_extent]x7xi32> -> i32
    %relative32 = view.load %media[%i, 1] : view<[%media_extent]x7xi32> -> i32
    %feature_offset = view.load %media[%i, 2] : view<[%media_extent]x7xi32> -> i32
    %feature_length = view.load %media[%i, 3] : view<[%media_extent]x7xi32> -> i32
    %feature_index = view.load %media[%i, 6] : view<[%media_extent]x7xi32> -> i32
    %plan_index_bound = scalar.assume %plan_index32 [range(%plan_index32, 0, 2147483646)] : i32
    %plan_index_value = index.cast %plan_index_bound : i32 to index
    %bounded_relative = scalar.assume %relative32 [range(%relative32, 0, 524287)] : i32
    %plan_index = index.assume %plan_index_value [lt(%plan_index_value, %plan_extent)] : index
    %relative = index.cast %bounded_relative : i32 to index
    %input_begin32 = view.load %requests[%plan_index, 4] : view<[%plan_extent]x9xi32> -> i32
    %bounded_begin = scalar.assume %input_begin32 [range(%input_begin32, 0, 524287)] : i32
    %input_begin = index.cast %bounded_begin : i32 to index
    %position = index.add %input_begin, %relative : index
    %packet_position = index.assume %position [lt(%position, %packet_extent)] : index
    view.store %feature_offset, %records[%packet_position, 1] : i32, view<[%packet_extent]x8xi32>
    view.store %feature_length, %records[%packet_position, 2] : i32, view<[%packet_extent]x8xi32>
    view.store %feature_index, %records[%packet_position, 3] : i32, view<[%packet_extent]x8xi32>
  }
  func.return
}

// Device packets retain the first cohort's nine-field plan records. Feedback
// slots are span-indexed, including unselected input-only spans.
func.def @plain_encode_epoch(%control_state: buffer, %plan: buffer, %inputs: buffer, %media_plan: buffer, %first_count: i32, %next_count: i32, %input_count: i32, %first_media_count: i32, %next_media_count: i32, %first_packet_capacity: i32, %next_packet_capacity: i32, %eos: i32, %metadata: buffer, %tokens: buffer) -> (i32, buffer, i64, i64) {
  %origin = index.constant 0 : offset
  %header_bytes = index.constant 16 : offset
  %count64 = scalar.extui %first_count : i32 to i64
  %record_bytes = scalar.constant 36 : i64
  %plan_length = scalar.muli %count64, %record_bytes : i64
  %plan_bytes = index.cast %plan_length : i64 to offset
  %header = buffer.view %metadata[%origin] : buffer -> view<4xi32>
  %c0 = scalar.constant 0 : i32
  view.store %first_count, %header[0] : i32, view<4xi32>
  view.store %eos, %header[1] : i32, view<4xi32>
  %vision_media = scalar.addi %first_media_count, %next_media_count : i32
  %vision_has = scalar.cmpi ne, %vision_media, %c0 : i32
  %vision_flag = scalar.extui %vision_has : i1 to i32
  view.store %vision_flag, %header[2] : i32, view<4xi32>
  view.store %c0, %header[3] : i32, view<4xi32>
  buffer.copy %plan[%origin], %metadata[%header_bytes], %plan_bytes
  // Device copy only: span fields 2, 5, 7, 8 carry the row's sampling record
  // (temperature, top_p, top_k, seed); the kernels never read the originals.
  %state_length = buffer.length %control_state
  %sampling_header = index.constant 2048 : offset
  %sampling_stride = index.constant 16 : offset
  %span_stride = index.constant 36 : offset
  %c0_span = index.constant 0 : index
  %c1_span = index.constant 1 : index
  %bounded_first = scalar.assume %first_count [range(%first_count, 0, 8192)] : i32
  %span_extent = index.cast %bounded_first : i32 to index
  scf.for %s = [%c0_span to %span_extent step %c1_span] {
    %span_at = index.scale %s, %span_stride : index, offset -> offset
    %row_at = index.constant 12 : offset
    %row_field = index.add %span_at, %row_at : offset
    %row_view = buffer.view %plan[%row_field] : buffer -> view<1xi32>
    %row32 = view.load %row_view[0] : view<1xi32> -> i32
    %row_bound = scalar.assume %row32 [range(%row32, 0, 1048575)] : i32
    %row_index = index.cast %row_bound : i32 to index
    %record_rel = index.scale %row_index, %sampling_stride : index, offset -> offset
    %record_at = index.add %sampling_header, %record_rel : offset
    %record_end = index.add %record_at, %sampling_stride : offset
    %has_record = index.cmp ule, %record_end, %state_length : offset
    %packet_at = index.add %header_bytes, %span_at : offset
    %packet = buffer.view %metadata[%packet_at] : buffer -> view<9xi32>
    scf.if %has_record {
      %record = buffer.view %control_state[%record_at] : buffer -> view<4xi32>
      %temperature = view.load %record[0] : view<4xi32> -> i32
      %top_p = view.load %record[1] : view<4xi32> -> i32
      %top_k = view.load %record[2] : view<4xi32> -> i32
      %seed = view.load %record[3] : view<4xi32> -> i32
      view.store %temperature, %packet[2] : i32, view<9xi32>
      view.store %top_p, %packet[5] : i32, view<9xi32>
      view.store %top_k, %packet[7] : i32, view<9xi32>
      view.store %seed, %packet[8] : i32, view<9xi32>
    } else {
      view.store %c0, %packet[2] : i32, view<9xi32>
    }
  }
  %media_count = scalar.addi %first_media_count, %next_media_count : i32
  %has_media = scalar.cmpi ne, %media_count, %c0 : i32
  %input_count64 = scalar.extui %input_count : i32 to i64
  %token_stride = scalar.constant 4 : i64
  %packet_stride = scalar.constant 32 : i64
  %stride = scf.select %has_media, %packet_stride, %token_stride : i64
  %input_length = scalar.muli %input_count64, %stride : i64
  %input_bytes = index.cast %input_length : i64 to offset
  scf.if %has_media {
    // Ordinary records need zero feature fields; inactive capacity is not read.
    buffer.fill %c0, %tokens[%origin], %input_bytes : i32
    %packet_capacity = scalar.addi %first_packet_capacity, %next_packet_capacity : i32
    %c0_index = index.constant 0 : index
    func.call @encode_mixed_plan(%plan, %inputs, %c0_index, %first_count, %input_count, %packet_capacity, %tokens) : (buffer, buffer, index, i32, i32, i32, buffer)
    %has_next = scalar.cmpi ne, %next_count, %c0 : i32
    scf.if %has_next {
      %bounded_first = scalar.assume %first_count [range(%first_count, 1, 2147483647)] : i32
      %next_begin = index.cast %bounded_first : i32 to index
      func.call @encode_mixed_plan(%plan, %inputs, %next_begin, %next_count, %input_count, %packet_capacity, %tokens) : (buffer, buffer, index, i32, i32, i32, buffer)
    }
    func.call @encode_mixed_media(%plan, %media_plan, %media_count, %packet_capacity, %tokens) : (buffer, buffer, i32, i32, buffer)
  } else {
    buffer.copy %inputs[%origin], %tokens[%origin], %input_bytes
  }
  // M-RoPE: per-span source-position offset after the plan; media records carry (t, h, w)
  %mr_total = scalar.addi %first_count, %next_count : i32
  %mr_total_b = scalar.assume %first_count [range(%first_count, 0, 8192)] : i32
  %mr_spans = index.cast %mr_total_b : i32 to index
  %mr_plan_extent = func.call @plan_capacity(%plan) : (buffer) -> (index)
  %mr_requests = buffer.view %plan[%origin] : buffer -> view<[%mr_plan_extent]x9xi32>
  %mr_table_at = index.add %header_bytes, %plan_bytes : offset
  %mr_table = buffer.view %metadata[%mr_table_at] : buffer -> view<[%mr_spans]xi32>
  %mr_c0 = index.constant 0 : index
  %mr_c1 = index.constant 1 : index
  scf.for %mr_s = [%mr_c0 to %mr_spans step %mr_c1] {
    %mr_r = index.assume %mr_s [lt(%mr_s, %mr_plan_extent)] : index
    %mr_pos = view.load %mr_requests[%mr_r, 1] : view<[%mr_plan_extent]x9xi32> -> i32
    %mr_src = view.load %mr_requests[%mr_r, 2] : view<[%mr_plan_extent]x9xi32> -> i32
    %mr_delta = scalar.subi %mr_src, %mr_pos : i32
    view.store %mr_delta, %mr_table[%mr_s] : i32, view<[%mr_spans]xi32>
  }
  scf.if %has_media {
    %mr_cap = scalar.addi %first_packet_capacity, %next_packet_capacity : i32
    func.call @vision_mrope_records(%plan, %media_plan, %media_count, %mr_cap, %tokens, %mr_total) : (buffer, buffer, i32, i32, buffer, i32)
  }
  %transfer_offset = index.constant 8 : offset
  %transfers = buffer.view %control_state[%transfer_offset] : buffer -> view<2x5xi64>
  %zero64 = scalar.constant 0 : i64
  %one64 = scalar.constant 1 : i64
  %header_length = scalar.constant 16 : i64
  %mr_four64 = scalar.constant 4 : i64
  %mr_table_length = scalar.muli %count64, %mr_four64 : i64
  %metadata_plan_length = scalar.addi %header_length, %plan_length : i64
  %metadata_length = scalar.addi %metadata_plan_length, %mr_table_length : i64
  view.store %zero64, %transfers[0, 0] : i64, view<2x5xi64>
  view.store %zero64, %transfers[0, 1] : i64, view<2x5xi64>
  view.store %zero64, %transfers[0, 2] : i64, view<2x5xi64>
  view.store %zero64, %transfers[0, 3] : i64, view<2x5xi64>
  view.store %metadata_length, %transfers[0, 4] : i64, view<2x5xi64>
  view.store %one64, %transfers[1, 0] : i64, view<2x5xi64>
  view.store %zero64, %transfers[1, 1] : i64, view<2x5xi64>
  view.store %one64, %transfers[1, 2] : i64, view<2x5xi64>
  view.store %zero64, %transfers[1, 3] : i64, view<2x5xi64>
  view.store %input_length, %transfers[1, 4] : i64, view<2x5xi64>
  %transfer_begin = scalar.constant 8 : i64
  %transfer_length = scalar.constant 80 : i64
  func.return %first_count, %control_state, %transfer_begin, %transfer_length : i32, buffer, i64, i64
}

func.def @plain_publish_epoch(%plan: buffer, %media_plan: buffer, %count: i32, %first_media_count: i32, %next_media_count: i32, %verified: i32, %continues: i32, %next_speculative: buffer, %ordinary: buffer, %first_results: buffer, %next_results: buffer, %progress: buffer) {
  %origin = index.constant 0 : offset
  %c0 = index.constant 0 : index
  %c1 = index.constant 1 : index
  %c0_i32 = scalar.constant 0 : i32
  %c1_i32 = scalar.constant 1 : i32
  %c2_i32 = scalar.constant 2 : i32
  %progress_bytes = buffer.length %progress
  buffer.fill %c0_i32, %progress[%origin], %progress_bytes : i32
  %bounded_count = scalar.assume %count [range(%count, 1, 2147483647)] : i32
  %length = index.cast %bounded_count : i32 to index
  %plan_extent = func.call @plan_capacity(%plan) : (buffer) -> (index)
  %requests = buffer.view %plan[%origin] : buffer -> view<[%plan_extent]x9xi32>
  %outputs = buffer.view %ordinary[%origin] : buffer -> view<[%length]xi32>
  %published = buffer.view %progress[%origin] : buffer -> view<[%length]x21xi32>
  scf.for %i = [%c0 to %length step %c1] {
    %request = index.assume %i [lt(%i, %plan_extent)] : index
    %consumed = view.load %requests[%request, 0] : view<[%plan_extent]x9xi32> -> i32
    %source_position = view.load %requests[%request, 2] : view<[%plan_extent]x9xi32> -> i32
    %mr_saved = func.call @vision_mrope_saved(%media_plan, %first_media_count, %next_media_count, %i) : (buffer, i32, i32, index) -> (i32)
    %source_advance = scalar.subi %consumed, %mr_saved : i32
    %next_source_position = scalar.addi %source_position, %source_advance : i32
    %flags = view.load %requests[%request, 6] : view<[%plan_extent]x9xi32> -> i32
    %bits = scalar.andi %flags, %c1_i32 : i32
    %selected = scalar.cmpi ne, %bits, %c0_i32 : i32
    %selected_count = scalar.extui %selected : i1 to i32
    view.store %consumed, %published[%i, 0] : i32, view<[%length]x21xi32>
    view.store %consumed, %published[%i, 1] : i32, view<[%length]x21xi32>
    view.store %selected_count, %published[%i, 2] : i32, view<[%length]x21xi32>
    view.store %next_source_position, %published[%i, 4] : i32, view<[%length]x21xi32>
    scf.if %selected {
      %token = view.load %outputs[%i] : view<[%length]xi32> -> i32
      view.store %token, %published[%i, 5] : i32, view<[%length]x21xi32>
    }
  }
  func.return
}

func.def public @step(%state: buffer, %initialize: i32, %source_position: i32, %input_count: i32, %residual: hal.buffer, %control: hal.buffer, %recurrent: hal.buffer, %attention: hal.buffer, %tokens: hal.buffer, %progress: hal.buffer) -> (i64, i32) {
  %c0 = scalar.constant 0 : i32
  %c2 = scalar.constant 2 : i32
  %c0_i64 = scalar.constant 0 : i64
  %source_advance = scalar.muli %input_count, %c2 : i32
  %next_source_position = scalar.addi %source_position, %source_advance : i32
  %error = global.load @unsupported : buffer
  func.call @require(%c0, %error) : (i32, buffer)
  func.return %c0_i64, %next_source_position : i64, i32
}

// Selects the stage compiled for this packing shape.
func.def @plain_epoch(%control_state: buffer, %shape: i32, %proposes: i32, %verifies: i32, %span_count: i32, %output_count: i32, %epoch_count: i32, %continuation_shape: i32, %continuation_proposes: i32, %first_media_count: i32, %next_media_count: i32, %residual: hal.buffer, %metadata: hal.buffer, %origins: hal.buffer, %state: hal.buffer, %tokens: hal.buffer, %outputs: hal.buffer, %carry: hal.buffer, %committed: hal.buffer, %results: hal.buffer, %draft_cache: hal.buffer, %draft_origins: hal.buffer, %next_results: hal.buffer) -> (i64) {
  %stage_origin = index.constant 128 : offset
  %bounded_shape = scalar.assume %shape [range(%shape, 0, 127)] : i32
  %shape_index = index.cast %bounded_shape : i32 to index
  %stages = buffer.view %control_state[%stage_origin] : buffer -> view<128xi32>
  %stage = view.load %stages[%shape_index] : view<128xi32> -> i32
  %completion = func.call @execute_6(%stage, %residual, %metadata, %origins, %state, %tokens, %outputs) : (i32, hal.buffer, hal.buffer, hal.buffer, hal.buffer, hal.buffer, hal.buffer) -> (i64)
  %c0 = scalar.constant 0 : i32
  %c0_i64 = scalar.constant 0 : i64
  %c4_i64 = scalar.constant 4 : i64
  %count64 = scalar.extui %span_count : i32 to i64
  %length = scalar.muli %count64, %c4_i64 : i64
  %feedback = func.call @feedback(%c0, %outputs, %c0_i64, %length) : (i32, hal.buffer, i64, i64) -> (i64)
  func.return %completion : i64
}

func.decl @llm_storage(%maximum: i64, %span_capacity: i64, %context: i64, %pool: i64, %rows: i64, %pins: i64, %drafting: i64) -> (buffer, buffer, buffer, buffer, buffer)

func.def public @resize_state(%old_state: buffer, %rows: i64) -> (buffer, buffer, buffer, buffer, buffer, buffer) {
  %origin = index.constant 0 : offset
  %c0_fill = scalar.constant 0 : i32
  %header = index.constant 2048 : offset
  %record_bytes = index.constant 16 : offset
  %bounded_rows = scalar.assume %rows [range(%rows, 1, 1048576)] : i64
  %row_count = index.cast %bounded_rows : i64 to index
  %table = index.scale %row_count, %record_bytes : index, offset -> offset
  %wanted = index.add %header, %table : offset
  %old_length = buffer.length %old_state
  %grow = index.cmp ugt, %wanted, %old_length : offset
  %state = scf.if %grow -> (buffer) {
    %grown = buffer.alloca<private> align(8) %wanted : buffer
    buffer.fill %c0_fill, %grown[%origin], %wanted : i32
    buffer.copy %old_state[%origin], %grown[%origin], %old_length
    scf.yield %grown : buffer
  } else {
    scf.yield %old_state : buffer
  }
  %layout_origin = index.constant 88 : offset
  %layout = buffer.view %state[%layout_origin] : buffer -> view<5xi64>
  %maximum = view.load %layout[0] : view<5xi64> -> i64
  %span_capacity = view.load %layout[1] : view<5xi64> -> i64
  %context = view.load %layout[2] : view<5xi64> -> i64
  %pool = view.load %layout[3] : view<5xi64> -> i64
  %pins = view.load %layout[4] : view<5xi64> -> i64
  %kind_at = index.constant 1672 : offset
  %kind_view = buffer.view %state[%kind_at] : buffer -> view<1xi32>
  %kind_word = view.load %kind_view[0] : view<1xi32> -> i32
  %kind_zero = scalar.constant 0 : i32
  %drafting_on = scalar.cmpi ne, %kind_word, %kind_zero : i32
  %drafting64 = scalar.extui %drafting_on : i1 to i64
  %allocations, %views, %origins, %draft, %geometry = func.call @llm_storage(%maximum, %span_capacity, %context, %pool, %rows, %pins, %drafting64) : (i64, i64, i64, i64, i64, i64, i64) -> (buffer, buffer, buffer, buffer, buffer)
  func.return %state, %allocations, %views, %origins, %draft, %geometry : buffer, buffer, buffer, buffer, buffer, buffer
}

func.def public @prepare_input(%text: buffer, %markers: buffer, %marker_count: i64, %format: i32, %boundary: i32, %capacity: i64) -> (buffer, i64, buffer) {
  %zero = scalar.constant 0 : i64
  %plain = scalar.cmpi eq, %marker_count, %zero : i64
  %tokens, %count, %spans = scf.if %plain -> (buffer, i64, buffer) {
    %t, %n, %s = func.call @plain_prepare_input(%text, %markers, %marker_count, %format, %boundary, %capacity) : (buffer, buffer, i64, i32, i32, i64) -> (buffer, i64, buffer)
    scf.yield %t, %n, %s : buffer, i64, buffer
  } else {
    %t, %n, %s = func.call @vision_prepare_input(%text, %markers, %marker_count, %capacity) : (buffer, buffer, i64, i64) -> (buffer, i64, buffer)
    scf.yield %t, %n, %s : buffer, i64, buffer
  }
  func.return %tokens, %count, %spans : buffer, i64, buffer
}

// ---- image input (generated by gen_chat_vision.py) ----
// An image part renders as BEGIN + SENTINEL + END. The plan's marker covers only the sentinel, which
// prepare_input replaces with one placeholder token (id 0) per projected row; the projected rows replace
// those inputs' embeddings on the device (llama.cpp: img_beg + embeddings + img_end).
global.rodata.def @vision_begin = bytes("3c7c766973696f6e5f73746172747c3e")
global.rodata.def @vision_end = bytes("3c7c766973696f6e5f656e647c3e")
global.rodata.def @vision_sentinel = bytes("1a4c4f4f4d5f494d4147451a")
global.rodata.def @vision_newline = bytes("0a")

func.def @vision_geometry(%w: i32, %h: i32) -> (i32, i32, i32) {
  %ff = scalar.constant 32.0 : f32
  %fi = scalar.constant 32 : i32
  %mx = scalar.constant 4194304 : i32
  %mn = scalar.constant 8192 : i32
  %mxf = scalar.constant 4194304.0 : f32
  %mnf = scalar.constant 8192.0 : f32
  %wf = scalar.uitofp %w : i32 to f32
  %hf = scalar.uitofp %h : i32 to f32
  %wq = scalar.divf %wf, %ff : f32
  %hq = scalar.divf %hf, %ff : f32
  %wr = scalar.roundevenf %wq : f32
  %hr = scalar.roundevenf %hq : f32
  %wri = scalar.fptoui %wr : f32 to i32
  %hri = scalar.fptoui %hr : f32 to i32
  %wb0 = scalar.muli %wri, %fi : i32
  %hb0 = scalar.muli %hri, %fi : i32
  %wb = scalar.maxui %wb0, %fi : i32
  %hb = scalar.maxui %hb0, %fi : i32
  %area = scalar.muli %wb, %hb : i32
  %over = scalar.cmpi ugt, %area, %mx : i32
  %under = scalar.cmpi ult, %area, %mn : i32
  %hw = scalar.mulf %hf, %wf : f32
  %r_over = scalar.divf %hw, %mxf : f32
  %b_over = scalar.sqrtf %r_over : f32
  %ho0 = scalar.divf %hf, %b_over : f32
  %wo0 = scalar.divf %wf, %b_over : f32
  %ho1 = scalar.divf %ho0, %ff : f32
  %wo1 = scalar.divf %wo0, %ff : f32
  %ho2 = scalar.floorf %ho1 : f32
  %wo2 = scalar.floorf %wo1 : f32
  %hoi = scalar.fptoui %ho2 : f32 to i32
  %woi = scalar.fptoui %wo2 : f32 to i32
  %ho3 = scalar.muli %hoi, %fi : i32
  %wo3 = scalar.muli %woi, %fi : i32
  %ho = scalar.maxui %ho3, %fi : i32
  %wo = scalar.maxui %wo3, %fi : i32
  %r_under = scalar.divf %mnf, %hw : f32
  %b_under = scalar.sqrtf %r_under : f32
  %hu0 = scalar.mulf %hf, %b_under : f32
  %wu0 = scalar.mulf %wf, %b_under : f32
  %hu1 = scalar.divf %hu0, %ff : f32
  %wu1 = scalar.divf %wu0, %ff : f32
  %hu2 = scalar.ceilf %hu1 : f32
  %wu2 = scalar.ceilf %wu1 : f32
  %hui = scalar.fptoui %hu2 : f32 to i32
  %wui = scalar.fptoui %wu2 : f32 to i32
  %hu = scalar.muli %hui, %fi : i32
  %wu = scalar.muli %wui, %fi : i32
  %th1 = scf.select %under, %hu, %hb : i32
  %tw1 = scf.select %under, %wu, %wb : i32
  %th = scf.select %over, %ho, %th1 : i32
  %tw = scf.select %over, %wo, %tw1 : i32
  %gh = scalar.divui %th, %fi : i32
  %gw = scalar.divui %tw, %fi : i32
  %rows = scalar.muli %gh, %gw : i32
  func.return %tw, %th, %rows : i32, i32, i32
}

// Text parts joined as llama.cpp's server does: a newline between text parts, none next to an image.
// Returns (text, plan, image count). Plan: per image [image_begin, image_count, marker offset (set by
// vision_locate), marker length, rows, metadata offset, metadata length] then metadata [width, height].
func.def @vision_content(%content: buffer, %parts: buffer, %frames: buffer, %part_count: i64) -> (buffer, buffer, i64) {
  %origin = index.constant 0 : offset
  %c0 = index.constant 0 : index
  %c1 = index.constant 1 : index
  %c4 = index.constant 4 : index
  %zero32 = scalar.constant 0 : i32
  %text_kind = scalar.constant 0 : i32
  %bounded_count = scalar.assume %part_count [range(%part_count, 1, 4096)] : i64
  %count = index.cast %bounded_count : i64 to index
  %records = buffer.view %parts[%origin] : buffer -> view<[%count]x6xi32>
  %begin = global.load @vision_begin : buffer
  %end = global.load @vision_end : buffer
  %sentinel = global.load @vision_sentinel : buffer
  %newline = global.load @vision_newline : buffer
  %begin_length = buffer.length %begin
  %end_length = buffer.length %end
  %sentinel_length = buffer.length %sentinel
  %marker_bytes0 = index.add %begin_length, %end_length : offset
  %marker_bytes = index.add %marker_bytes0, %sentinel_length : offset
  %images, %text_bytes = scf.for %i = [%c0 to %count step %c1](%n = %c0 : index, %b = %origin : offset) -> (index, offset) {
    %kind = view.load %records[%i, 0] : view<[%count]x6xi32> -> i32
    %is_text = scalar.cmpi eq, %kind, %text_kind : i32
    %length32 = view.load %records[%i, 2] : view<[%count]x6xi32> -> i32
    %length64 = scalar.extui %length32 : i32 to i64
    %lb = scalar.assume %length64 [range(%length64, 0, 4294967295)] : i64
    %length = index.cast %lb : i64 to offset
    %one_byte = index.constant 1 : offset
    %with_nl = index.add %length, %one_byte : offset
    %grow = scf.select %is_text, %with_nl, %marker_bytes : offset
    %nb = index.add %b, %grow : offset
    %inc = scf.select %is_text, %c0, %c1 : index
    %nn = index.add %n, %inc : index
    scf.yield %nn, %nb : index, offset
  }
  %scratch = buffer.alloca<private> align(1) %text_bytes : buffer
  %c28 = index.constant 28 : offset
  %c8 = index.constant 8 : offset
  %record_bytes = index.scale %images, %c28 : index, offset -> offset
  %meta_bytes = index.scale %images, %c8 : index, offset -> offset
  %plan_bytes = index.add %record_bytes, %meta_bytes : offset
  %plan = buffer.alloca<private> align(4) %plan_bytes : buffer
  %frame_bytes = buffer.length %frames
  %frame_words0 = index.cast %frame_bytes : offset to index
  %frame_words = index.div %frame_words0, %c4 : index
  %frame_view = buffer.view %frames[%origin] : buffer -> view<[%frame_words]xi32>
  %false = scalar.constant false : i1
  %used, %image_n, %last_media = scf.for %i = [%c0 to %count step %c1](%cursor = %origin : offset, %image = %c0 : index, %was_media = %false : i1) -> (offset, index, i1) {
    %kind = view.load %records[%i, 0] : view<[%count]x6xi32> -> i32
    %is_text = scalar.cmpi eq, %kind, %text_kind : i32
    %nc, %ni, %nm = scf.if %is_text -> (offset, index, i1) {
      %source32 = view.load %records[%i, 1] : view<[%count]x6xi32> -> i32
      %length32 = view.load %records[%i, 2] : view<[%count]x6xi32> -> i32
      %source64 = scalar.extui %source32 : i32 to i64
      %length64 = scalar.extui %length32 : i32 to i64
      %sb = scalar.assume %source64 [range(%source64, 0, 4294967295)] : i64
      %lb = scalar.assume %length64 [range(%length64, 0, 4294967295)] : i64
      %source = index.cast %sb : i64 to offset
      %length = index.cast %lb : i64 to offset
      %nonempty = index.cmp ne, %cursor, %origin : offset
      %true = scalar.constant true : i1
      %not_media = scalar.xori %was_media, %true : i1
      %add_nl = scalar.andi %nonempty, %not_media : i1
      %after_nl = scf.if %add_nl -> (offset) {
        %one_byte = index.constant 1 : offset
        buffer.copy %newline[%origin], %scratch[%cursor], %one_byte
        %c = index.add %cursor, %one_byte : offset
        scf.yield %c : offset
      } else {
        scf.yield %cursor : offset
      }
      buffer.copy %content[%source], %scratch[%after_nl], %length
      %after = index.add %after_nl, %length : offset
      scf.yield %after, %image, %false : offset, index, i1
    } else {
      %frame32 = view.load %records[%i, 3] : view<[%count]x6xi32> -> i32
      %frame_count32 = view.load %records[%i, 4] : view<[%count]x6xi32> -> i32
      %frame_bound = scalar.assume %frame32 [range(%frame32, 0, 4095)] : i32
      %frame = index.cast %frame_bound : i32 to index
      %wi0 = index.mul %frame, %c4 : index
      %hi0 = index.add %wi0, %c1 : index
      %wi = index.assume %wi0 [lt(%wi0, %frame_words)] : index
      %hi = index.assume %hi0 [lt(%hi0, %frame_words)] : index
      %width = view.load %frame_view[%wi] : view<[%frame_words]xi32> -> i32
      %height = view.load %frame_view[%hi] : view<[%frame_words]xi32> -> i32
      %tw, %th, %rows = func.call @vision_geometry(%width, %height) : (i32, i32) -> (i32, i32, i32)
      buffer.copy %begin[%origin], %scratch[%cursor], %begin_length
      %c_a = index.add %cursor, %begin_length : offset
      buffer.copy %sentinel[%origin], %scratch[%c_a], %sentinel_length
      %c_b = index.add %c_a, %sentinel_length : offset
      buffer.copy %end[%origin], %scratch[%c_b], %end_length
      %c_c = index.add %c_b, %end_length : offset
      %bi = index.assume %image [range(%image, 0, 4095), lt(%image, %images)] : index
      %rec = buffer.view %plan[%origin] : buffer -> view<[%images]x7xi32>
      %sl64 = index.cast %sentinel_length : offset to i64
      %sl32 = scalar.trunci %sl64 : i64 to i32
      %mo0 = index.scale %bi, %c8 : index, offset -> offset
      %mo1 = index.add %record_bytes, %mo0 : offset
      %mo64 = index.cast %mo1 : offset to i64
      %mo32 = scalar.trunci %mo64 : i64 to i32
      %eight32 = scalar.constant 8 : i32
      view.store %frame32, %rec[%bi, 0] : i32, view<[%images]x7xi32>
      view.store %frame_count32, %rec[%bi, 1] : i32, view<[%images]x7xi32>
      view.store %zero32, %rec[%bi, 2] : i32, view<[%images]x7xi32>
      view.store %sl32, %rec[%bi, 3] : i32, view<[%images]x7xi32>
      view.store %rows, %rec[%bi, 4] : i32, view<[%images]x7xi32>
      view.store %mo32, %rec[%bi, 5] : i32, view<[%images]x7xi32>
      view.store %eight32, %rec[%bi, 6] : i32, view<[%images]x7xi32>
      %meta = buffer.view %plan[%mo1] : buffer -> view<2xi32>
      view.store %tw, %meta[0] : i32, view<2xi32>
      view.store %th, %meta[1] : i32, view<2xi32>
      %ni2 = index.add %image, %c1 : index
      %true2 = scalar.constant true : i1
      scf.yield %c_c, %ni2, %true2 : offset, index, i1
    }
    scf.yield %nc, %ni, %nm : offset, index, i1
  }
  %text = buffer.alloca<private> align(1) %used : buffer
  buffer.copy %scratch[%origin], %text[%origin], %used
  %images64 = index.cast %images : index to i64
  func.return %text, %plan, %images64 : buffer, buffer, i64
}

// Fills each image record's marker offset with the position of its sentinel in the final fragment.
func.def @vision_locate(%fragment: buffer, %plan: buffer, %count64: i64) {
  %origin = index.constant 0 : offset
  %c0 = index.constant 0 : index
  %c1 = index.constant 1 : index
  %bounded = scalar.assume %count64 [range(%count64, 0, 4096)] : i64
  %count = index.cast %bounded : i64 to index
  %sentinel = global.load @vision_sentinel : buffer
  %sentinel_length = buffer.length %sentinel
  %end = buffer.length %fragment
  %rec = buffer.view %plan[%origin] : buffer -> view<[%count]x7xi32>
  %final = scf.for %i = [%c0 to %count step %c1](%from = %origin : offset) -> (offset) {
    %at = func.call @find(%fragment, %from, %end, %sentinel) : (buffer, offset, offset, buffer) -> (offset)
    %found = index.cmp ult, %at, %end : offset
    %f32 = scalar.extui %found : i1 to i32
    %error = global.load @vision_lost : buffer
    func.call @require(%f32, %error) : (i32, buffer)
    %at64 = index.cast %at : offset to i64
    %at32 = scalar.trunci %at64 : i64 to i32
    view.store %at32, %rec[%i, 2] : i32, view<[%count]x7xi32>
    %next = index.add %at, %sentinel_length : offset
    scf.yield %next : offset
  }
  func.return
}
global.rodata.def @vision_lost = bytes("696d616765206d61726b6572206c6f7374207768696c652072656e646572696e6720746865206d6573736167652028616e20696d616765207061727420696e73696465207465787420746865206368617420666f726d61742072657772697465733f29")

func.def @vision_slice(%text: buffer, %begin: offset, %end: offset) -> (buffer) {
  %origin = index.constant 0 : offset
  %length = index.sub %end, %begin : offset
  %out = buffer.alloca<private> align(1) %length : buffer
  buffer.copy %text[%begin], %out[%origin], %length
  func.return %out : buffer
}

// prepare_input with image markers [projection, byte offset, byte length, rows, metadata offset, length]:
// text between markers is encoded as usual; each marker becomes rows placeholder inputs (id 0), and a
// span [projection, input offset, rows] tells the host where its projected rows go.
func.def @vision_prepare_input(%text: buffer, %markers: buffer, %marker_count: i64, %capacity: i64) -> (buffer, i64, buffer) {
  %origin = index.constant 0 : offset
  %c0 = index.constant 0 : index
  %c1 = index.constant 1 : index
  %c0_i32 = scalar.constant 0 : i32
  %c0_i64 = scalar.constant 0 : i64
  %c1_i64 = scalar.constant 1 : i64
  %four = index.constant 4 : offset
  %bounded = scalar.assume %marker_count [range(%marker_count, 1, 4096)] : i64
  %count = index.cast %bounded : i64 to index
  %marks = buffer.view %markers[%origin] : buffer -> view<[%count]x6xi32>
  %text_end = buffer.length %text
  %probe = scalar.addi %capacity, %c1_i64 : i64
  // pass 1: total inputs
  %last, %total0 = scf.for %i = [%c0 to %count step %c1](%cursor = %origin : offset, %sum = %c0_i64 : i64) -> (offset, i64) {
    %off32 = view.load %marks[%i, 1] : view<[%count]x6xi32> -> i32
    %len32 = view.load %marks[%i, 2] : view<[%count]x6xi32> -> i32
    %rows32 = view.load %marks[%i, 3] : view<[%count]x6xi32> -> i32
    %off64 = scalar.extui %off32 : i32 to i64
    %len64 = scalar.extui %len32 : i32 to i64
    %ob = scalar.assume %off64 [range(%off64, 0, 4294967295)] : i64
    %lb = scalar.assume %len64 [range(%len64, 0, 4294967295)] : i64
    %off = index.cast %ob : i64 to offset
    %len = index.cast %lb : i64 to offset
    %segment = func.call @vision_slice(%text, %cursor, %off) : (buffer, offset, offset) -> (buffer)
    %ids, %n = func.call @encode(%segment, %c0_i32, %probe) : (buffer, i32, i64) -> (buffer, i64)
    %rows64 = scalar.extui %rows32 : i32 to i64
    %s1 = scalar.addi %sum, %n : i64
    %s2 = scalar.addi %s1, %rows64 : i64
    %next = index.add %off, %len : offset
    scf.yield %next, %s2 : offset, i64
  }
  %tail = func.call @vision_slice(%text, %last, %text_end) : (buffer, offset, offset) -> (buffer)
  %tail_ids, %tail_n = func.call @encode(%tail, %c0_i32, %probe) : (buffer, i32, i64) -> (buffer, i64)
  %total = scalar.addi %total0, %tail_n : i64
  %fits = scalar.cmpi ule, %total, %capacity : i64
  %fits32 = scalar.extui %fits : i1 to i32
  %error = global.load @overflow : buffer
  func.call @require(%fits32, %error) : (i32, buffer)
  %tb = scalar.assume %total [range(%total, 0, 1073741823)] : i64
  %total_index = index.cast %tb : i64 to index
  %token_bytes = index.scale %total_index, %four : index, offset -> offset
  %tokens = buffer.alloca<private> align(4) %token_bytes : buffer
  buffer.fill %c0_i32, %tokens[%origin], %token_bytes : i32
  %c12 = index.constant 12 : offset
  %span_bytes = index.scale %count, %c12 : index, offset -> offset
  %spans = buffer.alloca<private> align(4) %span_bytes : buffer
  %span_view = buffer.view %spans[%origin] : buffer -> view<[%count]x3xi32>
  // pass 2: write ids and spans
  %last2, %out_end = scf.for %i = [%c0 to %count step %c1](%cursor = %origin : offset, %out = %origin : offset) -> (offset, offset) {
    %proj = view.load %marks[%i, 0] : view<[%count]x6xi32> -> i32
    %off32 = view.load %marks[%i, 1] : view<[%count]x6xi32> -> i32
    %len32 = view.load %marks[%i, 2] : view<[%count]x6xi32> -> i32
    %rows32 = view.load %marks[%i, 3] : view<[%count]x6xi32> -> i32
    %off64 = scalar.extui %off32 : i32 to i64
    %len64 = scalar.extui %len32 : i32 to i64
    %ob = scalar.assume %off64 [range(%off64, 0, 4294967295)] : i64
    %lb = scalar.assume %len64 [range(%len64, 0, 4294967295)] : i64
    %off = index.cast %ob : i64 to offset
    %len = index.cast %lb : i64 to offset
    %segment = func.call @vision_slice(%text, %cursor, %off) : (buffer, offset, offset) -> (buffer)
    %ids, %n = func.call @encode(%segment, %c0_i32, %probe) : (buffer, i32, i64) -> (buffer, i64)
    %nb = scalar.assume %n [range(%n, 0, 1073741823)] : i64
    %ni = index.cast %nb : i64 to index
    %id_bytes = index.scale %ni, %four : index, offset -> offset
    buffer.copy %ids[%origin], %tokens[%out], %id_bytes
    %image_at = index.add %out, %id_bytes : offset
    %image_at64 = index.cast %image_at : offset to i64
    %four64 = scalar.constant 4 : i64
    %input_offset64 = scalar.divui %image_at64, %four64 : i64
    %input_offset = scalar.trunci %input_offset64 : i64 to i32
    view.store %proj, %span_view[%i, 0] : i32, view<[%count]x3xi32>
    view.store %input_offset, %span_view[%i, 1] : i32, view<[%count]x3xi32>
    view.store %rows32, %span_view[%i, 2] : i32, view<[%count]x3xi32>
    %rows64 = scalar.extui %rows32 : i32 to i64
    %rb = scalar.assume %rows64 [range(%rows64, 0, 1073741823)] : i64
    %ri = index.cast %rb : i64 to index
    %row_bytes = index.scale %ri, %four : index, offset -> offset
    %after = index.add %image_at, %row_bytes : offset
    %next = index.add %off, %len : offset
    scf.yield %next, %after : offset, offset
  }
  %tail_b = scalar.assume %tail_n [range(%tail_n, 0, 1073741823)] : i64
  %tail_i = index.cast %tail_b : i64 to index
  %tail_bytes = index.scale %tail_i, %four : index, offset -> offset
  buffer.copy %tail_ids[%origin], %tokens[%out_end], %tail_bytes
  func.return %tokens, %total, %spans : buffer, i64, buffer
}

// ---- M-RoPE positions (generated by build_vision.py) ----
// Grid frontier after `consumed` rows of a row-major grid `width` wide: one past the largest coordinate.
func.def @vision_frontier(%consumed: i32, %width: i32) -> (i32) {
  %one = scalar.constant 1 : i32
  %bias = scalar.subi %width, %one : i32
  %rounded = scalar.addi %consumed, %bias : i32
  %rows = scalar.divui %rounded, %width : i32
  %cols = scalar.minui %consumed, %width : i32
  %frontier = scalar.maxui %rows, %cols : i32
  func.return %frontier : i32
}

// Media entries [plan index, relative input, feature offset, feature bytes, metadata offset, metadata bytes,
// feature index]; metadata = [processed width, processed height].
func.def @vision_entry_width(%media_plan: buffer, %meta_offset: i32) -> (i32) {
  %zero = scalar.constant 0 : i32
  %mo_c = scalar.maxsi %meta_offset, %zero : i32
  %mo64 = scalar.extui %mo_c : i32 to i64
  %mo_b = scalar.assume %mo64 [range(%mo64, 0, 4294967295)] : i64
  %mo = index.cast %mo_b : i64 to offset
  %meta = buffer.view %media_plan[%mo] : buffer -> view<2xi32>
  %width_px = view.load %meta[0] : view<2xi32> -> i32
  %px = scalar.constant 32 : i32
  %width = scalar.divui %width_px, %px : i32
  %one = scalar.constant 1 : i32
  %safe = scalar.maxui %width, %one : i32
  func.return %safe : i32
}

// Rows of span `span` that did not advance the source position (1 - frontier advance each).
func.def @vision_mrope_saved(%media_plan: buffer, %first: i32, %next: i32, %span: index) -> (i32) {
  %origin = index.constant 0 : offset
  %c0 = index.constant 0 : index
  %c1 = index.constant 1 : index
  %zero = scalar.constant 0 : i32
  %one = scalar.constant 1 : i32
  %total = scalar.addi %first, %next : i32
  %tb = scalar.assume %total [range(%total, 0, 524288)] : i32
  %count = index.cast %tb : i32 to index
  %entries = buffer.view %media_plan[%origin] : buffer -> view<[%count]x7xi32>
  %span32a = index.cast %span : index to i64
  %span32 = scalar.trunci %span32a : i64 to i32
  %saved = scf.for %e = [%c0 to %count step %c1](%acc = %zero : i32) -> (i32) {
    %owner = view.load %entries[%e, 0] : view<[%count]x7xi32> -> i32
    %mine = scalar.cmpi eq, %owner, %span32 : i32
    %next_acc = scf.if %mine -> (i32) {
      %meta_offset = view.load %entries[%e, 4] : view<[%count]x7xi32> -> i32
      %fi = view.load %entries[%e, 6] : view<[%count]x7xi32> -> i32
      %width = func.call @vision_entry_width(%media_plan, %meta_offset) : (buffer, i32) -> (i32)
      %before = func.call @vision_frontier(%fi, %width) : (i32, i32) -> (i32)
      %fi1 = scalar.addi %fi, %one : i32
      %after = func.call @vision_frontier(%fi1, %width) : (i32, i32) -> (i32)
      %advance = scalar.subi %after, %before : i32
      %not = scalar.subi %one, %advance : i32
      %sum = scalar.addi %acc, %not : i32
      scf.yield %sum : i32
    } else {
      scf.yield %acc : i32
    }
    scf.yield %next_acc : i32
  }
  func.return %saved : i32
}

// Record words 4..6 = (t, h, w) for every input of every span (media or text).
func.def @vision_mrope_records(%plan: buffer, %media_plan: buffer, %media_count: i32, %packet_capacity: i32, %packet: buffer, %span_count: i32) {
  %origin = index.constant 0 : offset
  %c0 = index.constant 0 : index
  %c1 = index.constant 1 : index
  %one = scalar.constant 1 : i32
  %mb = scalar.assume %media_count [range(%media_count, 1, 524288)] : i32
  %media_n = index.cast %mb : i32 to index
  %pb = scalar.assume %packet_capacity [range(%packet_capacity, 1, 524288)] : i32
  %packet_n = index.cast %pb : i32 to index
  %sb = scalar.assume %span_count [range(%span_count, 0, 8192)] : i32
  %spans = index.cast %sb : i32 to index
  %plan_extent = func.call @plan_capacity(%plan) : (buffer) -> (index)
  %requests = buffer.view %plan[%origin] : buffer -> view<[%plan_extent]x9xi32>
  %entries = buffer.view %media_plan[%origin] : buffer -> view<[%media_n]x7xi32>
  %records = buffer.view %packet[%origin] : buffer -> view<[%packet_n]x8xi32>
  %final = scf.for %s = [%c0 to %spans step %c1](%cursor = %c0 : index) -> (index) {
    %r = index.assume %s [lt(%s, %plan_extent)] : index
    %length32 = view.load %requests[%r, 0] : view<[%plan_extent]x9xi32> -> i32
    %source0 = view.load %requests[%r, 2] : view<[%plan_extent]x9xi32> -> i32
    %begin32 = view.load %requests[%r, 4] : view<[%plan_extent]x9xi32> -> i32
    %lb = scalar.assume %length32 [range(%length32, 0, 524288)] : i32
    %bb = scalar.assume %begin32 [range(%begin32, 0, 524287)] : i32
    %length = index.cast %lb : i32 to index
    %begin = index.cast %bb : i32 to index
    %s64 = index.cast %s : index to i64
    %s32 = scalar.trunci %s64 : i64 to i32
    %src_end, %cur_end = scf.for %j = [%c0 to %length step %c1](%source = %source0 : i32, %cur = %cursor : index) -> (i32, index) {
      %at0 = index.add %begin, %j : index
      %at = index.assume %at0 [lt(%at0, %packet_n)] : index
      %j64 = index.cast %j : index to i64
      %j32 = scalar.trunci %j64 : i64 to i32
      %has = index.cmp ult, %cur, %media_n : index
      %match = scf.if %has -> (i1) {
        %cb = index.assume %cur [lt(%cur, %media_n)] : index
        %owner = view.load %entries[%cb, 0] : view<[%media_n]x7xi32> -> i32
        %rel = view.load %entries[%cb, 1] : view<[%media_n]x7xi32> -> i32
        %m0 = scalar.cmpi eq, %owner, %s32 : i32
        %m1 = scalar.cmpi eq, %rel, %j32 : i32
        %m = scalar.andi %m0, %m1 : i1
        scf.yield %m : i1
      } else {
        %f = scalar.constant false : i1
        scf.yield %f : i1
      }
      %next_source, %next_cur = scf.if %match -> (i32, index) {
        %cb = index.assume %cur [lt(%cur, %media_n)] : index
        %meta_offset = view.load %entries[%cb, 4] : view<[%media_n]x7xi32> -> i32
        %fi = view.load %entries[%cb, 6] : view<[%media_n]x7xi32> -> i32
        %width = func.call @vision_entry_width(%media_plan, %meta_offset) : (buffer, i32) -> (i32)
        %prefix = func.call @vision_frontier(%fi, %width) : (i32, i32) -> (i32)
        %base = scalar.subi %source, %prefix : i32
        %row = scalar.divui %fi, %width : i32
        %col = scalar.remui %fi, %width : i32
        %ph = scalar.addi %base, %row : i32
        %pw = scalar.addi %base, %col : i32
        view.store %base, %records[%at, 4] : i32, view<[%packet_n]x8xi32>
        view.store %ph, %records[%at, 5] : i32, view<[%packet_n]x8xi32>
        view.store %pw, %records[%at, 6] : i32, view<[%packet_n]x8xi32>
        %fi1 = scalar.addi %fi, %one : i32
        %suffix = func.call @vision_frontier(%fi1, %width) : (i32, i32) -> (i32)
        %adv = scalar.subi %suffix, %prefix : i32
        %ns = scalar.addi %source, %adv : i32
        %nc = index.add %cur, %c1 : index
        scf.yield %ns, %nc : i32, index
      } else {
        view.store %source, %records[%at, 4] : i32, view<[%packet_n]x8xi32>
        view.store %source, %records[%at, 5] : i32, view<[%packet_n]x8xi32>
        view.store %source, %records[%at, 6] : i32, view<[%packet_n]x8xi32>
        %ns = scalar.addi %source, %one : i32
        scf.yield %ns, %cur : i32, index
      }
      scf.yield %next_source, %next_cur : i32, index
    }
    scf.yield %cur_end : index
  }
  func.return
}

// ---- Speculative decoding (generated by draft/build_draft.py) ----
// Speculative spans reserve draft_depth + 1 packed inputs but the host supplies only the anchor; inputs
// therefore move to packed cursors (the sum of earlier span lengths), placeholders are zeroed, and the
// device plan copy carries the cursor in word 4, flag bit 4 (speculative: verify, do not publish
// recurrent state) and the output credit in bits 8..15. Spans are moved last to first, so a move never
// overwrites inputs not yet moved (cursors never precede their host offsets).
func.def public @encode_epoch(%control_state: buffer, %plan: buffer, %inputs: buffer, %media_plan: buffer, %first_count: i32, %next_count: i32, %input_count: i32, %first_media_count: i32, %next_media_count: i32, %first_packet_capacity: i32, %next_packet_capacity: i32, %eos: i32, %metadata: buffer, %tokens: buffer) -> (i32, buffer, i64, i64) {
  %count, %state, %transfer_begin, %transfer_length = func.call @plain_encode_epoch(%control_state, %plan, %inputs, %media_plan, %first_count, %next_count, %input_count, %first_media_count, %next_media_count, %first_packet_capacity, %next_packet_capacity, %eos, %metadata, %tokens) : (buffer, buffer, buffer, buffer, i32, i32, i32, i32, i32, i32, i32, i32, buffer, buffer) -> (i32, buffer, i64, i64)
  %origin = index.constant 0 : offset
  %c0 = index.constant 0 : index
  %c1 = index.constant 1 : index
  %c0_i32 = scalar.constant 0 : i32
  %c4_i32 = scalar.constant 4 : i32
  %c8_i32 = scalar.constant 8 : i32
  %header_bytes = index.constant 16 : offset
  %bounded_first = scalar.assume %first_count [range(%first_count, 1, 8192)] : i32
  %spans = index.cast %bounded_first : i32 to index
  %plan_extent = func.call @plan_capacity(%plan) : (buffer) -> (index)
  %requests = buffer.view %plan[%origin] : buffer -> view<[%plan_extent]x9xi32>
  %device = buffer.view %metadata[%header_bytes] : buffer -> view<[%spans]x9xi32>
  %media_total = scalar.addi %first_media_count, %next_media_count : i32
  %mixed = scalar.cmpi ne, %media_total, %c0_i32 : i32
  %one = index.constant 1 : index
  %eight = index.constant 8 : index
  %stride = scf.select %mixed, %eight, %one : index
  %token_bytes = buffer.length %tokens
  %token_words = index.cast %token_bytes : offset to index
  %four = index.constant 4 : index
  %words = index.div %token_words, %four : index
  %flat = buffer.view %tokens[%origin] : buffer -> view<[%words]xi32>
  // occupancy gate: all spans speculative and at least 2 of them -> verify the anchors only
  %c1_i32 = scalar.constant 1 : i32
  %nspec = scf.for %g = [%c0 to %spans step %c1](%acc = %c0_i32 : i32) -> (i32) {
    %gr = index.assume %g [lt(%g, %plan_extent)] : index
    %gcredit = view.load %requests[%gr, 7] : view<[%plan_extent]x9xi32> -> i32
    %gspec = scalar.cmpi ne, %gcredit, %c0_i32 : i32
    %gadd = scalar.extui %gspec : i1 to i32
    %gnext = scalar.addi %acc, %gadd : i32
    scf.yield %gnext : i32
  }
  %all_spec = scalar.cmpi eq, %nspec, %first_count : i32
  %occ_below = scalar.constant 1 : i32
  %occupied = scalar.cmpi ugt, %first_count, %occ_below : i32
  %gate_limit = scalar.constant 32 : i32
  %few_spans = scalar.cmpi ult, %first_count, %gate_limit : i32
  %gate_max = scalar.constant 31 : i32
  %gate_slot32 = scalar.minui %first_count, %gate_max : i32
  %gate_slot_b = scalar.assume %gate_slot32 [range(%gate_slot32, 0, 31)] : i32
  %gate_slot = index.cast %gate_slot_b : i32 to index
  %gate_at = index.constant 1700 : offset
  %gate_view = buffer.view %control_state[%gate_at] : buffer -> view<32xi32>
  %gate_raw = view.load %gate_view[%gate_slot] : view<32xi32> -> i32
  %gate_shape = scf.select %few_spans, %gate_raw, %c0_i32 : i32
  %has_shape = scalar.cmpi ne, %gate_shape, %c0_i32 : i32
  %g1 = scalar.andi %all_spec, %occupied : i1
  %gate = scalar.andi %g1, %has_shape : i1
  %flag_value = scf.select %gate, %gate_shape, %c0_i32 : i32
  %flag_at = index.constant 1676 : offset
  %flag_view = buffer.view %control_state[%flag_at] : buffer -> view<1xi32>
  view.store %flag_value, %flag_view[0] : i32, view<1xi32>
  // cursors, flags and the total packed length
  %total = scf.for %s = [%c0 to %spans step %c1](%cursor = %c0_i32 : i32) -> (i32) {
    %sr = index.assume %s [lt(%s, %plan_extent)] : index
    %length_host = view.load %requests[%sr, 0] : view<[%plan_extent]x9xi32> -> i32
    %length = scf.select %gate, %c1_i32, %length_host : i32
    view.store %length, %device[%s, 0] : i32, view<[%spans]x9xi32>
    %flags = view.load %requests[%sr, 6] : view<[%plan_extent]x9xi32> -> i32
    %credit = view.load %requests[%sr, 7] : view<[%plan_extent]x9xi32> -> i32
    %speculative = scalar.cmpi ne, %credit, %c0_i32 : i32
    %credit_bits = scalar.shli %credit, %c8_i32 : i32
    %spec_bits = scalar.ori %credit_bits, %c4_i32 : i32
    %marked = scalar.ori %flags, %spec_bits : i32
    %device_flags = scf.select %speculative, %marked, %flags : i32
    view.store %cursor, %device[%s, 4] : i32, view<[%spans]x9xi32>
    view.store %device_flags, %device[%s, 6] : i32, view<[%spans]x9xi32>
    %next = scalar.addi %cursor, %length : i32
    scf.yield %next : i32
  }
  // move inputs to their cursors (last span first), zero placeholders
  scf.for %r = [%c0 to %spans step %c1] {
    %last = index.sub %spans, %c1 : index
    %s = index.sub %last, %r : index
    %sr = index.assume %s [lt(%s, %plan_extent)] : index
    %sd = index.assume %s [lt(%s, %spans)] : index
    %length32_host = view.load %requests[%sr, 0] : view<[%plan_extent]x9xi32> -> i32
    %length32 = scf.select %gate, %c1_i32, %length32_host : i32
    %begin32 = view.load %requests[%sr, 4] : view<[%plan_extent]x9xi32> -> i32
    %known32 = view.load %requests[%sr, 5] : view<[%plan_extent]x9xi32> -> i32
    %cursor32 = view.load %device[%sd, 4] : view<[%spans]x9xi32> -> i32
    %moves = scalar.cmpi ne, %begin32, %cursor32 : i32
    %length_b = scalar.assume %length32 [range(%length32, 0, 8192)] : i32
    %known_b = scalar.assume %known32 [range(%known32, 0, 8192)] : i32
    %begin_b = scalar.assume %begin32 [range(%begin32, 0, 8191)] : i32
    %cursor_b = scalar.assume %cursor32 [range(%cursor32, 0, 8191)] : i32
    %length = index.cast %length_b : i32 to index
    %known = index.cast %known_b : i32 to index
    %begin = index.cast %begin_b : i32 to index
    %cursor = index.cast %cursor_b : i32 to index
    scf.if %moves {
      scf.for %q = [%c0 to %known step %c1] {
        %kl = index.sub %known, %c1 : index
        %j = index.sub %kl, %q : index
        %src_t = index.add %begin, %j : index
        %dst_t = index.add %cursor, %j : index
        %src0 = index.mul %src_t, %stride : index
        %dst0 = index.mul %dst_t, %stride : index
        scf.for %w = [%c0 to %stride step %c1] {
          %si = index.add %src0, %w : index
          %di = index.add %dst0, %w : index
          %sb = index.assume %si [lt(%si, %words)] : index
          %db = index.assume %di [lt(%di, %words)] : index
          %v = view.load %flat[%sb] : view<[%words]xi32> -> i32
          view.store %v, %flat[%db] : i32, view<[%words]xi32>
        }
      }
    }
    // placeholders after the known inputs (speculative spans): zero ids; media records keep text
    // positions continuing the anchor's (t = h = w)
    scf.for %j = [%known to %length step %c1] {
      %dst_t = index.add %cursor, %j : index
      %dst0 = index.mul %dst_t, %stride : index
      scf.for %w = [%c0 to %stride step %c1] {
        %di = index.add %dst0, %w : index
        %db = index.assume %di [lt(%di, %words)] : index
        view.store %c0_i32, %flat[%db] : i32, view<[%words]xi32>
      }
      scf.if %mixed {
        %anchor0 = index.mul %cursor, %stride : index
        %anchor4 = index.add %anchor0, %four : index
        %ab = index.assume %anchor4 [lt(%anchor4, %words)] : index
        %t0 = view.load %flat[%ab] : view<[%words]xi32> -> i32
        %j32 = index.cast %j : index to i32
        %tj = scalar.addi %t0, %j32 : i32
        %five = index.constant 5 : index
        %six = index.constant 6 : index
        %p4 = index.add %dst0, %four : index
        %p5 = index.add %dst0, %five : index
        %p6 = index.add %dst0, %six : index
        %b4 = index.assume %p4 [lt(%p4, %words)] : index
        %b5 = index.assume %p5 [lt(%p5, %words)] : index
        %b6 = index.assume %p6 [lt(%p6, %words)] : index
        view.store %tj, %flat[%b4] : i32, view<[%words]xi32>
        view.store %tj, %flat[%b5] : i32, view<[%words]xi32>
        view.store %tj, %flat[%b6] : i32, view<[%words]xi32>
      }
    }
  }
  // the input transfer covers every packed slot
  %total64 = scalar.extui %total : i32 to i64
  %stride_index = index.cast %stride : index to i64
  %word64 = scalar.constant 4 : i64
  %record_bytes = scalar.muli %stride_index, %word64 : i64
  %input_length = scalar.muli %total64, %record_bytes : i64
  %transfer_offset = index.constant 8 : offset
  %transfers = buffer.view %state[%transfer_offset] : buffer -> view<2x5xi64>
  view.store %input_length, %transfers[1, 4] : i64, view<2x5xi64>
  func.return %count, %state, %transfer_begin, %transfer_length : i32, buffer, i64, i64
}

// Verified epochs: semantic progress comes from device acceptance (records of 10 i32:
// {consumed, output_count, token[8]}); a speculative span's known count is zero.
func.def public @publish_epoch(%plan: buffer, %media_plan: buffer, %count: i32, %first_media_count: i32, %next_media_count: i32, %verified: i32, %continues: i32, %next_speculative: buffer, %ordinary: buffer, %first_results: buffer, %next_results: buffer, %progress: buffer) {
  func.call @plain_publish_epoch(%plan, %media_plan, %count, %first_media_count, %next_media_count, %verified, %continues, %next_speculative, %ordinary, %first_results, %next_results, %progress) : (buffer, buffer, i32, i32, i32, i32, i32, buffer, buffer, buffer, buffer, buffer)
  %c0_i32 = scalar.constant 0 : i32
  %verifies = scalar.cmpi ne, %verified, %c0_i32 : i32
  scf.if %verifies {
    %origin = index.constant 0 : offset
    %c0 = index.constant 0 : index
    %c1 = index.constant 1 : index
    %c1_i32 = scalar.constant 1 : i32
    %step = scalar.constant 1 : i32
    %bounded_count = scalar.assume %count [range(%count, 1, 2147483647)] : i32
    %length = index.cast %bounded_count : i32 to index
    %plan_extent = func.call @plan_capacity(%plan) : (buffer) -> (index)
    %requests = buffer.view %plan[%origin] : buffer -> view<[%plan_extent]x9xi32>
    %records = buffer.view %first_results[%origin] : buffer -> view<[%length]x10xi32>
    %published = buffer.view %progress[%origin] : buffer -> view<[%length]x21xi32>
    scf.for %i = [%c0 to %length step %c1] {
      %ir = index.assume %i [lt(%i, %plan_extent)] : index
      %consumed = view.load %records[%i, 0] : view<[%length]x10xi32> -> i32
      %outputs = view.load %records[%i, 1] : view<[%length]x10xi32> -> i32
      %credit = view.load %requests[%ir, 7] : view<[%plan_extent]x9xi32> -> i32
      %speculative = scalar.cmpi ne, %credit, %c0_i32 : i32
      %known = scf.select %speculative, %c0_i32, %consumed : i32
      %verification = scalar.extui %speculative : i1 to i32
      view.store %consumed, %published[%i, 0] : i32, view<[%length]x21xi32>
      view.store %known, %published[%i, 1] : i32, view<[%length]x21xi32>
      view.store %outputs, %published[%i, 2] : i32, view<[%length]x21xi32>
      view.store %verification, %published[%i, 3] : i32, view<[%length]x21xi32>
      scf.if %speculative {
        %source = view.load %requests[%ir, 2] : view<[%plan_extent]x9xi32> -> i32
        %advance = scalar.muli %consumed, %step : i32
        %next_source = scalar.addi %source, %advance : i32
        view.store %next_source, %published[%i, 4] : i32, view<[%length]x21xi32>
      }
      %bounded_outputs = scalar.assume %outputs [range(%outputs, 0, 8)] : i32
      %output_extent = index.cast %bounded_outputs : i32 to index
      %c2 = index.constant 2 : index
      %c5 = index.constant 5 : index
      scf.for %j = [%c0 to %output_extent step %c1] {
        %src = index.add %j, %c2 : index
        %dst = index.add %j, %c5 : index
        %src_b = index.assume %src [range(%src, 2, 9)] : index
        %dst_b = index.assume %dst [range(%dst, 5, 12)] : index
        %token = view.load %records[%i, %src_b] : view<[%length]x10xi32> -> i32
        view.store %token, %published[%i, %dst_b] : i32, view<[%length]x21xi32>
      }
    }
  }
  func.return
}

// propose (when any span proposes) -> verify or advance -> drafter catch-up. Stage tables: advance at
// 128, verify at 640, warm at 1152; first proposal stage, level count and draft kind at 1664.
func.def public @epoch(%control_state: buffer, %shape: i32, %proposes: i32, %verifies: i32, %span_count: i32, %output_count: i32, %epoch_count: i32, %continuation_shape: i32, %continuation_proposes: i32, %first_media_count: i32, %next_media_count: i32, %residual: hal.buffer, %metadata: hal.buffer, %origins: hal.buffer, %state: hal.buffer, %tokens: hal.buffer, %outputs: hal.buffer, %carry: hal.buffer, %committed: hal.buffer, %results: hal.buffer, %draft_cache: hal.buffer, %draft_origins: hal.buffer, %next_results: hal.buffer) -> (i64) {
  %c0 = scalar.constant 0 : i32
  %c1 = scalar.constant 1 : i32
  %c0_i64 = scalar.constant 0 : i64
  %bounded_shape = scalar.assume %shape [range(%shape, 0, 127)] : i32
  %shape_index = index.cast %bounded_shape : i32 to index
  %advance_at = index.constant 128 : offset
  %verify_at = index.constant 640 : offset
  %warm_at = index.constant 1152 : offset
  %draft_at = index.constant 1664 : offset
  %advance_view = buffer.view %control_state[%advance_at] : buffer -> view<128xi32>
  %verify_view = buffer.view %control_state[%verify_at] : buffer -> view<128xi32>
  %warm_view = buffer.view %control_state[%warm_at] : buffer -> view<128xi32>
  %draft_view = buffer.view %control_state[%draft_at] : buffer -> view<3xi32>
  %propose_first = view.load %draft_view[0] : view<3xi32> -> i32
  %levels = view.load %draft_view[1] : view<3xi32> -> i32
  %kind = view.load %draft_view[2] : view<3xi32> -> i32
  %drafting = scalar.cmpi ne, %kind, %c0 : i32
  %propose = scalar.cmpi ne, %proposes, %c0 : i32
  %verify = scalar.cmpi ne, %verifies, %c0 : i32
  %flag_at = index.constant 1676 : offset
  %flag_view = buffer.view %control_state[%flag_at] : buffer -> view<1xi32>
  %flag = view.load %flag_view[0] : view<1xi32> -> i32
  %gated = scalar.cmpi ne, %flag, %c0 : i32
  %flag_nz = scf.select %gated, %flag, %c1 : i32
  %flag_idx = scalar.subi %flag_nz, %c1 : i32
  %flag_b = scalar.assume %flag_idx [range(%flag_idx, 0, 127)] : i32
  %flag_shape = index.cast %flag_b : i32 to index
  %eff_index = scf.select %gated, %flag_shape, %shape_index : index
  %ungated = scalar.cmpi eq, %flag, %c0 : i32
  %propose_on = scalar.andi %propose, %ungated : i1
  scf.if %propose_on {
    %bits = scalar.constant 32 : i32
    %below = scalar.subi %span_count, %c1 : i32
    %leading = scalar.ctlzi %below : i32
    %level = scalar.subi %bits, %leading : i32
    %last = scalar.subi %levels, %c1 : i32
    %chosen = scalar.minui %level, %last : i32
    %pstage = scalar.addi %propose_first, %chosen : i32
    %proposal = func.call @execute_5(%pstage, %metadata, %tokens, %draft_origins, %draft_cache, %carry) : (i32, hal.buffer, hal.buffer, hal.buffer, hal.buffer, hal.buffer) -> (i64)
  }
  %target = scf.if %verify -> (i64) {
    %vstage = view.load %verify_view[%eff_index] : view<128xi32> -> i32
    %completion = func.call @execute_7(%vstage, %residual, %metadata, %origins, %state, %tokens, %committed, %results) : (i32, hal.buffer, hal.buffer, hal.buffer, hal.buffer, hal.buffer, hal.buffer, hal.buffer) -> (i64)
    %count64 = scalar.extui %span_count : i32 to i64
    %record = scalar.constant 40 : i64
    %length = scalar.muli %count64, %record : i64
    %feedback = func.call @feedback(%c1, %results, %c0_i64, %length) : (i32, hal.buffer, i64, i64) -> (i64)
    scf.yield %completion : i64
  } else {
    %astage = view.load %advance_view[%eff_index] : view<128xi32> -> i32
    %completion = func.call @execute_6(%astage, %residual, %metadata, %origins, %state, %tokens, %outputs) : (i32, hal.buffer, hal.buffer, hal.buffer, hal.buffer, hal.buffer, hal.buffer) -> (i64)
    %count64 = scalar.extui %span_count : i32 to i64
    %word = scalar.constant 4 : i64
    %length = scalar.muli %count64, %word : i64
    %feedback = func.call @feedback(%c0, %outputs, %c0_i64, %length) : (i32, hal.buffer, i64, i64) -> (i64)
    scf.yield %completion : i64
  }
  %done = scf.if %drafting -> (i64) {
    %accepted = scf.if %verify -> (hal.buffer) {
      scf.yield %committed : hal.buffer
    } else {
      scf.yield %metadata : hal.buffer
    }
    %wstage = view.load %warm_view[%eff_index] : view<128xi32> -> i32
    %warm = func.call @execute_6(%wstage, %residual, %accepted, %draft_origins, %draft_cache, %carry, %tokens) : (i32, hal.buffer, hal.buffer, hal.buffer, hal.buffer, hal.buffer, hal.buffer) -> (i64)
    scf.yield %warm : i64
  } else {
    scf.yield %target : i64
  }
  func.return %done : i64
}