From ab667139475478f97fb53ba0041daaf61bd55cf7 Mon Sep 17 00:00:00 2001 From: Ettore Di Giacinto Date: Wed, 12 Aug 2026 23:36:02 +0000 Subject: [PATCH 1/4] =?UTF-8?q?port(ltx-2.5):=20L10=20=E2=80=94=20a=20text?= =?UTF-8?q?=20prompt=20drives=20the=2012B=20tower,=20and=20the=20oracle=20?= =?UTF-8?q?L3=20said=20did=20not=20exist=20(#435)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit LTX-2.5 advertises text-to-video and could not be typed at. `has_encoder()` was false and a prompt-carrying request was refused by name. This makes the prompt path RUN: a real string tokenizes with the tokenizer the checkpoint ships as a TENSOR, the torchao-NVFP4 Gemma-4 tower is materialized and forwarded, all 49 hidden states feed the existing aggregation, and both caption projections emit the two conditioning streams. One commit because the doc-checkpoint gate is per-commit and every part owes the same two documents; the four blocks below are how a reviewer should read it. ──────────────────────────────────────────────────────────────────────────────── 1. THE ORACLE L3 RECORDED AS IMPOSSIBLE WAS A `transformers` VERSION Phase L3 recorded that the tower could not be gated: no `gemma4_unified` in `CONFIG_MAPPING`, so it could not be built at reduced dims and there was nothing to compare against. That was never a property of the tower. MEASURED both ways on this box: /usr/bin/python3 transformers 5.3.0 -> KeyError 'gemma4_unified' /home/mudler/recon-cpu/venv transformers 5.12.1 -> builds and RUNS the tower So `Gemma4Model::ForwardHiddenStates` is now held to a RUNNING upstream instead of to invariants derived from its own output. gemma4.h has said "grounded + compiles" since it landed; compiling is not running. THE TOLERANCE IS A MEASUREMENT. Our stream carries bf16 and widens only on the way out; bf16 is also upstream's own resolved model dtype (base_encoder.py:41). So "is a difference a defect?" has a measurable answer: how far does UPSTREAM's answer move when the SAME upstream code runs at bf16 instead of f32? The generator measures exactly that, per state, and emits it as the bound. Nobody picked it, and it cannot be loosened to rescue a failure — loosening it means regenerating it, which means the oracle moved. state ours vs bf16 oracle the floor ratio 0 0 0.000923 0.00x 1 0.03125 0.072665 0.43x 3 0.191406 0.305009 0.63x 6 0.34375 0.559325 0.61x 9 0.46875 0.683670 0.69x 11 0.650391 1.098824 0.59x 12 0.149658 0.210947 0.71x Worst 0.71x over all 13 states. We are closer to upstream-in-bf16 than upstream-in-bf16 is to upstream-in-f32, at every layer; state 0 is bit-identical. The f32 arm is gated too, at the triangle bound, because a bf16 store is exactly what absorbs a reduction-order defect. THE FIXTURE DISCRIMINATES (§7.0(c)). The shipped 12B is not one repeated layer: (sliding x 5, full) eight times, and the two kinds differ — 16 q heads x 256 with 8 kv heads and a `v_proj`, against 16 x 512 with ONE kv head and no `v_proj` at all (`attention_k_eq_v` aliases V onto K), plus two rope types at two thetas and partial rotary on the full arm only. The reduced arch keeps every one and repeats the pattern twice, so a full layer is neither first nor last and a sliding layer FOLLOWS a full one. MUTATION-PROVEN: dropping `layer_scalar` -> 34 assertions RED; capturing the RAW last layer instead of the final-normed one -> 3 RED. Tree restored byte-for-byte (md5 040b97bf6b753f04be1855eaefc76ea1) and green re-confirmed after each. THE CONFIG IS NOT GUESSED. The shipped vonkaiser build has NO `__metadata__`, so its Gemma config cannot come from the file — which is also why upstream's own `GemmaAssets.from_single_file` raises on it. The committed config is the `__metadata__["gemma_config"]` of the OFFICIAL bf16 text encoder, read with an 84 KB HTTP RANGE request over the safetensors header: no large download, and the authoritative source rather than a reconstruction. It independently confirms §1.4's corrected width — `video_aggregate_embed.weight` is BF16 [4096, 188160] there, unpacked, where the NVFP4 build stores [4096, 94080]. `ParseHfConfig(json, source)` exists for that: a config does not always arrive as a sibling config.json, and writing one to a temp file to read it back would put the temp directory on a model path. ──────────────────────────────────────────────────────────────────────────────── 2. THE PROMPT PATH, AND A TOKENIZER THAT SHIPS AS A TENSOR LTX-2.5's text encoder embeds its tokenizer as `tokenizer_json` U8 [32169626] inside the one safetensors file (gemma_assets.py:34-36). Every loader in this tree assumed a sibling `tokenizer.json`, so none could read this checkpoint; hence `Tokenizer::FromHfJsonBytes`. GATE 1 — the WRAPPER, inline fixture, no asset. Strip; BOS prepended CONDITIONALLY (prepending unconditionally doubles it and drops the last token); LEFT padding so the valid run is the TAIL; truncate-then-prepend-then-re-truncate so a maximal prompt loses its LAST token rather than its BOS; an empty prompt still carrying exactly one BOS; and a refusal with no bos id, where upstream also raises (tokenizer.py:34-36). GATE 2 — REAL prompts, the REAL 262144-entry vocab, TOKEN-EXACT. Four prompts x 1024 positions, ids and mask, vs HuggingFace `tokenizers` 0.22.2: prompt 0 (10 valid tokens): first mismatching index = -1 (-1 = EXACT) prompt 1 (11 valid tokens): -1 prompt 2 ( 1 valid token ): -1 prompt 3 (43 valid tokens): -1 No tolerance appears in that gate. The prompts discriminate: one with leading and trailing whitespace, one EMPTY, one 43-token cinematic prompt with punctuation and digits. THE DISAGREEMENT, followed to the model author and recorded. `ltx_core` prepends BOS explicitly and says why — "Gemma 3 already emits it via post_processor; Gemma 4 does not, so we prepend" (tokenizer.py:12-15). diffusers instead passes `add_special_tokens=True` (pipeline_ltx2.py:339). MEASURED on the shipped tokenizer: its post_processor is a TemplateProcessing with ZERO special_tokens, so it adds nothing and diffusers would produce every prompt without a BOS. That measurement is emitted into the goldens header, so the reason is attached to the artifact. ──────────────────────────────────────────────────────────────────────────────── 3. THE TOWER ITSELF, CLOSING L6's RECORDED DEBT L6 recorded verbatim: "the torchao arm of the Gemma TOWER itself (`Gemma4Weights`) is not wired ... L6 loads the two caption projections, the asset pack and the geometry, and VALIDATES every tower module without materializing it." `Ltx2LoadGemmaTowerFromSafetensors` closes it, reusing L6's own `Ltx2DequantTorchaoNvfp4ToBf16` unchanged. WHY NOT `gemma4_weights.cpp`. The LTX file ships FLAT names (`model.layers.{i}.self_attn.q_proj.weight`); that loader reads the multimodal-wrapper form `model.language_model.layers.{i}....`. And every U8 width is HALF its logical one, so each layer's geometry is resolved from the CONFIG and the stored shapes are checked against it, never the reverse — a loader that trusted stored widths would build a tower of exactly half the right width whose matmuls all still conform among themselves. REFUSALS, each naming a specific wrong model: a PLE config against a checkpoint with no PLE tensors; `num_kv_shared_layers` != 0, where a shared layer reads a cache nobody wrote; a `v_proj` present or absent against what `attention_k_eq_v` declares, which is 16 kv heads of difference that every shape check passes; and a module in neither the BF16 nor the torchao-NVFP4 form. THE COST THE PORT DOES NOT PAY. Upstream pads every prompt to 1024 and runs all 1024 rows through a 12B tower; this runs the prompt's OWN length at the original absolute positions. Both halves of that equivalence are MEASURED, not argued: upstream's own padded-vs-short f32 spread is 3.2e-05 over a max|value| of 14.35, and our short run reproduces the padded run's valid rows at 0.5x the dtype bound. Writing that gate the obvious wrong way is kept in the test rather than quietly fixed: declaring seq_len = P + T while writing only T keys has attention read P slots of zeroes and call them keys — max|diff| 17.97 against max|value| 14.35. MEASURED END TO END on the real checkpoint (opt-in; ~33 GB host, ~26 min CPU): 329 torchao-NVFP4 modules dequantized; 48 layers, 8 of them full-attention at head_dim 512 / 1 kv head / no v_proj, 40 sliding at 256 / 8 kv heads prompt "a red fox running through deep snow at sunrise" -> 10 tokens -> video [1024, 4096] max|v| = 34.0715 mean|v| = 0.0401384 -> audio [1024, 2048] max|v| = 27.1555 a DIFFERENT prompt differs by max|diff| = 33.7318 6,292,805 assertions, 0 failed VALUES, not `isfinite`: a conditioning tensor of zeros would satisfy every shape and finiteness check and render an unconditioned clip, and a tower that ignored its input entirely would pass everything except the two-prompt arm. ──────────────────────────────────────────────────────────────────────────────── 4. WHY `has_encoder()` IS STILL FALSE Upstream does not hand the caption projections to cross-attention. Each stream goes through an `Embeddings1DConnector` first (embeddings_processor.py:70-117). Its MATH is ported — `Ltx2ConnectorForward` — but its WEIGHTS are not loaded: they ship inside the DiT file as `video_embeddings_connector.*` / `audio_embeddings_connector.*` and remain among the modules `Ltx2LoadDitFromSafetensors` REFUSES (ltx2_loader.h:96-99). MEASURED in the shipped FP8 DiT header: 372 such tensors, `learnable_registers [128, 2048]` on the audio arm, and `attn2.to_k.weight [4096, 4096]` confirming the video stream's 4096 is exactly the width the projections emit. So the conditioning this change computes has nowhere to go, and a `true` here would promise a render that cannot complete. The refusal therefore MOVES rather than lifts: `encoder_path` is still refused, but the message now names the connector weights instead of the tower, because the old message — "the Gemma-4 TOWER itself is owed" — is no longer true, and a stale refusal is worse than a blunt one. Flipping the flag is one change away, in files this row does not own. ──────────────────────────────────────────────────────────────────────────────── BASELINES, all matching, none moved test_ltx2 29/1615 test_ltx2_vae 16/1816 test_ltx2_pipeline 35/2358 test_ltx2_loader 20/2363 test_ltx2_video 17/170 test_ops_attention_cross 9/32 test_minimax_h3 79/57395 test_minimax_h3_video_fold 6/137 test_video_engine 11/254 test_capi 55/505 test_gemma4_honesty 2/6 test_gemma4_rocm_fp8_seams 2/10 test_gemma3_forward 3/503 test_tool_parser_gemma4 72/161 test_gemma4_vision_tower / registry_e2e / audio_tower / paged_engine 1/0 each test_ltx2_text_encoder 17/3350 -> 23/3583 (+6 cases; +16 assertions with CHECKPOINT_ROOT, +6,289,222 with the e2e opt-in) FOLLOWING_AGENTS_PROTOCOL Following-Agents-Protocol: true AI-Assisted: true Assisted-by: AGENT:claude-opus-5 [Claude Code] --- .agents/porting-inventory.md | 19 +- docs/FEATURES.md | 2 +- docs/USAGE.md | 57 + .../model_executor/models/ltx2_text_encoder.h | 189 ++ include/vllm/multimodal/ltx2_video.h | 27 +- include/vllm/tokenizer/tokenizer.h | 12 + include/vllm/transformers_utils/hf_config.h | 17 + scripts/gen-ltx2-gemma-tower-goldens.py | 549 ++++ scripts/gen-ltx2-prompt-tokens-goldens.py | 191 ++ .../models/ltx2_text_encoder.cpp | 498 +++ src/vllm/multimodal/ltx2_video.cpp | 40 +- src/vllm/tokenizer/tokenizer.cpp | 12 +- src/vllm/transformers_utils/hf_config.cpp | 44 +- .../vllm/models/ltx2_gemma4_text_config.json | 170 + .../vllm/models/ltx2_gemma_tower_goldens.inc | 2784 +++++++++++++++++ .../models/ltx2_prompt_tokens_goldens.inc | 574 ++++ tests/vllm/models/test_ltx2_text_encoder.cpp | 837 +++++ 17 files changed, 5994 insertions(+), 28 deletions(-) create mode 100644 scripts/gen-ltx2-gemma-tower-goldens.py create mode 100644 scripts/gen-ltx2-prompt-tokens-goldens.py create mode 100644 tests/vllm/models/ltx2_gemma4_text_config.json create mode 100644 tests/vllm/models/ltx2_gemma_tower_goldens.inc create mode 100644 tests/vllm/models/ltx2_prompt_tokens_goldens.inc diff --git a/.agents/porting-inventory.md b/.agents/porting-inventory.md index db65f3f9e..10a27d2fd 100644 --- a/.agents/porting-inventory.md +++ b/.agents/porting-inventory.md @@ -1250,7 +1250,24 @@ Examples: `examples/cli` ✅ (C-API client), `examples/server` ✅ (OpenAI serve (`Gemma4Weights`) is not wired — `ltx2_text_encoder.h` declares no tower contract, so L6 loads the two caption projections, the asset pack and the geometry, and VALIDATES every - tower module without materializing it. + tower module without materializing it. **CLOSED at L10 (2026-08-12):** + `Ltx2LoadGemmaTowerFromSafetensors` (ltx2_text_encoder.h/.cpp) materializes + the tower onto `Gemma4Weights`, reusing L6's + `Ltx2DequantTorchaoNvfp4ToBf16` unchanged. It reads the FLAT + `model.layers.{i}.*` names the LTX file ships — not the + `model.language_model.layers.{i}.*` form `gemma4_weights.cpp` reads, which + is why the tower could not simply go through that loader — and resolves + each layer's geometry from `layer_types`, `global_head_dim` and + `num_global_key_value_heads` rather than from the stored tensor widths, + which are HALF the logical ones under NVFP4. It REFUSES by name: a PLE + config against a checkpoint with no PLE tensors, `num_kv_shared_layers` + != 0, a `v_proj` present or absent against what `attention_k_eq_v` + declares, and a module in neither the BF16 nor the torchao-NVFP4 form. + The Gemma config is an INPUT and is never inferred: the shipped + `vonkaiser` build has NO `__metadata__` at all, and `layer_types`, + `global_head_dim`, `num_global_key_value_heads`, `attention_k_eq_v` and + both `rope_parameters` entries each move every hidden state while leaving + the tensor set byte-identical. * **Spec:** [ltx-2.5 spec](specs/ltx-2-5.md) §1.4 and §6 (L6). Lifecycle: shipped (host + load-time device staging). Owner: the LTX-2.5 row. * **OWED, FOUND 2026-08-12 by the phase-L8 GB10 run (entry 20 below).** The diff --git a/docs/FEATURES.md b/docs/FEATURES.md index 907278e6c..e32731eb8 100644 --- a/docs/FEATURES.md +++ b/docs/FEATURES.md @@ -149,7 +149,7 @@ they sit outside the gated list above. | Voxtral audio (`VoxtralForConditionalGeneration`) | Voxtral-Mini-3B-2507 | near-tie-robust 16/16 vs vLLM 0.25.0 | decode 0.97x (beats vLLM); encoder TTFT ~17x, pending | | Whisper audio encoder | openai/whisper-small; whisper-large-v3 (Voxtral cfg) | encoder tower 77/77; large-v3 tower 203/203 | pending | | MiniMax-H3 DiT (`MiniMaxH3DiTModel`, vllm-omni lane) | MiniMax-H3 (33.1B video+audio) | portable 79/79; all three modalities COHERENT on Q4_K_M (§8.20); PRUNED ckpts run, Q8_0 seam 0.9941 (§8.21); ref2va grid was NVFP4 quant error, §8.9 REFUTED; GGUF/NVFP4/bf16 shards stream | FP4/Marlin landed; speed pending; no bf16 render yet. Render from the Q4_K_M GGUF, not the NVFP4 arm. Krea 2 text-to-image (roadmap C11) is scoped to reuse these DiT seams | -| LTX-2.5 DiT (`LTX2VideoTransformer3DModel`, Lightricks lane) | LTX-2.5 (21.00B video+audio) | `SPIKE`. DiT, both VAE decoders, the pipeline layer and the quantized loaders gated vs upstream at reduced dims: max\|diff\| 1.2e-07 DiT, 1.8e-06 VAE, 2.8e-06 pipeline. Reachable as VideoEngine family `ltx-2.5`; STRUCTURAL e2e only, no render-quality claim | Fits ONE GB10 at ~29 GB NVFP4. FP8 + torchao-NVFP4 arms load. CPU (f32) and CUDA (`device=1`, bf16 device-resident). Text tower, DiffVAE, LoRA, image conditioning refused. FP4-resident arm OWED. Speed PENDING | +| LTX-2.5 DiT (`LTX2VideoTransformer3DModel`, Lightricks lane) | LTX-2.5 (21.00B video+audio) | `SPIKE`. DiT, both VAE decoders, the pipeline layer and the quantized loaders gated vs upstream at reduced dims: max\|diff\| 1.2e-07 DiT, 1.8e-06 VAE, 2.8e-06 pipeline. Reachable as VideoEngine family `ltx-2.5`; STRUCTURAL e2e only, no render-quality claim | Fits ONE GB10 at ~29 GB NVFP4. FP8 + torchao-NVFP4 arms load. CPU (f32), CUDA (`device=1`, bf16). Text tower RUNS; `encoder_path` refused, connector weights unbound. DiffVAE/LoRA/image cond refused. Speed PENDING | | MTP speculator | Qwen3.6-27B, Qwen3.6-35B-A3B | token-identical to vLLM `mtp` at c1 | ~4% faster c1; +16% output tput (MoE) | | DFlash block-diffusion | Qwen3 (DFlash draft) | near-tie e2e 27/27 vs vLLM | 2.9x over spec-off, 1.003x vs vLLM DFlash-on | | DeepSeek-V4 MTP | DeepSeek-V4-Flash (nextn head) | lossless 5/5; real-model weight-blocked | pending | diff --git a/docs/USAGE.md b/docs/USAGE.md index 991e08c4f..47d7614f3 100644 --- a/docs/USAGE.md +++ b/docs/USAGE.md @@ -333,6 +333,19 @@ message naming the missing neighborhood-attention kernel. It never falls back to the convolutional decoder, because that would hand back a lower quality render as if it were the one you asked for. +A second behaviour changed and is worth stating precisely, because the reason a +prompt is refused has moved. The Gemma-4 text tower now RUNS: a prompt string +tokenizes with the tokenizer the checkpoint ships as a tensor, the torchao-NVFP4 +tower is materialized and forwarded, all 49 hidden states feed the multi-layer +aggregation, and both caption projections produce the 4096-wide video and +2048-wide audio conditioning streams. What is still missing is the hop from there +into cross-attention: upstream routes each stream through an +`Embeddings1DConnector` first, and while that connector's math is ported, its +weights ship inside the DiT file and are still among the modules the DiT loader +refuses. So `encoder_path` is still refused — with a message that now names the +connector weights rather than the tower — and `has_encoder()` is still false. +Conditioning meanwhile comes from `prompt_embeds_path`. + ### Muse Glimmer: exactly what has been checked `MuseGlimmerForCausalLM` / `MuseGlimmerForConditionalGeneration` are not in that @@ -1543,6 +1556,50 @@ python3 scripts/gen-ltx2-pipeline-goldens.py \ cmake --build build --target test_ltx2_pipeline && ./build/tests/test_ltx2_pipeline ``` +### The Gemma-4 text tower gate, and the interpreter it needs + +The text tower is gated against the UPSTREAM HuggingFace implementation built and +run at reduced dimensions. It needs a `transformers` that registers +`gemma4_unified` in `CONFIG_MAPPING` — **5.8 or newer; 5.3.0 does not have it and +fails in a way that reads exactly like "Gemma-4 is unsupported"**. The generator +refuses such an interpreter by name rather than emitting goldens from a tower it +could not build. + +```sh +/path/to/venv/bin/python scripts/gen-ltx2-gemma-tower-goldens.py \ + --out tests/vllm/models/ltx2_gemma_tower_goldens.inc +cmake --build build --target test_ltx2_text_encoder && ./build/tests/test_ltx2_text_encoder +``` + +No checkpoint and no download: the reduced config comes from +`tests/vllm/models/ltx2_gemma4_text_config.json`, which is the +`__metadata__["gemma_config"]` of the official bf16 text encoder, and every weight +is rebuilt on both sides from the deterministic stream. The tolerance is not a +constant — the generator MEASURES how far upstream's own answer moves between f32 +and bf16 and emits that per state as the bound. + +Two more gates want the real checkpoint. The prompt-token goldens are regenerated +from the tokenizer the text encoder ships **as a tensor**, and the end-to-end case +dequantizes the 12B tower to roughly 24 GB of host bf16, so it is opt-in rather +than checkpoint-presence gated: + +```sh +TE=$CHECKPOINT_ROOT/ltx-2.5/vonkaiser-fp8-nvfp4/text_encoders/gemma4-12b-with-proj-nvfp4-torchao.safetensors +/path/to/venv/bin/python scripts/gen-ltx2-prompt-tokens-goldens.py \ + --text-encoder "$TE" \ + --out tests/vllm/models/ltx2_prompt_tokens_goldens.inc + +# real vocab, token-exact vs HuggingFace +CHECKPOINT_ROOT=... ./build/tests/test_ltx2_text_encoder --test-case="ltx2 prompt: REAL*" + +# the full 12B vertical: ~33 GB host, minutes of CPU +CHECKPOINT_ROOT=... VLLM_CPP_LTX2_TOWER_E2E=1 \ + ./build/tests/test_ltx2_text_encoder --test-case="ltx2 e2e*" +``` + +`VLLM_CPP_LTX2_TEXT_ENCODER` names the file directly when it does not sit under +`CHECKPOINT_ROOT` at the path above. + Recipes resolve on an EXACT `(pipeline_kind, model_version)` pair and refuse anything else by name rather than defaulting, because a plausible but wrong sigma schedule or guidance scale renders a video instead of failing. The pairs that diff --git a/include/vllm/model_executor/models/ltx2_text_encoder.h b/include/vllm/model_executor/models/ltx2_text_encoder.h index c64262197..4b5236efe 100644 --- a/include/vllm/model_executor/models/ltx2_text_encoder.h +++ b/include/vllm/model_executor/models/ltx2_text_encoder.h @@ -90,11 +90,15 @@ #include +#include "vllm/model_executor/models/gemma4.h" #include "vt/dtype.h" namespace vllm { class SafetensorsFile; +namespace tok { +class Tokenizer; +} // namespace tok // ─────────────────────────── the hidden-state contract ─────────────────────── @@ -372,4 +376,189 @@ inline constexpr const char* kLtx2GemmaAssetPrefix = "hf_asset__"; Ltx2GemmaAssets Ltx2LoadGemmaAssets(const SafetensorsFile& file, bool require_config = true); +// ─────────────────────── the prompt -> tokens hand-off ─────────────────────── +// +// `LTXGemmaTokenizer.tokenize_with_weights` (tokenizer.py:31-59), which is the +// ONLY tokenization on the conditioning path. Both references agree that no chat +// template is applied here — the template belongs to the separate prompt +// ENHANCEMENT path (base_encoder.py:100, diffusers pipeline_ltx2.py:624), which +// produces a plain string that then comes back through this function. + +// gemma_assets.py:162 — `TOKENIZER_MAX_LENGTH = 1024`, bound at +// base_encoder.py:231-236. Confirmed independently by diffusers, whose +// `_get_gemma_prompt_embeds` defaults `max_sequence_length: int = 1024` +// (pipeline_ltx2.py:304). +inline constexpr int64_t kLtx2GemmaTokenizerMaxLength = 1024; + +// base_encoder.py:235 — `PaddingSide.LEFT`. diffusers sets the same thing +// explicitly with the comment "Gemma expects left padding for chat-style +// prompts" (pipeline_ltx2.py:328-329). +// +// This is why `Ltx2GemmaPromptTokens` reports `first_valid` rather than assuming +// position 0: the valid tokens are the TAIL, and their absolute positions start +// at the pad count, not at zero. +enum class Ltx2GemmaPaddingSide { kLeft, kRight }; + +// One tokenized prompt, in upstream's `[max_length]` shape. +struct Ltx2GemmaPromptTokens { + // [max_length]. Pad positions carry `pad_id`. + std::vector input_ids; + // [max_length] in {0, 1} — the second element of upstream's (token, weight) + // pairs (tokenizer.py:57-59), used as the attention mask at + // base_encoder.py:65-67. + std::vector attention_mask; + // Index of the first valid token, and how many there are. On the LEFT-padded + // default `first_valid` is the pad count and the valid run is the tail. + int64_t first_valid = 0; + int64_t num_valid = 0; + // True when the prompt was longer than `max_length` and lost tokens. + bool truncated = false; +}; + +// tokenizer.py:31-59, mirrored including the parts that look like details: +// +// * `text.strip()` first (:33). diffusers strips too (pipeline_ltx2.py:333). +// * encode with NO special tokens added by the post_processor. The shipped +// tokenizer's `post_processor` is a TemplateProcessing whose `special_tokens` +// map is EMPTY, so it would add nothing anyway — measured on the shipped +// file, not assumed. +// * then PREPEND BOS unconditionally if it is not already first (:44-46). +// THIS IS WHERE THE TWO REFERENCES DISAGREE and upstream is followed: +// `ltx_core` prepends explicitly and says why — "Gemma 3 already emits it +// via post_processor; Gemma 4 does not, so we prepend" (tokenizer.py:12-15) +// — while diffusers passes `add_special_tokens=True` and relies on the +// post_processor (pipeline_ltx2.py:339), which for THIS tokenizer.json adds +// nothing. Following diffusers would drop token 0 of every prompt. Recorded +// rather than silently resolved: `ltx_core` is the model author's own +// runtime and is explicit about the case. +// * EOS is never appended (:14). +// * truncation happens BEFORE the BOS prepend and again after (:41, :46), so a +// maximal prompt loses its LAST token to make room for BOS rather than +// losing the BOS. +// * pad to exactly `max_length` on `padding_side` (:48-54). +// +// Throws std::runtime_error when `bos_id` is negative — upstream raises for the +// same reason at tokenizer.py:34-36, because a conditioning path with no BOS is +// a different prompt, not a degraded one. +Ltx2GemmaPromptTokens Ltx2TokenizeGemmaPrompt( + const tok::Tokenizer& tokenizer, const std::string& prompt, int32_t bos_id, + int32_t pad_id, int64_t max_length = kLtx2GemmaTokenizerMaxLength, + Ltx2GemmaPaddingSide padding_side = Ltx2GemmaPaddingSide::kLeft); + +// The two ids upstream reads off the tokenizer/config rather than hardcoding. +// MEASURED on the shipped checkpoint's own `hf_asset__generation_config.json`: +// `bos_token_id` 2, `pad_token_id` 0 — and its `tokenizer_json` added_tokens +// agree (`` 0, `` 1, `` 2). +struct Ltx2GemmaSpecialIds { + int32_t bos_id = -1; + int32_t pad_id = -1; +}; + +// Resolve the two ids from the asset pack, or throw naming which one is missing. +// Reads `hf_asset__generation_config.json` first (that is where the checkpoint +// states them) and falls back to the tokenizer's own added-token table, which is +// what `LTXGemmaTokenizer` does through `tokenizer.bos_token_id` +// (tokenizer.py:35) and `tokenizer.pad_token` (:26-27). +Ltx2GemmaSpecialIds Ltx2ResolveGemmaSpecialIds(const Ltx2GemmaAssets& assets, + const tok::Tokenizer& tokenizer); + +// ───────────────────────────── the Gemma-4 TOWER ───────────────────────────── +// +// Phase L6 loaded the two caption projections and the asset pack and recorded +// "wiring the tower's torchao arm onto `Gemma4Weights` is owed and named as such +// rather than half-done" (ltx2_loader.h:325-329). This is that wiring. +// +// WHERE THE CONFIG COMES FROM, because this checkpoint cannot answer it. +// The shipped `vonkaiser` NVFP4 build carries NO `__metadata__` block at all, so +// upstream's own `GemmaAssets.from_single_file` raises on it before reading a +// tensor (gemma_assets.py:110-114) and there is nothing in the file to read a +// Gemma config out of. The config is therefore an INPUT, and a caller that has +// none gets a refusal naming the missing piece rather than a plausible default. +// +// The fields that no shape encodes, and that a default would get wrong: +// +// layer_types which layers are full vs sliding. The shipped +// tower is (sliding x 5, full) x 8, and the two +// have DIFFERENT geometry. +// global_head_dim 512 on the full layers against head_dim 256. +// num_global_key_value_heads ONE, against 8 on the sliding layers. +// attention_k_eq_v true — the full layers ship no `v_proj` at all. +// rope_parameters two rope types at two thetas, partial rotary +// 0.25 on the full arm only. +// rms_norm_eps, sliding_window, final_logit_softcapping +// +// Each moves every hidden state while leaving the tensor set byte-identical, so +// a wrong config resolves a DIFFERENT MODEL out of the same file and nothing +// downstream can tell. That is why this takes the config rather than inferring +// it: shapes can confirm a config, and cannot supply one. + +// The tower, materialized. `weights` is bf16 throughout — the NVFP4 modules are +// dequantized on the way in, which is what `Gemma4Model::ForwardHiddenStates` +// consumes and what upstream's own resolved model dtype is +// (base_encoder.py:41). At the shipped 12B that is ~24 GB of host memory, and +// the caller is told so here rather than discovering it. +struct Ltx2GemmaTower { + HfConfig config; + Gemma4Weights weights; + // Every module that arrived NVFP4-packed and was dequantized, in header order. + // A tower whose modules are all bf16 already leaves this empty. + std::vector dequantized_modules; +}; + +// Materialize the Gemma-4 tower from an LTX text-encoder safetensors file. +// +// Reads `model.embed_tokens.*`, `model.norm.weight` and `model.layers.{i}.*` and +// IGNORES everything else the file carries — `vision_model.*`, +// `multi_modal_projector`, `audio_projector` and the two caption projections are +// all present in the shipped checkpoint and none of them is on the text path. +// Ignoring is deliberate and not laziness: choking on their presence would make +// the only shipped checkpoint unreadable. +// +// Each module is taken bf16 when it is stored bf16 and dequantized through +// `Ltx2DequantTorchaoNvfp4ToBf16` when it carries a `torchao_nvfp4` marker. +// A module in neither form throws BY NAME. +// +// REFUSES, by name, rather than loading something shaped like a tower: +// * a `v_proj` present on a layer the config says is `attention_k_eq_v`, or +// absent on one it does not — the two cases are 16 kv heads apart; +// * any per-layer tensor whose width disagrees with the geometry the config +// resolves for THAT layer; +// * `hidden_size_per_layer_input` > 0, i.e. a PLE tower, since this checkpoint +// family ships no `embed_tokens_per_layer` and a silently-absent PLE is a +// different model. +Ltx2GemmaTower Ltx2LoadGemmaTowerFromSafetensors(const SafetensorsFile& file, + const nlohmann::json& gemma_config); + +// ─────────────────────── prompt -> conditioning, end to end ────────────────── +// +// `LTXGemmaTextEncoder.encode` (base_encoder.py:49-71) followed by +// `EmbeddingsProcessor.process_hidden_states` (embeddings_processor.py:70-117). +// +// WHAT THIS DOES NOT DO, and why it is not a shortcut. Upstream pads every +// prompt to 1024 and runs all 1024 rows through the tower. This runs only the +// VALID tokens, at their ORIGINAL absolute positions, and treats the pad rows as +// zero. That is equivalent, not approximate: pads are masked out of attention +// and sit causally before every valid token, and the feature extractor zeroes +// their rows anyway (feature_extractor.py:63-64). Both halves of that are +// MEASURED rather than argued — upstream's own padded-vs-short f32 spread is +// f32 round-off, and our short run reproduces the padded run's valid rows, both +// gated in tests/vllm/models/test_ltx2_text_encoder.cpp. At the shipped 1024 it +// is the difference between a 12B forward over 1024 rows and over the prompt's +// own length. +struct Ltx2PromptConditioning { + Ltx2TextConditioning conditioning; + Ltx2GemmaPromptTokens tokens; + // [max_length], the binary mask the extractor consumed — 1 on a valid token. + std::vector mask; + int64_t seq = 0; // == max_length; the DiT sees the full padded width +}; + +// `queue` runs the tower. `weights`/`config` are the caption projections and the +// resolved V1/V2 shape, exactly as `Ltx2TextFeatureExtractorForward` takes them. +Ltx2PromptConditioning Ltx2EncodePromptToConditioning( + const Ltx2GemmaTower& tower, const tok::Tokenizer& tokenizer, + const Ltx2GemmaSpecialIds& ids, const Ltx2TextEncoderWeights& weights, + const Ltx2TextFeatureConfig& feature_config, const std::string& prompt, + vt::Queue& queue, int64_t max_length = kLtx2GemmaTokenizerMaxLength); + } // namespace vllm diff --git a/include/vllm/multimodal/ltx2_video.h b/include/vllm/multimodal/ltx2_video.h index 8019e8679..610bf31a4 100644 --- a/include/vllm/multimodal/ltx2_video.h +++ b/include/vllm/multimodal/ltx2_video.h @@ -44,12 +44,27 @@ // CPU forward behind a CUDA-looking handle, because that substitution is what // would make every later timing and every "it ran on the GPU" claim false. // -// 2. A PROMPT with no text tower. Phase L6 loads the caption projections and the -// embedded tokenizer, and records the Gemma-4 TOWER itself as owed -// (ltx2_loader.h:318-324) — so this engine cannot turn a prompt string into -// hidden states. `has_encoder()` is therefore false and a prompt-carrying -// request is refused BY NAME. Conditioning comes from prompt-embeds, which is -// the seam's own documented fallback (video_engine.h:55-57). +// 2. A PROMPT, whose refusal has MOVED and is stated where it now lives. +// Phase L10 built the text tower: the embedded tokenizer reaches a prompt +// string, the torchao-NVFP4 Gemma-4 tower is materialized onto Gemma4Weights, +// it runs, all 49 hidden states come out within the oracle's own bf16 noise +// floor, and the aggregation and both caption projections turn them into the +// 4096-wide video and 2048-wide audio conditioning streams +// (`Ltx2EncodePromptToConditioning`). +// +// What is missing is the last hop. Upstream does not hand the projections to +// cross-attention: each stream goes through an `Embeddings1DConnector` first +// (embeddings_processor.py:70-117). Its math IS ported +// (`Ltx2ConnectorForward`); its WEIGHTS are not loaded — they ship inside the +// DiT file as `video_embeddings_connector.*` / `audio_embeddings_connector.*` +// and remain among the modules `Ltx2LoadDitFromSafetensors` refuses +// (ltx2_loader.h:96-99). +// +// So `has_encoder()` is STILL false, and deliberately: the tower runs, but its +// output cannot reach the DiT, and a `true` here would promise a render that +// conditioning cannot complete. Flipping it is one change away — bind those +// tensors — and that change owns the flag. Conditioning meanwhile comes from +// prompt-embeds, the seam's own documented fallback (video_engine.h:55-57). // // 3. Any pipeline kind / model version the recipe table does not carry. // `ResolveLtx2PipelineRecipe` already throws rather than defaulting diff --git a/include/vllm/tokenizer/tokenizer.h b/include/vllm/tokenizer/tokenizer.h index effcd3c95..79e3d9fb7 100644 --- a/include/vllm/tokenizer/tokenizer.h +++ b/include/vllm/tokenizer/tokenizer.h @@ -47,6 +47,18 @@ class Tokenizer { // not byte-level BPE with a recognized Split pre-tokenizer regex (no silent // wrong tokenization). static Tokenizer FromHfJson(const std::string& tokenizer_json_path); + // The same parse, from bytes already in hand. `source` appears in error + // messages exactly where the path would. + // + // Exists because a tokenizer does not always arrive as a FILE. LTX-2.5's text + // encoder ships its tokenizer AS A TENSOR — `tokenizer_json` U8 [32169626] + // inside the one safetensors file, alongside `hf_asset__*` sidecars + // (gemma_assets.py:34-36) — so a loader that assumes a sibling + // `tokenizer.json` cannot read that checkpoint at all. Spilling 32 MB to a + // temporary file just to read it back would put the temp directory on a model + // path and leave a 32 MB file behind on every failure. + static Tokenizer FromHfJsonBytes(std::string_view tokenizer_json, + const std::string& source); // Loads a GGUF byte-level BPE vocab (tokenizer.ggml.* kvs). Throws // std::runtime_error unless tokenizer.ggml.model == "gpt2" and // tokenizer.ggml.pre is a recognized pre-tokenizer name. diff --git a/include/vllm/transformers_utils/hf_config.h b/include/vllm/transformers_utils/hf_config.h index 186d12a0e..140703383 100644 --- a/include/vllm/transformers_utils/hf_config.h +++ b/include/vllm/transformers_utils/hf_config.h @@ -125,6 +125,23 @@ struct HfConfig { // path) on missing file, malformed JSON, or missing required fields. HfConfig LoadHfConfig(const std::string& path); +// The same parse, from a config object already in hand. `source` appears in +// every error message exactly where the path would, so a refusal still names +// where the config came from. +// +// Exists because a config does not always arrive as a sibling `config.json`. +// LTX-2.5's text encoder ships as ONE safetensors file whose HuggingFace config +// rides in the file's own `__metadata__["gemma_config"]` +// (gemma_assets.py:34, :110-114) — and the shipped `vonkaiser` NVFP4 build +// carries no `__metadata__` at all, so its caller has to source the config out +// of band and hand it over as an object. Writing it to a temporary file just to +// read it back would make the temp directory part of a model path. +// +// Reads no sibling `generation_config.json`: without a path there is no sibling +// to read, so `generation_config_eos_ids` stays empty rather than picking up +// whatever happens to sit in the working directory. +HfConfig ParseHfConfig(const nlohmann::json& doc, const std::string& source); + // Cheap, non-throwing peek at config.json's `architectures` array — empty on // any parse/read problem. Exists for TASK dispatch BEFORE the full text-model // HfConfig parse: a SupportsTranscription-only checkpoint (Parakeet) nests its diff --git a/scripts/gen-ltx2-gemma-tower-goldens.py b/scripts/gen-ltx2-gemma-tower-goldens.py new file mode 100644 index 000000000..93a69041d --- /dev/null +++ b/scripts/gen-ltx2-gemma-tower-goldens.py @@ -0,0 +1,549 @@ +#!/usr/bin/env python3 +"""Emit tests/vllm/models/ltx2_gemma_tower_goldens.inc — the Gemma-4 TOWER oracle. + +Phase L3 recorded that this gate could not exist: the `transformers` on the box +had no `gemma4_unified` in `CONFIG_MAPPING`, so the tower could not be built at +reduced dimensions and there was nothing to compare against. That is no longer +true, and this generator is the proof — it BUILDS AND RUNS the tower. + +What it gates, and why each piece is here rather than assumed: + + * `Gemma4Model::ForwardHiddenStates` against the REAL upstream forward. Until + now the Gemma-4 port's own header said the forward was "grounded + compiles" + with the end-to-end gate BLOCKED (gemma4.h, G1 HONEST STATUS). Compiling is + not running, and this is the first execution-grounded comparison. + + * The MIXED per-layer attention geometry the LTX tower actually ships. The + shipped 12B has 48 layers in an 8-fold `sliding, sliding, sliding, sliding, + sliding, full` pattern, and the two kinds are NOT the same shape: + + sliding : 16 q heads x head_dim 256, 8 kv heads, v_proj PRESENT + full : 16 q heads x global_head_dim 512, 1 kv head, NO v_proj + (attention_k_eq_v: V aliases K), rope_type "proportional" + with partial_rotary_factor 0.25 and theta 1e6, against the + sliding layers' plain rope at theta 1e4 + + A fixture with one uniform layer type cannot separate a port that handles + both from a port that handles one and silently applies it twice, which is + §7.0(c)'s "a fixture that cannot discriminate is the same defect as an + unpinned constant". The reduced arch below keeps BOTH kinds and keeps the + ratios (global head_dim = 2 x sliding head_dim, global kv heads = 1). + + * The LEFT-PADDING EQUIVALENCE, which is what makes a prompt affordable. + Upstream pads every prompt to 1024 (gemma_assets.py:162, + base_encoder.py:231-236, PaddingSide.LEFT) and runs all 1024 rows through a + 12B tower. Our port runs only the VALID tokens at their ORIGINAL absolute + positions. That is equivalent -- pads are masked out of attention and are + causally before every valid token, and the feature extractor zeroes their + rows anyway -- but "is equivalent" is a claim, so section 3 emits the full + left-padded oracle run and the C++ suite holds the short run's valid rows + to the padded run's valid rows. If the equivalence is ever false, that gate + is what says so, and a 100x cost claim stops resting on an argument. + + * ONE arithmetic width per state, both ways round. Section 2 is the oracle in + float32 and section 4 the SAME oracle in bfloat16. Our forward carries the + stream in bf16 and widens only on the way out (gemma4.h, + Gemma4HiddenStatesResult), so bf16 is the dtype-MATCHED arm and f32 is the + arm that would catch a reduction-order defect a bf16 store absorbs. Gating + only one of them has burned this project before. + +Both sides rebuild every weight from one deterministic FNV-1a + splitmix64 +stream keyed by the parameter's own HuggingFace NAME, exactly as +scripts/gen-ltx2-text-goldens.py does, so no weight byte is checked in and the +weight-NAMING contract is itself part of the gate. A port that merges q/k/v in +the wrong order, or that reads `v_proj` on a full-attention layer that has none, +builds a different tensor from the same names and fails. + +Upstream sources: + transformers/models/gemma4_unified/modeling_gemma4_unified.py -> the tower + Lightricks/LTX-2 packages/ltx-core/src/ltx_core/text_encoders/gemma/ + encoders/base_encoder.py:68 -> model.model(..., output_hidden_states=True) + encoders/encoder_configurator.py:68-73 -> AutoModelForImageTextToText.from_config + encoders/base_encoder.py:231-236 -> max_length 1024, PaddingSide.LEFT + diffusers src/diffusers/pipelines/ltx2/pipeline_ltx2.py:347-352 -> the same + call and the stack/flatten pack, read as an INDEPENDENT second opinion + +The real tower's `text_config` is not invented here: it is the one carried in +`__metadata__["gemma_config"]` of the OFFICIAL bf16 text encoder +(Lightricks/LTX-2.5, text_encoders/gemma4-12b-with-proj-ltx-2.5-bf16.safetensors), +read with an 84 KB HTTP range request over the safetensors header and committed +as `--real-config`. The SHIPPED vonkaiser NVFP4 file carries no `__metadata__` +at all, which is why the config has to come from somewhere and why it is not +guessed. + +Usage: + scripts/gen-ltx2-gemma-tower-goldens.py \ + --python /home/mudler/recon-cpu/venv/bin/python \ + --out tests/vllm/models/ltx2_gemma_tower_goldens.inc + +Needs a `transformers` that registers `gemma4_unified` (>= 5.8; MEASURED working +at 5.12.1, MEASURED absent at 5.3.0) plus torch and numpy. CPU only. No +checkpoint, no download, no network. +""" + +from __future__ import annotations + +import argparse +import json +import os +import subprocess +import sys +from pathlib import Path + +import numpy as np +import torch + +# --------------------------------------------------------------------------- +# ORACLE IDENTITY — asserted, never assumed (spec 7.0(1)). +# +# A decoy once produced byte-identical goldens on this project, so the module +# that answers has to be the module we meant. `transformers` 5.3.0 is present on +# the same box under a different interpreter and does NOT register +# `gemma4_unified`; picking it up by accident reads exactly like "Gemma-4 is +# unsupported" rather than like a wrong environment. +# --------------------------------------------------------------------------- + +MIN_TRANSFORMERS = (5, 8) + + +def assert_oracle_identity() -> dict: + import transformers # noqa: PLC0415 + from transformers import CONFIG_MAPPING # noqa: PLC0415 + + version = transformers.__version__ + parts = [] + for piece in version.split(".")[:2]: + digits = "".join(c for c in piece if c.isdigit()) + parts.append(int(digits) if digits else 0) + if tuple(parts) < MIN_TRANSFORMERS: + raise SystemExit( + f"transformers {version} is below the {MIN_TRANSFORMERS[0]}." + f"{MIN_TRANSFORMERS[1]} that first registers gemma4_unified. " + "Point --python at an interpreter whose transformers has it; this " + "is the exact blocker phase L3 recorded." + ) + if "gemma4_unified" not in CONFIG_MAPPING: + raise SystemExit( + f"transformers {version} at {transformers.__file__} does not register " + "'gemma4_unified' in CONFIG_MAPPING. Refusing to emit goldens from a " + "tower this interpreter cannot build." + ) + return { + "transformers_version": version, + "transformers_path": str(Path(transformers.__file__).resolve().parent), + "torch_version": torch.__version__, + } + + +def upstream_revision(root: Path) -> str: + """HEAD, plus a DIRTY marker. + + `git rev-parse HEAD` reports the committed SHA whether or not the tree has + uncommitted edits, so a revision recorded from it alone can name a commit + that is not what ran (spec 7.0(2)). + """ + if not root.is_dir(): + return "absent" + try: + head = subprocess.run( + ["git", "-C", str(root), "rev-parse", "HEAD"], + check=True, capture_output=True, text=True, + ).stdout.strip() + status = subprocess.run( + ["git", "-C", str(root), "status", "--porcelain"], + check=True, capture_output=True, text=True, + ).stdout.strip() + except Exception: # noqa: BLE001 - a tarball checkout has no git metadata + return "unknown" + return head + ("-DIRTY" if status else "") + + +# --------------------------------------------------------------------------- +# The deterministic stream — byte-identical to scripts/gen-ltx2-text-goldens.py +# and to tests/vllm/models/test_ltx2_text_encoder.cpp :: Ltx2Rand. +# --------------------------------------------------------------------------- + +_MASK64 = (1 << 64) - 1 + + +def fnv1a64(name: str) -> int: + h = 0xCBF29CE484222325 + for byte in name.encode("utf-8"): + h ^= byte + h = (h * 0x100000001B3) & _MASK64 + return h + + +def splitmix64(x: int) -> int: + x = (x + 0x9E3779B97F4A7C15) & _MASK64 + z = x + z = ((z ^ (z >> 30)) * 0xBF58476D1CE4E5B9) & _MASK64 + z = ((z ^ (z >> 27)) * 0x94D049BB133111EB) & _MASK64 + return z ^ (z >> 31) + + +def ltx2_rand(name: str, count: int) -> np.ndarray: + seed = fnv1a64(name) + out = np.empty(count, dtype=np.float64) + for i in range(count): + u = splitmix64((seed + i) & _MASK64) + out[i] = (u >> 11) * (2.0**-53) * 2.0 - 1.0 + return out + + +def gemma_param_spec(name: str) -> tuple[float, float]: + """(scale, offset) keyed ONLY by the HuggingFace parameter name. + + The offsets are not cosmetic. Gemma-4's RMSNorm is PLAIN — it multiplies by + `self.weight` directly rather than by `1 + weight` + (modeling_gemma4_unified.py:181-185), and its weights initialize to ones — so + a norm weight centred on 0 would put every normalized activation near zero + and hide a scale error. `layer_scalar` is a BUFFER initialized to ones + (:501) and applied as `hidden_states *= self.layer_scalar` (:535); leaving it + at exactly 1 would make a port that ignores it entirely pass. + """ + if name.endswith("layer_scalar"): + return 0.1, 1.0 + if name.endswith("_layernorm.weight") or name.endswith("norm.weight"): + return 0.1, 1.0 + if name.endswith("embed_tokens.weight"): + return 0.05, 0.0 + if name.endswith(".bias"): + return 0.02, 0.0 + return 0.05, 0.0 + + +def make_param(name: str, shape) -> torch.Tensor: + scale, offset = gemma_param_spec(name) + count = int(np.prod(shape)) if len(shape) else 1 + values = ltx2_rand(name, count) * scale + offset + return torch.from_numpy(values.astype(np.float32)).reshape(tuple(shape)) + + +# --------------------------------------------------------------------------- +# The reduced architecture. +# +# Every ratio the port branches on is preserved; only the magnitudes shrink. +# The layer_types pattern keeps the shipped tower's shape -- a run of sliding +# layers CLOSED by a full one, twice -- so a port that mixes the two head_dims +# up, or that resolves layer 0's geometry once and reuses it, diverges. +# --------------------------------------------------------------------------- + +HIDDEN = 32 # real 3840 +NUM_LAYERS = 12 # real 48 +HEAD_DIM = 8 # real 256 +GLOBAL_HEAD_DIM = 16 # real 512 +NUM_HEADS = 4 # real 16 +NUM_KV_HEADS = 2 # real 8 +NUM_GLOBAL_KV_HEADS = 1 # real 1 (unchanged: it IS one upstream) +INTERMEDIATE = 64 # real 15360 +VOCAB = 64 # real 262144 +SLIDING_WINDOW = 6 # real 1024 +MAX_POSITION = 128 # real 262144 + +# The shipped pattern is (sliding x 5, full) x 8. Two repeats is the smallest +# fixture in which a full layer is neither first nor last and a sliding layer +# FOLLOWS a full one -- the case a port that latches geometry once gets wrong. +LAYER_TYPES = (["sliding_attention"] * 5 + ["full_attention"]) * 2 +assert len(LAYER_TYPES) == NUM_LAYERS + +# Section 1/2: an unpadded run. Section 3: the same VALID tokens left-padded. +TOKENS = [2, 17, 41, 5, 23, 9, 60, 33] +SEQ = len(TOKENS) +PADDED_SEQ = 20 # > SLIDING_WINDOW, so the window is LIVE +PAD_ID = 0 +NUM_PAD = PADDED_SEQ - SEQ + + +def reduced_text_config(real: dict) -> dict: + """The REAL text_config with only the magnitudes reduced. + + Starting from the shipped config rather than from a hand-written dict is + deliberate: every field this generator does not name -- `attention_k_eq_v`, + `final_logit_softcapping`, `rms_norm_eps`, both `rope_parameters` entries, + `tie_word_embeddings`, `hidden_activation` -- is carried over EXACTLY, so the + fixture cannot quietly disagree with the checkpoint about a field nobody + thought to reduce. + """ + t = dict(real) + t.update( + hidden_size=HIDDEN, + num_hidden_layers=NUM_LAYERS, + num_attention_heads=NUM_HEADS, + num_key_value_heads=NUM_KV_HEADS, + head_dim=HEAD_DIM, + global_head_dim=GLOBAL_HEAD_DIM, + num_global_key_value_heads=NUM_GLOBAL_KV_HEADS, + intermediate_size=INTERMEDIATE, + vocab_size=VOCAB, + vocab_size_per_layer_input=VOCAB, + sliding_window=SLIDING_WINDOW, + max_position_embeddings=MAX_POSITION, + layer_types=list(LAYER_TYPES), + ) + return t + + +def build_tower(real_config: dict): + """Exactly `GemmaTextEncoderConfigurator.from_metadata` at reduced dims.""" + from transformers import CONFIG_MAPPING, AutoModelForImageTextToText # noqa: PLC0415 + + wrapper = dict(real_config) + wrapper["text_config"] = reduced_text_config(real_config["text_config"]) + # The vision and audio towers are not on the text-conditioning path and the + # checkpoint's copies of them are not reduced here; dropping the sub-configs + # makes transformers skip building them entirely. + wrapper.pop("vision_config", None) + wrapper.pop("audio_config", None) + + config_cls = CONFIG_MAPPING[real_config["model_type"]] + config = config_cls.from_dict(wrapper) + model = AutoModelForImageTextToText.from_config(config) + inner = model.model # base_encoder.py:68 -- the inner model, no lm_head + + filled = [] + with torch.no_grad(): + for name, param in inner.named_parameters(): + param.copy_(make_param(name, tuple(param.shape))) + filled.append((name, tuple(param.shape))) + # `layer_scalar` is a BUFFER, so named_parameters() misses it. It + # multiplies every layer's output (:535) and a port that drops it is + # invisible while it stays at its initialized 1.0. + for name, buf in inner.named_buffers(): + if name.endswith("layer_scalar"): + buf.copy_(make_param(name, tuple(buf.shape))) + filled.append((name, tuple(buf.shape))) + return model, inner, config, filled + + +def run_tower(inner, ids, mask, dtype, positions=None): + m = inner.to(dtype).eval() + kwargs = {} + if positions is not None: + # The absolute positions the tokens occupy in the padded batch. Left + # padding does NOT renumber them: with no explicit `position_ids` + # transformers derives them from `cache_position`, which counts the pad + # rows, so a short run has to be told where its tokens really sit. + kwargs["position_ids"] = torch.tensor([positions], dtype=torch.long) + with torch.no_grad(): + out = m( + input_ids=torch.tensor([ids], dtype=torch.long), + attention_mask=torch.tensor([mask], dtype=torch.long), + output_hidden_states=True, + **kwargs, + ) + states = [h[0].to(torch.float32).contiguous().numpy() for h in out.hidden_states] + inner.to(torch.float32) + return states + + +# --------------------------------------------------------------------------- +# Emission helpers (identical to scripts/gen-ltx2-text-goldens.py's) +# --------------------------------------------------------------------------- + + +def _cxx_float(value: float, digits: int) -> str: + if value != value: + return "NAN" + if value == float("inf"): + return "INFINITY" + if value == float("-inf"): + return "-INFINITY" + return repr(float(f"%.{digits}g" % value)) + + +def emit_f32(out, name: str, values) -> None: + flat = np.asarray(values, dtype=np.float32).reshape(-1).tolist() + out.write(f"inline constexpr float {name}[] = {{\n") + for i in range(0, len(flat), 6): + out.write(" " + ", ".join(_cxx_float(v, 9) + "f" for v in flat[i : i + 6]) + ",\n") + out.write("};\n\n") + + +def emit_i32(out, name: str, values) -> None: + flat = [int(v) for v in np.asarray(values).reshape(-1).tolist()] + out.write(f"inline constexpr int32_t {name}[] = {{\n") + for i in range(0, len(flat), 12): + out.write(" " + ", ".join(str(v) for v in flat[i : i + 12]) + ",\n") + out.write("};\n\n") + + +def emit_scalar(out, name: str, value) -> None: + out.write(f"inline constexpr int64_t {name} = {int(value)};\n") + + +def emit_string(out, name: str, value: str) -> None: + out.write(f'inline constexpr const char* {name} = R"JSON({value})JSON";\n\n') + + +# --------------------------------------------------------------------------- + + +def main() -> int: + ap = argparse.ArgumentParser() + ap.add_argument("--out", required=True, type=Path) + ap.add_argument( + "--real-config", + type=Path, + default=None, + help="the gemma_config JSON from the official bf16 TE's __metadata__; " + "defaults to the copy committed beside this script", + ) + ap.add_argument("--ltx2", type=Path, default=Path.home() / "_git" / "LTX-2") + ap.add_argument("--diffusers", type=Path, default=Path.home() / "_git" / "diffusers") + args = ap.parse_args() + + identity = assert_oracle_identity() + real_config_path = args.real_config or ( + Path(__file__).resolve().parent.parent + / "tests" / "vllm" / "models" / "ltx2_gemma4_text_config.json" + ) + real_config = json.loads(real_config_path.read_text()) + + model, inner, config, filled = build_tower(real_config) + + padded_ids = [PAD_ID] * NUM_PAD + TOKENS + padded_mask = [0] * NUM_PAD + [1] * SEQ + + plain_f32 = run_tower(inner, TOKENS, [1] * SEQ, torch.float32) + plain_bf16 = run_tower(inner, TOKENS, [1] * SEQ, torch.bfloat16) + padded_f32 = run_tower(inner, padded_ids, padded_mask, torch.float32) + # The equivalence claim, isolated INSIDE the oracle and in f32 so no dtype + # noise is mixed into it: the same valid tokens, told their absolute + # positions, run WITHOUT the pads. If upstream's own two answers agree, the + # claim "dropping the pads is free" is upstream's property; our port then + # only has to inherit it, and the C++ gate can hold those two claims apart. + short_abs_f32 = run_tower( + inner, TOKENS, [1] * SEQ, torch.float32, + positions=list(range(NUM_PAD, NUM_PAD + SEQ)), + ) + equivalence = [ + float(np.abs(s - p[NUM_PAD:]).max()) + for s, p in zip(short_abs_f32, padded_f32) + ] + sys.stderr.write( + "left-pad equivalence measured INSIDE the oracle (f32, per state): " + f"max {max(equivalence):.3e}\n" + ) + + assert len(plain_f32) == NUM_LAYERS + 1, len(plain_f32) + + argv = " ".join([Path(sys.argv[0]).name] + sys.argv[1:]) + with args.out.open("w", encoding="utf-8") as out: + out.write( + "// GENERATED by scripts/gen-ltx2-gemma-tower-goldens.py — DO NOT EDIT BY HAND.\n" + "//\n" + "// The Gemma-4 TOWER oracle: the upstream HuggingFace implementation BUILT\n" + "// AND RUN at reduced dimensions, which phase L3 recorded as impossible on\n" + "// the transformers it had. Every weight is rebuilt on both sides from the\n" + "// deterministic Ltx2Rand stream keyed by the HuggingFace parameter NAME, so\n" + "// no weight byte is checked in and the naming contract is part of the gate.\n" + "//\n" + f"// Oracle: transformers {identity['transformers_version']} at\n" + f"// {identity['transformers_path']}\n" + f"// torch {identity['torch_version']}\n" + f"// Lightricks/LTX-2 revision: {upstream_revision(args.ltx2)}\n" + f"// diffusers revision: {upstream_revision(args.diffusers)}\n" + "// Regenerate with:\n" + f"// {argv}\n" + "#pragma once\n\n" + "#include \n\n" + "namespace vllm_test {\n\n" + ) + + out.write("// --- section 0: the reduced architecture ---\n") + emit_scalar(out, "kLtxTowerHidden", HIDDEN) + emit_scalar(out, "kLtxTowerNumLayers", NUM_LAYERS) + emit_scalar(out, "kLtxTowerNumStates", NUM_LAYERS + 1) + emit_scalar(out, "kLtxTowerHeadDim", HEAD_DIM) + emit_scalar(out, "kLtxTowerGlobalHeadDim", GLOBAL_HEAD_DIM) + emit_scalar(out, "kLtxTowerNumHeads", NUM_HEADS) + emit_scalar(out, "kLtxTowerNumKvHeads", NUM_KV_HEADS) + emit_scalar(out, "kLtxTowerNumGlobalKvHeads", NUM_GLOBAL_KV_HEADS) + emit_scalar(out, "kLtxTowerIntermediate", INTERMEDIATE) + emit_scalar(out, "kLtxTowerVocab", VOCAB) + emit_scalar(out, "kLtxTowerSlidingWindow", SLIDING_WINDOW) + emit_scalar(out, "kLtxTowerSeq", SEQ) + emit_scalar(out, "kLtxTowerPaddedSeq", PADDED_SEQ) + emit_scalar(out, "kLtxTowerNumPad", NUM_PAD) + emit_scalar(out, "kLtxTowerPadId", PAD_ID) + out.write("\n") + # The exact reduced text_config, so the C++ side PARSES what ran rather + # than reconstructing it field by field and drifting. + emit_string( + out, + "kLtxTowerTextConfigJson", + json.dumps(reduced_text_config(real_config["text_config"]), indent=1), + ) + out.write("// The layer types, in order. 1 = full_attention, 0 = sliding.\n") + emit_i32(out, "kLtxTowerLayerIsFull", + [1 if t == "full_attention" else 0 for t in LAYER_TYPES]) + + out.write("// --- section 1: the inputs ---\n") + emit_i32(out, "kLtxTowerTokens", TOKENS) + emit_i32(out, "kLtxTowerPaddedTokens", padded_ids) + emit_i32(out, "kLtxTowerPaddedMask", padded_mask) + + out.write( + "// --- section 2: hidden states, oracle in FLOAT32 ---\n" + "// [state][seq * hidden]. state 0 is the sqrt(hidden)-scaled embeddings;\n" + "// state i is decoder layer i-1's output; the LAST state is model.norm of\n" + "// the last layer, and the raw last-layer output never appears.\n" + ) + for i, s in enumerate(plain_f32): + emit_f32(out, f"kLtxTowerStateF32_{i}", s) + + out.write("// --- section 3: hidden states, oracle in BFLOAT16 (the SHIPPED dtype) ---\n") + for i, s in enumerate(plain_bf16): + emit_f32(out, f"kLtxTowerStateBf16_{i}", s) + + # THE NOISE FLOOR, MEASURED — the thing that makes the gate's tolerance a + # measurement instead of a number somebody picked. + # + # Upstream's own answer moves by this much when the SAME code runs at + # bf16 instead of f32, so it is the smallest difference this comparison + # can possibly resolve. Holding our bf16 forward to it says something + # precise: we are closer to upstream-in-bf16 than upstream-in-bf16 is to + # upstream-in-f32. It also cannot be relaxed to rescue a failing port — + # widening it means regenerating it, which means the oracle itself moved. + noise = [float(np.abs(a - b).max()) for a, b in zip(plain_f32, plain_bf16)] + scale = [float(np.abs(a).max()) for a in plain_f32] + out.write( + "// --- section 3b: the oracle's OWN f32-vs-bf16 spread, per state ---\n" + "// The dtype noise floor, MEASURED rather than assumed. This is the\n" + "// tolerance: a port whose bf16 answer sits inside it is indistinguishable\n" + "// from upstream at upstream's own arithmetic width, and one that sits\n" + "// outside it has a defect that bf16 rounding does not explain.\n" + ) + emit_f32(out, "kLtxTowerDtypeNoise", noise) + emit_f32(out, "kLtxTowerStateScale", scale) + + out.write( + "// --- section 4: the LEFT-PADDED run, float32 ---\n" + "// [state][padded_seq * hidden]. Rows 0..kLtxTowerNumPad-1 are pad rows and\n" + "// their contents are upstream's garbage-but-masked values; the gate reads\n" + "// only the VALID tail and holds section 2 to it.\n" + ) + for i, s in enumerate(padded_f32): + emit_f32(out, f"kLtxTowerPaddedStateF32_{i}", s) + + out.write( + "// --- section 5: the equivalence, measured INSIDE the oracle ---\n" + "// Per state, max|short-run-at-absolute-positions - padded-run's valid rows|,\n" + "// both f32, so this number carries NO dtype noise. It is upstream's own\n" + "// answer to 'is dropping the pads free?'. Our port inherits it; the C++\n" + "// gate checks the two claims separately so a failure says which one broke.\n" + ) + emit_f32(out, "kLtxTowerPadEquivalence", equivalence) + + out.write("} // namespace vllm_test\n") + + sys.stderr.write( + f"wrote {args.out} — {len(filled)} named tensors, " + f"{NUM_LAYERS + 1} states x {SEQ} x {HIDDEN}\n" + ) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/scripts/gen-ltx2-prompt-tokens-goldens.py b/scripts/gen-ltx2-prompt-tokens-goldens.py new file mode 100644 index 000000000..7bc5e0154 --- /dev/null +++ b/scripts/gen-ltx2-prompt-tokens-goldens.py @@ -0,0 +1,191 @@ +#!/usr/bin/env python3 +"""Emit tests/vllm/models/ltx2_prompt_tokens_goldens.inc — REAL prompts, REAL vocab. + +`LTXGemmaTokenizer.tokenize_with_weights` (tokenizer.py:31-59) run against the +tokenizer the LTX-2.5 text encoder actually ships — which it ships AS A TENSOR, +`tokenizer_json` U8 [32169626] inside the safetensors file, not as a sibling +`tokenizer.json` (gemma_assets.py:34-36). + +Why this gate is separate from a synthetic one. A hand-built tokenizer fixture +proves the WRAPPER — strip, BOS prepend, left pad, truncation order — and proves +nothing about the 262144-entry SentencePiece-flavoured BPE the model was trained +with. This one runs real English prompts through the real merges and checks the +ids, so a pre-tokenizer or normalizer mismatch on the shipped vocab is caught as +a wrong id rather than as a slightly different video. + +The shipped tokenizer is the Gemma metaspace-via-normalizer form the C++ side +already recognizes: `Replace(" " -> "U+2581")` NORMALIZER plus +`Split(" ", MergedWithPrevious)` PRE-TOKENIZER, byte-fallback decoder, BPE with +262144 entries and 24 added tokens. Its `post_processor` is a TemplateProcessing +whose `special_tokens` map is EMPTY, which is exactly why `ltx_core` prepends BOS +itself and says so (tokenizer.py:12-15) — measured here rather than believed. + +Needs the checkpoint, so this is not a CI generator; the emitted .inc is, and the +C++ case that uses the 32 MB tensor is env-gated on the checkpoint being present. + +Usage: + scripts/gen-ltx2-prompt-tokens-goldens.py \ + --text-encoder $CHECKPOINT_ROOT/ltx-2.5/vonkaiser-fp8-nvfp4/text_encoders/\ +gemma4-12b-with-proj-nvfp4-torchao.safetensors \ + --out tests/vllm/models/ltx2_prompt_tokens_goldens.inc +""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import struct +import sys +from pathlib import Path + +# gemma_assets.py:162 / base_encoder.py:231-236, and diffusers +# pipeline_ltx2.py:304 independently. +MAX_LENGTH = 1024 + +# Deliberately varied. Each one is here for a reason a single prompt would miss: +# * leading/trailing whitespace, which upstream strips (tokenizer.py:33); +# * an empty prompt, which must still produce a BOS and 1023 pads; +# * punctuation and digits, which the Split/Replace pre-tokenizer treats +# differently from letters; +# * a long cinematic prompt of the kind this model is actually driven with. +PROMPTS = [ + "a red fox running through deep snow at sunrise", + " a cat sits on a windowsill, watching rain fall ", + "", + "Cinematic wide shot, 35mm: two astronauts walk across a rust-coloured dune " + "field while a ringed planet rises behind them; slow dolly-in, volumetric " + "light, 24 fps.", +] + + +def read_tokenizer_tensor(path: Path) -> bytes: + """Pull `tokenizer_json` out of the safetensors file WITHOUT loading weights.""" + with path.open("rb") as f: + header_len = struct.unpack(" MAX_LENGTH: # truncation=True + ids = ids[:MAX_LENGTH] + if not ids or ids[0] != bos_id: # :44-46 + ids = [bos_id, *ids][:MAX_LENGTH] + pad = MAX_LENGTH - len(ids) # :48-54, LEFT side + return [pad_id] * pad + ids, [0] * pad + [1] * len(ids) + + +def _emit_i32(out, name: str, values) -> None: + out.write(f"inline constexpr int32_t {name}[] = {{\n") + for i in range(0, len(values), 16): + out.write(" " + ", ".join(str(int(v)) for v in values[i : i + 16]) + ",\n") + out.write("};\n\n") + + +def _cxx_string(s: str) -> str: + out = [] + for ch in s: + if ch == '"': + out.append('\\"') + elif ch == "\\": + out.append("\\\\") + elif ch == "\n": + out.append("\\n") + elif 0x20 <= ord(ch) < 0x7F: + out.append(ch) + else: + out.extend("\\x%02x" % b for b in ch.encode("utf-8")) + out.append('" "') + return '"' + "".join(out) + '"' + + +def main() -> int: + ap = argparse.ArgumentParser() + ap.add_argument("--text-encoder", required=True, type=Path) + ap.add_argument("--out", required=True, type=Path) + args = ap.parse_args() + + # ORACLE IDENTITY, asserted: `tokenizers` is what HuggingFace's own fast + # tokenizer runs, and it is the thing our BPE is being compared against. + import tokenizers # noqa: PLC0415 + from tokenizers import Tokenizer # noqa: PLC0415 + + blob = read_tokenizer_tensor(args.text_encoder) + digest = hashlib.sha256(blob).hexdigest() + tok = Tokenizer.from_str(blob.decode("utf-8")) + + doc = json.loads(blob) + post = doc.get("post_processor") or {} + specials = post.get("special_tokens") or {} + # MEASURED, and the reason `ltx_core` prepends BOS by hand. + added = {t["content"]: t["id"] for t in doc.get("added_tokens", [])} + bos_id, pad_id = added[""], added[""] + + rows_ids, rows_mask, valid = [], [], [] + for p in PROMPTS: + ids, mask = tokenize_with_weights(tok, p, bos_id, pad_id) + assert len(ids) == MAX_LENGTH and len(mask) == MAX_LENGTH + rows_ids.append(ids) + rows_mask.append(mask) + valid.append(sum(mask)) + + with args.out.open("w", encoding="utf-8") as out: + out.write( + "// GENERATED by scripts/gen-ltx2-prompt-tokens-goldens.py — DO NOT EDIT.\n" + "//\n" + "// `LTXGemmaTokenizer.tokenize_with_weights` (tokenizer.py:31-59) over the\n" + "// tokenizer the LTX-2.5 text encoder SHIPS AS A TENSOR, run by HuggingFace\n" + f"// `tokenizers` {tokenizers.__version__}.\n" + "//\n" + f"// tokenizer_json sha256: {digest}\n" + f"// source: {args.text_encoder}\n" + "//\n" + "// MEASURED on that tokenizer, and the reason upstream prepends BOS by hand\n" + f"// (tokenizer.py:12-15): its post_processor is `{post.get('type')}` with\n" + f"// {len(specials)} special_tokens, so `add_special_tokens=True` adds NOTHING.\n" + "// diffusers relies on exactly that flag (pipeline_ltx2.py:339) and would\n" + "// therefore produce a prompt with no BOS; `ltx_core` is followed here.\n" + "#pragma once\n\n" + "#include \n\n" + "namespace vllm_test {\n\n" + ) + out.write(f"inline constexpr int64_t kLtxPromptMaxLength = {MAX_LENGTH};\n") + out.write(f"inline constexpr int32_t kLtxPromptBosId = {bos_id};\n") + out.write(f"inline constexpr int32_t kLtxPromptPadId = {pad_id};\n") + out.write(f"inline constexpr int64_t kLtxPromptCount = {len(PROMPTS)};\n") + out.write( + f'inline constexpr const char* kLtxPromptTokenizerSha256 = "{digest}";\n\n') + out.write("inline constexpr const char* kLtxPromptText[] = {\n") + for p in PROMPTS: + out.write(" " + _cxx_string(p) + ",\n") + out.write("};\n\n") + _emit_i32(out, "kLtxPromptValidCount", valid) + for i, (ids, mask) in enumerate(zip(rows_ids, rows_mask)): + _emit_i32(out, f"kLtxPromptIds_{i}", ids) + _emit_i32(out, f"kLtxPromptMask_{i}", mask) + out.write("} // namespace vllm_test\n") + + sys.stderr.write( + f"wrote {args.out} — {len(PROMPTS)} prompts, valid token counts {valid}\n") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/src/vllm/model_executor/models/ltx2_text_encoder.cpp b/src/vllm/model_executor/models/ltx2_text_encoder.cpp index 4dbee3ff7..37aea68ad 100644 --- a/src/vllm/model_executor/models/ltx2_text_encoder.cpp +++ b/src/vllm/model_executor/models/ltx2_text_encoder.cpp @@ -21,7 +21,12 @@ #include #include +#include + #include "vllm/model_executor/model_loader/safetensors_reader.h" +#include "vllm/model_executor/models/ltx2_loader.h" +#include "vllm/tokenizer/tokenizer.h" +#include "vllm/transformers_utils/hf_config.h" namespace vllm { namespace { @@ -598,4 +603,497 @@ Ltx2GemmaAssets Ltx2LoadGemmaAssets(const SafetensorsFile& file, bool require_co return assets; } +// ─────────────────────── the prompt -> tokens hand-off ─────────────────────── + +Ltx2GemmaSpecialIds Ltx2ResolveGemmaSpecialIds(const Ltx2GemmaAssets& assets, + const tok::Tokenizer& tokenizer) { + Ltx2GemmaSpecialIds ids; + + // The checkpoint STATES both, and that is the first place to look: the + // tokenizer's own added-token table lists `` and `` by content, but + // reading them by content would make this port depend on two strings rather + // than on the ids the model was trained with. + const auto gen = assets.sidecars.find("generation_config.json"); + if (gen != assets.sidecars.end()) { + nlohmann::json doc; + try { + doc = nlohmann::json::parse(std::string(gen->second.begin(), gen->second.end())); + } catch (const nlohmann::json::exception&) { + doc = nlohmann::json::object(); + } + if (doc.is_object()) { + const auto bos = doc.find("bos_token_id"); + if (bos != doc.end() && bos->is_number_integer()) + ids.bos_id = bos->get(); + const auto pad = doc.find("pad_token_id"); + if (pad != doc.end() && pad->is_number_integer()) + ids.pad_id = pad->get(); + } + } + + // Fall back to the tokenizer, which is what upstream reads + // (tokenizer.py:35 `tokenizer.bos_token_id`, :26-27 the pad_token default). + if (ids.bos_id < 0) ids.bos_id = tokenizer.BosId(); + if (ids.bos_id < 0) { + for (const tok::SpecialToken& t : tokenizer.AddedTokens()) + if (t.text == "") ids.bos_id = t.id; + } + if (ids.pad_id < 0) { + for (const tok::SpecialToken& t : tokenizer.AddedTokens()) + if (t.text == "") ids.pad_id = t.id; + } + // tokenizer.py:26-27 — when there is no pad token, the EOS one is used. + if (ids.pad_id < 0) ids.pad_id = tokenizer.EosId(); + + if (ids.bos_id < 0) { + Fail( + "the text encoder's asset pack declares no bos_token_id, and its tokenizer " + "carries no added token. Upstream raises here too " + "(tokenizer.py:34-36): every LTX conditioning prompt is tokenized with a " + "LEADING BOS, so a prompt without one is a DIFFERENT prompt rather than a " + "slightly degraded one."); + } + if (ids.pad_id < 0) { + Fail( + "the text encoder's asset pack declares no pad_token_id and its tokenizer " + "has neither a added token nor an eos to fall back on " + "(tokenizer.py:26-27), so the prompt cannot be padded to the " + "fixed-width batch the tower is run on."); + } + return ids; +} + +Ltx2GemmaPromptTokens Ltx2TokenizeGemmaPrompt(const tok::Tokenizer& tokenizer, + const std::string& prompt, + int32_t bos_id, int32_t pad_id, + int64_t max_length, + Ltx2GemmaPaddingSide padding_side) { + if (bos_id < 0) { + Fail( + "Ltx2TokenizeGemmaPrompt requires a bos_token_id: upstream refuses the same " + "way (tokenizer.py:34-36) because the conditioning path always tokenizes " + "with a leading BOS."); + } + if (max_length <= 0) Fail("max_length must be positive"); + + // tokenizer.py:33 — `text.strip()`. Python's bare `str.strip()` removes + // whitespace from BOTH ends; mirrored on the ASCII whitespace set, which is + // what a prompt's leading/trailing run is in practice. + const char* kSpace = " \t\n\r\f\v"; + const size_t begin = prompt.find_first_not_of(kSpace); + const std::string stripped = + begin == std::string::npos + ? std::string() + : prompt.substr(begin, prompt.find_last_not_of(kSpace) - begin + 1); + + // NOT EncodeWithSpecialTokens. The shipped tokenizer's post_processor is a + // TemplateProcessing with an EMPTY `special_tokens` map, so it adds nothing and + // the two are identical HERE — but upstream calls the plain encode and then + // prepends BOS itself, and mirroring which call is made keeps that true if a + // future checkpoint ships a post_processor that does add something. Doing both + // would double the BOS. + std::vector ids = tokenizer.Encode(stripped); + + Ltx2GemmaPromptTokens out; + // tokenizer.py:39-42 — truncate to max_length FIRST. + out.truncated = static_cast(ids.size()) > max_length; + if (out.truncated) ids.resize(static_cast(max_length)); + + // tokenizer.py:44-46 — then prepend BOS if it is not already leading, and + // re-truncate. A maximal prompt therefore loses its LAST token, not its BOS. + if (ids.empty() || ids.front() != bos_id) { + ids.insert(ids.begin(), bos_id); + if (static_cast(ids.size()) > max_length) { + ids.resize(static_cast(max_length)); + out.truncated = true; + } + } + + out.num_valid = static_cast(ids.size()); + const int64_t pad = max_length - out.num_valid; + out.input_ids.assign(static_cast(max_length), pad_id); + out.attention_mask.assign(static_cast(max_length), 0); + // tokenizer.py:48-54 — pad to exactly max_length on the configured side. + out.first_valid = padding_side == Ltx2GemmaPaddingSide::kLeft ? pad : 0; + for (int64_t i = 0; i < out.num_valid; ++i) { + out.input_ids[static_cast(out.first_valid + i)] = + ids[static_cast(i)]; + out.attention_mask[static_cast(out.first_valid + i)] = 1; + } + return out; +} + +// ───────────────────────────── the Gemma-4 TOWER ───────────────────────────── + +namespace { + +// Every name this loader reads lives under `model.`. The shipped checkpoint is +// FLAT (`model.layers.0.self_attn.q_proj.weight`), not the multimodal-wrapper +// form gemma4_weights.cpp reads (`model.language_model.layers.0....`), which is +// why the tower cannot simply go through that loader. +constexpr const char* kTowerPrefix = "model."; + +bool TowerHas(const SafetensorsFile& file, const std::string& name) { + try { + file.Get(name); + return true; + } catch (const std::runtime_error&) { + return false; + } +} + +int64_t TowerRawInt(const nlohmann::json& doc, const char* key, int64_t fallback) { + const auto it = doc.find(key); + if (it == doc.end() || it->is_null() || !it->is_number_integer()) return fallback; + return it->get(); +} + +// One module -> bf16, whichever form it arrived in. +// +// `out`/`in` are the LOGICAL widths the config resolves, and they are passed in +// rather than read off the tensor precisely because an NVFP4 tensor's stored +// width is HALF its logical one. A loader that trusted the stored shape would +// build a tower of exactly half the right width, whose every matmul still has +// conforming dimensions among themselves. +OwnedTensor TowerModule(const SafetensorsFile& file, const std::string& module, + int64_t out_features, int64_t in_features, bool nk, + std::vector* dequantized) { + const std::string weight = module + ".weight"; + const StTensor& w = file.Get(weight); + + OwnedTensor t; + t.dtype = vt::DType::kBF16; + t.nk = nk; + t.rank = 2; + t.shape[0] = out_features; + t.shape[1] = in_features; + + if (w.dtype == "BF16") { + if (w.shape.size() != 2 || w.shape[0] != out_features || w.shape[1] != in_features) { + Fail("tower module '" + module + "' is BF16 " + std::to_string(w.shape.size()) + + "-D but the config resolves [" + std::to_string(out_features) + ", " + + std::to_string(in_features) + "] for this layer"); + } + t.bytes.resize(w.nbytes); + std::memcpy(t.bytes.data(), w.data, w.nbytes); + return t; + } + + const std::string marker = module + std::string(kLtx2TorchaoNvfp4MarkerSuffix); + if (w.dtype != "U8" || !TowerHas(file, marker)) { + Fail("tower module '" + module + "' is stored as " + w.dtype + + " with no '" + marker + + "' sidecar, so it is neither the BF16 form nor the torchao-NVFP4 form " + "this loader understands. Refusing rather than reading its bytes as " + "whichever of the two happens to parse."); + } + // Parsed, not assumed: the marker is what says block_size 16 and swizzled + // scales, and it REFUSES a combination the dequant would silently mis-read. + ParseLtx2TorchaoNvfp4Marker(module, file.Get(marker)); + + t.bytes.resize(static_cast(out_features) * static_cast(in_features) * + sizeof(uint16_t)); + Ltx2DequantTorchaoNvfp4ToBf16(module, w, file.Get(module + ".weight_scale"), + file.Get(module + ".weight_scale_2"), out_features, + in_features, reinterpret_cast(t.bytes.data())); + if (dequantized != nullptr) dequantized->push_back(module); + return t; +} + +// A plain bf16 vector weight (a norm, or `layer_scalar`). Never quantized in any +// shipped build, so a non-BF16 one is a checkpoint this loader has not seen. +OwnedTensor TowerVector(const SafetensorsFile& file, const std::string& name, + int64_t n) { + const StTensor& w = file.Get(name); + if (w.dtype != "BF16") + Fail("tower tensor '" + name + "' is " + w.dtype + ", expected BF16"); + int64_t numel = 1; + for (int64_t d : w.shape) numel *= d; + if (numel != n) + Fail("tower tensor '" + name + "' has " + std::to_string(numel) + + " elements, expected " + std::to_string(n)); + OwnedTensor t; + t.dtype = vt::DType::kBF16; + t.rank = 1; + t.shape[0] = n; + t.bytes.resize(w.nbytes); + std::memcpy(t.bytes.data(), w.data, w.nbytes); + return t; +} + +// Concatenate already-materialized bf16 [rows_i, in] blocks into one raw-NK +// tensor, which is the layout `Gemma4Weights` carries q/k/v and gate/up in +// (gemma4_weights.cpp:290-296). +OwnedTensor TowerConcat(std::vector parts, int64_t in_features) { + int64_t rows = 0; + for (const OwnedTensor* p : parts) rows += p->shape[0]; + OwnedTensor t; + t.dtype = vt::DType::kBF16; + t.nk = true; + t.rank = 2; + t.shape[0] = rows; + t.shape[1] = in_features; + t.bytes.resize(static_cast(rows) * static_cast(in_features) * + sizeof(uint16_t)); + size_t at = 0; + for (const OwnedTensor* p : parts) { + std::memcpy(t.bytes.data() + at, p->bytes.data(), p->bytes.size()); + at += p->bytes.size(); + } + return t; +} + +} // namespace + +Ltx2GemmaTower Ltx2LoadGemmaTowerFromSafetensors(const SafetensorsFile& file, + const nlohmann::json& gemma_config) { + Ltx2GemmaTower tower; + tower.config = ParseHfConfig(gemma_config, "ltx2 gemma tower config"); + const HfConfig& c = tower.config; + + const nlohmann::json& text = c.raw.contains("text_config") && c.raw["text_config"].is_object() + ? c.raw["text_config"] + : c.raw; + + const int64_t H = c.hidden_size; + const int64_t L = c.num_hidden_layers; + const int64_t V = c.vocab_size; + const int64_t I = c.intermediate_size; + const int64_t Hq = c.num_attention_heads; + const int64_t Dh_slide = c.head_dim; + const int64_t Dh_full = TowerRawInt(text, "global_head_dim", Dh_slide); + const int64_t Hkv_slide = c.num_key_value_heads; + const int64_t Hkv_full = TowerRawInt(text, "num_global_key_value_heads", Hkv_slide); + const int64_t ple = TowerRawInt(text, "hidden_size_per_layer_input", 0); + const int64_t shared = TowerRawInt(text, "num_kv_shared_layers", 0); + + if (H <= 0 || L <= 0 || V <= 0 || I <= 0 || Hq <= 0) + Fail("the gemma config resolves a degenerate tower geometry"); + if (ple > 0) { + Fail( + "the gemma config declares hidden_size_per_layer_input=" + std::to_string(ple) + + ", i.e. a Per-Layer-Embeddings tower, but this checkpoint family ships no " + "`model.embed_tokens_per_layer` and no `per_layer_model_projection`. A PLE " + "tower whose PLE tensors are silently absent is a DIFFERENT model that " + "still produces 49 finite hidden states."); + } + if (shared != 0) { + Fail("the gemma config declares num_kv_shared_layers=" + std::to_string(shared) + + "; the LTX text tower ships none and YOCO KV-sharing is not wired on this " + "path. Refusing rather than reading a target layer's cache that was never " + "written."); + } + if (static_cast(c.layer_types.size()) != L) { + Fail("the gemma config declares " + std::to_string(c.layer_types.size()) + + " layer_types for " + std::to_string(L) + + " layers. Which layers are full-attention decides their head_dim (" + + std::to_string(Dh_full) + " vs " + std::to_string(Dh_slide) + + ") and their kv head count, so it cannot be defaulted."); + } + + const std::string prefix = kTowerPrefix; + tower.weights.tie_word_embeddings = true; + tower.weights.embed_tokens = + TowerModule(file, prefix + "embed_tokens", V, H, /*nk=*/false, + &tower.dequantized_modules); + tower.weights.final_norm = TowerVector(file, prefix + "norm.weight", H); + + const bool k_eq_v_declared = text.contains("attention_k_eq_v") && + text["attention_k_eq_v"].is_boolean() && + text["attention_k_eq_v"].get(); + + tower.weights.layers.reserve(static_cast(L)); + for (int64_t l = 0; l < L; ++l) { + const std::string base = prefix + "layers." + std::to_string(l) + "."; + const std::string sa = base + "self_attn."; + const std::string mlp = base + "mlp."; + const bool full = c.layer_types[static_cast(l)] == "full_attention"; + const int64_t Dh = full ? Dh_full : Dh_slide; + const int64_t Hkv = full ? Hkv_full : Hkv_slide; + + Gemma4LayerWeights w; + w.is_full_attention = full; + w.is_kv_shared = false; + w.kv_target_layer = -1; + w.head_dim = Dh; + w.num_kv_heads = Hkv; + + // `attention_k_eq_v` is a config-level flag but a PER-LAYER fact: the shipped + // tower's full layers carry no `v_proj` and its sliding layers do. Resolving + // it from tensor PRESENCE is what gemma4_weights.cpp:275 does; cross-checking + // it against the declaration is what stops a checkpoint that dropped a + // `v_proj` by accident from loading as a deliberately K-aliased layer, which + // is a 16-kv-head difference that every shape check still passes. + const bool has_v = TowerHas(file, sa + "v_proj.weight"); + w.k_eq_v = !has_v; + if (!has_v && !k_eq_v_declared) { + Fail("layer " + std::to_string(l) + " has no `" + sa + + "v_proj.weight`, but the config does not declare attention_k_eq_v. " + "Aliasing V onto K is a deliberate architecture, not a repair for a " + "missing tensor."); + } + + const OwnedTensor q = TowerModule(file, sa + "q_proj", Hq * Dh, H, true, + &tower.dequantized_modules); + const OwnedTensor k = TowerModule(file, sa + "k_proj", Hkv * Dh, H, true, + &tower.dequantized_modules); + if (has_v) { + const OwnedTensor v = TowerModule(file, sa + "v_proj", Hkv * Dh, H, true, + &tower.dequantized_modules); + w.attn.qkv_proj = TowerConcat({&q, &k, &v}, H); + } else { + w.attn.qkv_proj = TowerConcat({&q, &k, &k}, H); + } + w.attn.o_proj = TowerModule(file, sa + "o_proj", H, Hq * Dh, true, + &tower.dequantized_modules); + w.attn.q_norm = TowerVector(file, sa + "q_norm.weight", Dh); + w.attn.k_norm = TowerVector(file, sa + "k_norm.weight", Dh); + + const OwnedTensor gate = + TowerModule(file, mlp + "gate_proj", I, H, true, &tower.dequantized_modules); + const OwnedTensor up = + TowerModule(file, mlp + "up_proj", I, H, true, &tower.dequantized_modules); + w.mlp.gate_up_proj = TowerConcat({&gate, &up}, H); + w.mlp.down_proj = + TowerModule(file, mlp + "down_proj", H, I, true, &tower.dequantized_modules); + + w.input_layernorm = TowerVector(file, base + "input_layernorm.weight", H); + w.post_attention_layernorm = + TowerVector(file, base + "post_attention_layernorm.weight", H); + w.pre_feedforward_layernorm = + TowerVector(file, base + "pre_feedforward_layernorm.weight", H); + w.post_feedforward_layernorm = + TowerVector(file, base + "post_feedforward_layernorm.weight", H); + // Optional: a tower without it is upstream's `torch.ones(1)` default + // (modeling_gemma4_unified.py:501), which is the identity. + if (TowerHas(file, base + "layer_scalar")) + w.layer_scalar = TowerVector(file, base + "layer_scalar", 1); + + tower.weights.layers.push_back(std::move(w)); + } + return tower; +} + +// ─────────────────────── prompt -> conditioning, end to end ────────────────── + +Ltx2PromptConditioning Ltx2EncodePromptToConditioning( + const Ltx2GemmaTower& tower, const tok::Tokenizer& tokenizer, + const Ltx2GemmaSpecialIds& ids, const Ltx2TextEncoderWeights& weights, + const Ltx2TextFeatureConfig& feature_config, const std::string& prompt, + vt::Queue& queue, int64_t max_length) { + const HfConfig& c = tower.config; + const int64_t H = c.hidden_size; + const int64_t L = c.num_hidden_layers; + + if (feature_config.embedding_dim != H) { + Fail("the caption projections were resolved for a " + + std::to_string(feature_config.embedding_dim) + + "-wide Gemma hidden state but the tower is " + std::to_string(H) + " wide"); + } + if (feature_config.num_layers != Ltx2GemmaHiddenStateContract::Count(L)) { + Fail("the caption projections expect " + std::to_string(feature_config.num_layers) + + " hidden states but the tower has " + std::to_string(L) + + " layers, i.e. " + std::to_string(Ltx2GemmaHiddenStateContract::Count(L)) + + " states (encoder_configurator.py:182)"); + } + + Ltx2PromptConditioning out; + out.tokens = Ltx2TokenizeGemmaPrompt(tokenizer, prompt, ids.bos_id, ids.pad_id, + max_length); + out.seq = max_length; + out.mask = out.tokens.attention_mask; + + const int64_t T = out.tokens.num_valid; + // Upstream always has at least the BOS, so this cannot be zero; asserted + // because a zero-token forward would produce empty states that every later + // shape check would then compare against zero-length goldens. + if (T <= 0) Fail("the tokenizer produced no valid tokens"); + + std::vector token_ids(static_cast(T)); + std::vector positions(static_cast(T)); + for (int64_t i = 0; i < T; ++i) { + token_ids[static_cast(i)] = + out.tokens.input_ids[static_cast(out.tokens.first_valid + i)]; + // The ORIGINAL absolute position, not a renumbering from zero: transformers + // derives positions from the cache position, which counts the pad rows, so a + // left-padded prompt's first real token sits at `first_valid`. + positions[static_cast(i)] = + static_cast(out.tokens.first_valid + i); + } + + // A KV pool sized PER LAYER. The sliding and full layers do not share a + // geometry, and the runner's single-uniform-head_dim allocation cannot express + // that (gemma4.h, G1 HONEST STATUS) — so this path builds its own rather than + // routing through a seam that would have to lie about one of the two. + const int64_t block = 16; + const int64_t blocks = (T + block - 1) / block; + std::vector> kv_storage; + std::vector attn_kv; + kv_storage.reserve(static_cast(L)); + for (int64_t l = 0; l < L; ++l) { + const Gemma4LayerWeights& lw = tower.weights.layers[static_cast(l)]; + kv_storage.emplace_back( + static_cast(blocks * 2 * block * lw.num_kv_heads * lw.head_dim), 0.0f); + PagedKvCache kv; + kv.data = kv_storage.back().data(); + kv.dtype = vt::DType::kF32; + kv.num_blocks = blocks; + kv.block_size = block; + kv.num_kv_heads = lw.num_kv_heads; + kv.head_size = lw.head_dim; + attn_kv.push_back(kv); + } + + v1::CommonAttentionMetadata meta; + meta.num_reqs = 1; + meta.num_actual_tokens = static_cast(T); + meta.query_start_loc = {0, static_cast(T)}; + meta.query_start_loc_cpu = meta.query_start_loc; + meta.seq_lens = {static_cast(T)}; + meta.seq_lens_cpu = meta.seq_lens; + meta.max_query_len = static_cast(T); + meta.max_seq_len = static_cast(T); + meta.block_table_num_cols = static_cast(blocks); + meta.block_table_tensor.resize(static_cast(blocks)); + for (int64_t b = 0; b < blocks; ++b) + meta.block_table_tensor[static_cast(b)] = static_cast(b); + meta.slot_mapping.resize(static_cast(T)); + for (int64_t i = 0; i < T; ++i) + meta.slot_mapping[static_cast(i)] = static_cast(i); + meta.causal = true; + + const Gemma4HiddenStatesResult run = Gemma4Model::ForwardHiddenStates( + token_ids, positions, meta, attn_kv, tower.weights, c, queue); + if (static_cast(run.hidden_states.size()) != feature_config.num_layers) { + Fail("the tower returned " + std::to_string(run.hidden_states.size()) + + " hidden states, expected " + std::to_string(feature_config.num_layers)); + } + + // Scatter the valid rows back into the full padded width and leave the pad rows + // ZERO. Their VALUE is irrelevant — the extractor zeroes every masked position + // before the projection (feature_extractor.py:63-64) — but the DiT is fed the + // full 1024-wide conditioning, so the rows have to exist. + std::vector> padded(static_cast(feature_config.num_layers)); + std::vector layer_ptrs; + layer_ptrs.reserve(static_cast(feature_config.num_layers)); + for (int64_t s = 0; s < feature_config.num_layers; ++s) { + std::vector& dst = padded[static_cast(s)]; + dst.assign(static_cast(out.seq * H), 0.0f); + const std::vector& src = run.hidden_states[static_cast(s)]; + std::memcpy(dst.data() + static_cast(out.tokens.first_valid * H), + src.data(), src.size() * sizeof(float)); + layer_ptrs.push_back(dst.data()); + } + + Ltx2TextHiddenStates states; + states.layers = std::move(layer_ptrs); + states.batch = 1; + states.seq = out.seq; + states.hidden = H; + + out.conditioning = + Ltx2TextEncoderConditioning(states, out.mask.data(), weights, feature_config); + return out; +} + } // namespace vllm diff --git a/src/vllm/multimodal/ltx2_video.cpp b/src/vllm/multimodal/ltx2_video.cpp index 743c19e9d..4c865581a 100644 --- a/src/vllm/multimodal/ltx2_video.cpp +++ b/src/vllm/multimodal/ltx2_video.cpp @@ -597,12 +597,42 @@ std::unique_ptr Ltx2VideoEngine::Load(const VideoModelParams& p // turned into hidden states here. Saying so at LOAD, when the caller supplied // one, is better than accepting the path and refusing every request later. if (!params.encoder_path.empty()) { + // The refusal STANDS, and its REASON has moved. Saying so precisely matters + // more than the refusal itself: the previous message named the Gemma-4 tower + // as the missing piece, and that is no longer true. + // + // What phase L10 built: the embedded tokenizer reaches a prompt string + // (Ltx2TokenizeGemmaPrompt, token-exact against HuggingFace on the shipped + // 262144-entry vocab), the torchao-NVFP4 tower is materialized onto + // Gemma4Weights (Ltx2LoadGemmaTowerFromSafetensors), it runs and produces all + // 49 hidden states within the oracle's own bf16 noise floor, and the existing + // aggregation and both caption projections turn those into the two + // conditioning streams (Ltx2EncodePromptToConditioning), at 4096 and 2048 — + // which are exactly `attn2.to_k.weight [4096, 4096]` and the audio arm's + // 2048 in the shipped DiT. + // + // What is STILL missing is the last hop between them. Upstream does not feed + // the projections to cross-attention directly: it passes each stream through + // an `Embeddings1DConnector` first (embeddings_processor.py:70-117). The MATH + // of that connector is ported — `Ltx2ConnectorForward` — but its WEIGHTS are + // not loaded: they ship inside the DiT file as + // `video_embeddings_connector.*` / `audio_embeddings_connector.*`, and + // `Ltx2LoadDitFromSafetensors` still lists them among the modules it REFUSES + // (ltx2_loader.h:96-99). So the conditioning this engine could now compute + // has nowhere to go. + // + // Refusing here rather than at request time is unchanged: a caller who + // supplied an encoder_path finds out while they can still choose. Fail( - "encoder_path was supplied, but this family cannot encode a prompt yet: phase L6 " - "loads the caption projections and the embedded tokenizer and records the Gemma-4 " - "TOWER itself as owed (ltx2_loader.h:318-324), so there is nothing to produce the " - "49 hidden states `Ltx2TextFeatureExtractorForward` consumes. Condition through " - "prompt_embeds_path + the '" + + "encoder_path was supplied, and the text tower it names can now be RUN — phase L10 " + "tokenizes a prompt with the embedded tokenizer, materializes the torchao-NVFP4 " + "Gemma-4 tower, produces all 49 hidden states and projects them to the 4096-wide " + "video and 2048-wide audio streams. What is missing is the hop from there to " + "cross-attention: upstream routes both streams through an Embeddings1DConnector " + "first, whose math is ported (Ltx2ConnectorForward) but whose WEIGHTS live in the " + "DiT file as video_embeddings_connector.* / audio_embeddings_connector.* and are " + "still among the modules Ltx2LoadDitFromSafetensors refuses (ltx2_loader.h:96-99). " + "Condition through prompt_embeds_path + the '" + std::string(kLtx2AudioPromptEmbedsExtra) + "' extra meanwhile; that is the seam's own documented fallback."); } diff --git a/src/vllm/tokenizer/tokenizer.cpp b/src/vllm/tokenizer/tokenizer.cpp index d958b1146..38ac4265a 100644 --- a/src/vllm/tokenizer/tokenizer.cpp +++ b/src/vllm/tokenizer/tokenizer.cpp @@ -528,11 +528,19 @@ void Tokenizer::FinalizeTables() { Tokenizer Tokenizer::FromHfJson(const std::string& tokenizer_json_path) { std::ifstream in(tokenizer_json_path, std::ios::binary); if (!in) Fail("cannot open " + tokenizer_json_path); + std::string bytes((std::istreambuf_iterator(in)), + std::istreambuf_iterator()); + return FromHfJsonBytes( + std::string_view(bytes.data(), bytes.size()), tokenizer_json_path); +} + +Tokenizer Tokenizer::FromHfJsonBytes(std::string_view tokenizer_json, + const std::string& source) { json doc; try { - doc = json::parse(in); + doc = json::parse(tokenizer_json); } catch (const json::exception& e) { - Fail("JSON parse error in " + tokenizer_json_path + ": " + e.what()); + Fail("JSON parse error in " + source + ": " + e.what()); } if (!doc.is_object()) Fail("top-level JSON is not an object"); diff --git a/src/vllm/transformers_utils/hf_config.cpp b/src/vllm/transformers_utils/hf_config.cpp index 876bf60ca..699b6d0c1 100644 --- a/src/vllm/transformers_utils/hf_config.cpp +++ b/src/vllm/transformers_utils/hf_config.cpp @@ -375,18 +375,13 @@ std::vector ReadGenerationConfigEosIds(const std::string& path) { } // namespace -HfConfig LoadHfConfig(const std::string& path) { - std::ifstream in(path, std::ios::binary); - if (!in) { - throw std::runtime_error("hf_config: cannot open " + path); - } - nlohmann::json doc; - try { - doc = nlohmann::json::parse(in); - } catch (const nlohmann::json::exception& e) { - throw std::runtime_error("hf_config: JSON parse error in " + path + ": " + - e.what()); - } +namespace { + +// The whole parse, shared by the path and the in-memory entry points. `path` is +// what error messages name; `sibling_generation_config` is false when there is +// no file and therefore no sibling generation_config.json to read. +HfConfig ParseHfConfigDoc(nlohmann::json doc, const std::string& path, + bool sibling_generation_config) { if (!doc.is_object()) { throw std::runtime_error("hf_config: top-level JSON is not an object in " + path); @@ -527,8 +522,31 @@ HfConfig LoadHfConfig(const std::string& path) { } cfg.raw = std::move(doc); - cfg.generation_config_eos_ids = ReadGenerationConfigEosIds(path); + if (sibling_generation_config) { + cfg.generation_config_eos_ids = ReadGenerationConfigEosIds(path); + } return cfg; } +} // namespace + +HfConfig LoadHfConfig(const std::string& path) { + std::ifstream in(path, std::ios::binary); + if (!in) { + throw std::runtime_error("hf_config: cannot open " + path); + } + nlohmann::json doc; + try { + doc = nlohmann::json::parse(in); + } catch (const nlohmann::json::exception& e) { + throw std::runtime_error("hf_config: JSON parse error in " + path + ": " + + e.what()); + } + return ParseHfConfigDoc(std::move(doc), path, /*sibling_generation_config=*/true); +} + +HfConfig ParseHfConfig(const nlohmann::json& doc, const std::string& source) { + return ParseHfConfigDoc(doc, source, /*sibling_generation_config=*/false); +} + } // namespace vllm diff --git a/tests/vllm/models/ltx2_gemma4_text_config.json b/tests/vllm/models/ltx2_gemma4_text_config.json new file mode 100644 index 000000000..de640a04e --- /dev/null +++ b/tests/vllm/models/ltx2_gemma4_text_config.json @@ -0,0 +1,170 @@ +{ + "architectures": [ + "Gemma4UnifiedForConditionalGeneration" + ], + "audio_config": { + "_name_or_path": "", + "architectures": null, + "audio_embed_dim": 640, + "chunk_size_feed_forward": 0, + "dtype": "bfloat16", + "id2label": { + "0": "LABEL_0", + "1": "LABEL_1" + }, + "initializer_range": 0.02, + "is_encoder_decoder": false, + "label2id": { + "LABEL_0": 0, + "LABEL_1": 1 + }, + "model_type": "gemma4_unified_audio", + "output_attentions": false, + "output_hidden_states": false, + "problem_type": null, + "return_dict": true, + "rms_norm_eps": 1e-06 + }, + "audio_token_id": 258881, + "boa_token_id": 256000, + "boi_token_id": 255999, + "dtype": "bfloat16", + "eoa_token_index": 258883, + "eoi_token_id": 258882, + "eos_token_id": [ + 1, + 106 + ], + "gemma_version": "gemma4-12b-ltx-v1", + "image_token_id": 258880, + "initializer_range": 0.02, + "model_type": "gemma4_unified", + "text_config": { + "attention_bias": false, + "attention_dropout": 0.0, + "attention_k_eq_v": true, + "bos_token_id": 2, + "dtype": "bfloat16", + "enable_moe_block": false, + "eos_token_id": 1, + "final_logit_softcapping": 30.0, + "global_head_dim": 512, + "head_dim": 256, + "hidden_activation": "gelu_pytorch_tanh", + "hidden_size": 3840, + "hidden_size_per_layer_input": 0, + "initializer_range": 0.02, + "intermediate_size": 15360, + "layer_types": [ + "sliding_attention", + "sliding_attention", + "sliding_attention", + "sliding_attention", + "sliding_attention", + "full_attention", + "sliding_attention", + "sliding_attention", + "sliding_attention", + "sliding_attention", + "sliding_attention", + "full_attention", + "sliding_attention", + "sliding_attention", + "sliding_attention", + "sliding_attention", + "sliding_attention", + "full_attention", + "sliding_attention", + "sliding_attention", + "sliding_attention", + "sliding_attention", + "sliding_attention", + "full_attention", + "sliding_attention", + "sliding_attention", + "sliding_attention", + "sliding_attention", + "sliding_attention", + "full_attention", + "sliding_attention", + "sliding_attention", + "sliding_attention", + "sliding_attention", + "sliding_attention", + "full_attention", + "sliding_attention", + "sliding_attention", + "sliding_attention", + "sliding_attention", + "sliding_attention", + "full_attention", + "sliding_attention", + "sliding_attention", + "sliding_attention", + "sliding_attention", + "sliding_attention", + "full_attention" + ], + "max_position_embeddings": 262144, + "model_type": "gemma4_unified_text", + "moe_intermediate_size": null, + "num_attention_heads": 16, + "num_experts": null, + "num_global_key_value_heads": 1, + "num_hidden_layers": 48, + "num_key_value_heads": 8, + "num_kv_shared_layers": 0, + "pad_token_id": 0, + "rms_norm_eps": 1e-06, + "rope_parameters": { + "full_attention": { + "partial_rotary_factor": 0.25, + "rope_theta": 1000000.0, + "rope_type": "proportional" + }, + "sliding_attention": { + "rope_theta": 10000.0, + "rope_type": "default" + } + }, + "sliding_window": 1024, + "tie_word_embeddings": true, + "top_k_experts": null, + "use_bidirectional_attention": "vision", + "use_cache": true, + "use_double_wide_mlp": false, + "vocab_size": 262144, + "vocab_size_per_layer_input": 262144 + }, + "tie_word_embeddings": true, + "transformers_version": "5.10.1", + "video_token_id": 258884, + "vision_config": { + "_name_or_path": "", + "architectures": null, + "chunk_size_feed_forward": 0, + "dtype": "bfloat16", + "id2label": { + "0": "LABEL_0", + "1": "LABEL_1" + }, + "initializer_range": 0.02, + "is_encoder_decoder": false, + "label2id": { + "LABEL_0": 0, + "LABEL_1": 1 + }, + "mm_embed_dim": 3840, + "mm_posemb_size": 1120, + "model_type": "gemma4_unified_vision", + "num_soft_tokens": 280, + "output_attentions": false, + "output_hidden_states": false, + "output_proj_dims": 3840, + "patch_size": 16, + "pooling_kernel_size": 3, + "problem_type": null, + "return_dict": true, + "rms_norm_eps": 1e-06 + } +} diff --git a/tests/vllm/models/ltx2_gemma_tower_goldens.inc b/tests/vllm/models/ltx2_gemma_tower_goldens.inc new file mode 100644 index 000000000..e3b049174 --- /dev/null +++ b/tests/vllm/models/ltx2_gemma_tower_goldens.inc @@ -0,0 +1,2784 @@ +// GENERATED by scripts/gen-ltx2-gemma-tower-goldens.py — DO NOT EDIT BY HAND. +// +// The Gemma-4 TOWER oracle: the upstream HuggingFace implementation BUILT +// AND RUN at reduced dimensions, which phase L3 recorded as impossible on +// the transformers it had. Every weight is rebuilt on both sides from the +// deterministic Ltx2Rand stream keyed by the HuggingFace parameter NAME, so +// no weight byte is checked in and the naming contract is part of the gate. +// +// Oracle: transformers 5.12.1 at +// /home/mudler/recon-cpu/venv/lib/python3.10/site-packages/transformers +// torch 2.12.1+cpu +// Lightricks/LTX-2 revision: fd4ded7f2d88d3da713abcdd4ad41ecc4a9314ca +// diffusers revision: 3a2f35d4efa4c059c8bfb3bc0d6c906264895c81 +// Regenerate with: +// gen-ltx2-gemma-tower-goldens.py --out tests/vllm/models/ltx2_gemma_tower_goldens.inc +#pragma once + +#include + +namespace vllm_test { + +// --- section 0: the reduced architecture --- +inline constexpr int64_t kLtxTowerHidden = 32; +inline constexpr int64_t kLtxTowerNumLayers = 12; +inline constexpr int64_t kLtxTowerNumStates = 13; +inline constexpr int64_t kLtxTowerHeadDim = 8; +inline constexpr int64_t kLtxTowerGlobalHeadDim = 16; +inline constexpr int64_t kLtxTowerNumHeads = 4; +inline constexpr int64_t kLtxTowerNumKvHeads = 2; +inline constexpr int64_t kLtxTowerNumGlobalKvHeads = 1; +inline constexpr int64_t kLtxTowerIntermediate = 64; +inline constexpr int64_t kLtxTowerVocab = 64; +inline constexpr int64_t kLtxTowerSlidingWindow = 6; +inline constexpr int64_t kLtxTowerSeq = 8; +inline constexpr int64_t kLtxTowerPaddedSeq = 20; +inline constexpr int64_t kLtxTowerNumPad = 12; +inline constexpr int64_t kLtxTowerPadId = 0; + +inline constexpr const char* kLtxTowerTextConfigJson = R"JSON({ + "attention_bias": false, + "attention_dropout": 0.0, + "attention_k_eq_v": true, + "bos_token_id": 2, + "dtype": "bfloat16", + "enable_moe_block": false, + "eos_token_id": 1, + "final_logit_softcapping": 30.0, + "global_head_dim": 16, + "head_dim": 8, + "hidden_activation": "gelu_pytorch_tanh", + "hidden_size": 32, + "hidden_size_per_layer_input": 0, + "initializer_range": 0.02, + "intermediate_size": 64, + "layer_types": [ + "sliding_attention", + "sliding_attention", + "sliding_attention", + "sliding_attention", + "sliding_attention", + "full_attention", + "sliding_attention", + "sliding_attention", + "sliding_attention", + "sliding_attention", + "sliding_attention", + "full_attention" + ], + "max_position_embeddings": 128, + "model_type": "gemma4_unified_text", + "moe_intermediate_size": null, + "num_attention_heads": 4, + "num_experts": null, + "num_global_key_value_heads": 1, + "num_hidden_layers": 12, + "num_key_value_heads": 2, + "num_kv_shared_layers": 0, + "pad_token_id": 0, + "rms_norm_eps": 1e-06, + "rope_parameters": { + "full_attention": { + "partial_rotary_factor": 0.25, + "rope_theta": 1000000.0, + "rope_type": "proportional" + }, + "sliding_attention": { + "rope_theta": 10000.0, + "rope_type": "default" + } + }, + "sliding_window": 6, + "tie_word_embeddings": true, + "top_k_experts": null, + "use_bidirectional_attention": "vision", + "use_cache": true, + "use_double_wide_mlp": false, + "vocab_size": 64, + "vocab_size_per_layer_input": 64 +})JSON"; + +// The layer types, in order. 1 = full_attention, 0 = sliding. +inline constexpr int32_t kLtxTowerLayerIsFull[] = { + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, +}; + +// --- section 1: the inputs --- +inline constexpr int32_t kLtxTowerTokens[] = { + 2, 17, 41, 5, 23, 9, 60, 33, +}; + +inline constexpr int32_t kLtxTowerPaddedTokens[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 2, 17, 41, 5, 23, 9, 60, 33, +}; + +inline constexpr int32_t kLtxTowerPaddedMask[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, 1, 1, 1, +}; + +// --- section 2: hidden states, oracle in FLOAT32 --- +// [state][seq * hidden]. state 0 is the sqrt(hidden)-scaled embeddings; +// state i is decoder layer i-1's output; the LAST state is model.norm of +// the last layer, and the raw last-layer output never appears. +inline constexpr float kLtxTowerStateF32_0[] = { + 0.23475647f, 0.0555820465f, -0.0445346832f, -0.243041992f, 0.186424255f, -0.125663757f, + -0.0149312019f, -0.0811290741f, -0.0321063995f, -0.175376892f, 0.0383205414f, 0.0704269409f, + -0.0469512939f, 0.0735340118f, 0.178138733f, -0.103569031f, 0.103569031f, 0.278945923f, + 0.104259491f, 0.0345230103f, -0.139472961f, -0.0586891174f, 0.10218811f, -0.0398740768f, + 0.080783844f, -0.0510940552f, -0.240280151f, -0.0107452869f, 0.208518982f, 0.0455703735f, + -0.280326843f, 0.130496979f, -0.23613739f, 0.151901245f, -0.0569629669f, -0.040391922f, + 0.0353860855f, -0.129116058f, 0.107021332f, 0.142925262f, -0.116687775f, -0.0852718353f, + 0.0994262695f, 0.126354218f, 0.179519653f, 0.190567017f, 0.244422913f, -0.0724983215f, + -0.198852539f, 0.0904502869f, 0.209899902f, -0.274803162f, 0.244422913f, 0.102878571f, + 0.209899902f, -0.227851868f, 0.207138062f, -0.170543671f, -0.231994629f, 0.109783173f, + 0.022008419f, 0.0994262695f, -0.205757141f, 0.00798344612f, -0.173305511f, -0.142234802f, + 0.245803833f, -0.138092041f, 0.06731987f, 0.262374878f, 0.260993958f, 0.193328857f, + 0.00841498375f, -0.0731887817f, 0.2029953f, -0.0697364807f, -0.106330872f, -0.198852539f, + -0.230613708f, 0.0832004547f, -0.106330872f, 0.260993958f, 0.276184082f, 0.0838909149f, + 0.0835456848f, 0.0662841797f, 0.0866527557f, -0.143615723f, 0.0586891174f, 0.212661743f, + 0.26789856f, 0.205757141f, 0.0289993286f, 0.229232788f, -0.0645580292f, -0.070772171f, + 0.176757812f, 0.189186096f, -0.272041321f, 0.180900574f, -0.0880336761f, 0.0262374878f, + 0.23475647f, -0.0724983215f, -0.252708435f, 0.0566177368f, -0.259613037f, -0.13325882f, + 0.124282837f, 0.023475647f, 0.205757141f, 0.0728435516f, 0.208518982f, 0.0212316513f, + 0.0621414185f, 0.226470947f, -0.0987358093f, 0.237518311f, -0.0125145912f, -0.207138062f, + -0.057308197f, -0.124282837f, 0.237518311f, 0.244422913f, -0.0752601624f, -0.16985321f, + -0.127044678f, -0.163639069f, -0.043844223f, 0.230613708f, 0.0030207634f, -0.254089355f, + 0.107021332f, 0.0521297455f, -0.120140076f, -0.144306183f, 0.155353546f, 0.00340914726f, + 0.220947266f, -0.223709106f, -0.183662415f, 0.197471619f, -0.194709778f, 0.244422913f, + -0.263755798f, -0.153282166f, 0.254089355f, -0.027100563f, 0.241661072f, -0.16709137f, + 0.0731887817f, -0.223709106f, 0.0987358093f, 0.216804504f, 0.162258148f, -0.0386657715f, + -0.180900574f, -0.138092041f, -0.105640411f, -0.0728435516f, -0.252708435f, 0.243041992f, + -0.238899231f, -0.0510940552f, -0.0939025879f, 0.131187439f, -0.216804504f, -0.249946594f, + 0.0814743042f, 0.0804386139f, 0.173305511f, 0.0704269409f, 0.122211456f, 0.10011673f, + -0.225090027f, 0.189186096f, 0.218185425f, -0.151210785f, -0.0569629669f, 0.0959739685f, + -0.151210785f, -0.0281362534f, -0.0845813751f, -0.259613037f, 0.140853882f, -0.0600700378f, + 0.237518311f, -0.108402252f, -0.0593795776f, -0.0362491608f, 0.057308197f, -0.20161438f, + -0.0252017975f, -0.0669746399f, -0.0759506226f, 0.0192465782f, -0.148448944f, -0.166400909f, + -0.0123419762f, 0.180900574f, 0.194709778f, -0.171234131f, -0.0814743042f, -0.137401581f, + 0.0932121277f, 0.183662415f, 0.150520325f, 0.0455703735f, -0.0153627396f, -0.0869979858f, + -0.214042664f, -0.178138733f, -0.070772171f, 0.132568359f, -0.204376221f, -0.159496307f, + -0.015103817f, 0.237518311f, 0.0852718353f, -0.0662841797f, 0.2029953f, -0.247184753f, + 0.16709137f, -0.278945923f, -0.26927948f, -0.229232788f, 0.237518311f, 0.00229793787f, + 0.0364217758f, -0.190567017f, 0.176757812f, 0.0762958527f, 0.259613037f, 0.16778183f, + 0.243041992f, -0.2029953f, 0.220947266f, -0.115997314f, -0.0980453491f, -0.233375549f, + -0.266517639f, 0.222328186f, -0.243041992f, 0.0738792419f, 0.00591206551f, -0.0291719437f, + -0.0838909149f, -0.16985321f, -0.0397014618f, -0.182281494f, 0.164329529f, 0.0548915863f, + -0.111164093f, 0.266517639f, -0.0756053925f, -0.196090698f, +}; + +inline constexpr float kLtxTowerStateF32_1[] = { + -1.98886085f, -0.161533013f, -0.767248511f, 1.01953781f, 2.21974063f, -0.224783361f, + 0.650467873f, 2.76067042f, 0.67104578f, -0.614901066f, -1.25036561f, 0.972369254f, + 0.293569535f, -0.274536461f, 1.60135472f, 0.0462248959f, 0.673270881f, -0.301604062f, + 2.34471965f, 0.0311507694f, -1.75879371f, 0.420391083f, 2.8137219f, -1.24765635f, + -1.49731588f, -1.04393268f, 0.095809713f, -2.37909365f, -0.265560567f, -1.05342603f, + 1.31991398f, -0.289815426f, -0.306324184f, -1.25913584f, 1.54124987f, 1.15922952f, + -0.265950859f, -0.175296515f, 1.48632336f, 2.41660476f, 0.61280483f, -1.56943882f, + -0.801014364f, 1.46623623f, 1.68214762f, -0.310024142f, 0.498268604f, -1.61938131f, + -1.16377866f, -0.151858628f, 1.07389331f, -3.25863051f, -1.21410787f, 0.9916991f, + 1.15239596f, -1.0513134f, -3.23364305f, -1.45446253f, -0.431717306f, -0.717489719f, + 1.04536355f, 0.436770588f, -0.476055562f, 0.203867108f, -0.0265903063f, -2.8408339f, + 1.28742123f, 0.774915934f, -0.0671822652f, 0.773778141f, -0.940563262f, 1.33605695f, + 0.642415822f, -0.478788555f, -0.436185777f, 0.219911054f, 0.25594902f, -0.973068655f, + 0.680380285f, -1.11183858f, 0.667416215f, -3.12762117f, 1.32686079f, -0.449384749f, + 1.9288578f, 0.0183842871f, 3.4499445f, -0.291047812f, -2.73255324f, -1.49775004f, + 1.59177828f, -0.166832834f, -0.158490524f, -0.454606593f, 2.48707509f, 0.639238596f, + 1.49145257f, -1.00018036f, 1.75359464f, 0.632275522f, -0.60626936f, 0.130294412f, + -0.901580334f, -2.70690346f, -1.22284985f, 3.023736f, -1.13127661f, 0.148766771f, + -0.345613688f, 2.54525042f, 0.104476988f, 0.311318636f, -0.70954603f, -0.135165706f, + 2.01163936f, -1.20645773f, -0.165860549f, 0.50821209f, -1.99371672f, 1.15101171f, + 0.572166502f, -0.978789389f, -0.675005615f, 0.133932978f, 0.6774382f, 2.28858066f, + 1.65163159f, 1.79313815f, -1.63658369f, -1.16571999f, -0.32019937f, -0.205226034f, + -0.0303114019f, 0.121651798f, 0.630501747f, 2.34752369f, 1.83826804f, -0.763303876f, + -0.109862961f, 0.847837269f, 1.90964162f, -1.47741365f, -0.133202136f, -2.06875253f, + -0.908202946f, -0.784467578f, -1.2017529f, -3.07011032f, -1.51081681f, -0.361628085f, + -0.902171612f, -0.292488277f, -1.38241994f, 1.33940518f, -0.571171463f, -1.25617349f, + 0.476145416f, -1.61201036f, -0.283013433f, 0.602500141f, 0.637002409f, 0.437475502f, + 0.667068005f, 2.33962846f, -0.851365089f, 1.29004872f, -1.11395395f, -0.108941659f, + 2.08845305f, 3.30334783f, -1.98544359f, 1.28557515f, 1.44853747f, -0.338534653f, + -0.60062927f, 0.44739604f, -2.02487063f, 0.0862877965f, 1.57380068f, -1.51752126f, + -0.664628804f, 0.0803941786f, -2.50829911f, -0.283353031f, 1.64878738f, -0.478527963f, + 0.202982843f, -1.64396226f, 0.593567312f, 2.26732922f, 0.138387948f, 1.8037256f, + 1.15336657f, -1.42335522f, -1.44530022f, -0.182660729f, 2.97099829f, -0.63236177f, + -1.89968216f, 0.168847948f, -1.37503338f, -2.41509938f, 1.69015992f, -1.09445739f, + 1.09429657f, 2.02528548f, -0.092379868f, -1.32578158f, -1.19390798f, -0.208321497f, + 0.968699396f, 0.866377234f, 0.140280724f, -1.13199401f, 0.315516025f, -0.964631736f, + 0.536807299f, 2.82521653f, -0.491432905f, 0.266447663f, 0.956912994f, 0.257664442f, + -1.12140024f, 0.308237523f, 1.60896873f, 3.26095748f, -0.518111825f, 1.9679774f, + 1.15453458f, -0.415152609f, -1.04181921f, -1.94303906f, -1.80022275f, 0.97140938f, + 0.810593247f, -1.86375475f, 0.200901568f, -0.00160488114f, -0.0159314796f, -0.655395985f, + -0.650143206f, 2.91487384f, 0.744379938f, -0.521372616f, -1.05467725f, -0.344256997f, + -1.82837272f, -0.467980832f, 0.244995952f, 1.62551904f, 0.789782822f, 0.83481741f, + 0.953185737f, 2.10035467f, 0.599633694f, -0.387934119f, +}; + +inline constexpr float kLtxTowerStateF32_2[] = { + -3.33602643f, 1.38034976f, -1.09736311f, 0.369083762f, 2.1213448f, 0.0179143585f, + -0.573706329f, 0.99459523f, 1.6684984f, -0.609581351f, -2.89156318f, 1.76444817f, + -2.18246293f, -1.98946178f, 4.15764332f, 1.26136172f, -1.06169498f, 2.0369215f, + 2.66516733f, -1.03545225f, -2.71756887f, 0.345697939f, 2.78603292f, -1.61341357f, + -0.416000634f, -1.53710818f, -2.1350317f, 0.647517264f, 1.31271732f, -2.18382716f, + 1.52610838f, 0.529773831f, -3.03355479f, -1.35661745f, 2.11288142f, 1.76929212f, + -1.32637274f, -1.17311764f, 1.33504546f, 4.43245649f, 2.82521224f, 0.275987059f, + -1.98884988f, 0.949342787f, -0.811731637f, 0.449940771f, 1.37091708f, -2.00187373f, + -2.07055211f, -0.194292352f, 1.59364915f, -4.95764256f, 0.237190798f, 0.685321689f, + 2.40491724f, -1.84622264f, -2.2234385f, -1.79950261f, 0.522072375f, 2.18992829f, + 3.02510762f, -0.143185392f, -0.753312349f, -1.11410785f, -0.77024436f, -5.04726791f, + 1.14633965f, 1.68938184f, 0.211432725f, 0.286622703f, -3.60937095f, 1.69264352f, + 1.30486f, -2.13476324f, -2.05765367f, -1.01949883f, -2.55044675f, -3.80488729f, + 0.755642831f, -1.05458999f, -1.36714804f, -2.93426371f, 2.78113198f, -2.76256585f, + 1.71680713f, 0.855419338f, 4.7215476f, -1.44789374f, -1.30497503f, -0.789304852f, + 1.16152442f, 3.42392921f, -0.200296372f, -2.46315694f, 2.41203594f, 0.979191422f, + 0.350706547f, -0.166043982f, 3.42161322f, -1.49679744f, 1.83753335f, -2.14757109f, + 0.622548044f, -4.4998455f, -0.82774967f, 0.648491979f, -1.44455147f, -2.3723588f, + -0.998302162f, 2.70399332f, -0.65700388f, 2.30982757f, -0.921415329f, 1.25141191f, + -1.06015229f, -2.89452696f, 0.0088805398f, 0.747650146f, -2.22776556f, 0.476962358f, + -0.188264146f, 0.38052687f, -1.176404f, 0.10885641f, 3.12309504f, 4.5671382f, + 0.327920884f, 1.45854461f, -1.07232928f, -3.28218937f, -0.710650682f, 0.532570004f, + -0.261209309f, 0.516385734f, -0.259078562f, 4.00530434f, 3.42084432f, 2.82872009f, + 0.417563707f, 1.43597651f, 0.0262908731f, -1.79207361f, 1.31346345f, -4.89049387f, + -0.894897163f, -1.88119078f, -0.132271156f, -3.56273365f, 0.100122578f, 0.26775527f, + -0.632734418f, -2.22207236f, -2.18956757f, 1.81542599f, 1.28781128f, 1.23305416f, + 0.00589755457f, -2.21389079f, -2.30106759f, -0.371245414f, 2.73057389f, -1.3984834f, + 2.13347602f, 0.598048747f, 0.73804915f, 2.82423472f, -1.73249924f, -2.33199859f, + 2.68605661f, 2.80688095f, -0.247047544f, 0.714337587f, 0.284152001f, 0.254234105f, + 0.313443124f, -0.779782355f, -2.50863314f, -1.02531898f, 1.47264946f, -1.91602266f, + 2.0841229f, -1.27137208f, -2.25216484f, -1.9057976f, 0.571214378f, 2.331532f, + 1.78978562f, -1.26980519f, -1.72148263f, 3.15862465f, 0.0669101477f, 3.67808032f, + 3.21012855f, -0.456762969f, -3.03391361f, -1.29744279f, 2.34820318f, -1.12553442f, + -2.84812164f, -1.06300366f, -0.30298233f, -2.28643847f, -0.242187217f, -0.749162257f, + -0.761653304f, 0.887720823f, 1.26191366f, 0.233692855f, -3.63975692f, 2.22317028f, + -0.225644454f, -1.10077155f, -2.50560212f, -2.24941707f, 1.75155044f, -0.170508072f, + 2.59194493f, 4.06068182f, -0.00505530694f, 2.56501079f, 2.52117395f, 0.308424473f, + -0.0322841555f, 0.246650174f, 2.87685609f, 3.65093994f, 0.814967453f, 1.35474861f, + 0.478883773f, -1.66722f, -1.48925257f, -4.03605461f, -5.558568f, 0.347447872f, + -0.328560829f, -0.521028996f, 0.752093494f, 0.785017669f, 0.0857213959f, 0.46583569f, + -0.792840064f, 4.7875905f, 0.113957822f, -3.17228007f, -2.6299367f, -2.00681901f, + 2.52796149f, 0.38529247f, 2.1779027f, -0.934797943f, -0.999926984f, 0.579317629f, + 1.26110184f, 2.19630361f, 0.550613284f, 0.547042608f, +}; + +inline constexpr float kLtxTowerStateF32_3[] = { + -4.62408972f, 1.41430128f, -1.27646315f, 1.5123924f, 2.53752446f, 2.64778066f, + 1.45493925f, 0.550230742f, -0.499934822f, 0.217706457f, -4.22821283f, 1.93419075f, + -4.78617048f, -4.08878136f, 3.98168635f, 0.87554419f, 1.49893427f, 4.53367138f, + 3.95623779f, -1.91546273f, -3.01503682f, 3.40431356f, 4.44517899f, -3.78030872f, + 1.53354096f, -0.567785203f, -4.26043558f, 0.916204691f, 2.81639576f, -2.52821851f, + -0.520380497f, 0.734793663f, -2.95599198f, -1.85244501f, 3.06702256f, 2.3922267f, + 0.379886508f, 0.800960124f, 2.90772724f, 2.41730475f, 1.05462658f, -1.10404491f, + -3.47042561f, 1.52323294f, -2.25982308f, -0.93752867f, 0.638689816f, -1.54404855f, + 1.18063426f, 1.96123993f, 1.32690322f, -4.60424566f, 0.469890952f, 3.86540532f, + 5.02931786f, -3.1551764f, -1.47835863f, -0.878591061f, -0.0995051339f, 1.77965868f, + 3.93136716f, 0.497424841f, -2.34846163f, -1.25529385f, -1.25628138f, -7.00377464f, + 2.65834713f, 1.55195642f, 1.87900412f, 3.12139416f, -2.63576508f, -0.522455096f, + 0.132164448f, -2.26670218f, -2.18054295f, 0.074770011f, -3.62865686f, -6.29518318f, + -0.28004387f, -2.37198687f, 1.29008603f, -0.827113092f, 2.20892382f, -4.45102978f, + 2.60752749f, 1.94525552f, 7.39378119f, -3.66374326f, 0.873647213f, -0.241161466f, + 0.636564851f, 3.76137781f, 1.90893781f, -0.0343148708f, 1.4969995f, 1.64521122f, + 1.45160079f, 1.13905299f, 6.39156628f, -2.22731662f, 2.09590459f, -0.53562063f, + 1.09016514f, -5.24967861f, -3.13929343f, 0.0689904019f, -3.51119757f, -2.66153908f, + -2.59894204f, 2.47461867f, -1.34113431f, 0.355490953f, -0.144486606f, 1.96874964f, + 0.359715641f, -3.21898627f, 1.25713336f, 1.40014374f, 1.25112867f, -1.90323019f, + -0.618415892f, -0.357517034f, -0.074207522f, 0.588298738f, 1.08245492f, 4.71839952f, + 0.912317991f, 0.375117481f, 0.100281432f, -3.19975853f, -0.805853903f, 3.84240294f, + -2.88034678f, 0.799629867f, 1.38343191f, 6.19320583f, 2.19100094f, 0.590761483f, + 2.0959723f, 0.237630039f, 0.537999868f, -0.42064324f, 0.782653272f, -5.10960388f, + -2.96208549f, -1.61699462f, 0.0727628991f, -2.96610713f, 2.67829013f, -1.77715123f, + 1.09870291f, -0.472747982f, -4.04855347f, 2.03833199f, 1.79762208f, 0.333740115f, + -1.37219346f, -2.328758f, -0.758469105f, -0.282896787f, 5.24553204f, -2.30156255f, + -0.231537789f, 0.741683125f, -2.1706965f, 2.08346534f, -1.52045405f, 0.00632803049f, + 3.45525837f, 3.63812304f, -0.150114089f, 0.982470155f, 1.54951f, 2.15077424f, + -0.894323766f, -2.78702807f, -3.05326796f, -1.05728364f, 0.828608036f, -0.0103121288f, + 4.10025978f, -1.42179728f, 0.0770527571f, -0.362042904f, -1.9601351f, 3.5560298f, + 2.68822837f, -0.127467141f, -1.35870552f, 3.31202197f, -1.46062052f, 6.22333527f, + 4.73564577f, -1.96383512f, -3.61688924f, -1.935624f, 5.8666358f, -1.26087177f, + -1.992975f, -4.52770185f, 1.01269794f, -3.12209654f, 1.28939879f, -2.48918295f, + 1.8202399f, 0.967494369f, 1.59786713f, -1.21273577f, -4.30623102f, 3.31613803f, + -1.77630925f, -2.01201129f, -4.07225037f, -4.05497026f, 4.55474663f, -0.337012917f, + 1.32252228f, 3.84242439f, 0.777473867f, 2.24292064f, 2.04793024f, 0.650741637f, + 0.0977209061f, -2.11515284f, 2.13438797f, 4.24094677f, 4.16001272f, 0.758553207f, + -0.370572507f, 0.0387053601f, -2.38277507f, -4.07648849f, -7.39979506f, -0.425550163f, + -0.864881814f, -3.03831077f, 0.0658055767f, 0.701537013f, -1.25495219f, -1.64132774f, + -1.3736378f, 6.34368467f, 0.834853888f, -2.27600479f, -1.63849711f, -1.51054895f, + 4.3952632f, 0.0115857748f, 1.23823118f, -1.59052992f, -0.216206506f, 1.01388228f, + 0.759358346f, 4.87487173f, 0.326841801f, 1.08901393f, +}; + +inline constexpr float kLtxTowerStateF32_4[] = { + -7.09659529f, 1.09092796f, 0.221957535f, 3.88664937f, 2.03621531f, 4.74946785f, + 1.71300888f, 0.437405229f, 0.19550021f, 2.25704241f, -4.85564137f, 2.95899892f, + -5.70593643f, -6.23454905f, 1.36526835f, 2.05749822f, 4.10939264f, 3.15098763f, + 3.1633873f, -0.664293528f, -3.54874873f, 5.16659737f, 3.27077365f, -4.87856627f, + 0.580941558f, -2.15387249f, -1.6979475f, 2.77348185f, 5.88290691f, -0.95225358f, + -0.807212889f, 0.896836042f, -5.52220678f, -0.883058786f, 5.76442289f, 2.91979027f, + -0.737561285f, 3.96142054f, 2.62343407f, 2.82571697f, 1.87364054f, 0.573143363f, + -4.94557428f, 1.46841347f, -4.03376579f, -1.94102907f, -0.226458237f, 0.372621179f, + 1.74001861f, 0.235141262f, -0.0726416185f, -2.75017953f, 2.56372809f, 7.78648853f, + 6.28970003f, -3.80327678f, -0.334172368f, -2.63793182f, 1.57528222f, 4.18233585f, + 4.90970182f, 1.50939608f, -2.53221655f, -1.60665381f, -2.75980067f, -8.08221531f, + 4.07224035f, 2.62519383f, 0.0570049211f, 5.65306902f, -3.61701131f, -0.144306093f, + 2.59889531f, -1.71344018f, -4.14062214f, 1.03784871f, -3.63472962f, -7.47968483f, + -0.725453496f, -1.64410138f, 0.54261595f, -1.81725216f, 1.28904283f, -2.43226767f, + 2.75482082f, 4.08635712f, 7.22616243f, -5.24877644f, 0.268827975f, -0.285331488f, + 0.387226582f, 5.03208828f, 3.3828311f, -0.418687314f, 2.86640596f, 2.09243417f, + -0.398092866f, 3.0968821f, 7.78252077f, -0.626020432f, 3.6802485f, -0.396163195f, + 1.86912835f, -3.64719009f, -3.751405f, -0.822821379f, -4.92837858f, -2.58722901f, + -3.12394142f, 3.63575649f, -3.28017306f, 0.701405168f, 0.247738212f, 1.74262023f, + 1.25225878f, -1.92253017f, 1.81276751f, 3.44589448f, -0.0340086818f, -4.26487637f, + 0.175242707f, -1.601035f, 0.0704507753f, 2.38339233f, 1.51479781f, 3.88791442f, + 1.56852794f, 0.29295212f, -2.29032111f, -2.96778917f, -0.0547429435f, 2.86540461f, + -2.89290023f, 4.10176039f, 0.555796742f, 6.98050642f, 3.33610702f, 0.380705625f, + 0.836640239f, 0.0599458367f, -1.67267549f, 0.230495006f, 2.22266793f, -4.84138155f, + -1.75605547f, -3.50261164f, -1.55031013f, -2.00038695f, 3.21677637f, 1.91770816f, + 1.70449948f, -0.00773459952f, -3.32507372f, -0.006777253f, 1.85394585f, -0.108257711f, + -1.72079813f, -1.5599823f, -1.44400859f, 0.0399995036f, 3.47325826f, -2.07407784f, + -1.46816874f, -1.81626427f, -0.916266382f, 4.79381943f, -2.48494768f, -0.0581848212f, + 4.27908373f, 3.53843617f, -0.943952262f, 2.76223254f, 2.48304224f, 2.00144291f, + 0.883091271f, -1.30752885f, -2.25114417f, -4.49406576f, -0.104430273f, -2.13201332f, + 4.4455533f, 2.52515602f, -0.756389439f, -0.522008955f, -0.982368946f, 1.49938965f, + 3.51814604f, 2.56618214f, -1.2733978f, 3.92712617f, -4.21127129f, 6.46508884f, + 4.59245968f, -2.24167871f, -4.69311714f, -1.30543017f, 8.60545349f, 0.655608058f, + -2.61527205f, -4.05005169f, -0.863291383f, -2.70658708f, 0.696379542f, -3.64124489f, + 4.25085115f, -0.572361112f, -0.148256451f, 1.26456714f, -1.98901665f, 4.2405448f, + -3.93667436f, -2.02401304f, -7.42632723f, -3.98102093f, 3.15226054f, -0.801098168f, + 3.1164484f, 2.07886696f, 1.2769891f, 4.42076588f, 3.09378934f, 0.93234247f, + 0.884845257f, -2.74771309f, 1.22384548f, 6.67200089f, 6.02826691f, 3.0943222f, + 0.656011105f, 1.20506442f, -2.0333972f, -3.55973005f, -8.61177158f, -1.03222871f, + -2.41653252f, -1.11985505f, -0.155672833f, 0.969347894f, -1.12273121f, -2.47904468f, + 0.873010576f, 5.17176247f, 1.49148631f, -2.12953043f, -2.67013764f, 1.08429337f, + 3.7580533f, -2.13662505f, 1.90941083f, -3.2081852f, -0.511538029f, 1.99235892f, + 0.776497602f, 5.46192551f, 0.91294378f, 0.257184267f, +}; + +inline constexpr float kLtxTowerStateF32_5[] = { + -6.64045811f, 0.258258611f, 2.66247058f, 1.69855809f, -0.580469966f, 4.99917841f, + 2.92916846f, -3.13593745f, -0.705907643f, 1.01345515f, -3.65989399f, 1.28651237f, + -7.21720505f, -4.94238472f, 0.438347757f, 1.15158808f, 4.75012589f, 3.38233805f, + 3.07190537f, -2.9253068f, -5.14442635f, 6.62584019f, 2.60874295f, -5.67679214f, + -0.16155155f, -1.90863144f, 0.220604479f, 3.13170433f, 6.78018332f, -1.25791955f, + -1.23095798f, 2.8856144f, -4.38338995f, -1.15597796f, 7.75671005f, 1.43476462f, + -2.11274529f, 5.3797121f, 1.60535693f, 0.899000168f, 0.416427583f, 1.41785741f, + -3.93825245f, 0.612451553f, -2.77717853f, -2.60971355f, -1.04285669f, 1.09381974f, + 4.44897127f, 0.0579791106f, -1.9534862f, -2.91131377f, 1.59319079f, 8.97343063f, + 5.49822044f, -5.31195545f, -0.282789707f, -2.07471251f, 5.25232792f, 3.47393751f, + 6.82102013f, 0.296510607f, -2.90642142f, -0.32622695f, -1.24837995f, -9.3463316f, + 3.31207275f, 1.1867398f, -2.18857574f, 6.29563475f, -1.37613273f, -2.41928029f, + 2.55490208f, -2.01294231f, -2.53836846f, -0.176113054f, -5.00076485f, -8.38374901f, + -0.500873566f, -1.81493115f, 2.32042789f, -1.19453537f, 0.960481942f, -3.91206336f, + 0.545101225f, 4.08958864f, 6.90070581f, -6.7409215f, 2.52353454f, 0.592550933f, + 3.55457377f, 6.10243511f, 3.69302535f, -0.73185885f, 1.74486899f, 3.50318861f, + 0.636627436f, 1.94069934f, 7.2266078f, -0.523864329f, 4.8303051f, -0.339312106f, + 1.13631833f, -4.42943764f, -5.11327171f, -3.49207544f, -3.14545059f, -3.96305203f, + -3.62993932f, 2.85470867f, -1.95036864f, 1.83606315f, 2.85544467f, 1.86200058f, + 0.532652795f, -2.34022212f, 0.0567901209f, 4.45599794f, -0.915765822f, -7.06522512f, + 2.77338648f, 0.212453395f, 0.762414634f, 3.92422867f, 2.00806594f, 4.5887475f, + -0.46376738f, 3.66994452f, -2.75633979f, -4.37250185f, 0.219367146f, 4.63318586f, + -2.42925858f, 5.76155567f, 0.321090907f, 3.26956844f, 4.09680557f, -0.611449778f, + 1.90063572f, -1.55128443f, -2.98251748f, -0.207330436f, 0.981945574f, -5.94470739f, + 1.70992076f, -5.10749483f, -3.16103935f, -1.29736972f, 3.71641207f, 3.62377691f, + 1.13639116f, -2.88478851f, -2.76372051f, -1.17572129f, 5.92212963f, -1.0109477f, + -2.51534128f, -0.892828345f, -1.88865507f, 2.11595154f, 3.02990079f, -1.73219252f, + 1.19213927f, 0.0774225965f, -1.75198841f, 6.44073963f, -2.10677075f, -0.938620687f, + 5.17380857f, 6.80739832f, 1.90408933f, 3.64415979f, 2.4848187f, 0.959942579f, + -2.13620043f, -1.08752096f, -1.22001326f, -4.49826956f, -1.65654016f, -1.29317904f, + 4.48115444f, 2.86725378f, -0.653137982f, -1.5064075f, -0.774149776f, 3.36947966f, + 6.64984655f, 2.96175122f, -1.25763977f, 2.09291911f, -2.90981722f, 8.11131096f, + 5.84355307f, -4.66170931f, -3.73882818f, -0.224931225f, 9.98898315f, 2.4647162f, + -4.07140112f, -2.50167322f, -1.85393035f, -1.93972862f, 1.9603678f, -3.04948711f, + 2.08471751f, 0.177211046f, 0.074416317f, 1.24735272f, -1.88436759f, 4.99502802f, + -5.80410814f, -2.8898313f, -7.23471642f, -3.71495843f, 4.20570326f, -3.3050015f, + 4.53427744f, 4.87243938f, 3.18710375f, 5.21848202f, 0.750816822f, 2.42432237f, + 0.95847255f, -1.71749032f, 0.428037107f, 6.035604f, 5.16329002f, 4.81914902f, + -1.16977036f, 1.99182796f, -2.49854064f, -2.5547576f, -7.70520449f, 0.445138633f, + -1.1305598f, -0.0970844999f, -1.91000211f, 0.556091905f, -2.50502014f, -2.34511471f, + 2.33597803f, 2.11226869f, 2.19589734f, -2.42968583f, -2.81563687f, 0.0614120439f, + 4.29045057f, -1.57668376f, 4.18834829f, -2.76709294f, -0.750096381f, 0.0431225523f, + 0.126475736f, 7.05367708f, 1.89862216f, -0.216908365f, +}; + +inline constexpr float kLtxTowerStateF32_6[] = { + -7.62095928f, -0.981662273f, 2.282161f, 3.13395262f, -0.466449618f, 6.39862156f, + 4.43844318f, -5.81806707f, 2.1706543f, 2.20054436f, -2.85642481f, 1.33196759f, + -9.07043457f, -3.79968309f, 1.70141912f, -2.23640442f, 4.04678345f, 2.16642451f, + 2.09990692f, -4.59141541f, -6.26420307f, 6.33999586f, 3.22913218f, -5.65510654f, + 1.49053919f, -1.13045537f, -0.995037556f, 4.60238886f, 7.50435448f, -0.878966987f, + -0.658555984f, 1.81321383f, -4.87576914f, -2.57472491f, 9.40969658f, 1.91823304f, + -3.23441958f, 8.24658871f, 1.00620043f, 1.27793705f, 1.38728631f, 1.39769113f, + -3.74314833f, 1.33322811f, -3.06646514f, -0.302460968f, 0.440436512f, -0.566105902f, + 4.91932058f, -0.404088467f, -2.35718393f, -3.31529784f, 0.604920387f, 7.93081808f, + 6.26774549f, -3.89024544f, 3.4206357f, 1.79299462f, 5.32616568f, 3.34620261f, + 6.87704372f, 2.15493727f, -3.77659655f, -1.98675382f, -2.04230738f, -12.5902777f, + 3.54818058f, 1.66695356f, -3.06009912f, 8.95375729f, 0.546765149f, -4.05432701f, + 3.4335568f, -1.9554224f, -2.22007251f, 0.218481645f, -4.72781038f, -5.26103973f, + 0.852730751f, -2.74248552f, 2.02177858f, -0.702832103f, 0.357966185f, -3.76474595f, + 0.644140601f, 2.97337127f, 6.39885664f, -8.5484581f, 4.45122766f, 2.11893177f, + 3.8757515f, 6.67151165f, 3.25328279f, -0.246316925f, 1.54884672f, 3.64997959f, + 2.75412488f, 4.10560465f, 9.79255676f, -0.0770471022f, 7.07832384f, 0.717390001f, + 0.972127736f, -7.05186462f, -5.04230404f, -5.13266325f, -3.60082388f, -3.94363379f, + -2.49090457f, 1.22013354f, -1.94966638f, 0.684180081f, 2.56452107f, 2.11440873f, + 0.621891916f, -0.330242574f, -0.279531747f, 2.63899708f, 0.180352271f, -10.8166924f, + 8.15256405f, -0.204465002f, 1.54138684f, 5.39111233f, 1.02309525f, 5.26201916f, + -0.609070063f, 4.5033927f, -3.31266689f, -5.27713919f, -0.0519546121f, 6.24016285f, + -0.685716748f, 7.91884804f, 1.61114943f, 2.09856248f, 7.4138751f, -1.30306923f, + 1.34319317f, -3.0907166f, -2.74976826f, 1.57180607f, 2.71959853f, -9.29377174f, + 1.13725698f, -6.927917f, -1.69592476f, -1.74221826f, 2.75648928f, 3.6543901f, + -0.882521391f, -3.02234745f, -2.95082331f, 0.788434565f, 4.91456223f, 0.359275967f, + -1.8393358f, -0.564957738f, -4.74281693f, 3.27098536f, 4.55890512f, -2.48625493f, + 1.82624328f, -0.0501777008f, -1.7281388f, 7.52305984f, -2.95553398f, -2.87898993f, + 6.77482796f, 7.02660942f, 2.49488115f, 2.56563354f, 2.45345473f, 2.01499081f, + -1.125705f, -4.66371059f, -3.03194904f, -5.53936625f, -3.07800007f, -1.65754652f, + 4.72685385f, 0.660622299f, 0.463680267f, 0.475651383f, 0.907410145f, 5.22579241f, + 7.42294741f, 3.12048459f, -2.9734993f, 1.73003578f, -4.31428766f, 9.31255627f, + 10.036005f, -4.08131647f, -3.89415717f, -0.913606346f, 10.3652487f, 4.92859983f, + -3.36162996f, -4.37665033f, -3.24141383f, -1.34864402f, 3.22894573f, -1.78101945f, + 0.706115305f, 0.365581453f, -0.445115924f, 4.25244188f, -3.02807546f, 5.27494621f, + -7.71827745f, -2.58702135f, -10.3369379f, -7.53080606f, 4.91269779f, -2.69294977f, + 8.68276119f, 5.7092638f, 2.71127176f, 4.90983105f, 0.562995315f, 2.46402049f, + 0.605989516f, -0.758041739f, 1.11307836f, 6.66029406f, 5.77147198f, 5.09689045f, + 0.733112335f, 4.63741207f, -2.63856363f, -4.90740299f, -5.08221722f, 0.398807406f, + -2.59628105f, 0.80354321f, -0.00657770038f, -0.535695612f, -1.5581702f, -5.18215942f, + 3.04947066f, 0.648498774f, -0.129533753f, -0.857033372f, -1.75286281f, 2.49847603f, + 5.36100769f, -2.98962498f, 6.36075163f, -2.56882739f, -0.0264763311f, 0.921184719f, + -1.12411273f, 7.7364006f, 1.44296908f, -1.14173746f, +}; + +inline constexpr float kLtxTowerStateF32_7[] = { + -8.49834442f, -0.873637855f, 1.17466438f, 2.65314245f, -0.25795427f, 4.23031902f, + 1.7094239f, -3.2902925f, 1.16402686f, 2.7514677f, -2.84108019f, 0.178414404f, + -8.80039024f, -4.86490774f, 2.11539364f, -1.48792613f, 1.58716655f, 2.26404047f, + 3.78828692f, -4.93216801f, -5.80612373f, 4.66260719f, 2.46323276f, -5.69036388f, + 6.96226454f, -0.842600882f, -0.506489158f, 4.39151859f, 6.89374018f, -0.951885462f, + -1.93642688f, 1.89574707f, -6.93889618f, -1.23520339f, 7.53861856f, -0.36138615f, + -3.49966788f, 6.57432508f, -0.694968462f, 3.20523095f, 0.269503206f, 1.13088739f, + -3.40728068f, -1.2106849f, -3.62305665f, -2.61257386f, 0.883216918f, 0.502232134f, + 3.04939008f, 0.0804888383f, -0.958589494f, -2.62659717f, 0.0633456111f, 7.47036839f, + 6.11367702f, -2.84202433f, 6.2226162f, 0.375266969f, 5.25863075f, 2.83969784f, + 6.95168018f, 2.35091758f, -4.07692099f, -0.8662166f, -3.35073972f, -11.5040922f, + 1.86765802f, 0.450118691f, -2.09285331f, 6.96746206f, -1.21641803f, -1.33300495f, + 1.93164313f, -0.658451974f, -1.88817263f, -2.40654063f, -4.2668829f, -6.68298769f, + 1.02009094f, -1.54492974f, 1.22988915f, -0.388663918f, 2.33958054f, -3.13674951f, + 0.810291469f, 2.44879484f, 4.77488041f, -7.22301435f, 7.17418194f, 1.54781783f, + 2.86882257f, 7.25169468f, 2.09206653f, 0.131587505f, 1.12161875f, 3.66356802f, + 1.92293549f, 4.35820293f, 6.81576538f, -1.27211416f, 7.05986023f, 1.57275248f, + 0.0727321208f, -5.70369959f, -6.21478462f, -4.0205121f, -2.70171523f, -4.99440765f, + -1.67809081f, -1.76749063f, -2.26094913f, 2.75878358f, 1.0782429f, 3.507792f, + 3.250633f, 1.42178261f, 0.224160105f, 3.30605316f, 1.39648426f, -9.38075829f, + 11.3223095f, -0.785044611f, 0.659722567f, 5.40761948f, 0.803944767f, 6.50185585f, + -2.43570733f, 3.96475959f, -3.86472821f, -4.46944427f, -2.1037662f, 3.8133955f, + -0.101657271f, 6.58825779f, -0.298534364f, 3.94105649f, 4.78750944f, -0.507418394f, + 0.852116823f, -4.30704069f, -3.89199638f, 0.0799167231f, 2.20116568f, -8.00322533f, + 0.443808347f, -5.21188641f, -0.0477513112f, -0.0606098659f, 2.31084251f, 2.83685184f, + 0.112851791f, -4.26348734f, 0.0684685558f, 0.43975693f, 2.8758657f, 1.52292371f, + -3.62064409f, 0.817336679f, -6.63829231f, 1.76102805f, 2.11459064f, -0.895296693f, + 0.997049689f, -1.81692636f, -0.414703548f, 7.35225248f, -5.01954174f, -2.42031121f, + 7.16339731f, 5.83196211f, 2.56851578f, 0.978822291f, 2.69182324f, 2.76491475f, + -0.898054838f, -4.61955214f, -4.02682161f, -4.45842361f, -1.8343271f, -0.445201904f, + 6.09529018f, 1.03628051f, 1.40738893f, -0.911989152f, 0.280343056f, 3.97059035f, + 5.96301746f, 4.77971315f, -3.80170083f, 2.43440032f, -5.84114552f, 7.74407911f, + 8.09362125f, -3.06557393f, -3.43920231f, -2.97823644f, 9.56220818f, 4.69717979f, + -3.28704286f, -3.72267008f, -4.2550745f, -0.979709148f, 2.1988163f, -1.23262262f, + 2.36890507f, 0.963974953f, 0.66211468f, 6.43177176f, -5.84802246f, 3.13942575f, + -4.41907454f, -2.53415465f, -9.79857826f, -8.69124222f, 4.02037573f, -2.38569808f, + 7.57376909f, 3.15761089f, 4.66583633f, 3.71530032f, 0.447664678f, 4.03252125f, + 0.0345930569f, 1.19508684f, 0.797563195f, 7.0261941f, 4.43590832f, 3.5985024f, + 0.728785634f, 6.59305763f, -2.81570315f, -3.80692267f, -4.66345072f, -0.658967853f, + -2.39364028f, -1.22480357f, 0.764415383f, -1.3827759f, -0.59791398f, -2.11538196f, + 3.23551416f, 0.462123811f, -0.416427672f, -2.57915974f, -2.5140605f, 2.21760631f, + 3.14963913f, -1.4278779f, 7.40687847f, -0.897321999f, -0.285782725f, 2.11375475f, + -1.97638083f, 7.23275471f, 1.71333241f, 0.390788555f, +}; + +inline constexpr float kLtxTowerStateF32_8[] = { + -8.89666748f, 1.47443414f, 0.113001645f, 0.999195695f, -0.978735447f, 1.46556187f, + 1.03754544f, -0.1596549f, 3.12240124f, 3.11176109f, -0.159532368f, 0.626370132f, + -9.10763073f, -2.18295288f, 1.65931785f, -1.64609313f, 1.79899406f, 0.0894851163f, + 1.94550753f, -6.26336813f, -8.74751759f, 5.05050468f, 2.27574468f, -5.87296057f, + 4.15928221f, -0.321590841f, -0.582106233f, 4.14281797f, 4.34223223f, -2.66388583f, + -2.21306324f, 2.19005322f, -8.96586227f, 0.402103662f, 5.87622833f, -2.29227877f, + -4.40230989f, 4.80448484f, -0.95537734f, 4.04994154f, 0.657325864f, 1.50221407f, + -1.75279033f, -0.397925198f, -5.09878159f, -0.66034025f, 1.61729503f, -0.580871522f, + 1.74966359f, -1.07339287f, -3.69334888f, -2.76639438f, -1.89973652f, 8.24288082f, + 5.31527233f, -3.0976882f, 5.91194391f, 3.08062172f, 2.95019293f, 2.03634882f, + 4.08052206f, 0.710775495f, -3.99575996f, -0.501146317f, -4.88123608f, -10.139884f, + -0.0594870895f, -1.42214191f, -4.17995977f, 5.16755438f, -0.563805103f, -0.262178481f, + 2.56712294f, -0.826998234f, -1.25387549f, -2.76285601f, -5.04604006f, -4.98763943f, + 2.8367517f, -1.95541501f, 1.88831329f, -2.20704603f, 0.848620415f, -3.92970848f, + -0.603257239f, -0.209418252f, 3.61950445f, -8.93019485f, 6.93354988f, 4.39131784f, + 2.79347301f, 9.01318169f, 2.32380891f, -3.00228477f, 1.16290545f, 3.09832788f, + 1.26439285f, 7.9791708f, 3.96017456f, -2.72606826f, 6.31140471f, 1.42313826f, + 1.13342798f, -6.18063116f, -4.69985533f, -4.92953873f, -1.59554744f, -3.73838019f, + -1.70634425f, 0.528439879f, -0.776169062f, 0.763163507f, 1.65481949f, 1.42519534f, + 1.66258931f, 1.05192113f, -1.12366855f, 1.69234157f, 0.587724686f, -8.93082047f, + 10.9405537f, -0.114068896f, 2.64867663f, 6.02424049f, -0.530430079f, 7.07655048f, + -3.05626941f, 5.64795303f, -4.80421877f, -3.70805383f, -1.81250048f, 4.15021086f, + -1.49169064f, 5.00555468f, -0.403893203f, 5.61924219f, 7.12678862f, -1.81187415f, + 2.43807721f, -6.90765238f, -3.4289031f, 3.16852593f, 4.59258175f, -7.11897993f, + 0.759932458f, -6.15730858f, -1.90000784f, -2.62460184f, 0.755879343f, 1.34102941f, + 0.846354723f, -4.99675226f, 1.45593584f, 1.48284709f, 2.61561465f, 1.0396297f, + -2.30277133f, -1.06425333f, -8.67167759f, 2.16669226f, 2.21694326f, 0.944532514f, + 2.02493334f, -1.27835822f, -0.238702253f, 7.23182631f, -6.77246189f, -1.22375453f, + 7.56545925f, 4.04469156f, 1.91317987f, 2.10669231f, 2.74039221f, 3.29452872f, + -0.522690892f, -4.15895557f, -1.97957361f, -2.63728285f, -3.55455136f, -1.80352139f, + 4.5436945f, -0.46376738f, 2.30623221f, -3.35908461f, 0.208210617f, 5.31032753f, + 6.98699665f, 3.5921979f, -4.88545942f, 1.90018177f, -6.55318928f, 8.98570919f, + 7.33708477f, 0.915291488f, -3.07205319f, -1.64598811f, 9.87949276f, 4.41820288f, + -4.32650757f, -1.41129768f, -3.53711486f, -2.70183134f, 2.51146626f, -0.443964958f, + 1.63425601f, 4.23555517f, 0.392281592f, 6.43338251f, -5.93971062f, 4.80417967f, + -5.41934204f, -1.54837906f, -8.47145557f, -7.86640739f, 5.67212915f, -2.48102927f, + 6.37353754f, 4.18409157f, 4.63562679f, 3.44346213f, -1.87933648f, 2.85634112f, + -0.819639683f, 0.73191607f, 1.70474029f, 10.6217146f, 2.90466285f, 2.99207807f, + 0.805480123f, 6.96130228f, -2.69046545f, -5.44529486f, -4.81665421f, -2.25945163f, + -2.27988458f, -1.03602636f, 2.25907445f, 0.816514194f, -0.719133437f, -3.44558477f, + 4.53946924f, 1.11308527f, -1.32202876f, -0.912063777f, -2.84469008f, 2.49753284f, + 4.6531229f, -2.75543833f, 7.87581444f, -0.647483528f, 1.09567332f, 3.2607851f, + -3.26447868f, 6.67052698f, -0.606357455f, 0.904661238f, +}; + +inline constexpr float kLtxTowerStateF32_9[] = { + -7.98905897f, 1.07012022f, 1.19448471f, -0.168709204f, -4.15389872f, 2.86906886f, + 1.27955115f, 0.408624649f, 4.16084051f, 4.67889118f, -1.44683444f, 0.189235747f, + -9.41539288f, -3.21791267f, 2.46761465f, -0.129669294f, 2.1088903f, 0.446422815f, + 3.13126969f, -4.06435061f, -9.45978832f, 5.5650177f, 0.769539416f, -5.90411139f, + 5.13654423f, -0.319432467f, 0.758417785f, 5.06055832f, 2.68431973f, -2.65829706f, + -0.660979867f, 0.987872839f, -7.67157745f, 0.643084764f, 5.74514961f, -2.95755887f, + -8.08782387f, 6.25476933f, -0.241490036f, 2.76279664f, 0.876176059f, 3.17139482f, + -3.42479062f, -0.197523028f, -5.08722782f, -1.52657723f, 2.29209757f, 0.958932042f, + 1.7287761f, -0.767237246f, -2.63483572f, -1.00536644f, -2.13769293f, 8.2647419f, + 3.94306254f, -2.4666431f, 6.43194056f, 3.21983194f, 4.98314762f, 3.07138348f, + 2.21779776f, 0.811147749f, -3.9456811f, -1.05466747f, -4.30965185f, -6.91315842f, + -2.61527038f, -1.76346993f, -6.04869843f, 3.91941261f, 0.263270587f, -0.867761135f, + 2.17146897f, -0.193176627f, -1.09077287f, -0.739105105f, -5.1051054f, -4.95326757f, + 3.87040901f, -0.318579108f, 1.48049986f, -3.77590656f, 0.289928943f, -2.12141252f, + -1.12817919f, 0.0341742709f, 3.9541986f, -10.6331205f, 6.59723282f, 5.61022186f, + 4.79323339f, 10.2208366f, 3.70197845f, -4.6836195f, 1.25972593f, 2.39875889f, + 1.81174648f, 6.63287878f, 3.20791864f, -2.46075344f, 5.38671589f, 1.24200344f, + 1.26430261f, -5.95467281f, -7.32837582f, -5.07036495f, -2.20266032f, -3.89838481f, + -3.77679491f, 0.430505246f, -0.316910505f, 2.79611397f, 1.6870364f, -1.04928982f, + 2.01692939f, 1.55579543f, -1.0748868f, 4.07556391f, 0.139841422f, -8.12611771f, + 11.0480576f, -2.15695786f, 4.49498463f, 7.01229906f, -0.596126914f, 5.14263773f, + -4.58548689f, 3.85866976f, -1.2992568f, -1.86024892f, -4.02736664f, 3.70135808f, + -1.59720349f, 5.17665625f, 0.374105126f, 5.13426876f, 4.29770517f, -0.832965612f, + 1.63416934f, -4.04449081f, -2.23023939f, 3.02391958f, 4.28402233f, -4.07153416f, + 1.76518631f, -6.86801052f, 0.0719789043f, -0.0605986081f, 1.46703279f, 0.871914625f, + -0.0263378676f, -5.36559868f, 1.03366792f, 2.91751695f, 5.02618837f, 2.20366502f, + -4.19801188f, -0.812761486f, -9.19817066f, 1.97473228f, 4.16007996f, 1.44928777f, + 1.18782628f, -1.77651083f, -3.09952378f, 7.07375526f, -6.13746452f, -1.24793684f, + 7.40372896f, 4.56146097f, 1.59537625f, 3.11497188f, 2.66899753f, 3.29797053f, + -1.9849745f, -1.2279892f, -2.43315125f, -4.59993029f, -3.37539482f, 0.0787637159f, + 4.45215273f, -0.635657072f, 2.10226154f, -4.60948706f, 0.374538481f, 4.99755192f, + 6.44663811f, 4.95611477f, -3.52952051f, -0.268921971f, -3.37786484f, 8.98293018f, + 7.76643276f, 4.20714951f, -1.30278146f, -0.284399331f, 11.244628f, 1.75483286f, + -3.68983793f, -1.66757357f, -2.12750578f, -1.99463117f, 3.72828007f, -1.75569999f, + 0.573991895f, 5.94898033f, 0.333549321f, 7.5821166f, -5.91927004f, 6.01273489f, + -3.93865919f, -0.798281074f, -7.22117567f, -5.99380541f, 5.20279694f, -1.63386381f, + 2.87024474f, 3.17611098f, 4.32253695f, 3.89654255f, -2.76097107f, 2.85952187f, + -0.163388893f, 0.726254225f, 2.96556711f, 11.3621979f, 0.579110503f, 0.397756755f, + 1.94119453f, 6.48859262f, -2.62826371f, -6.02984667f, -4.98078442f, -0.64517504f, + -0.572482824f, 1.36027944f, 1.12749255f, 2.33699155f, 0.932537556f, -3.13388014f, + 5.80395842f, 0.932920039f, -0.164066747f, 0.614224553f, -1.3270694f, 4.58675957f, + 6.75548363f, -3.54308796f, 7.83798075f, -0.881007314f, 2.00171924f, 4.3159852f, + -3.15997362f, 5.10211611f, -0.985054016f, -1.29464889f, +}; + +inline constexpr float kLtxTowerStateF32_10[] = { + -8.52307224f, 1.10527396f, 1.78683031f, 2.90404677f, -4.35291004f, 3.03260446f, + 1.82637274f, 0.639061034f, 6.466434f, 5.93906546f, -0.706212997f, 0.425357282f, + -9.81959152f, -4.4940567f, 3.27147007f, 2.92910361f, 1.10508645f, -1.71333182f, + 6.56148815f, -3.95104432f, -12.8597584f, 4.39411736f, -0.138561472f, -6.2195363f, + 5.64308929f, 0.44396773f, 0.605854452f, 4.83758545f, 3.75780487f, -0.980947554f, + -0.10482654f, 2.67226958f, -8.71569252f, 1.15851164f, 5.68400383f, 1.44172168f, + -9.43976879f, 8.501647f, -0.912305117f, 3.33709955f, 2.06532621f, 4.5697751f, + -2.60921049f, -0.0349133387f, -4.85168982f, -3.20838022f, 4.35604572f, 3.63469505f, + 1.63121748f, -2.66742754f, 0.120117284f, -0.836144984f, -4.92554808f, 7.94208002f, + 2.69201946f, -2.43046546f, 6.41477346f, 3.14026666f, 5.03228664f, 2.67944407f, + 3.18262553f, 2.8026154f, -2.97326493f, 0.0179074183f, -6.36227512f, -4.33496189f, + -3.37246156f, -0.14029783f, -7.45821667f, 4.70964003f, 0.542722523f, -2.41902637f, + 3.07188225f, 0.424771041f, -1.53381228f, 0.637826264f, -5.52321625f, -7.59294891f, + 3.82047653f, 0.214417413f, 3.02935576f, -4.58319855f, 1.32184052f, -1.73229635f, + -1.71995616f, -1.6907016f, 4.19011211f, -10.6887732f, 7.65380621f, 7.77050161f, + 5.52828264f, 10.5099287f, 3.77334881f, -3.00513673f, 2.35665417f, 3.79471612f, + 1.58186901f, 8.6727066f, 1.58094978f, -0.24085328f, 5.89161634f, -0.613869011f, + 2.43912816f, -8.51510525f, -7.56772614f, -3.52561331f, -3.34027982f, -6.26344299f, + -3.90032744f, -0.425635576f, 0.939684749f, 2.25144672f, 1.70222282f, -0.128912568f, + 3.07821131f, 2.9989233f, -3.0375011f, 3.25370264f, -1.03290808f, -10.3850918f, + 11.7690182f, -0.82862401f, 5.28730917f, 7.6972909f, 0.529997349f, 5.14428329f, + -3.61815381f, 4.2850523f, -3.0278542f, -0.249319762f, -4.35183287f, 7.96982241f, + -1.22270012f, 7.503407f, 1.7927984f, 5.55061531f, 4.66779137f, -2.02345872f, + 2.55099034f, -4.80968046f, -1.14073491f, 0.949027181f, 6.27550793f, -3.80439043f, + 3.14254594f, -6.71389627f, 1.56238973f, 1.32242954f, -0.153346613f, -0.404025227f, + -0.579973221f, -6.40607882f, 1.81001103f, 4.4962821f, 5.6432662f, 1.53044081f, + -3.92477417f, 1.24696457f, -8.24374485f, 1.21226239f, 4.62543631f, 3.24167299f, + 2.62980008f, 1.465855f, -4.18123913f, 7.34492159f, -5.83200598f, -1.67532587f, + 10.1371708f, 4.46220589f, 0.921527863f, 2.20669389f, 2.21607471f, 1.28917849f, + -0.493447632f, -0.515477657f, -0.887134016f, -3.36539507f, -2.36737847f, 0.942536712f, + 3.04549217f, -1.96591389f, 2.28403282f, -3.23088098f, -0.239649624f, 4.53751993f, + 8.26951408f, 4.68299532f, -1.62686479f, 3.45304298f, -2.76980472f, 10.7689438f, + 8.71770668f, 4.73885584f, -3.17616987f, -0.250516683f, 13.0098753f, -1.8199569f, + -5.29504585f, -3.25702739f, 0.0543692037f, -2.48085022f, 1.23591506f, -4.4782958f, + 0.0390323773f, 4.57036924f, 1.11613858f, 6.02355433f, -7.26775599f, 5.07422352f, + -2.15222454f, 1.10182202f, -6.71940374f, -4.78729725f, 5.1091218f, -3.3079977f, + 3.26789212f, 2.61278462f, 6.18807364f, 6.07982302f, -1.58792937f, 3.49098635f, + -0.0759347081f, 0.547790825f, 3.56012726f, 13.3253717f, -0.17380102f, 1.2553941f, + 1.36288035f, 4.64590645f, -2.90525961f, -7.59574175f, -4.26921654f, -0.828262568f, + -2.40509176f, 0.555953026f, 2.64763522f, -0.30369541f, 1.95189118f, -4.72842073f, + 4.56664419f, 1.24492812f, 0.443064123f, -0.166653246f, -0.356190771f, 5.52631044f, + 6.70994949f, -4.1490469f, 7.36099386f, -1.52611911f, 2.40721941f, 6.97960281f, + -3.35792637f, 4.96081161f, -1.29951847f, -1.90697289f, +}; + +inline constexpr float kLtxTowerStateF32_11[] = { + -10.4740276f, 0.437290102f, 2.24770164f, 4.01959515f, -5.66471004f, 1.91573715f, + 1.07405579f, 0.951644063f, 4.8576436f, 8.86246395f, -1.30542302f, 1.14762485f, + -9.0353775f, -5.09133434f, 2.99516034f, 1.2989912f, 1.02667689f, -1.35771024f, + 4.10051966f, -5.11249971f, -14.3474884f, 3.33703589f, -0.486126631f, -5.90158272f, + 6.8576932f, 1.98699152f, -0.396765739f, 7.69790554f, 1.59108329f, 0.919567466f, + -2.03158998f, 0.711704075f, -10.3879118f, -1.3196528f, 6.39248037f, 1.05162942f, + -10.3230867f, 7.55200624f, -1.67566395f, 4.46364355f, 0.709992349f, 7.01943302f, + -3.70433187f, -0.134767652f, -5.26701736f, -3.44417238f, 5.37974262f, 2.06776953f, + 1.74762082f, -3.02765989f, -1.97744024f, -0.973250687f, -4.68753624f, 8.60931206f, + 4.14788437f, -2.73269224f, 7.19721889f, 3.2382288f, 5.16952181f, 6.43129301f, + 0.240483493f, 3.99875331f, -5.65129185f, -1.36769021f, -8.46576309f, -7.05421305f, + -5.2063818f, -2.23480105f, -7.97974253f, 3.8100369f, 0.617892385f, -2.8024869f, + 4.63120413f, 0.89815104f, 0.0757322535f, 0.934928715f, -5.70472479f, -7.89497042f, + 3.07881117f, -0.24930805f, 4.58067465f, -3.88367867f, -0.904992819f, -2.96854877f, + -2.23694134f, -1.9647361f, 3.64094591f, -11.6473217f, 6.32698488f, 8.41881561f, + 6.2231698f, 12.1317616f, 3.10856986f, -3.4147377f, 1.28725052f, 4.61093235f, + 0.928768575f, 7.94312906f, 1.36085737f, -0.663224339f, 3.87129474f, -0.917633474f, + 4.46280098f, -9.03922844f, -5.00054598f, -4.43932629f, -2.30886793f, -5.39179707f, + -2.52395844f, -4.33256102f, -1.51983154f, -0.941569924f, -1.41458917f, 1.2230705f, + 4.17483473f, 2.74037981f, -3.21676159f, 4.24135542f, -0.9486866f, -11.6470194f, + 10.8221054f, 1.61834335f, 6.89228582f, 9.15462589f, -0.57447958f, 4.65220928f, + -7.10379028f, 4.31602621f, -3.09226203f, 0.281245381f, -3.41114473f, 6.88357306f, + -2.61687899f, 6.52702665f, 2.33096814f, 3.39968681f, 6.73240709f, -0.850903332f, + 3.27274919f, -4.71687889f, -1.38627684f, 0.426597208f, 4.92534876f, -5.17606068f, + 3.20844412f, -6.20686626f, -1.16918099f, 0.505259216f, -2.08208275f, 1.92891681f, + -0.193895891f, -7.22647762f, 2.31564736f, 3.83772373f, 6.58814001f, 3.2071712f, + -4.15688467f, 2.00606728f, -7.96086311f, 0.787867844f, 4.2715168f, 1.72501743f, + 2.25897074f, 1.6719377f, -5.41219997f, 6.41696548f, -6.90699196f, -1.62064314f, + 11.1021643f, 6.25573921f, 1.86573625f, 2.94127989f, 2.229496f, 2.20132184f, + -2.31459928f, -1.03336906f, 0.172224194f, -5.0651269f, -3.54183531f, 0.646074474f, + 1.61906838f, -1.70173967f, 2.94312501f, -5.66239405f, -1.06667185f, 3.27210617f, + 7.52058983f, 6.50908518f, -2.05644417f, 2.99036384f, -3.71024919f, 10.7238245f, + 10.985796f, 4.65637445f, -5.40730572f, -1.17280912f, 11.516119f, -1.05594933f, + -3.51127648f, -4.67581701f, 4.12159395f, -3.36471677f, 2.99047542f, -4.10896206f, + 0.797381043f, 2.58732605f, -0.257887661f, 3.9427743f, -8.73944092f, 5.58911562f, + -0.280680835f, 1.36038756f, -5.45010233f, -3.45343947f, 6.28265476f, -2.82866621f, + 3.27174306f, 1.77691472f, 7.35992432f, 6.05205345f, -2.94361234f, 2.32204413f, + -1.56125116f, 0.944332778f, 4.99127865f, 11.985652f, -1.27042162f, 2.19188476f, + 0.470014215f, 4.18202257f, 0.246873543f, -6.25241899f, -0.392022818f, -1.50070691f, + -0.393733084f, 2.19860625f, 3.75392556f, -2.30166125f, 1.27025378f, -4.41586542f, + 6.46792841f, 2.15690351f, 3.03431702f, -1.48454475f, -0.629978895f, 5.69442749f, + 7.24988174f, -5.91887188f, 7.508955f, 0.0952121764f, 1.68246675f, 4.91202497f, + -3.23985457f, 3.45387864f, 0.211053327f, -2.52414536f, +}; + +inline constexpr float kLtxTowerStateF32_12[] = { + -1.95430505f, -0.110438295f, 0.516875148f, 0.972905457f, -1.3906244f, 0.394593f, + -0.0994492546f, 0.210273683f, 1.26857543f, 1.85849893f, -0.16672194f, 0.583491623f, + -1.42908251f, -0.713450074f, 0.68597424f, -0.208518654f, 0.44005242f, -0.342173755f, + 0.835361302f, -0.726223171f, -2.705369f, 0.480481118f, -0.140720487f, -1.39041114f, + 0.983665049f, 0.116292492f, 0.307106793f, 1.38160169f, 0.49981299f, 0.812870264f, + -0.164643705f, 0.179613307f, -1.74933803f, -0.288582295f, 1.39409745f, 0.19742471f, + -2.19802642f, 1.58833337f, -0.839731336f, 1.12293243f, 0.373419195f, 1.54722869f, + -0.512908638f, -0.0065075676f, -0.820044339f, -0.219146341f, 1.05945873f, 0.243723318f, + 0.370777041f, -0.740059137f, 0.118271619f, -0.215995297f, -0.964961648f, 1.39070201f, + 0.565507889f, -1.03243446f, 1.58020175f, 0.338692248f, 1.14460039f, 1.07852757f, + 0.0277301334f, 1.27410603f, -0.899438262f, -0.149870694f, -1.32035398f, -1.14738464f, + -1.02281523f, -0.296709746f, -2.02580476f, 0.772643745f, 0.0338883102f, -0.297688097f, + 1.01897085f, 0.236964002f, 0.015476427f, -0.133203611f, -0.711076558f, -1.28035259f, + 0.706716478f, -0.109417386f, 0.878617644f, -0.385746062f, 0.25156644f, -0.3203637f, + -0.774000227f, -0.744667888f, 0.801415622f, -2.18040729f, 1.28684771f, 1.29494286f, + 1.43230629f, 2.05493689f, 0.635742486f, -0.0990568101f, 0.21701239f, 0.960909307f, + 0.215385467f, 1.219154f, 0.252415985f, -0.160854355f, 0.422010452f, -0.120809287f, + 0.627729952f, -1.5410291f, -0.945060968f, -0.863019228f, -0.278156102f, -1.1197145f, + -0.456743717f, -0.91505152f, -0.811584771f, -0.0191241484f, -0.275212944f, 0.0747536421f, + 1.11831701f, 0.85599041f, -0.574614167f, 0.679712832f, -0.143595636f, -2.49205351f, + 1.80915689f, 0.174201995f, 1.61180258f, 1.24724543f, -0.0947520211f, 1.28033197f, + -1.48456848f, 1.26913488f, -0.727236688f, 0.0140682161f, -0.145905674f, 1.20949423f, + -0.996572554f, 1.69373608f, 0.574404061f, 1.26810896f, 1.28485024f, 0.404163182f, + 0.182477593f, -1.32829762f, -0.521237314f, -0.00461404491f, 1.00245059f, -1.42755568f, + 0.562996984f, -1.52737617f, 0.229845285f, 0.203554168f, -0.339108884f, -0.227017149f, + 0.153269008f, -2.25530171f, 0.456833124f, 0.705507159f, 2.01019311f, 0.707207143f, + -0.66482538f, 1.11161327f, -1.6004715f, 0.436216384f, 0.802683175f, 0.297375619f, + 0.492484719f, 0.364805698f, -1.40622294f, 1.05801189f, -1.77676189f, -0.132053167f, + 2.59603477f, 1.21610367f, 0.370344877f, 0.754165769f, 0.0457150191f, 0.819229186f, + -0.410216033f, -0.282863647f, -0.223227724f, -1.190925f, -0.383738011f, 0.251355797f, + 0.462008387f, -0.624758661f, 0.527448654f, -1.24961674f, -0.442322165f, 0.573105156f, + 1.83266568f, 0.963394403f, -0.0940001756f, 0.681350529f, -0.587373018f, 2.28392148f, + 2.1126852f, 1.40172851f, -1.41646636f, 0.42352137f, 2.0795505f, -0.228382856f, + -0.0499425344f, -1.0200721f, 0.911744714f, -0.461284935f, 0.0633383542f, -0.812260687f, + 0.126657814f, 0.154919684f, 0.0795625746f, 0.552505672f, -2.03954887f, 0.854217052f, + -0.395199895f, 0.860563338f, -1.23792481f, -1.15010142f, 1.24822891f, -0.147703111f, + 0.596217334f, 0.66546309f, 1.45141864f, 1.32918441f, -0.891044855f, 0.760291934f, + -0.332593352f, 0.352823675f, 1.00904238f, 2.37247777f, 0.133320257f, 0.847827375f, + -0.499672174f, 1.47128308f, 0.169222474f, -1.33053029f, 0.332021505f, -0.581721902f, + -0.150868416f, 1.04442215f, 0.898613095f, -0.626254439f, -0.0338237397f, -1.03031552f, + 1.32300103f, -0.0949449167f, 1.14165175f, -0.222016126f, 0.112375326f, 1.24457645f, + 1.9614681f, -1.30386126f, 1.66887248f, -0.0367611311f, 0.548551917f, 0.8907938f, + -0.40549621f, 1.14253092f, -0.254538596f, -0.0270994119f, +}; + +// --- section 3: hidden states, oracle in BFLOAT16 (the SHIPPED dtype) --- +inline constexpr float kLtxTowerStateBf16_0[] = { + 0.234375f, 0.0556640625f, -0.0444335938f, -0.243164062f, 0.186523438f, -0.125976562f, + -0.0149536133f, -0.0810546875f, -0.0322265625f, -0.17578125f, 0.0383300781f, 0.0703125f, + -0.046875f, 0.0737304688f, 0.177734375f, -0.103515625f, 0.103515625f, 0.279296875f, + 0.104492188f, 0.0344238281f, -0.139648438f, -0.05859375f, 0.102050781f, -0.0397949219f, + 0.0805664062f, -0.0510253906f, -0.240234375f, -0.0107421875f, 0.208984375f, 0.0456542969f, + -0.28125f, 0.130859375f, -0.236328125f, 0.15234375f, -0.0568847656f, -0.0402832031f, + 0.0354003906f, -0.12890625f, 0.106933594f, 0.142578125f, -0.116699219f, -0.0854492188f, + 0.099609375f, 0.125976562f, 0.1796875f, 0.190429688f, 0.244140625f, -0.072265625f, + -0.19921875f, 0.0903320312f, 0.209960938f, -0.275390625f, 0.244140625f, 0.103027344f, + 0.209960938f, -0.227539062f, 0.20703125f, -0.170898438f, -0.232421875f, 0.109863281f, + 0.0219726562f, 0.099609375f, -0.206054688f, 0.00799560547f, -0.172851562f, -0.142578125f, + 0.24609375f, -0.137695312f, 0.0673828125f, 0.26171875f, 0.26171875f, 0.193359375f, + 0.00842285156f, -0.0732421875f, 0.203125f, -0.0698242188f, -0.106445312f, -0.19921875f, + -0.23046875f, 0.0830078125f, -0.106445312f, 0.26171875f, 0.275390625f, 0.083984375f, + 0.0834960938f, 0.06640625f, 0.0864257812f, -0.143554688f, 0.05859375f, 0.212890625f, + 0.267578125f, 0.206054688f, 0.0290527344f, 0.229492188f, -0.064453125f, -0.0708007812f, + 0.176757812f, 0.189453125f, -0.271484375f, 0.180664062f, -0.087890625f, 0.0262451172f, + 0.234375f, -0.072265625f, -0.251953125f, 0.056640625f, -0.259765625f, -0.1328125f, + 0.124511719f, 0.0234375f, 0.206054688f, 0.0727539062f, 0.208984375f, 0.0212402344f, + 0.0622558594f, 0.2265625f, -0.0986328125f, 0.237304688f, -0.012512207f, -0.20703125f, + -0.0573730469f, -0.124511719f, 0.237304688f, 0.244140625f, -0.0751953125f, -0.169921875f, + -0.126953125f, -0.1640625f, -0.0439453125f, 0.23046875f, 0.00302124023f, -0.25390625f, + 0.106933594f, 0.0522460938f, -0.120117188f, -0.14453125f, 0.155273438f, 0.00340270996f, + 0.220703125f, -0.223632812f, -0.18359375f, 0.197265625f, -0.194335938f, 0.244140625f, + -0.263671875f, -0.153320312f, 0.25390625f, -0.0270996094f, 0.241210938f, -0.166992188f, + 0.0732421875f, -0.223632812f, 0.0986328125f, 0.216796875f, 0.162109375f, -0.0385742188f, + -0.180664062f, -0.137695312f, -0.10546875f, -0.0727539062f, -0.251953125f, 0.243164062f, + -0.239257812f, -0.0510253906f, -0.09375f, 0.130859375f, -0.216796875f, -0.25f, + 0.0815429688f, 0.0805664062f, 0.172851562f, 0.0703125f, 0.122070312f, 0.100097656f, + -0.224609375f, 0.189453125f, 0.217773438f, -0.151367188f, -0.0568847656f, 0.0961914062f, + -0.151367188f, -0.0280761719f, -0.0844726562f, -0.259765625f, 0.140625f, -0.0600585938f, + 0.237304688f, -0.108398438f, -0.0593261719f, -0.0361328125f, 0.0573730469f, -0.201171875f, + -0.0251464844f, -0.0668945312f, -0.076171875f, 0.0192871094f, -0.1484375f, -0.166015625f, + -0.0123291016f, 0.180664062f, 0.194335938f, -0.170898438f, -0.0815429688f, -0.137695312f, + 0.0932617188f, 0.18359375f, 0.150390625f, 0.0456542969f, -0.0153808594f, -0.0869140625f, + -0.213867188f, -0.177734375f, -0.0708007812f, 0.1328125f, -0.204101562f, -0.159179688f, + -0.0150756836f, 0.237304688f, 0.0854492188f, -0.06640625f, 0.203125f, -0.247070312f, + 0.166992188f, -0.279296875f, -0.26953125f, -0.229492188f, 0.237304688f, 0.00230407715f, + 0.0363769531f, -0.190429688f, 0.176757812f, 0.076171875f, 0.259765625f, 0.16796875f, + 0.243164062f, -0.203125f, 0.220703125f, -0.116210938f, -0.0981445312f, -0.233398438f, + -0.265625f, 0.22265625f, -0.243164062f, 0.0737304688f, 0.00592041016f, -0.0291748047f, + -0.083984375f, -0.169921875f, -0.0397949219f, -0.182617188f, 0.1640625f, 0.0549316406f, + -0.111328125f, 0.265625f, -0.0756835938f, -0.196289062f, +}; + +inline constexpr float kLtxTowerStateBf16_1[] = { + -2.0f, -0.166015625f, -0.765625f, 1.03125f, 2.21875f, -0.23046875f, + 0.65234375f, 2.765625f, 0.671875f, -0.60546875f, -1.2578125f, 0.984375f, + 0.28515625f, -0.2734375f, 1.59375f, 0.0529785156f, 0.66796875f, -0.306640625f, + 2.328125f, 0.0302734375f, -1.7578125f, 0.423828125f, 2.796875f, -1.2578125f, + -1.5f, -1.046875f, 0.0991210938f, -2.375f, -0.2734375f, -1.0625f, + 1.3203125f, -0.279296875f, -0.3125f, -1.25f, 1.5390625f, 1.1640625f, + -0.275390625f, -0.173828125f, 1.484375f, 2.421875f, 0.625f, -1.5703125f, + -0.8046875f, 1.46875f, 1.6796875f, -0.302734375f, 0.51171875f, -1.625f, + -1.171875f, -0.153320312f, 1.0859375f, -3.265625f, -1.21875f, 0.9921875f, + 1.1484375f, -1.0703125f, -3.21875f, -1.453125f, -0.4453125f, -0.72265625f, + 1.046875f, 0.435546875f, -0.4921875f, 0.198242188f, -0.0264892578f, -2.828125f, + 1.2890625f, 0.77734375f, -0.060546875f, 0.7890625f, -0.93359375f, 1.3359375f, + 0.640625f, -0.48828125f, -0.44921875f, 0.2265625f, 0.25390625f, -0.96875f, + 0.6796875f, -1.1171875f, 0.6640625f, -3.15625f, 1.328125f, -0.447265625f, + 1.921875f, 0.0264892578f, 3.453125f, -0.291015625f, -2.71875f, -1.5078125f, + 1.5859375f, -0.16015625f, -0.15234375f, -0.447265625f, 2.5f, 0.63671875f, + 1.453125f, -1.015625f, 1.75f, 0.625f, -0.66015625f, 0.109863281f, + -0.9296875f, -2.734375f, -1.2265625f, 3.0f, -1.125f, 0.185546875f, + -0.330078125f, 2.53125f, 0.105957031f, 0.29296875f, -0.73828125f, -0.159179688f, + 1.96875f, -1.2109375f, -0.105957031f, 0.435546875f, -1.953125f, 1.1484375f, + 0.578125f, -1.015625f, -0.7265625f, 0.106933594f, 0.6484375f, 2.234375f, + 1.6640625f, 1.8515625f, -1.625f, -1.1875f, -0.3203125f, -0.219726562f, + -0.0189208984f, 0.115234375f, 0.6328125f, 2.328125f, 1.8359375f, -0.7578125f, + -0.107910156f, 0.8671875f, 1.9140625f, -1.4765625f, -0.12890625f, -2.0625f, + -0.92578125f, -0.77734375f, -1.1953125f, -3.09375f, -1.5078125f, -0.3671875f, + -0.90625f, -0.302734375f, -1.359375f, 1.34375f, -0.57421875f, -1.2421875f, + 0.48046875f, -1.5859375f, -0.298828125f, 0.6171875f, 0.65625f, 0.404296875f, + 0.6875f, 2.34375f, -0.81640625f, 1.28125f, -1.09375f, -0.104003906f, + 2.078125f, 3.328125f, -1.984375f, 1.28125f, 1.453125f, -0.33984375f, + -0.625f, 0.455078125f, -2.015625f, 0.0908203125f, 1.5859375f, -1.515625f, + -0.6953125f, 0.115234375f, -2.515625f, -0.26953125f, 1.671875f, -0.462890625f, + 0.235351562f, -1.609375f, 0.61328125f, 2.265625f, 0.141601562f, 1.7734375f, + 1.1484375f, -1.4375f, -1.4453125f, -0.181640625f, 2.96875f, -0.62109375f, + -1.9296875f, 0.166015625f, -1.390625f, -2.421875f, 1.6796875f, -1.0859375f, + 1.09375f, 2.03125f, -0.0908203125f, -1.3203125f, -1.1875f, -0.197265625f, + 0.96484375f, 0.85546875f, 0.143554688f, -1.1171875f, 0.326171875f, -0.9609375f, + 0.52734375f, 2.8125f, -0.4921875f, 0.259765625f, 0.94140625f, 0.279296875f, + -1.1328125f, 0.33203125f, 1.609375f, 3.265625f, -0.51953125f, 1.96875f, + 1.1328125f, -0.408203125f, -1.03125f, -1.9375f, -1.7890625f, 1.0f, + 0.796875f, -1.875f, 0.204101562f, -0.0227050781f, -0.0207519531f, -0.64453125f, + -0.65625f, 2.90625f, 0.73828125f, -0.5234375f, -1.09375f, -0.341796875f, + -1.8359375f, -0.458984375f, 0.234375f, 1.609375f, 0.8125f, 0.83203125f, + 0.9609375f, 2.140625f, 0.609375f, -0.375f, +}; + +inline constexpr float kLtxTowerStateBf16_2[] = { + -3.375f, 1.390625f, -1.09375f, 0.408203125f, 2.109375f, 0.015625f, + -0.57421875f, 1.0078125f, 1.6640625f, -0.609375f, -2.921875f, 1.7890625f, + -2.203125f, -1.9765625f, 4.125f, 1.28125f, -1.078125f, 2.046875f, + 2.65625f, -1.03125f, -2.71875f, 0.34765625f, 2.765625f, -1.6171875f, + -0.4296875f, -1.546875f, -2.140625f, 0.6328125f, 1.3046875f, -2.203125f, + 1.53125f, 0.54296875f, -3.046875f, -1.359375f, 2.09375f, 1.7734375f, + -1.34375f, -1.1796875f, 1.34375f, 4.4375f, 2.84375f, 0.267578125f, + -1.9609375f, 0.9765625f, -0.828125f, 0.47265625f, 1.390625f, -2.046875f, + -2.0625f, -0.16015625f, 1.6015625f, -4.96875f, 0.20703125f, 0.69140625f, + 2.40625f, -1.8515625f, -2.21875f, -1.8046875f, 0.5078125f, 2.1875f, + 3.015625f, -0.163085938f, -0.7734375f, -1.109375f, -0.76953125f, -5.03125f, + 1.1640625f, 1.6953125f, 0.21484375f, 0.30078125f, -3.609375f, 1.7109375f, + 1.3046875f, -2.140625f, -2.078125f, -1.0f, -2.53125f, -3.796875f, + 0.75f, -1.046875f, -1.390625f, -2.953125f, 2.78125f, -2.78125f, + 1.671875f, 0.859375f, 4.6875f, -1.453125f, -1.28125f, -0.8203125f, + 1.1484375f, 3.4375f, -0.180664062f, -2.4375f, 2.4375f, 0.97265625f, + 0.30078125f, -0.193359375f, 3.28125f, -1.4765625f, 1.9140625f, -2.171875f, + 0.447265625f, -4.53125f, -0.83203125f, 0.5234375f, -1.5234375f, -2.265625f, + -0.9375f, 2.59375f, -0.59375f, 2.265625f, -1.0703125f, 1.203125f, + -1.015625f, -2.9375f, 0.0947265625f, 0.70703125f, -2.265625f, 0.486328125f, + -0.219726562f, 0.421875f, -1.171875f, 0.0322265625f, 3.125f, 4.4375f, + 0.2578125f, 1.578125f, -1.0859375f, -3.265625f, -0.734375f, 0.53515625f, + -0.228515625f, 0.5078125f, -0.2421875f, 4.0f, 3.40625f, 2.78125f, + 0.421875f, 1.4453125f, 0.0258789062f, -1.7890625f, 1.328125f, -4.875f, + -0.89453125f, -1.828125f, -0.150390625f, -3.578125f, 0.0688476562f, 0.236328125f, + -0.640625f, -2.234375f, -2.1875f, 1.796875f, 1.2734375f, 1.2421875f, + 0.0603027344f, -2.171875f, -2.3125f, -0.35546875f, 2.75f, -1.4140625f, + 2.15625f, 0.56640625f, 0.75f, 2.78125f, -1.6953125f, -2.3125f, + 2.640625f, 2.765625f, -0.275390625f, 0.6796875f, 0.32421875f, 0.241210938f, + 0.283203125f, -0.70703125f, -2.515625f, -0.984375f, 1.4609375f, -1.9140625f, + 2.0625f, -1.2421875f, -2.171875f, -1.859375f, 0.55859375f, 2.375f, + 1.828125f, -1.25f, -1.6796875f, 3.171875f, 0.133789062f, 3.609375f, + 3.171875f, -0.47265625f, -3.0625f, -1.296875f, 2.375f, -1.1015625f, + -2.875f, -1.09375f, -0.3359375f, -2.328125f, -0.259765625f, -0.74609375f, + -0.7890625f, 0.9296875f, 1.2734375f, 0.193359375f, -3.6875f, 2.25f, + -0.202148438f, -1.1015625f, -2.515625f, -2.21875f, 1.7890625f, -0.155273438f, + 2.546875f, 4.09375f, -0.0495605469f, 2.546875f, 2.515625f, 0.353515625f, + -0.0258789062f, 0.241210938f, 2.921875f, 3.625f, 0.83203125f, 1.3515625f, + 0.46484375f, -1.578125f, -1.46875f, -4.125f, -5.5f, 0.404296875f, + -0.37890625f, -0.47265625f, 0.78125f, 0.765625f, 0.0893554688f, 0.5625f, + -0.796875f, 4.75f, 0.139648438f, -3.1875f, -2.6875f, -2.03125f, + 2.515625f, 0.435546875f, 2.171875f, -0.9296875f, -0.96484375f, 0.546875f, + 1.125f, 2.15625f, 0.53515625f, 0.62109375f, +}; + +inline constexpr float kLtxTowerStateBf16_3[] = { + -4.6875f, 1.421875f, -1.265625f, 1.5390625f, 2.53125f, 2.65625f, + 1.453125f, 0.55859375f, -0.5078125f, 0.231445312f, -4.25f, 1.9453125f, + -4.8125f, -4.0625f, 3.9375f, 0.90234375f, 1.46875f, 4.5f, + 3.953125f, -1.9140625f, -3.03125f, 3.359375f, 4.40625f, -3.796875f, + 1.5078125f, -0.546875f, -4.25f, 0.89453125f, 2.8125f, -2.546875f, + -0.494140625f, 0.74609375f, -2.984375f, -1.8515625f, 3.046875f, 2.390625f, + 0.359375f, 0.79296875f, 2.90625f, 2.40625f, 1.0625f, -1.09375f, + -3.4375f, 1.5390625f, -2.25f, -0.90625f, 0.65625f, -1.5703125f, + 1.1875f, 1.984375f, 1.3359375f, -4.625f, 0.4296875f, 3.859375f, + 4.96875f, -3.171875f, -1.4765625f, -0.87890625f, -0.0981445312f, 1.78125f, + 3.921875f, 0.478515625f, -2.359375f, -1.2421875f, -1.28125f, -7.0f, + 2.6875f, 1.53125f, 1.9140625f, 3.140625f, -2.671875f, -0.515625f, + 0.147460938f, -2.25f, -2.21875f, 0.08203125f, -3.609375f, -6.28125f, + -0.27734375f, -2.34375f, 1.2578125f, -0.8515625f, 2.203125f, -4.4375f, + 2.578125f, 1.921875f, 7.3125f, -3.6875f, 0.86328125f, -0.26171875f, + 0.62109375f, 3.75f, 1.90625f, 0.00817871094f, 1.5625f, 1.6171875f, + 1.2421875f, 1.140625f, 6.1875f, -2.296875f, 2.1875f, -0.5546875f, + 0.78515625f, -5.09375f, -3.171875f, 0.130859375f, -3.5625f, -2.671875f, + -2.65625f, 2.453125f, -1.3203125f, 0.421875f, -0.200195312f, 1.9140625f, + 0.34765625f, -3.390625f, 1.328125f, 1.5234375f, 1.3359375f, -1.9609375f, + -0.470703125f, -0.122558594f, -0.127929688f, 0.515625f, 1.1484375f, 4.4375f, + 0.80859375f, 0.65625f, 0.083984375f, -3.1875f, -0.8515625f, 3.828125f, + -2.84375f, 0.890625f, 1.375f, 6.25f, 2.1875f, 0.5546875f, + 2.09375f, 0.200195312f, 0.53125f, -0.408203125f, 0.8359375f, -5.0625f, + -2.921875f, -1.640625f, 0.0571289062f, -2.984375f, 2.578125f, -1.75f, + 1.0625f, -0.498046875f, -3.984375f, 2.015625f, 1.8203125f, 0.3359375f, + -1.328125f, -2.25f, -0.76953125f, -0.28515625f, 5.4375f, -2.328125f, + -0.212890625f, 0.6796875f, -2.171875f, 2.125f, -1.5234375f, 0.130859375f, + 3.40625f, 3.625f, -0.108398438f, 0.83203125f, 1.6171875f, 2.15625f, + -0.85546875f, -2.65625f, -3.0625f, -1.109375f, 0.796875f, -0.106445312f, + 4.125f, -1.390625f, 0.161132812f, -0.322265625f, -1.8984375f, 3.5625f, + 2.8125f, -0.0737304688f, -1.2890625f, 3.296875f, -1.2890625f, 6.125f, + 4.625f, -2.0625f, -3.578125f, -1.9140625f, 5.96875f, -1.125f, + -2.09375f, -4.5625f, 0.90625f, -3.078125f, 1.203125f, -2.5f, + 1.796875f, 0.98828125f, 1.6171875f, -1.2890625f, -4.28125f, 3.296875f, + -1.75f, -1.9921875f, -4.09375f, -3.953125f, 4.625f, -0.384765625f, + 1.2734375f, 3.828125f, 0.703125f, 2.1875f, 2.03125f, 0.75390625f, + 0.0795898438f, -2.109375f, 2.234375f, 4.21875f, 4.125f, 0.76953125f, + -0.34375f, 0.0776367188f, -2.375f, -4.21875f, -7.28125f, -0.287109375f, + -0.93359375f, -3.0f, 0.0737304688f, 0.63671875f, -1.1875f, -1.640625f, + -1.4375f, 6.28125f, 0.79296875f, -2.328125f, -1.6796875f, -1.546875f, + 4.46875f, 0.0561523438f, 1.296875f, -1.46875f, -0.0693359375f, 0.96484375f, + 0.62109375f, 4.875f, 0.314453125f, 1.203125f, +}; + +inline constexpr float kLtxTowerStateBf16_4[] = { + -7.125f, 1.1171875f, 0.231445312f, 3.9375f, 2.015625f, 4.75f, + 1.7109375f, 0.46484375f, 0.171875f, 2.25f, -4.84375f, 2.96875f, + -5.78125f, -6.21875f, 1.3125f, 2.09375f, 4.09375f, 3.125f, + 3.140625f, -0.6640625f, -3.59375f, 5.15625f, 3.21875f, -4.90625f, + 0.5625f, -2.109375f, -1.6796875f, 2.765625f, 5.84375f, -0.9609375f, + -0.765625f, 0.91796875f, -5.53125f, -0.88671875f, 5.78125f, 2.90625f, + -0.74609375f, 3.953125f, 2.609375f, 2.828125f, 1.875f, 0.58984375f, + -4.90625f, 1.4765625f, -4.03125f, -1.8984375f, -0.186523438f, 0.361328125f, + 1.7421875f, 0.28125f, -0.0893554688f, -2.8125f, 2.53125f, 7.84375f, + 6.21875f, -3.84375f, -0.318359375f, -2.640625f, 1.59375f, 4.1875f, + 4.90625f, 1.4921875f, -2.546875f, -1.578125f, -2.78125f, -8.0625f, + 4.09375f, 2.625f, 0.124511719f, 5.65625f, -3.640625f, -0.0942382812f, + 2.609375f, -1.71875f, -4.1875f, 1.03125f, -3.59375f, -7.4375f, + -0.734375f, -1.5859375f, 0.515625f, -1.875f, 1.28125f, -2.421875f, + 2.671875f, 4.03125f, 7.09375f, -5.28125f, 0.28125f, -0.291015625f, + 0.373046875f, 5.0625f, 3.40625f, -0.375f, 2.953125f, 2.078125f, + -0.6171875f, 3.09375f, 7.5f, -0.65625f, 3.6875f, -0.33984375f, + 1.59375f, -3.46875f, -3.8125f, -0.8984375f, -5.21875f, -2.625f, + -3.125f, 3.59375f, -3.15625f, 0.74609375f, 0.169921875f, 1.53125f, + 0.94140625f, -2.234375f, 1.9453125f, 3.75f, 0.0124511719f, -4.4375f, + 0.31640625f, -1.3515625f, 0.0466308594f, 2.4375f, 1.53125f, 3.625f, + 1.46875f, 0.60546875f, -2.28125f, -2.953125f, -0.0217285156f, 2.828125f, + -2.78125f, 4.15625f, 0.55078125f, 6.96875f, 3.359375f, 0.361328125f, + 0.90625f, -0.0249023438f, -1.640625f, 0.265625f, 2.375f, -4.75f, + -1.7109375f, -3.59375f, -1.5f, -2.03125f, 3.125f, 2.0f, + 1.6875f, -0.0810546875f, -3.3125f, 0.0456542969f, 1.90625f, -0.19921875f, + -1.625f, -1.4609375f, -1.4453125f, -0.0124511719f, 3.734375f, -2.125f, + -1.40625f, -1.8984375f, -0.9453125f, 4.84375f, -2.453125f, 0.06640625f, + 4.21875f, 3.515625f, -0.84375f, 2.5625f, 2.59375f, 2.046875f, + 0.9609375f, -1.109375f, -2.25f, -4.59375f, -0.135742188f, -2.296875f, + 4.46875f, 2.5625f, -0.71484375f, -0.5390625f, -0.87890625f, 1.484375f, + 3.671875f, 2.546875f, -1.1640625f, 3.890625f, -4.0625f, 6.34375f, + 4.46875f, -2.421875f, -4.5f, -1.3828125f, 8.625f, 0.88671875f, + -2.671875f, -4.125f, -1.0859375f, -2.609375f, 0.640625f, -3.6875f, + 4.28125f, -0.62109375f, -0.00415039062f, 1.4375f, -1.78125f, 4.21875f, + -3.890625f, -1.9765625f, -7.53125f, -3.765625f, 3.171875f, -0.7109375f, + 3.109375f, 2.171875f, 1.2734375f, 4.25f, 3.234375f, 0.96875f, + 0.828125f, -2.859375f, 1.3125f, 6.71875f, 6.03125f, 3.09375f, + 0.64453125f, 1.1484375f, -1.9609375f, -3.703125f, -8.4375f, -0.765625f, + -2.46875f, -0.99609375f, -0.13671875f, 0.84765625f, -1.1640625f, -2.453125f, + 0.73046875f, 5.28125f, 1.5625f, -2.203125f, -2.65625f, 1.0625f, + 3.984375f, -2.109375f, 1.875f, -3.15625f, -0.3046875f, 1.9453125f, + 0.71484375f, 5.375f, 0.92578125f, 0.490234375f, +}; + +inline constexpr float kLtxTowerStateBf16_5[] = { + -6.625f, 0.27734375f, 2.6875f, 1.796875f, -0.6328125f, 5.0f, + 2.9375f, -3.078125f, -0.72265625f, 1.0390625f, -3.65625f, 1.3203125f, + -7.3125f, -4.90625f, 0.37890625f, 1.1875f, 4.75f, 3.359375f, + 3.0625f, -2.953125f, -5.15625f, 6.625f, 2.5625f, -5.75f, + -0.202148438f, -1.8671875f, 0.219726562f, 3.09375f, 6.71875f, -1.25f, + -1.203125f, 2.890625f, -4.375f, -1.1640625f, 7.75f, 1.3984375f, + -2.109375f, 5.40625f, 1.609375f, 0.91015625f, 0.416015625f, 1.4296875f, + -3.890625f, 0.671875f, -2.765625f, -2.5625f, -1.0078125f, 1.1171875f, + 4.4375f, 0.163085938f, -1.953125f, -3.0f, 1.5625f, 9.0f, + 5.40625f, -5.375f, -0.248046875f, -2.0625f, 5.28125f, 3.4375f, + 6.8125f, 0.27734375f, -2.90625f, -0.30078125f, -1.2421875f, -9.3125f, + 3.359375f, 1.1640625f, -2.125f, 6.25f, -1.4140625f, -2.34375f, + 2.53125f, -2.015625f, -2.5625f, -0.178710938f, -4.9375f, -8.375f, + -0.49609375f, -1.7109375f, 2.296875f, -1.25f, 0.98046875f, -3.9375f, + 0.46484375f, 4.03125f, 6.78125f, -6.75f, 2.53125f, 0.57421875f, + 3.53125f, 6.09375f, 3.71875f, -0.6875f, 1.8515625f, 3.484375f, + 0.478515625f, 1.9609375f, 6.84375f, -0.52734375f, 4.75f, -0.30078125f, + 0.78515625f, -4.125f, -5.15625f, -3.484375f, -3.453125f, -4.0f, + -3.5625f, 2.8125f, -1.8671875f, 1.9375f, 2.671875f, 1.7265625f, + 0.322265625f, -2.703125f, 0.190429688f, 4.8125f, -0.8515625f, -7.21875f, + 2.921875f, 0.5703125f, 0.59375f, 4.03125f, 1.8828125f, 4.34375f, + -0.66796875f, 3.9375f, -2.703125f, -4.375f, 0.26953125f, 4.625f, + -2.359375f, 5.84375f, 0.267578125f, 3.328125f, 4.09375f, -0.68359375f, + 1.9765625f, -1.6796875f, -3.015625f, -0.216796875f, 1.2421875f, -5.75f, + 1.796875f, -5.15625f, -3.09375f, -1.4375f, 3.640625f, 3.78125f, + 1.09375f, -2.953125f, -2.828125f, -0.9765625f, 6.0f, -1.1015625f, + -2.421875f, -0.8984375f, -1.90625f, 2.140625f, 3.375f, -1.953125f, + 1.25f, 0.126953125f, -1.984375f, 6.6875f, -2.0f, -0.68359375f, + 5.0625f, 6.8125f, 1.984375f, 3.46875f, 2.734375f, 0.98046875f, + -1.9296875f, -0.87890625f, -1.2421875f, -4.78125f, -1.5078125f, -1.484375f, + 4.28125f, 2.703125f, -0.609375f, -1.3671875f, -0.515625f, 3.53125f, + 6.625f, 2.921875f, -0.80859375f, 2.15625f, -2.796875f, 7.84375f, + 5.78125f, -4.875f, -3.515625f, -0.126953125f, 9.875f, 2.75f, + -4.125f, -2.671875f, -2.0625f, -1.71875f, 2.0625f, -2.9375f, + 1.96875f, -0.111328125f, 0.26953125f, 1.4375f, -1.4765625f, 4.875f, + -5.71875f, -2.796875f, -7.53125f, -3.5f, 4.3125f, -3.0625f, + 4.5f, 5.0f, 2.9375f, 5.0625f, 0.90625f, 2.578125f, + 1.15625f, -1.859375f, 0.5390625f, 6.25f, 5.25f, 4.71875f, + -1.0390625f, 1.9921875f, -2.203125f, -2.71875f, -7.4375f, 0.73046875f, + -1.1640625f, -0.0197753906f, -1.890625f, 0.2890625f, -2.578125f, -2.125f, + 2.1875f, 2.171875f, 1.875f, -2.34375f, -2.5f, 0.0395507812f, + 4.46875f, -1.578125f, 4.0f, -2.84375f, -0.75390625f, -0.0158691406f, + 0.0791015625f, 7.125f, 1.96875f, 0.134765625f, +}; + +inline constexpr float kLtxTowerStateBf16_6[] = { + -7.59375f, -0.9296875f, 2.296875f, 3.234375f, -0.5078125f, 6.375f, + 4.4375f, -5.8125f, 2.109375f, 2.1875f, -2.84375f, 1.359375f, + -9.1875f, -3.796875f, 1.6171875f, -2.203125f, 4.0625f, 2.109375f, + 2.109375f, -4.6875f, -6.3125f, 6.3125f, 3.15625f, -5.75f, + 1.3828125f, -1.078125f, -0.98046875f, 4.5625f, 7.4375f, -0.93359375f, + -0.6640625f, 1.828125f, -4.84375f, -2.578125f, 9.4375f, 1.890625f, + -3.21875f, 8.25f, 0.984375f, 1.265625f, 1.3828125f, 1.390625f, + -3.703125f, 1.4140625f, -3.03125f, -0.298828125f, 0.48046875f, -0.53125f, + 4.875f, -0.30859375f, -2.328125f, -3.421875f, 0.53515625f, 7.9375f, + 6.1875f, -3.9375f, 3.4375f, 1.7578125f, 5.375f, 3.34375f, + 6.875f, 2.109375f, -3.71875f, -1.9609375f, -2.078125f, -12.5625f, + 3.640625f, 1.6171875f, -2.984375f, 8.875f, 0.4765625f, -3.953125f, + 3.375f, -1.9765625f, -2.328125f, 0.28515625f, -4.65625f, -5.28125f, + 0.8359375f, -2.609375f, 2.015625f, -0.78125f, 0.376953125f, -3.78125f, + 0.5390625f, 2.859375f, 6.3125f, -8.5f, 4.40625f, 2.109375f, + 3.84375f, 6.625f, 3.28125f, -0.204101562f, 1.6328125f, 3.609375f, + 2.5625f, 4.0625f, 9.3125f, -0.103515625f, 7.1875f, 0.72265625f, + 0.6015625f, -6.6875f, -5.1875f, -5.125f, -3.96875f, -4.03125f, + -2.4375f, 1.2421875f, -1.875f, 0.67578125f, 2.34375f, 2.046875f, + 0.357421875f, -0.72265625f, -0.147460938f, 2.96875f, 0.326171875f, -10.875f, + 8.25f, 0.306640625f, 1.4765625f, 5.3125f, 0.8125f, 4.875f, + -0.80078125f, 4.6875f, -3.21875f, -5.3125f, -0.0166015625f, 6.3125f, + -0.65625f, 8.0625f, 1.546875f, 2.21875f, 7.375f, -1.375f, + 1.390625f, -3.15625f, -2.84375f, 1.625f, 2.9375f, -9.125f, + 1.234375f, -6.9375f, -1.609375f, -1.9609375f, 2.71875f, 3.75f, + -0.9609375f, -3.125f, -3.140625f, 1.0f, 4.96875f, 0.265625f, + -1.78125f, -0.486328125f, -4.8125f, 3.28125f, 4.90625f, -2.734375f, + 2.109375f, -0.1328125f, -2.234375f, 7.625f, -2.640625f, -2.4375f, + 6.46875f, 6.9375f, 2.71875f, 2.375f, 2.671875f, 2.109375f, + -1.015625f, -4.40625f, -3.15625f, -5.84375f, -2.875f, -2.078125f, + 4.59375f, 0.298828125f, 0.453125f, 0.65625f, 0.953125f, 5.25f, + 7.4375f, 3.21875f, -2.453125f, 1.828125f, -4.34375f, 8.8125f, + 9.875f, -4.1875f, -3.78125f, -0.88671875f, 10.25f, 5.25f, + -3.625f, -4.375f, -3.59375f, -1.0390625f, 3.203125f, -1.4296875f, + 0.7734375f, 0.09765625f, -0.149414062f, 4.65625f, -2.46875f, 5.09375f, + -7.4375f, -2.421875f, -10.75f, -7.09375f, 4.84375f, -2.421875f, + 8.625f, 5.65625f, 2.375f, 4.71875f, 0.765625f, 2.5f, + 0.86328125f, -1.0390625f, 1.546875f, 6.8125f, 6.03125f, 4.96875f, + 0.86328125f, 4.8125f, -2.53125f, -5.0f, -4.875f, 0.50390625f, + -2.625f, 0.99609375f, 0.0913085938f, -0.8125f, -1.5625f, -4.84375f, + 2.90625f, 0.953125f, -0.404296875f, -0.50390625f, -1.4453125f, 2.65625f, + 5.375f, -3.1875f, 6.15625f, -2.640625f, -0.153320312f, 0.87109375f, + -0.984375f, 7.625f, 1.5f, -0.5859375f, +}; + +inline constexpr float kLtxTowerStateBf16_7[] = { + -8.4375f, -0.8125f, 1.1953125f, 2.75f, -0.310546875f, 4.1875f, + 1.7109375f, -3.28125f, 1.09375f, 2.71875f, -2.796875f, 0.237304688f, + -8.875f, -4.8125f, 2.0625f, -1.4453125f, 1.5703125f, 2.203125f, + 3.796875f, -5.03125f, -5.875f, 4.59375f, 2.390625f, -5.78125f, + 6.84375f, -0.78125f, -0.470703125f, 4.3125f, 6.8125f, -0.9609375f, + -1.96875f, 1.8984375f, -6.90625f, -1.25f, 7.59375f, -0.3828125f, + -3.515625f, 6.5625f, -0.68359375f, 3.203125f, 0.26953125f, 1.1015625f, + -3.375f, -1.140625f, -3.609375f, -2.578125f, 0.921875f, 0.48828125f, + 3.0f, 0.1953125f, -0.9609375f, -2.71875f, -0.0141601562f, 7.46875f, + 6.03125f, -2.890625f, 6.21875f, 0.33984375f, 5.25f, 2.890625f, + 6.9375f, 2.3125f, -4.0f, -0.88671875f, -3.40625f, -11.4375f, + 1.921875f, 0.3984375f, -2.03125f, 6.875f, -1.2578125f, -1.234375f, + 1.8828125f, -0.66796875f, -1.96875f, -2.34375f, -4.21875f, -6.6875f, + 1.0f, -1.40625f, 1.2265625f, -0.443359375f, 2.328125f, -3.15625f, + 0.71875f, 2.359375f, 4.6875f, -7.15625f, 7.125f, 1.546875f, + 2.859375f, 7.1875f, 2.09375f, 0.176757812f, 1.203125f, 3.65625f, + 1.8828125f, 4.3125f, 6.4375f, -1.4453125f, 7.125f, 1.640625f, + -0.365234375f, -5.4375f, -6.4375f, -4.125f, -3.0f, -5.0625f, + -1.4375f, -1.734375f, -2.1875f, 2.765625f, 1.0f, 3.3125f, + 3.09375f, 1.0859375f, 0.40625f, 3.546875f, 1.59375f, -9.5f, + 11.25f, -0.375f, 0.51953125f, 5.28125f, 0.5703125f, 6.0625f, + -2.609375f, 4.0f, -3.703125f, -4.46875f, -2.015625f, 3.90625f, + 0.00619506836f, 6.78125f, -0.365234375f, 3.9375f, 4.71875f, -0.5625f, + 0.86328125f, -4.34375f, -4.0f, 0.163085938f, 2.265625f, -7.9375f, + 0.5078125f, -5.25f, 0.0600585938f, -0.23046875f, 2.34375f, 3.0f, + 0.18359375f, -4.53125f, -0.212890625f, 0.6328125f, 2.78125f, 1.484375f, + -3.65625f, 0.88671875f, -6.71875f, 1.7109375f, 2.671875f, -1.109375f, + 1.3203125f, -2.09375f, -0.72265625f, 7.46875f, -4.84375f, -2.234375f, + 7.0f, 5.59375f, 2.65625f, 1.0625f, 2.6875f, 2.921875f, + -0.69921875f, -4.25f, -4.0625f, -4.65625f, -1.6484375f, -0.921875f, + 5.8125f, 0.6953125f, 1.4296875f, -0.95703125f, 0.11328125f, 3.734375f, + 5.59375f, 5.0625f, -3.625f, 2.34375f, -5.78125f, 7.15625f, + 8.0625f, -3.171875f, -3.34375f, -3.0625f, 9.375f, 5.0f, + -3.5625f, -3.734375f, -4.46875f, -0.70703125f, 2.34375f, -0.8515625f, + 2.390625f, 0.68359375f, 0.890625f, 6.96875f, -5.28125f, 3.109375f, + -4.15625f, -2.421875f, -10.1875f, -8.375f, 3.9375f, -2.09375f, + 7.53125f, 3.109375f, 4.25f, 3.453125f, 0.66015625f, 4.0625f, + 0.365234375f, 0.9765625f, 1.328125f, 7.25f, 4.4375f, 3.5625f, + 0.83984375f, 6.8125f, -2.640625f, -3.84375f, -4.46875f, -0.48046875f, + -2.203125f, -1.359375f, 0.734375f, -1.7265625f, -0.7578125f, -1.8515625f, + 3.1875f, 0.9609375f, -0.8515625f, -2.25f, -2.25f, 2.46875f, + 3.28125f, -1.46875f, 7.125f, -0.94921875f, -0.345703125f, 2.015625f, + -1.703125f, 7.15625f, 1.625f, 0.76953125f, +}; + +inline constexpr float kLtxTowerStateBf16_8[] = { + -8.8125f, 1.5390625f, 0.134765625f, 1.1171875f, -1.0703125f, 1.4453125f, + 1.0078125f, -0.142578125f, 3.046875f, 3.0625f, -0.142578125f, 0.71875f, + -9.1875f, -2.09375f, 1.5703125f, -1.6484375f, 1.828125f, -0.0317382812f, + 1.9453125f, -6.34375f, -8.8125f, 5.0f, 2.28125f, -5.90625f, + 4.09375f, -0.265625f, -0.546875f, 4.0625f, 4.21875f, -2.65625f, + -2.265625f, 2.21875f, -8.9375f, 0.375f, 5.96875f, -2.3125f, + -4.40625f, 4.8125f, -0.97265625f, 4.0625f, 0.64453125f, 1.4609375f, + -1.7109375f, -0.361328125f, -5.0625f, -0.625f, 1.671875f, -0.5859375f, + 1.6953125f, -0.9296875f, -3.6875f, -2.859375f, -2.0f, 8.25f, + 5.25f, -3.15625f, 5.90625f, 3.015625f, 2.90625f, 2.125f, + 4.0625f, 0.65234375f, -3.90625f, -0.53125f, -4.9375f, -10.0625f, + 0.00494384766f, -1.4609375f, -4.09375f, 5.0625f, -0.59375f, -0.150390625f, + 2.53125f, -0.8359375f, -1.3203125f, -2.703125f, -5.0f, -4.9375f, + 2.796875f, -1.84375f, 1.9375f, -2.28125f, 0.8125f, -3.921875f, + -0.67578125f, -0.27734375f, 3.609375f, -8.875f, 6.875f, 4.375f, + 2.765625f, 8.9375f, 2.3125f, -2.984375f, 1.21875f, 3.078125f, + 1.2265625f, 7.84375f, 3.515625f, -2.984375f, 6.4375f, 1.4765625f, + 0.69140625f, -6.03125f, -4.8125f, -5.03125f, -1.84375f, -3.84375f, + -1.3984375f, 0.396484375f, -0.5625f, 0.72265625f, 1.6484375f, 1.3984375f, + 1.484375f, 0.7578125f, -0.9921875f, 1.8984375f, 0.80078125f, -9.125f, + 10.875f, 0.23046875f, 2.40625f, 5.96875f, -0.7265625f, 6.59375f, + -3.234375f, 5.6875f, -4.59375f, -3.703125f, -1.71875f, 4.28125f, + -1.3984375f, 5.21875f, -0.453125f, 5.75f, 7.03125f, -1.78125f, + 2.375f, -6.96875f, -3.65625f, 3.203125f, 4.5625f, -7.21875f, + 0.80078125f, -6.15625f, -1.7578125f, -2.734375f, 0.80859375f, 1.5703125f, + 0.859375f, -5.34375f, 1.109375f, 1.78125f, 2.53125f, 1.0078125f, + -2.28125f, -1.03125f, -8.75f, 1.9609375f, 2.8125f, 0.9140625f, + 2.46875f, -1.5078125f, -0.59765625f, 7.25f, -6.5625f, -0.83203125f, + 7.53125f, 3.96875f, 2.0f, 2.0625f, 2.734375f, 3.390625f, + -0.326171875f, -3.953125f, -2.0625f, -2.703125f, -3.296875f, -2.28125f, + 4.21875f, -0.76171875f, 2.328125f, -3.265625f, -0.0634765625f, 4.90625f, + 6.625f, 3.921875f, -4.625f, 1.75f, -6.5f, 8.375f, + 7.28125f, 0.70703125f, -3.0625f, -1.875f, 9.3125f, 4.78125f, + -4.5f, -1.4921875f, -3.625f, -2.125f, 2.984375f, -0.0791015625f, + 1.7109375f, 4.1875f, 0.5859375f, 7.03125f, -5.375f, 4.75f, + -5.3125f, -1.359375f, -8.875f, -7.3125f, 5.71875f, -2.28125f, + 6.40625f, 4.0625f, 4.28125f, 3.109375f, -1.828125f, 2.921875f, + -0.54296875f, 0.240234375f, 2.046875f, 10.8125f, 2.953125f, 2.890625f, + 0.828125f, 7.1875f, -2.5625f, -5.53125f, -4.59375f, -2.09375f, + -2.046875f, -1.2265625f, 2.21875f, 0.462890625f, -0.8046875f, -3.078125f, + 4.5625f, 1.5703125f, -1.734375f, -0.578125f, -2.734375f, 2.671875f, + 4.71875f, -2.890625f, 7.65625f, -0.72265625f, 1.03125f, 3.109375f, + -2.890625f, 6.46875f, -0.69140625f, 1.234375f, +}; + +inline constexpr float kLtxTowerStateBf16_9[] = { + -7.875f, 1.1328125f, 1.234375f, -0.07421875f, -4.21875f, 2.875f, + 1.265625f, 0.44921875f, 4.09375f, 4.625f, -1.421875f, 0.2890625f, + -9.4375f, -3.109375f, 2.421875f, -0.15234375f, 2.15625f, 0.3671875f, + 3.15625f, -4.09375f, -9.5f, 5.53125f, 0.7578125f, -5.9375f, + 5.03125f, -0.21484375f, 0.7734375f, 4.96875f, 2.53125f, -2.671875f, + -0.71875f, 0.984375f, -7.65625f, 0.609375f, 5.8125f, -3.015625f, + -8.0625f, 6.25f, -0.248046875f, 2.78125f, 0.84765625f, 3.140625f, + -3.359375f, -0.159179688f, -5.0625f, -1.515625f, 2.390625f, 0.94921875f, + 1.6796875f, -0.63671875f, -2.609375f, -1.09375f, -2.203125f, 8.25f, + 3.859375f, -2.5f, 6.40625f, 3.140625f, 4.96875f, 3.140625f, + 2.15625f, 0.7421875f, -3.828125f, -1.09375f, -4.375f, -6.8125f, + -2.5625f, -1.828125f, -5.96875f, 3.828125f, 0.25390625f, -0.734375f, + 2.109375f, -0.200195312f, -1.171875f, -0.62890625f, -5.03125f, -4.9375f, + 3.828125f, -0.271484375f, 1.5703125f, -3.859375f, 0.267578125f, -2.109375f, + -1.234375f, -0.00970458984f, 3.9375f, -10.5625f, 6.53125f, 5.59375f, + 4.8125f, 10.125f, 3.65625f, -4.65625f, 1.3046875f, 2.359375f, + 1.78125f, 6.59375f, 2.734375f, -2.734375f, 5.5625f, 1.15625f, + 0.84375f, -5.875f, -7.46875f, -5.1875f, -2.375f, -3.921875f, + -3.5f, 0.220703125f, -0.0314941406f, 2.6875f, 1.59375f, -1.109375f, + 1.8046875f, 1.2421875f, -0.9453125f, 4.25f, 0.337890625f, -8.25f, + 11.0625f, -1.8515625f, 4.28125f, 6.9375f, -0.80859375f, 4.75f, + -4.78125f, 3.890625f, -1.0546875f, -1.9296875f, -3.96875f, 3.765625f, + -1.546875f, 5.375f, 0.34765625f, 5.21875f, 4.21875f, -0.7109375f, + 1.5703125f, -4.03125f, -2.453125f, 3.0625f, 4.25f, -4.3125f, + 1.6796875f, -6.90625f, 0.192382812f, -0.104003906f, 1.484375f, 1.0546875f, + 0.0405273438f, -5.625f, 0.8203125f, 3.203125f, 4.96875f, 2.234375f, + -4.125f, -0.82421875f, -9.3125f, 1.75f, 4.84375f, 1.390625f, + 1.4140625f, -2.03125f, -3.375f, 7.03125f, -5.875f, -0.76953125f, + 7.25f, 4.40625f, 1.671875f, 3.15625f, 2.484375f, 3.359375f, + -1.8046875f, -1.109375f, -2.46875f, -4.6875f, -3.078125f, -0.237304688f, + 4.15625f, -1.0390625f, 2.15625f, -4.59375f, 0.0306396484f, 4.5625f, + 6.1875f, 5.375f, -3.515625f, -0.4453125f, -3.25f, 8.375f, + 7.59375f, 4.03125f, -1.4453125f, -0.369140625f, 10.6875f, 2.078125f, + -3.6875f, -1.734375f, -2.078125f, -1.484375f, 4.125f, -1.2734375f, + 0.474609375f, 5.9375f, 0.66796875f, 8.25f, -5.375f, 5.9375f, + -3.921875f, -0.69921875f, -7.65625f, -5.40625f, 5.1875f, -1.46875f, + 2.78125f, 3.234375f, 4.0f, 3.625f, -2.671875f, 2.78125f, + 0.133789062f, 0.2890625f, 3.46875f, 11.375f, 0.69921875f, 0.28125f, + 2.046875f, 6.625f, -2.4375f, -6.1875f, -4.65625f, -0.37890625f, + -0.22265625f, 1.3046875f, 1.078125f, 2.015625f, 0.9140625f, -3.0625f, + 5.625f, 1.40625f, -0.66015625f, 0.94921875f, -1.15625f, 4.78125f, + 6.90625f, -3.6875f, 7.5625f, -0.7890625f, 1.7890625f, 4.125f, + -2.75f, 4.96875f, -0.87109375f, -1.2421875f, +}; + +inline constexpr float kLtxTowerStateBf16_10[] = { + -8.375f, 1.1875f, 1.859375f, 2.96875f, -4.4375f, 3.046875f, + 1.828125f, 0.6796875f, 6.40625f, 5.84375f, -0.6640625f, 0.5625f, + -9.875f, -4.375f, 3.21875f, 2.953125f, 1.171875f, -1.78125f, + 6.5625f, -4.0f, -12.9375f, 4.3125f, -0.121582031f, -6.28125f, + 5.5625f, 0.5546875f, 0.62890625f, 4.75f, 3.609375f, -0.96875f, + -0.174804688f, 2.625f, -8.6875f, 1.1171875f, 5.75f, 1.390625f, + -9.4375f, 8.5f, -0.921875f, 3.34375f, 2.046875f, 4.53125f, + -2.53125f, 0.0f, -4.8125f, -3.1875f, 4.4375f, 3.65625f, + 1.5859375f, -2.5f, 0.1640625f, -0.94140625f, -5.0f, 7.9375f, + 2.640625f, -2.484375f, 6.40625f, 3.078125f, 5.0625f, 2.78125f, + 3.125f, 2.734375f, -2.8125f, -0.0649414062f, -6.46875f, -4.21875f, + -3.3125f, -0.235351562f, -7.34375f, 4.59375f, 0.53515625f, -2.265625f, + 3.046875f, 0.427734375f, -1.578125f, 0.76953125f, -5.5f, -7.625f, + 3.765625f, 0.2734375f, 3.09375f, -4.65625f, 1.3359375f, -1.78125f, + -1.84375f, -1.7734375f, 4.15625f, -10.5625f, 7.5625f, 7.78125f, + 5.5625f, 10.4375f, 3.75f, -2.921875f, 2.40625f, 3.71875f, + 1.625f, 8.75f, 1.0625f, -0.49609375f, 6.125f, -0.6640625f, + 2.03125f, -8.4375f, -7.71875f, -3.625f, -3.59375f, -6.3125f, + -3.5f, -0.66796875f, 1.171875f, 2.0625f, 1.6796875f, -0.09765625f, + 2.859375f, 2.59375f, -2.90625f, 3.484375f, -0.94921875f, -10.5f, + 11.75f, -0.4609375f, 5.0f, 7.625f, 0.30859375f, 4.75f, + -3.71875f, 4.25f, -2.75f, -0.263671875f, -4.375f, 8.0625f, + -1.0546875f, 7.75f, 1.7734375f, 5.65625f, 4.625f, -1.96875f, + 2.421875f, -4.84375f, -1.3359375f, 0.921875f, 6.28125f, -4.09375f, + 2.953125f, -6.75f, 1.5f, 1.1875f, -0.184570312f, -0.231445312f, + -0.5390625f, -6.65625f, 1.578125f, 4.875f, 5.46875f, 1.5625f, + -3.890625f, 1.296875f, -8.25f, 1.0546875f, 5.375f, 3.171875f, + 2.953125f, 1.359375f, -4.53125f, 7.625f, -5.53125f, -1.1484375f, + 10.125f, 4.46875f, 0.95703125f, 2.234375f, 2.140625f, 1.375f, + -0.158203125f, -0.328125f, -0.94140625f, -3.640625f, -2.109375f, 0.470703125f, + 2.75f, -2.578125f, 2.34375f, -3.5f, -0.177734375f, 4.1875f, + 7.96875f, 4.90625f, -1.8671875f, 3.140625f, -2.625f, 9.9375f, + 8.25f, 4.4375f, -3.171875f, -0.296875f, 12.25f, -1.5078125f, + -5.1875f, -3.15625f, 0.0607910156f, -2.03125f, 1.5f, -3.875f, + -0.121582031f, 4.5f, 1.609375f, 6.84375f, -6.875f, 5.0625f, + -2.15625f, 1.203125f, -7.125f, -4.46875f, 5.15625f, -3.03125f, + 3.203125f, 2.484375f, 5.6875f, 5.90625f, -1.4765625f, 3.078125f, + 0.263671875f, -0.109375f, 4.09375f, 13.5f, 0.09765625f, 1.25f, + 1.5234375f, 4.6875f, -2.890625f, -7.78125f, -3.796875f, -0.7421875f, + -2.34375f, 0.482421875f, 2.40625f, -0.32421875f, 1.4453125f, -4.53125f, + 4.4375f, 1.8203125f, 0.178710938f, 0.259765625f, -0.21875f, 5.78125f, + 6.84375f, -4.28125f, 6.875f, -1.7890625f, 2.203125f, 6.84375f, + -2.71875f, 4.84375f, -1.328125f, -1.9296875f, +}; + +inline constexpr float kLtxTowerStateBf16_11[] = { + -10.375f, 0.484375f, 2.328125f, 4.0625f, -5.75f, 1.9140625f, + 1.0703125f, 0.9609375f, 4.75f, 8.75f, -1.3046875f, 1.3046875f, + -9.125f, -5.0f, 2.921875f, 1.3515625f, 1.078125f, -1.4296875f, + 4.0625f, -5.1875f, -14.4375f, 3.234375f, -0.470703125f, -5.90625f, + 6.78125f, 2.15625f, -0.37109375f, 7.65625f, 1.4609375f, 0.953125f, + -2.109375f, 0.67578125f, -10.375f, -1.328125f, 6.4375f, 1.0703125f, + -10.375f, 7.5625f, -1.6796875f, 4.5f, 0.69140625f, 6.9375f, + -3.640625f, -0.1328125f, -5.28125f, -3.390625f, 5.46875f, 2.0625f, + 1.640625f, -2.859375f, -1.953125f, -1.0859375f, -4.8125f, 8.5625f, + 4.09375f, -2.78125f, 7.1875f, 3.21875f, 5.21875f, 6.5f, + 0.166992188f, 3.953125f, -5.53125f, -1.4765625f, -8.75f, -6.96875f, + -5.0f, -2.28125f, -7.84375f, 3.78125f, 0.4609375f, -2.609375f, + 4.53125f, 0.87890625f, 0.0297851562f, 1.015625f, -5.59375f, -7.96875f, + 3.1875f, -0.176757812f, 4.625f, -3.90625f, -0.8828125f, -2.984375f, + -2.390625f, -2.078125f, 3.5625f, -11.4375f, 6.3125f, 8.4375f, + 6.21875f, 12.125f, 3.046875f, -3.296875f, 1.3671875f, 4.5f, + 0.98828125f, 8.125f, 0.87890625f, -0.83203125f, 4.0f, -1.03125f, + 4.0f, -8.8125f, -5.0625f, -4.5f, -2.53125f, -5.53125f, + -2.0625f, -4.5625f, -1.21875f, -1.1171875f, -1.3828125f, 1.3984375f, + 3.96875f, 2.203125f, -3.15625f, 4.5625f, -0.86328125f, -11.75f, + 10.875f, 2.0625f, 6.53125f, 9.0f, -0.78515625f, 4.21875f, + -7.03125f, 4.25f, -2.796875f, 0.357421875f, -3.34375f, 6.875f, + -2.5625f, 6.8125f, 2.28125f, 3.53125f, 6.75f, -0.796875f, + 3.140625f, -4.8125f, -1.5390625f, 0.453125f, 4.8125f, -5.46875f, + 3.078125f, -6.0625f, -1.2109375f, 0.357421875f, -2.15625f, 2.25f, + -0.158203125f, -7.46875f, 2.09375f, 4.3125f, 6.375f, 3.140625f, + -4.0f, 2.046875f, -7.9375f, 0.61328125f, 5.28125f, 1.59375f, + 2.40625f, 1.59375f, -5.65625f, 6.46875f, -6.1875f, -1.140625f, + 11.0f, 5.78125f, 2.0625f, 3.109375f, 2.0625f, 1.9453125f, + -2.265625f, -1.3203125f, 0.174804688f, -4.78125f, -2.984375f, 0.4609375f, + 1.125f, -2.0625f, 3.140625f, -5.65625f, -1.1171875f, 3.109375f, + 7.375f, 6.34375f, -2.25f, 2.671875f, -3.6875f, 9.625f, + 10.6875f, 4.4375f, -5.59375f, -1.1640625f, 10.9375f, -0.396484375f, + -3.59375f, -4.625f, 3.90625f, -2.875f, 2.984375f, -3.453125f, + 0.84765625f, 2.578125f, 0.151367188f, 4.65625f, -8.0f, 5.71875f, + -0.48046875f, 1.2890625f, -6.09375f, -3.140625f, 6.375f, -2.65625f, + 3.359375f, 1.609375f, 7.03125f, 5.4375f, -2.625f, 1.921875f, + -1.2109375f, 0.3828125f, 5.78125f, 12.25f, -1.1328125f, 2.109375f, + 0.73828125f, 4.40625f, 0.25390625f, -6.46875f, 0.23828125f, -1.34375f, + -0.30078125f, 1.9296875f, 3.6875f, -2.1875f, 0.50390625f, -4.15625f, + 6.25f, 2.75f, 2.765625f, -1.0078125f, -0.435546875f, 5.90625f, + 7.4375f, -6.0625f, 6.78125f, -0.4609375f, 1.6328125f, 4.625f, + -2.65625f, 3.21875f, -0.11328125f, -2.46875f, +}; + +inline constexpr float kLtxTowerStateBf16_12[] = { + -1.9453125f, -0.110351562f, 0.54296875f, 0.96875f, -1.40625f, 0.3984375f, + -0.0971679688f, 0.21484375f, 1.25f, 1.8515625f, -0.159179688f, 0.62109375f, + -1.4453125f, -0.6953125f, 0.66796875f, -0.200195312f, 0.458984375f, -0.3515625f, + 0.81640625f, -0.7421875f, -2.734375f, 0.453125f, -0.137695312f, -1.3828125f, + 0.9765625f, 0.140625f, 0.306640625f, 1.375f, 0.478515625f, 0.80859375f, + -0.17578125f, 0.170898438f, -1.7578125f, -0.291015625f, 1.3984375f, 0.189453125f, + -2.203125f, 1.5859375f, -0.84375f, 1.1328125f, 0.369140625f, 1.5390625f, + -0.49609375f, 0.0030670166f, -0.80859375f, -0.211914062f, 1.0703125f, 0.231445312f, + 0.36328125f, -0.70703125f, 0.110839844f, -0.231445312f, -0.9921875f, 1.3828125f, + 0.55859375f, -1.046875f, 1.5703125f, 0.33203125f, 1.140625f, 1.0859375f, + 0.0242919922f, 1.2734375f, -0.875f, -0.168945312f, -1.375f, -1.140625f, + -1.0f, -0.30078125f, -2.015625f, 0.765625f, -0.000261306763f, -0.267578125f, + 1.0f, 0.244140625f, 0.000331878662f, -0.112304688f, -0.6875f, -1.296875f, + 0.7265625f, -0.108398438f, 0.89453125f, -0.3984375f, 0.23828125f, -0.322265625f, + -0.796875f, -0.7578125f, 0.78125f, -2.15625f, 1.2734375f, 1.3046875f, + 1.4375f, 2.0625f, 0.6328125f, -0.07421875f, 0.23828125f, 0.953125f, + 0.227539062f, 1.265625f, 0.163085938f, -0.198242188f, 0.43359375f, -0.120117188f, + 0.546875f, -1.5390625f, -0.9765625f, -0.875f, -0.31640625f, -1.1484375f, + -0.34765625f, -0.9765625f, -0.75390625f, -0.064453125f, -0.26171875f, 0.103515625f, + 1.078125f, 0.76953125f, -0.578125f, 0.74609375f, -0.126953125f, -2.515625f, + 1.84375f, 0.240234375f, 1.5703125f, 1.2265625f, -0.139648438f, 1.2265625f, + -1.4921875f, 1.265625f, -0.6875f, 0.0297851562f, -0.126953125f, 1.1796875f, + -0.9609375f, 1.78125f, 0.56640625f, 1.2890625f, 1.3046875f, 0.41796875f, + 0.117675781f, -1.3046875f, -0.546875f, 0.00726318359f, 0.96875f, -1.4921875f, + 0.52734375f, -1.4609375f, 0.1953125f, 0.15234375f, -0.365234375f, -0.1875f, + 0.161132812f, -2.296875f, 0.4140625f, 0.80859375f, 1.9296875f, 0.69140625f, + -0.609375f, 1.1171875f, -1.625f, 0.400390625f, 1.0078125f, 0.27734375f, + 0.5078125f, 0.353515625f, -1.5078125f, 1.1015625f, -1.671875f, -0.0444335938f, + 2.65625f, 1.1171875f, 0.455078125f, 0.81640625f, -0.0118408203f, 0.75390625f, + -0.380859375f, -0.322265625f, -0.229492188f, -1.2421875f, -0.294921875f, 0.251953125f, + 0.40625f, -0.65234375f, 0.5546875f, -1.25f, -0.486328125f, 0.578125f, + 1.8359375f, 0.97265625f, -0.106445312f, 0.640625f, -0.6328125f, 2.140625f, + 2.109375f, 1.40625f, -1.484375f, 0.35546875f, 1.9609375f, -0.0544433594f, + -0.1328125f, -1.1015625f, 0.90234375f, -0.39453125f, 0.0556640625f, -0.73046875f, + 0.153320312f, 0.208007812f, 0.168945312f, 0.75390625f, -1.96875f, 0.93359375f, + -0.50390625f, 0.92578125f, -1.4140625f, -1.125f, 1.296875f, -0.125976562f, + 0.59765625f, 0.703125f, 1.3515625f, 1.2578125f, -0.85546875f, 0.7109375f, + -0.219726562f, 0.3359375f, 1.203125f, 2.40625f, 0.146484375f, 0.8046875f, + -0.40625f, 1.5234375f, 0.154296875f, -1.40625f, 0.54296875f, -0.6015625f, + -0.122558594f, 0.9765625f, 0.87890625f, -0.58203125f, -0.135742188f, -0.9765625f, + 1.1796875f, 0.037109375f, 0.9765625f, -0.1640625f, 0.216796875f, 1.390625f, + 2.046875f, -1.3046875f, 1.515625f, -0.168945312f, 0.443359375f, 0.87890625f, + -0.248046875f, 1.078125f, -0.373046875f, -0.0322265625f, +}; + +// --- section 3b: the oracle's OWN f32-vs-bf16 spread, per state --- +// The dtype noise floor, MEASURED rather than assumed. This is the +// tolerance: a port whose bf16 answer sits inside it is indistinguishable +// from upstream at upstream's own arithmetic width, and one that sits +// outside it has a defect that bf16 rounding does not explain. +inline constexpr float kLtxTowerDtypeNoise[] = { + 0.000923156738f, 0.0726652145f, 0.175282419f, 0.305008888f, 0.31251663f, 0.449046016f, + 0.559325457f, 0.587829113f, 0.61070919f, 0.683670044f, 0.831443787f, 1.0988245f, + 0.210947245f, +}; + +inline constexpr float kLtxTowerStateScale[] = { + 0.280326843f, 3.4499445f, 5.558568f, 7.39979506f, 8.61177158f, 9.98898315f, + 12.5902777f, 11.5040922f, 10.9405537f, 11.3621979f, 13.3253717f, 14.3474884f, + 2.705369f, +}; + +// --- section 4: the LEFT-PADDED run, float32 --- +// [state][padded_seq * hidden]. Rows 0..kLtxTowerNumPad-1 are pad rows and +// their contents are upstream's garbage-but-masked values; the gate reads +// only the VALID tail and holds section 2 to it. +inline constexpr float kLtxTowerPaddedStateF32_0[] = { + -0.109783173f, 0.197471619f, 0.0835456848f, 0.2029953f, -0.0555820465f, 0.277565002f, + 0.0393562317f, -0.0189013481f, -0.0070772171f, 0.212661743f, 0.191947937f, -0.160186768f, + -0.128425598f, -0.127044678f, 0.211280823f, -0.0305528641f, 0.165710449f, -0.179519653f, + 0.0542011261f, -0.138782501f, -0.00914859772f, 0.027100563f, -0.198852539f, 0.26789856f, + -0.175376892f, 0.0391836166f, -0.2029953f, -0.120140076f, 0.230613708f, 0.121520996f, + -0.211280823f, 0.149139404f, -0.109783173f, 0.197471619f, 0.0835456848f, 0.2029953f, + -0.0555820465f, 0.277565002f, 0.0393562317f, -0.0189013481f, -0.0070772171f, 0.212661743f, + 0.191947937f, -0.160186768f, -0.128425598f, -0.127044678f, 0.211280823f, -0.0305528641f, + 0.165710449f, -0.179519653f, 0.0542011261f, -0.138782501f, -0.00914859772f, 0.027100563f, + -0.198852539f, 0.26789856f, -0.175376892f, 0.0391836166f, -0.2029953f, -0.120140076f, + 0.230613708f, 0.121520996f, -0.211280823f, 0.149139404f, -0.109783173f, 0.197471619f, + 0.0835456848f, 0.2029953f, -0.0555820465f, 0.277565002f, 0.0393562317f, -0.0189013481f, + -0.0070772171f, 0.212661743f, 0.191947937f, -0.160186768f, -0.128425598f, -0.127044678f, + 0.211280823f, -0.0305528641f, 0.165710449f, -0.179519653f, 0.0542011261f, -0.138782501f, + -0.00914859772f, 0.027100563f, -0.198852539f, 0.26789856f, -0.175376892f, 0.0391836166f, + -0.2029953f, -0.120140076f, 0.230613708f, 0.121520996f, -0.211280823f, 0.149139404f, + -0.109783173f, 0.197471619f, 0.0835456848f, 0.2029953f, -0.0555820465f, 0.277565002f, + 0.0393562317f, -0.0189013481f, -0.0070772171f, 0.212661743f, 0.191947937f, -0.160186768f, + -0.128425598f, -0.127044678f, 0.211280823f, -0.0305528641f, 0.165710449f, -0.179519653f, + 0.0542011261f, -0.138782501f, -0.00914859772f, 0.027100563f, -0.198852539f, 0.26789856f, + -0.175376892f, 0.0391836166f, -0.2029953f, -0.120140076f, 0.230613708f, 0.121520996f, + -0.211280823f, 0.149139404f, -0.109783173f, 0.197471619f, 0.0835456848f, 0.2029953f, + -0.0555820465f, 0.277565002f, 0.0393562317f, -0.0189013481f, -0.0070772171f, 0.212661743f, + 0.191947937f, -0.160186768f, -0.128425598f, -0.127044678f, 0.211280823f, -0.0305528641f, + 0.165710449f, -0.179519653f, 0.0542011261f, -0.138782501f, -0.00914859772f, 0.027100563f, + -0.198852539f, 0.26789856f, -0.175376892f, 0.0391836166f, -0.2029953f, -0.120140076f, + 0.230613708f, 0.121520996f, -0.211280823f, 0.149139404f, -0.109783173f, 0.197471619f, + 0.0835456848f, 0.2029953f, -0.0555820465f, 0.277565002f, 0.0393562317f, -0.0189013481f, + -0.0070772171f, 0.212661743f, 0.191947937f, -0.160186768f, -0.128425598f, -0.127044678f, + 0.211280823f, -0.0305528641f, 0.165710449f, -0.179519653f, 0.0542011261f, -0.138782501f, + -0.00914859772f, 0.027100563f, -0.198852539f, 0.26789856f, -0.175376892f, 0.0391836166f, + -0.2029953f, -0.120140076f, 0.230613708f, 0.121520996f, -0.211280823f, 0.149139404f, + -0.109783173f, 0.197471619f, 0.0835456848f, 0.2029953f, -0.0555820465f, 0.277565002f, + 0.0393562317f, -0.0189013481f, -0.0070772171f, 0.212661743f, 0.191947937f, -0.160186768f, + -0.128425598f, -0.127044678f, 0.211280823f, -0.0305528641f, 0.165710449f, -0.179519653f, + 0.0542011261f, -0.138782501f, -0.00914859772f, 0.027100563f, -0.198852539f, 0.26789856f, + -0.175376892f, 0.0391836166f, -0.2029953f, -0.120140076f, 0.230613708f, 0.121520996f, + -0.211280823f, 0.149139404f, -0.109783173f, 0.197471619f, 0.0835456848f, 0.2029953f, + -0.0555820465f, 0.277565002f, 0.0393562317f, -0.0189013481f, -0.0070772171f, 0.212661743f, + 0.191947937f, -0.160186768f, -0.128425598f, -0.127044678f, 0.211280823f, -0.0305528641f, + 0.165710449f, -0.179519653f, 0.0542011261f, -0.138782501f, -0.00914859772f, 0.027100563f, + -0.198852539f, 0.26789856f, -0.175376892f, 0.0391836166f, -0.2029953f, -0.120140076f, + 0.230613708f, 0.121520996f, -0.211280823f, 0.149139404f, -0.109783173f, 0.197471619f, + 0.0835456848f, 0.2029953f, -0.0555820465f, 0.277565002f, 0.0393562317f, -0.0189013481f, + -0.0070772171f, 0.212661743f, 0.191947937f, -0.160186768f, -0.128425598f, -0.127044678f, + 0.211280823f, -0.0305528641f, 0.165710449f, -0.179519653f, 0.0542011261f, -0.138782501f, + -0.00914859772f, 0.027100563f, -0.198852539f, 0.26789856f, -0.175376892f, 0.0391836166f, + -0.2029953f, -0.120140076f, 0.230613708f, 0.121520996f, -0.211280823f, 0.149139404f, + -0.109783173f, 0.197471619f, 0.0835456848f, 0.2029953f, -0.0555820465f, 0.277565002f, + 0.0393562317f, -0.0189013481f, -0.0070772171f, 0.212661743f, 0.191947937f, -0.160186768f, + -0.128425598f, -0.127044678f, 0.211280823f, -0.0305528641f, 0.165710449f, -0.179519653f, + 0.0542011261f, -0.138782501f, -0.00914859772f, 0.027100563f, -0.198852539f, 0.26789856f, + -0.175376892f, 0.0391836166f, -0.2029953f, -0.120140076f, 0.230613708f, 0.121520996f, + -0.211280823f, 0.149139404f, -0.109783173f, 0.197471619f, 0.0835456848f, 0.2029953f, + -0.0555820465f, 0.277565002f, 0.0393562317f, -0.0189013481f, -0.0070772171f, 0.212661743f, + 0.191947937f, -0.160186768f, -0.128425598f, -0.127044678f, 0.211280823f, -0.0305528641f, + 0.165710449f, -0.179519653f, 0.0542011261f, -0.138782501f, -0.00914859772f, 0.027100563f, + -0.198852539f, 0.26789856f, -0.175376892f, 0.0391836166f, -0.2029953f, -0.120140076f, + 0.230613708f, 0.121520996f, -0.211280823f, 0.149139404f, -0.109783173f, 0.197471619f, + 0.0835456848f, 0.2029953f, -0.0555820465f, 0.277565002f, 0.0393562317f, -0.0189013481f, + -0.0070772171f, 0.212661743f, 0.191947937f, -0.160186768f, -0.128425598f, -0.127044678f, + 0.211280823f, -0.0305528641f, 0.165710449f, -0.179519653f, 0.0542011261f, -0.138782501f, + -0.00914859772f, 0.027100563f, -0.198852539f, 0.26789856f, -0.175376892f, 0.0391836166f, + -0.2029953f, -0.120140076f, 0.230613708f, 0.121520996f, -0.211280823f, 0.149139404f, + 0.23475647f, 0.0555820465f, -0.0445346832f, -0.243041992f, 0.186424255f, -0.125663757f, + -0.0149312019f, -0.0811290741f, -0.0321063995f, -0.175376892f, 0.0383205414f, 0.0704269409f, + -0.0469512939f, 0.0735340118f, 0.178138733f, -0.103569031f, 0.103569031f, 0.278945923f, + 0.104259491f, 0.0345230103f, -0.139472961f, -0.0586891174f, 0.10218811f, -0.0398740768f, + 0.080783844f, -0.0510940552f, -0.240280151f, -0.0107452869f, 0.208518982f, 0.0455703735f, + -0.280326843f, 0.130496979f, -0.23613739f, 0.151901245f, -0.0569629669f, -0.040391922f, + 0.0353860855f, -0.129116058f, 0.107021332f, 0.142925262f, -0.116687775f, -0.0852718353f, + 0.0994262695f, 0.126354218f, 0.179519653f, 0.190567017f, 0.244422913f, -0.0724983215f, + -0.198852539f, 0.0904502869f, 0.209899902f, -0.274803162f, 0.244422913f, 0.102878571f, + 0.209899902f, -0.227851868f, 0.207138062f, -0.170543671f, -0.231994629f, 0.109783173f, + 0.022008419f, 0.0994262695f, -0.205757141f, 0.00798344612f, -0.173305511f, -0.142234802f, + 0.245803833f, -0.138092041f, 0.06731987f, 0.262374878f, 0.260993958f, 0.193328857f, + 0.00841498375f, -0.0731887817f, 0.2029953f, -0.0697364807f, -0.106330872f, -0.198852539f, + -0.230613708f, 0.0832004547f, -0.106330872f, 0.260993958f, 0.276184082f, 0.0838909149f, + 0.0835456848f, 0.0662841797f, 0.0866527557f, -0.143615723f, 0.0586891174f, 0.212661743f, + 0.26789856f, 0.205757141f, 0.0289993286f, 0.229232788f, -0.0645580292f, -0.070772171f, + 0.176757812f, 0.189186096f, -0.272041321f, 0.180900574f, -0.0880336761f, 0.0262374878f, + 0.23475647f, -0.0724983215f, -0.252708435f, 0.0566177368f, -0.259613037f, -0.13325882f, + 0.124282837f, 0.023475647f, 0.205757141f, 0.0728435516f, 0.208518982f, 0.0212316513f, + 0.0621414185f, 0.226470947f, -0.0987358093f, 0.237518311f, -0.0125145912f, -0.207138062f, + -0.057308197f, -0.124282837f, 0.237518311f, 0.244422913f, -0.0752601624f, -0.16985321f, + -0.127044678f, -0.163639069f, -0.043844223f, 0.230613708f, 0.0030207634f, -0.254089355f, + 0.107021332f, 0.0521297455f, -0.120140076f, -0.144306183f, 0.155353546f, 0.00340914726f, + 0.220947266f, -0.223709106f, -0.183662415f, 0.197471619f, -0.194709778f, 0.244422913f, + -0.263755798f, -0.153282166f, 0.254089355f, -0.027100563f, 0.241661072f, -0.16709137f, + 0.0731887817f, -0.223709106f, 0.0987358093f, 0.216804504f, 0.162258148f, -0.0386657715f, + -0.180900574f, -0.138092041f, -0.105640411f, -0.0728435516f, -0.252708435f, 0.243041992f, + -0.238899231f, -0.0510940552f, -0.0939025879f, 0.131187439f, -0.216804504f, -0.249946594f, + 0.0814743042f, 0.0804386139f, 0.173305511f, 0.0704269409f, 0.122211456f, 0.10011673f, + -0.225090027f, 0.189186096f, 0.218185425f, -0.151210785f, -0.0569629669f, 0.0959739685f, + -0.151210785f, -0.0281362534f, -0.0845813751f, -0.259613037f, 0.140853882f, -0.0600700378f, + 0.237518311f, -0.108402252f, -0.0593795776f, -0.0362491608f, 0.057308197f, -0.20161438f, + -0.0252017975f, -0.0669746399f, -0.0759506226f, 0.0192465782f, -0.148448944f, -0.166400909f, + -0.0123419762f, 0.180900574f, 0.194709778f, -0.171234131f, -0.0814743042f, -0.137401581f, + 0.0932121277f, 0.183662415f, 0.150520325f, 0.0455703735f, -0.0153627396f, -0.0869979858f, + -0.214042664f, -0.178138733f, -0.070772171f, 0.132568359f, -0.204376221f, -0.159496307f, + -0.015103817f, 0.237518311f, 0.0852718353f, -0.0662841797f, 0.2029953f, -0.247184753f, + 0.16709137f, -0.278945923f, -0.26927948f, -0.229232788f, 0.237518311f, 0.00229793787f, + 0.0364217758f, -0.190567017f, 0.176757812f, 0.0762958527f, 0.259613037f, 0.16778183f, + 0.243041992f, -0.2029953f, 0.220947266f, -0.115997314f, -0.0980453491f, -0.233375549f, + -0.266517639f, 0.222328186f, -0.243041992f, 0.0738792419f, 0.00591206551f, -0.0291719437f, + -0.0838909149f, -0.16985321f, -0.0397014618f, -0.182281494f, 0.164329529f, 0.0548915863f, + -0.111164093f, 0.266517639f, -0.0756053925f, -0.196090698f, +}; + +inline constexpr float kLtxTowerPaddedStateF32_1[] = { + -0.433770001f, 0.755605817f, 0.349508345f, -0.851067066f, 1.01720726f, -0.0711843669f, + -0.427236468f, -1.99652624f, 0.34384349f, -1.21430302f, -0.1933382f, -2.33479309f, + -0.230848357f, -0.465642095f, 1.2489084f, -0.512278616f, 1.40072012f, -0.431816399f, + 0.934283912f, -0.51727283f, 0.546594501f, -0.441318065f, -0.0376381278f, -1.42697167f, + 0.984054267f, -1.38630164f, -0.566297114f, 0.18984212f, -1.10628676f, -0.221855938f, + 0.340159744f, 0.594956398f, -0.433770001f, 0.755605817f, 0.349508345f, -0.851067066f, + 1.01720726f, -0.0711843669f, -0.427236468f, -1.99652624f, 0.34384349f, -1.21430302f, + -0.1933382f, -2.33479309f, -0.230848357f, -0.465642095f, 1.2489084f, -0.512278616f, + 1.40072012f, -0.431816399f, 0.934283912f, -0.51727283f, 0.546594501f, -0.441318065f, + -0.0376381278f, -1.42697167f, 0.984054267f, -1.38630164f, -0.566297114f, 0.18984212f, + -1.10628676f, -0.221855938f, 0.340159744f, 0.594956398f, -0.433770001f, 0.755605817f, + 0.349508345f, -0.851067066f, 1.01720726f, -0.0711843669f, -0.427236468f, -1.99652624f, + 0.34384349f, -1.21430302f, -0.1933382f, -2.33479309f, -0.230848357f, -0.465642095f, + 1.2489084f, -0.512278616f, 1.40072012f, -0.431816399f, 0.934283912f, -0.51727283f, + 0.546594501f, -0.441318065f, -0.0376381278f, -1.42697167f, 0.984054267f, -1.38630164f, + -0.566297114f, 0.18984212f, -1.10628676f, -0.221855938f, 0.340159744f, 0.594956398f, + -0.433770001f, 0.755605817f, 0.349508345f, -0.851067066f, 1.01720726f, -0.0711843669f, + -0.427236468f, -1.99652624f, 0.34384349f, -1.21430302f, -0.1933382f, -2.33479309f, + -0.230848357f, -0.465642095f, 1.2489084f, -0.512278616f, 1.40072012f, -0.431816399f, + 0.934283912f, -0.51727283f, 0.546594501f, -0.441318065f, -0.0376381278f, -1.42697167f, + 0.984054267f, -1.38630164f, -0.566297114f, 0.18984212f, -1.10628676f, -0.221855938f, + 0.340159744f, 0.594956398f, -0.433770001f, 0.755605817f, 0.349508345f, -0.851067066f, + 1.01720726f, -0.0711843669f, -0.427236468f, -1.99652624f, 0.34384349f, -1.21430302f, + -0.1933382f, -2.33479309f, -0.230848357f, -0.465642095f, 1.2489084f, -0.512278616f, + 1.40072012f, -0.431816399f, 0.934283912f, -0.51727283f, 0.546594501f, -0.441318065f, + -0.0376381278f, -1.42697167f, 0.984054267f, -1.38630164f, -0.566297114f, 0.18984212f, + -1.10628676f, -0.221855938f, 0.340159744f, 0.594956398f, -0.433770001f, 0.755605817f, + 0.349508345f, -0.851067066f, 1.01720726f, -0.0711843669f, -0.427236468f, -1.99652624f, + 0.34384349f, -1.21430302f, -0.1933382f, -2.33479309f, -0.230848357f, -0.465642095f, + 1.2489084f, -0.512278616f, 1.40072012f, -0.431816399f, 0.934283912f, -0.51727283f, + 0.546594501f, -0.441318065f, -0.0376381278f, -1.42697167f, 0.984054267f, -1.38630164f, + -0.566297114f, 0.18984212f, -1.10628676f, -0.221855938f, 0.340159744f, 0.594956398f, + -0.433770001f, 0.755605817f, 0.349508345f, -0.851067066f, 1.01720726f, -0.0711843669f, + -0.427236468f, -1.99652624f, 0.34384349f, -1.21430302f, -0.1933382f, -2.33479309f, + -0.230848357f, -0.465642095f, 1.2489084f, -0.512278616f, 1.40072012f, -0.431816399f, + 0.934283912f, -0.51727283f, 0.546594501f, -0.441318065f, -0.0376381278f, -1.42697167f, + 0.984054267f, -1.38630164f, -0.566297114f, 0.18984212f, -1.10628676f, -0.221855938f, + 0.340159744f, 0.594956398f, -0.433770001f, 0.755605817f, 0.349508345f, -0.851067066f, + 1.01720726f, -0.0711843669f, -0.427236468f, -1.99652624f, 0.34384349f, -1.21430302f, + -0.1933382f, -2.33479309f, -0.230848357f, -0.465642095f, 1.2489084f, -0.512278616f, + 1.40072012f, -0.431816399f, 0.934283912f, -0.51727283f, 0.546594501f, -0.441318065f, + -0.0376381278f, -1.42697167f, 0.984054267f, -1.38630164f, -0.566297114f, 0.18984212f, + -1.10628676f, -0.221855938f, 0.340159744f, 0.594956398f, -0.433770001f, 0.755605817f, + 0.349508345f, -0.851067066f, 1.01720726f, -0.0711843669f, -0.427236468f, -1.99652624f, + 0.34384349f, -1.21430302f, -0.1933382f, -2.33479309f, -0.230848357f, -0.465642095f, + 1.2489084f, -0.512278616f, 1.40072012f, -0.431816399f, 0.934283912f, -0.51727283f, + 0.546594501f, -0.441318065f, -0.0376381278f, -1.42697167f, 0.984054267f, -1.38630164f, + -0.566297114f, 0.18984212f, -1.10628676f, -0.221855938f, 0.340159744f, 0.594956398f, + -0.433770001f, 0.755605817f, 0.349508345f, -0.851067066f, 1.01720726f, -0.0711843669f, + -0.427236468f, -1.99652624f, 0.34384349f, -1.21430302f, -0.1933382f, -2.33479309f, + -0.230848357f, -0.465642095f, 1.2489084f, -0.512278616f, 1.40072012f, -0.431816399f, + 0.934283912f, -0.51727283f, 0.546594501f, -0.441318065f, -0.0376381278f, -1.42697167f, + 0.984054267f, -1.38630164f, -0.566297114f, 0.18984212f, -1.10628676f, -0.221855938f, + 0.340159744f, 0.594956398f, -0.433770001f, 0.755605817f, 0.349508345f, -0.851067066f, + 1.01720726f, -0.0711843669f, -0.427236468f, -1.99652624f, 0.34384349f, -1.21430302f, + -0.1933382f, -2.33479309f, -0.230848357f, -0.465642095f, 1.2489084f, -0.512278616f, + 1.40072012f, -0.431816399f, 0.934283912f, -0.51727283f, 0.546594501f, -0.441318065f, + -0.0376381278f, -1.42697167f, 0.984054267f, -1.38630164f, -0.566297114f, 0.18984212f, + -1.10628676f, -0.221855938f, 0.340159744f, 0.594956398f, -0.433770001f, 0.755605817f, + 0.349508345f, -0.851067066f, 1.01720726f, -0.0711843669f, -0.427236468f, -1.99652624f, + 0.34384349f, -1.21430302f, -0.1933382f, -2.33479309f, -0.230848357f, -0.465642095f, + 1.2489084f, -0.512278616f, 1.40072012f, -0.431816399f, 0.934283912f, -0.51727283f, + 0.546594501f, -0.441318065f, -0.0376381278f, -1.42697167f, 0.984054267f, -1.38630164f, + -0.566297114f, 0.18984212f, -1.10628676f, -0.221855938f, 0.340159744f, 0.594956398f, + -1.98886085f, -0.161533013f, -0.767248511f, 1.01953781f, 2.21974063f, -0.224783361f, + 0.650467873f, 2.76067042f, 0.67104578f, -0.614901066f, -1.25036561f, 0.972369254f, + 0.293569535f, -0.274536461f, 1.60135472f, 0.0462248959f, 0.673270881f, -0.301604062f, + 2.34471965f, 0.0311507694f, -1.75879371f, 0.420391083f, 2.8137219f, -1.24765635f, + -1.49731588f, -1.04393268f, 0.095809713f, -2.37909365f, -0.265560567f, -1.05342603f, + 1.31991398f, -0.289815426f, -0.30631578f, -1.25914049f, 1.54125512f, 1.15922856f, + -0.265958905f, -0.175289124f, 1.48632967f, 2.41660357f, 0.612802684f, -1.56944323f, + -0.801020563f, 1.46623468f, 1.68214548f, -0.310023785f, 0.498262644f, -1.61938691f, + -1.16377735f, -0.151860133f, 1.07389152f, -3.25862741f, -1.21410131f, 0.991703808f, + 1.15240383f, -1.05130494f, -3.23364806f, -1.45446396f, -0.431719571f, -0.717480958f, + 1.04536748f, 0.436771333f, -0.476053506f, 0.203860834f, -0.0265636593f, -2.84084225f, + 1.28741896f, 0.774901688f, -0.0671837702f, 0.77377665f, -0.940532625f, 1.33604848f, + 0.642396808f, -0.47878471f, -0.436206907f, 0.219888717f, 0.255922556f, -0.973073244f, + 0.68038857f, -1.11182797f, 0.667417169f, -3.12759757f, 1.32684743f, -0.449378729f, + 1.92889833f, 0.0183931794f, 3.44997644f, -0.291030198f, -2.73255825f, -1.49776995f, + 1.5917964f, -0.166809529f, -0.158464953f, -0.45457083f, 2.4870863f, 0.639203668f, + 1.49144256f, -1.00002253f, 1.75339353f, 0.632306457f, -0.606394529f, 0.130232751f, + -0.901771665f, -2.7071867f, -1.22307718f, 3.02341795f, -1.13129365f, 0.149112016f, + -0.345503896f, 2.54521394f, 0.104782209f, 0.311388195f, -0.709555864f, -0.135203704f, + 2.01142311f, -1.20674562f, -0.165327236f, 0.508106291f, -1.99352217f, 1.15098381f, + 0.572008848f, -0.979201794f, -0.675259173f, 0.133523166f, 0.677297294f, 2.28855944f, + 1.65192556f, 1.79343069f, -1.63667917f, -1.16576838f, -0.32033807f, -0.205367506f, + -0.0302636214f, 0.121686734f, 0.630567789f, 2.34748912f, 1.83828008f, -0.763331592f, + -0.109890327f, 0.847685575f, 1.90958405f, -1.47753549f, -0.133232683f, -2.06883883f, + -0.908194721f, -0.784403682f, -1.20181692f, -3.06987381f, -1.51086128f, -0.36165604f, + -0.902179122f, -0.292360902f, -1.38245881f, 1.33951604f, -0.571103394f, -1.25618947f, + 0.476130038f, -1.61207187f, -0.283086628f, 0.602477252f, 0.637224555f, 0.437164336f, + 0.667343438f, 2.33977318f, -0.851174474f, 1.28994226f, -1.11364388f, -0.108714893f, + 2.08834529f, 3.30353713f, -1.98507571f, 1.28553224f, 1.44864535f, -0.33821708f, + -0.600777805f, 0.447428674f, -2.02474713f, 0.08626239f, 1.5738132f, -1.51757777f, + -0.664806366f, 0.080807291f, -2.50854897f, -0.283403039f, 1.64871252f, -0.477891505f, + 0.203556404f, -1.64373922f, 0.593579113f, 2.26764321f, 0.13872619f, 1.8034035f, + 1.15324223f, -1.42396784f, -1.44539225f, -0.182933956f, 2.97036314f, -0.631644607f, + -1.90151179f, 0.168508962f, -1.37633598f, -2.41606283f, 1.68950546f, -1.09449983f, + 1.09316671f, 2.02546191f, -0.0919578895f, -1.32638228f, -1.19337904f, -0.208551168f, + 0.968132734f, 0.866139114f, 0.140985519f, -1.13251209f, 0.316421896f, -0.96377331f, + 0.53603071f, 2.82450986f, -0.491189718f, 0.266211689f, 0.954997003f, 0.257930756f, + -1.1217463f, 0.30886963f, 1.60884786f, 3.2613101f, -0.518345296f, 1.96768546f, + 1.15511143f, -0.415646017f, -1.04215598f, -1.94319618f, -1.80034959f, 0.970089734f, + 0.811318457f, -1.86345124f, 0.20103991f, -0.00109709799f, -0.0157570411f, -0.655511439f, + -0.649728f, 2.91500592f, 0.744466424f, -0.521453917f, -1.05356979f, -0.344881296f, + -1.82803059f, -0.468131989f, 0.245427758f, 1.62624073f, 0.788545191f, 0.835015178f, + 0.952632129f, 2.09937024f, 0.599630117f, -0.38810128f, +}; + +inline constexpr float kLtxTowerPaddedStateF32_2[] = { + -0.817195654f, 1.78598189f, 2.80523515f, 0.321772784f, -2.2113297f, -0.56185782f, + -1.40183878f, -2.5610981f, 0.06667611f, -1.73667967f, -0.227453738f, -3.30554581f, + -0.345415801f, 0.163556129f, 0.880430937f, -1.1589812f, 2.69497013f, -1.29716444f, + 1.19802499f, 1.06004846f, 0.986157358f, 0.573756635f, 1.28363907f, -1.53790724f, + 0.941186666f, -2.31988263f, -0.871981323f, 0.740769625f, -1.03433609f, 0.880560875f, + 1.51334238f, -0.646003008f, -0.817195654f, 1.78598189f, 2.80523515f, 0.321772784f, + -2.2113297f, -0.56185782f, -1.40183878f, -2.5610981f, 0.06667611f, -1.73667967f, + -0.227453738f, -3.30554581f, -0.345415801f, 0.163556129f, 0.880430937f, -1.1589812f, + 2.69497013f, -1.29716444f, 1.19802499f, 1.06004846f, 0.986157358f, 0.573756635f, + 1.28363907f, -1.53790724f, 0.941186666f, -2.31988263f, -0.871981323f, 0.740769625f, + -1.03433609f, 0.880560875f, 1.51334238f, -0.646003008f, -0.817195654f, 1.78598189f, + 2.80523515f, 0.321772784f, -2.2113297f, -0.56185782f, -1.40183878f, -2.5610981f, + 0.06667611f, -1.73667967f, -0.227453738f, -3.30554581f, -0.345415801f, 0.163556129f, + 0.880430937f, -1.1589812f, 2.69497013f, -1.29716444f, 1.19802499f, 1.06004846f, + 0.986157358f, 0.573756635f, 1.28363907f, -1.53790724f, 0.941186666f, -2.31988263f, + -0.871981323f, 0.740769625f, -1.03433609f, 0.880560875f, 1.51334238f, -0.646003008f, + -0.817195654f, 1.78598189f, 2.80523515f, 0.321772784f, -2.2113297f, -0.56185782f, + -1.40183878f, -2.5610981f, 0.06667611f, -1.73667967f, -0.227453738f, -3.30554581f, + -0.345415801f, 0.163556129f, 0.880430937f, -1.1589812f, 2.69497013f, -1.29716444f, + 1.19802499f, 1.06004846f, 0.986157358f, 0.573756635f, 1.28363907f, -1.53790724f, + 0.941186666f, -2.31988263f, -0.871981323f, 0.740769625f, -1.03433609f, 0.880560875f, + 1.51334238f, -0.646003008f, -0.817195654f, 1.78598189f, 2.80523515f, 0.321772784f, + -2.2113297f, -0.56185782f, -1.40183878f, -2.5610981f, 0.06667611f, -1.73667967f, + -0.227453738f, -3.30554581f, -0.345415801f, 0.163556129f, 0.880430937f, -1.1589812f, + 2.69497013f, -1.29716444f, 1.19802499f, 1.06004846f, 0.986157358f, 0.573756635f, + 1.28363907f, -1.53790724f, 0.941186666f, -2.31988263f, -0.871981323f, 0.740769625f, + -1.03433609f, 0.880560875f, 1.51334238f, -0.646003008f, -0.817195654f, 1.78598189f, + 2.80523515f, 0.321772784f, -2.2113297f, -0.56185782f, -1.40183878f, -2.5610981f, + 0.06667611f, -1.73667967f, -0.227453738f, -3.30554581f, -0.345415801f, 0.163556129f, + 0.880430937f, -1.1589812f, 2.69497013f, -1.29716444f, 1.19802499f, 1.06004846f, + 0.986157358f, 0.573756635f, 1.28363907f, -1.53790724f, 0.941186666f, -2.31988263f, + -0.871981323f, 0.740769625f, -1.03433609f, 0.880560875f, 1.51334238f, -0.646003008f, + -0.817195654f, 1.78598189f, 2.80523515f, 0.321772784f, -2.2113297f, -0.56185782f, + -1.40183878f, -2.5610981f, 0.06667611f, -1.73667967f, -0.227453738f, -3.30554581f, + -0.345415801f, 0.163556129f, 0.880430937f, -1.1589812f, 2.69497013f, -1.29716444f, + 1.19802499f, 1.06004846f, 0.986157358f, 0.573756635f, 1.28363907f, -1.53790724f, + 0.941186666f, -2.31988263f, -0.871981323f, 0.740769625f, -1.03433609f, 0.880560875f, + 1.51334238f, -0.646003008f, -0.817195654f, 1.78598189f, 2.80523515f, 0.321772784f, + -2.2113297f, -0.56185782f, -1.40183878f, -2.5610981f, 0.06667611f, -1.73667967f, + -0.227453738f, -3.30554581f, -0.345415801f, 0.163556129f, 0.880430937f, -1.1589812f, + 2.69497013f, -1.29716444f, 1.19802499f, 1.06004846f, 0.986157358f, 0.573756635f, + 1.28363907f, -1.53790724f, 0.941186666f, -2.31988263f, -0.871981323f, 0.740769625f, + -1.03433609f, 0.880560875f, 1.51334238f, -0.646003008f, -0.817195654f, 1.78598189f, + 2.80523515f, 0.321772784f, -2.2113297f, -0.56185782f, -1.40183878f, -2.5610981f, + 0.06667611f, -1.73667967f, -0.227453738f, -3.30554581f, -0.345415801f, 0.163556129f, + 0.880430937f, -1.1589812f, 2.69497013f, -1.29716444f, 1.19802499f, 1.06004846f, + 0.986157358f, 0.573756635f, 1.28363907f, -1.53790724f, 0.941186666f, -2.31988263f, + -0.871981323f, 0.740769625f, -1.03433609f, 0.880560875f, 1.51334238f, -0.646003008f, + -0.817195654f, 1.78598189f, 2.80523515f, 0.321772784f, -2.2113297f, -0.56185782f, + -1.40183878f, -2.5610981f, 0.06667611f, -1.73667967f, -0.227453738f, -3.30554581f, + -0.345415801f, 0.163556129f, 0.880430937f, -1.1589812f, 2.69497013f, -1.29716444f, + 1.19802499f, 1.06004846f, 0.986157358f, 0.573756635f, 1.28363907f, -1.53790724f, + 0.941186666f, -2.31988263f, -0.871981323f, 0.740769625f, -1.03433609f, 0.880560875f, + 1.51334238f, -0.646003008f, -0.817195654f, 1.78598189f, 2.80523515f, 0.321772784f, + -2.2113297f, -0.56185782f, -1.40183878f, -2.5610981f, 0.06667611f, -1.73667967f, + -0.227453738f, -3.30554581f, -0.345415801f, 0.163556129f, 0.880430937f, -1.1589812f, + 2.69497013f, -1.29716444f, 1.19802499f, 1.06004846f, 0.986157358f, 0.573756635f, + 1.28363907f, -1.53790724f, 0.941186666f, -2.31988263f, -0.871981323f, 0.740769625f, + -1.03433609f, 0.880560875f, 1.51334238f, -0.646003008f, -0.817195654f, 1.78598189f, + 2.80523515f, 0.321772784f, -2.2113297f, -0.56185782f, -1.40183878f, -2.5610981f, + 0.06667611f, -1.73667967f, -0.227453738f, -3.30554581f, -0.345415801f, 0.163556129f, + 0.880430937f, -1.1589812f, 2.69497013f, -1.29716444f, 1.19802499f, 1.06004846f, + 0.986157358f, 0.573756635f, 1.28363907f, -1.53790724f, 0.941186666f, -2.31988263f, + -0.871981323f, 0.740769625f, -1.03433609f, 0.880560875f, 1.51334238f, -0.646003008f, + -3.33602643f, 1.38034976f, -1.09736311f, 0.369083762f, 2.1213448f, 0.0179143585f, + -0.573706329f, 0.99459523f, 1.6684984f, -0.609581351f, -2.89156318f, 1.76444817f, + -2.18246293f, -1.98946178f, 4.15764332f, 1.26136172f, -1.06169498f, 2.0369215f, + 2.66516733f, -1.03545225f, -2.71756887f, 0.345697939f, 2.78603292f, -1.61341357f, + -0.416000634f, -1.53710818f, -2.1350317f, 0.647517264f, 1.31271732f, -2.18382716f, + 1.52610838f, 0.529773831f, -3.03355598f, -1.35667944f, 2.11285591f, 1.76925611f, + -1.32635832f, -1.17310393f, 1.33510387f, 4.43243313f, 2.82520199f, 0.275970906f, + -1.98885691f, 0.949353874f, -0.811743855f, 0.450002164f, 1.37089264f, -2.00190234f, + -2.07053161f, -0.194285318f, 1.59363163f, -4.95765352f, 0.237132743f, 0.68529439f, + 2.40496421f, -1.84623432f, -2.22342873f, -1.79952109f, 0.522076488f, 2.18993759f, + 3.02512026f, -0.143188015f, -0.753290832f, -1.11415732f, -0.770203233f, -5.0472312f, + 1.14643049f, 1.68933463f, 0.211407617f, 0.286591023f, -3.60934496f, 1.69267952f, + 1.30492687f, -2.13472104f, -2.05770898f, -1.01953828f, -2.550457f, -3.80489397f, + 0.755630732f, -1.05458236f, -1.36714804f, -2.93418813f, 2.78120923f, -2.76251531f, + 1.71678412f, 0.855482876f, 4.7215519f, -1.447873f, -1.30497622f, -0.789352417f, + 1.16152573f, 3.42396855f, -0.200219035f, -2.46305513f, 2.41207194f, 0.979083478f, + 0.350380868f, -0.166144758f, 3.42020965f, -1.49596655f, 1.83858812f, -2.14805102f, + 0.621272743f, -4.49891615f, -0.828520715f, 0.647504091f, -1.44480515f, -2.37227893f, + -0.998114526f, 2.70375681f, -0.656378031f, 2.30941153f, -0.922689497f, 1.25135922f, + -1.05960643f, -2.89404321f, 0.00986304972f, 0.748238385f, -2.22822762f, 0.476626694f, + -0.18835938f, 0.381056011f, -1.1764791f, 0.108974919f, 3.1238451f, 4.5676322f, + 0.328201652f, 1.45811903f, -1.07248294f, -3.28176928f, -0.710666299f, 0.532594979f, + -0.261217892f, 0.516261876f, -0.258798063f, 4.00530958f, 3.4207828f, 2.82841158f, + 0.417595208f, 1.43562615f, 0.0262823366f, -1.79211664f, 1.31350088f, -4.89044762f, + -0.894658148f, -1.88089383f, -0.132363856f, -3.5623951f, 0.099839136f, 0.26791507f, + -0.632604241f, -2.22200298f, -2.18963718f, 1.81562281f, 1.28787374f, 1.23317623f, + 0.00617384445f, -2.21373153f, -2.30115056f, -0.371310323f, 2.73077822f, -1.39894426f, + 2.13341665f, 0.598042846f, 0.738605857f, 2.82453609f, -1.73271763f, -2.33198643f, + 2.68565893f, 2.8065722f, -0.246829286f, 0.714734316f, 0.284567297f, 0.253949523f, + 0.312478542f, -0.779141009f, -2.50853372f, -1.02553332f, 1.47277629f, -1.91645873f, + 2.0836134f, -1.27143753f, -2.25192595f, -1.90554309f, 0.571509302f, 2.33204532f, + 1.79024482f, -1.26949811f, -1.72168481f, 3.15852284f, 0.0678512901f, 3.67820454f, + 3.21147847f, -0.458659053f, -3.03419805f, -1.29854405f, 2.34733653f, -1.12480497f, + -2.84915543f, -1.06289124f, -0.304517925f, -2.28788686f, -0.241911173f, -0.749902189f, + -0.763695121f, 0.889834642f, 1.26291049f, 0.232054681f, -3.64003611f, 2.22192764f, + -0.2252855f, -1.09948242f, -2.50494957f, -2.24995327f, 1.75262547f, -0.169535592f, + 2.58954978f, 4.06241941f, -0.00502433255f, 2.56465054f, 2.51882195f, 0.309558779f, + -0.0309196152f, 0.245810539f, 2.87697554f, 3.65372944f, 0.816191435f, 1.35332179f, + 0.479074776f, -1.67067742f, -1.4906863f, -4.03290176f, -5.56160831f, 0.34615472f, + -0.327657729f, -0.525365472f, 0.750033617f, 0.786531746f, 0.087211147f, 0.462557614f, + -0.793803453f, 4.78909636f, 0.109938323f, -3.1718998f, -2.6276176f, -2.00504351f, + 2.53156614f, 0.383899391f, 2.17760181f, -0.931892514f, -1.00043201f, 0.579354882f, + 1.26393747f, 2.19797206f, 0.552204072f, 0.546010911f, +}; + +inline constexpr float kLtxTowerPaddedStateF32_3[] = { + -0.308454871f, 2.0162344f, 2.61621714f, 0.220649257f, -2.7621336f, -0.848266065f, + -0.293332756f, -2.34952736f, 0.0840880498f, -0.636105299f, 1.01803529f, -3.98714089f, + 0.90635556f, -0.234005123f, -2.39145827f, -0.978492439f, 1.18548334f, -1.77522862f, + 0.815743506f, 0.705357313f, 1.49866021f, 0.871145308f, 2.13691592f, -1.86757505f, + 0.362428993f, -2.91565776f, -0.375970662f, 1.04731929f, -1.84769964f, 0.478482664f, + -0.174804971f, -2.59919429f, -0.308454871f, 2.0162344f, 2.61621714f, 0.220649257f, + -2.7621336f, -0.848266065f, -0.293332756f, -2.34952736f, 0.0840880498f, -0.636105299f, + 1.01803529f, -3.98714089f, 0.90635556f, -0.234005123f, -2.39145827f, -0.978492439f, + 1.18548334f, -1.77522862f, 0.815743506f, 0.705357313f, 1.49866021f, 0.871145308f, + 2.13691592f, -1.86757505f, 0.362428993f, -2.91565776f, -0.375970662f, 1.04731929f, + -1.84769964f, 0.478482664f, -0.174804971f, -2.59919429f, -0.308454871f, 2.0162344f, + 2.61621714f, 0.220649257f, -2.7621336f, -0.848266065f, -0.293332756f, -2.34952736f, + 0.0840880498f, -0.636105299f, 1.01803529f, -3.98714089f, 0.90635556f, -0.234005123f, + -2.39145827f, -0.978492439f, 1.18548334f, -1.77522862f, 0.815743506f, 0.705357313f, + 1.49866021f, 0.871145308f, 2.13691592f, -1.86757505f, 0.362428993f, -2.91565776f, + -0.375970662f, 1.04731929f, -1.84769964f, 0.478482664f, -0.174804971f, -2.59919429f, + -0.308454871f, 2.0162344f, 2.61621714f, 0.220649257f, -2.7621336f, -0.848266065f, + -0.293332756f, -2.34952736f, 0.0840880498f, -0.636105299f, 1.01803529f, -3.98714089f, + 0.90635556f, -0.234005123f, -2.39145827f, -0.978492439f, 1.18548334f, -1.77522862f, + 0.815743506f, 0.705357313f, 1.49866021f, 0.871145308f, 2.13691592f, -1.86757505f, + 0.362428993f, -2.91565776f, -0.375970662f, 1.04731929f, -1.84769964f, 0.478482664f, + -0.174804971f, -2.59919429f, -0.308454871f, 2.0162344f, 2.61621714f, 0.220649257f, + -2.7621336f, -0.848266065f, -0.293332756f, -2.34952736f, 0.0840880498f, -0.636105299f, + 1.01803529f, -3.98714089f, 0.90635556f, -0.234005123f, -2.39145827f, -0.978492439f, + 1.18548334f, -1.77522862f, 0.815743506f, 0.705357313f, 1.49866021f, 0.871145308f, + 2.13691592f, -1.86757505f, 0.362428993f, -2.91565776f, -0.375970662f, 1.04731929f, + -1.84769964f, 0.478482664f, -0.174804971f, -2.59919429f, -0.308454871f, 2.0162344f, + 2.61621714f, 0.220649257f, -2.7621336f, -0.848266065f, -0.293332756f, -2.34952736f, + 0.0840880498f, -0.636105299f, 1.01803529f, -3.98714089f, 0.90635556f, -0.234005123f, + -2.39145827f, -0.978492439f, 1.18548334f, -1.77522862f, 0.815743506f, 0.705357313f, + 1.49866021f, 0.871145308f, 2.13691592f, -1.86757505f, 0.362428993f, -2.91565776f, + -0.375970662f, 1.04731929f, -1.84769964f, 0.478482664f, -0.174804971f, -2.59919429f, + -0.308454871f, 2.0162344f, 2.61621714f, 0.220649257f, -2.7621336f, -0.848266065f, + -0.293332756f, -2.34952736f, 0.0840880498f, -0.636105299f, 1.01803529f, -3.98714089f, + 0.90635556f, -0.234005123f, -2.39145827f, -0.978492439f, 1.18548334f, -1.77522862f, + 0.815743506f, 0.705357313f, 1.49866021f, 0.871145308f, 2.13691592f, -1.86757505f, + 0.362428993f, -2.91565776f, -0.375970662f, 1.04731929f, -1.84769964f, 0.478482664f, + -0.174804971f, -2.59919429f, -0.308454871f, 2.0162344f, 2.61621714f, 0.220649257f, + -2.7621336f, -0.848266065f, -0.293332756f, -2.34952736f, 0.0840880498f, -0.636105299f, + 1.01803529f, -3.98714089f, 0.90635556f, -0.234005123f, -2.39145827f, -0.978492439f, + 1.18548334f, -1.77522862f, 0.815743506f, 0.705357313f, 1.49866021f, 0.871145308f, + 2.13691592f, -1.86757505f, 0.362428993f, -2.91565776f, -0.375970662f, 1.04731929f, + -1.84769964f, 0.478482664f, -0.174804971f, -2.59919429f, -0.308454871f, 2.0162344f, + 2.61621714f, 0.220649257f, -2.7621336f, -0.848266065f, -0.293332756f, -2.34952736f, + 0.0840880498f, -0.636105299f, 1.01803529f, -3.98714089f, 0.90635556f, -0.234005123f, + -2.39145827f, -0.978492439f, 1.18548334f, -1.77522862f, 0.815743506f, 0.705357313f, + 1.49866021f, 0.871145308f, 2.13691592f, -1.86757505f, 0.362428993f, -2.91565776f, + -0.375970662f, 1.04731929f, -1.84769964f, 0.478482664f, -0.174804971f, -2.59919429f, + -0.308454871f, 2.0162344f, 2.61621714f, 0.220649257f, -2.7621336f, -0.848266065f, + -0.293332756f, -2.34952736f, 0.0840880498f, -0.636105299f, 1.01803529f, -3.98714089f, + 0.90635556f, -0.234005123f, -2.39145827f, -0.978492439f, 1.18548334f, -1.77522862f, + 0.815743506f, 0.705357313f, 1.49866021f, 0.871145308f, 2.13691592f, -1.86757505f, + 0.362428993f, -2.91565776f, -0.375970662f, 1.04731929f, -1.84769964f, 0.478482664f, + -0.174804971f, -2.59919429f, -0.308454871f, 2.0162344f, 2.61621714f, 0.220649257f, + -2.7621336f, -0.848266065f, -0.293332756f, -2.34952736f, 0.0840880498f, -0.636105299f, + 1.01803529f, -3.98714089f, 0.90635556f, -0.234005123f, -2.39145827f, -0.978492439f, + 1.18548334f, -1.77522862f, 0.815743506f, 0.705357313f, 1.49866021f, 0.871145308f, + 2.13691592f, -1.86757505f, 0.362428993f, -2.91565776f, -0.375970662f, 1.04731929f, + -1.84769964f, 0.478482664f, -0.174804971f, -2.59919429f, -0.308454871f, 2.0162344f, + 2.61621714f, 0.220649257f, -2.7621336f, -0.848266065f, -0.293332756f, -2.34952736f, + 0.0840880498f, -0.636105299f, 1.01803529f, -3.98714089f, 0.90635556f, -0.234005123f, + -2.39145827f, -0.978492439f, 1.18548334f, -1.77522862f, 0.815743506f, 0.705357313f, + 1.49866021f, 0.871145308f, 2.13691592f, -1.86757505f, 0.362428993f, -2.91565776f, + -0.375970662f, 1.04731929f, -1.84769964f, 0.478482664f, -0.174804971f, -2.59919429f, + -4.62408972f, 1.41430128f, -1.27646315f, 1.5123924f, 2.53752446f, 2.64778066f, + 1.45493925f, 0.550230742f, -0.499934822f, 0.217706457f, -4.22821283f, 1.93419075f, + -4.78617048f, -4.08878136f, 3.98168635f, 0.87554419f, 1.49893427f, 4.53367138f, + 3.95623779f, -1.91546273f, -3.01503682f, 3.40431356f, 4.44517899f, -3.78030872f, + 1.53354096f, -0.567785203f, -4.26043558f, 0.916204691f, 2.81639576f, -2.52821851f, + -0.520380497f, 0.734793663f, -2.95599771f, -1.85245013f, 3.06701136f, 2.39221907f, + 0.379837334f, 0.801000655f, 2.90783024f, 2.41729593f, 1.05457997f, -1.10409021f, + -3.47040701f, 1.52326465f, -2.259758f, -0.937417746f, 0.638614237f, -1.54408085f, + 1.18064678f, 1.96129322f, 1.32688177f, -4.60422325f, 0.469833463f, 3.86535454f, + 5.02937126f, -3.1551671f, -1.4783504f, -0.878624201f, -0.0994565263f, 1.77965188f, + 3.93133092f, 0.497385025f, -2.34844351f, -1.25530839f, -1.25624371f, -7.00368214f, + 2.6584487f, 1.55193996f, 1.8789885f, 3.12138629f, -2.63576078f, -0.522408187f, + 0.13223657f, -2.26665878f, -2.18062639f, 0.0747165978f, -3.62868977f, -6.29519939f, + -0.279996872f, -2.37196779f, 1.2901094f, -0.827016354f, 2.20898914f, -4.4509654f, + 2.60748196f, 1.94536436f, 7.39381933f, -3.66375923f, 0.873686492f, -0.241233781f, + 0.636552811f, 3.76143479f, 1.90901804f, -0.0342381187f, 1.49700689f, 1.64508259f, + 1.45100141f, 1.13833642f, 6.38964796f, -2.22645283f, 2.09769106f, -0.535243809f, + 1.08840775f, -5.24708271f, -3.14094377f, 0.0691219419f, -3.509758f, -2.66271996f, + -2.59777856f, 2.4748559f, -1.34081316f, 0.355470121f, -0.145867273f, 1.96931911f, + 0.358712763f, -3.21990943f, 1.25791836f, 1.39949656f, 1.25224793f, -1.90373576f, + -0.618343174f, -0.356607884f, -0.0751636997f, 0.588063776f, 1.0832026f, 4.71839857f, + 0.913038194f, 0.37490347f, 0.0997419059f, -3.19986057f, -0.80578059f, 3.84246206f, + -2.87999296f, 0.800070405f, 1.38343561f, 6.19318867f, 2.19088435f, 0.590590358f, + 2.09620762f, 0.236692294f, 0.538163841f, -0.42029047f, 0.782603681f, -5.10916615f, + -2.96164036f, -1.6167475f, 0.0725620985f, -2.96585751f, 2.6776607f, -1.77616739f, + 1.09871697f, -0.472761214f, -4.04857254f, 2.03864503f, 1.79774821f, 0.33365038f, + -1.37170899f, -2.32835984f, -0.758737922f, -0.283138037f, 5.24659443f, -2.30188584f, + -0.231487125f, 0.740843117f, -2.17022657f, 2.08424401f, -1.52083576f, 0.00668700971f, + 3.45457935f, 3.63822055f, -0.14963533f, 0.981996775f, 1.54970896f, 2.15139985f, + -0.894924104f, -2.78573656f, -3.0529654f, -1.05774605f, 0.82830739f, -0.0112429354f, + 4.10028887f, -1.42147434f, 0.0773144141f, -0.362290829f, -1.95927048f, 3.55703425f, + 2.6894629f, -0.12657471f, -1.35866261f, 3.31139421f, -1.45877612f, 6.22298336f, + 4.73708391f, -1.96700728f, -3.61718726f, -1.93594444f, 5.86519909f, -1.25871825f, + -1.99339366f, -4.52848625f, 1.01141608f, -3.12320638f, 1.28890777f, -2.48972344f, + 1.81892312f, 0.970252514f, 1.59880316f, -1.21354795f, -4.3056488f, 3.31475949f, + -1.77675283f, -2.01017189f, -4.0715766f, -4.05385828f, 4.55550098f, -0.33587113f, + 1.32094955f, 3.84346938f, 0.77734071f, 2.24306178f, 2.04568243f, 0.651385963f, + 0.0991551057f, -2.11703205f, 2.13421106f, 4.24084234f, 4.1594882f, 0.755002916f, + -0.367522597f, 0.034127675f, -2.38654065f, -4.07276678f, -7.40186119f, -0.428712547f, + -0.859261215f, -3.04533625f, 0.0684274435f, 0.703714788f, -1.25547159f, -1.6428411f, + -1.37262607f, 6.34524345f, 0.829199195f, -2.27742314f, -1.63645589f, -1.51034212f, + 4.39880371f, 0.0113883298f, 1.23504627f, -1.59028864f, -0.220352367f, 1.01576102f, + 0.76365149f, 4.87786961f, 0.328210533f, 1.08531308f, +}; + +inline constexpr float kLtxTowerPaddedStateF32_4[] = { + 0.905743062f, 2.4465611f, 3.15237021f, 1.34620404f, -1.66112959f, -0.449806243f, + 0.994887114f, -1.62693775f, -1.36469603f, -1.22012472f, -0.0767695606f, -3.99218893f, + 0.2721093f, 1.28985775f, -2.47501802f, -0.489204884f, 0.53827399f, -2.30264068f, + 1.45666873f, 0.237113476f, -0.227423877f, 0.0518611372f, 3.22442055f, -0.151570439f, + 0.622937083f, -2.26988506f, -1.44769335f, 0.384813458f, -1.99935925f, -0.657097042f, + 0.390910178f, -3.48270273f, 0.905743062f, 2.4465611f, 3.15237021f, 1.34620404f, + -1.66112959f, -0.449806243f, 0.994887114f, -1.62693775f, -1.36469603f, -1.22012472f, + -0.0767695606f, -3.99218893f, 0.2721093f, 1.28985775f, -2.47501802f, -0.489204884f, + 0.53827399f, -2.30264068f, 1.45666873f, 0.237113476f, -0.227423877f, 0.0518611372f, + 3.22442055f, -0.151570439f, 0.622937083f, -2.26988506f, -1.44769335f, 0.384813458f, + -1.99935925f, -0.657097042f, 0.390910178f, -3.48270273f, 0.905743062f, 2.4465611f, + 3.15237021f, 1.34620404f, -1.66112959f, -0.449806243f, 0.994887114f, -1.62693775f, + -1.36469603f, -1.22012472f, -0.0767695606f, -3.99218893f, 0.2721093f, 1.28985775f, + -2.47501802f, -0.489204884f, 0.53827399f, -2.30264068f, 1.45666873f, 0.237113476f, + -0.227423877f, 0.0518611372f, 3.22442055f, -0.151570439f, 0.622937083f, -2.26988506f, + -1.44769335f, 0.384813458f, -1.99935925f, -0.657097042f, 0.390910178f, -3.48270273f, + 0.905743062f, 2.4465611f, 3.15237021f, 1.34620404f, -1.66112959f, -0.449806243f, + 0.994887114f, -1.62693775f, -1.36469603f, -1.22012472f, -0.0767695606f, -3.99218893f, + 0.2721093f, 1.28985775f, -2.47501802f, -0.489204884f, 0.53827399f, -2.30264068f, + 1.45666873f, 0.237113476f, -0.227423877f, 0.0518611372f, 3.22442055f, -0.151570439f, + 0.622937083f, -2.26988506f, -1.44769335f, 0.384813458f, -1.99935925f, -0.657097042f, + 0.390910178f, -3.48270273f, 0.905743062f, 2.4465611f, 3.15237021f, 1.34620404f, + -1.66112959f, -0.449806243f, 0.994887114f, -1.62693775f, -1.36469603f, -1.22012472f, + -0.0767695606f, -3.99218893f, 0.2721093f, 1.28985775f, -2.47501802f, -0.489204884f, + 0.53827399f, -2.30264068f, 1.45666873f, 0.237113476f, -0.227423877f, 0.0518611372f, + 3.22442055f, -0.151570439f, 0.622937083f, -2.26988506f, -1.44769335f, 0.384813458f, + -1.99935925f, -0.657097042f, 0.390910178f, -3.48270273f, 0.905743062f, 2.4465611f, + 3.15237021f, 1.34620404f, -1.66112959f, -0.449806243f, 0.994887114f, -1.62693775f, + -1.36469603f, -1.22012472f, -0.0767695606f, -3.99218893f, 0.2721093f, 1.28985775f, + -2.47501802f, -0.489204884f, 0.53827399f, -2.30264068f, 1.45666873f, 0.237113476f, + -0.227423877f, 0.0518611372f, 3.22442055f, -0.151570439f, 0.622937083f, -2.26988506f, + -1.44769335f, 0.384813458f, -1.99935925f, -0.657097042f, 0.390910178f, -3.48270273f, + 0.905743062f, 2.4465611f, 3.15237021f, 1.34620404f, -1.66112959f, -0.449806243f, + 0.994887114f, -1.62693775f, -1.36469603f, -1.22012472f, -0.0767695606f, -3.99218893f, + 0.2721093f, 1.28985775f, -2.47501802f, -0.489204884f, 0.53827399f, -2.30264068f, + 1.45666873f, 0.237113476f, -0.227423877f, 0.0518611372f, 3.22442055f, -0.151570439f, + 0.622937083f, -2.26988506f, -1.44769335f, 0.384813458f, -1.99935925f, -0.657097042f, + 0.390910178f, -3.48270273f, 0.905743062f, 2.4465611f, 3.15237021f, 1.34620404f, + -1.66112959f, -0.449806243f, 0.994887114f, -1.62693775f, -1.36469603f, -1.22012472f, + -0.0767695606f, -3.99218893f, 0.2721093f, 1.28985775f, -2.47501802f, -0.489204884f, + 0.53827399f, -2.30264068f, 1.45666873f, 0.237113476f, -0.227423877f, 0.0518611372f, + 3.22442055f, -0.151570439f, 0.622937083f, -2.26988506f, -1.44769335f, 0.384813458f, + -1.99935925f, -0.657097042f, 0.390910178f, -3.48270273f, 0.905743062f, 2.4465611f, + 3.15237021f, 1.34620404f, -1.66112959f, -0.449806243f, 0.994887114f, -1.62693775f, + -1.36469603f, -1.22012472f, -0.0767695606f, -3.99218893f, 0.2721093f, 1.28985775f, + -2.47501802f, -0.489204884f, 0.53827399f, -2.30264068f, 1.45666873f, 0.237113476f, + -0.227423877f, 0.0518611372f, 3.22442055f, -0.151570439f, 0.622937083f, -2.26988506f, + -1.44769335f, 0.384813458f, -1.99935925f, -0.657097042f, 0.390910178f, -3.48270273f, + 0.905743062f, 2.4465611f, 3.15237021f, 1.34620404f, -1.66112959f, -0.449806243f, + 0.994887114f, -1.62693775f, -1.36469603f, -1.22012472f, -0.0767695606f, -3.99218893f, + 0.2721093f, 1.28985775f, -2.47501802f, -0.489204884f, 0.53827399f, -2.30264068f, + 1.45666873f, 0.237113476f, -0.227423877f, 0.0518611372f, 3.22442055f, -0.151570439f, + 0.622937083f, -2.26988506f, -1.44769335f, 0.384813458f, -1.99935925f, -0.657097042f, + 0.390910178f, -3.48270273f, 0.905743062f, 2.4465611f, 3.15237021f, 1.34620404f, + -1.66112959f, -0.449806243f, 0.994887114f, -1.62693775f, -1.36469603f, -1.22012472f, + -0.0767695606f, -3.99218893f, 0.2721093f, 1.28985775f, -2.47501802f, -0.489204884f, + 0.53827399f, -2.30264068f, 1.45666873f, 0.237113476f, -0.227423877f, 0.0518611372f, + 3.22442055f, -0.151570439f, 0.622937083f, -2.26988506f, -1.44769335f, 0.384813458f, + -1.99935925f, -0.657097042f, 0.390910178f, -3.48270273f, 0.905743062f, 2.4465611f, + 3.15237021f, 1.34620404f, -1.66112959f, -0.449806243f, 0.994887114f, -1.62693775f, + -1.36469603f, -1.22012472f, -0.0767695606f, -3.99218893f, 0.2721093f, 1.28985775f, + -2.47501802f, -0.489204884f, 0.53827399f, -2.30264068f, 1.45666873f, 0.237113476f, + -0.227423877f, 0.0518611372f, 3.22442055f, -0.151570439f, 0.622937083f, -2.26988506f, + -1.44769335f, 0.384813458f, -1.99935925f, -0.657097042f, 0.390910178f, -3.48270273f, + -7.09659529f, 1.09092796f, 0.221957535f, 3.88664937f, 2.03621531f, 4.74946785f, + 1.71300888f, 0.437405229f, 0.19550021f, 2.25704241f, -4.85564137f, 2.95899892f, + -5.70593643f, -6.23454905f, 1.36526835f, 2.05749822f, 4.10939264f, 3.15098763f, + 3.1633873f, -0.664293528f, -3.54874873f, 5.16659737f, 3.27077365f, -4.87856627f, + 0.580941558f, -2.15387249f, -1.6979475f, 2.77348185f, 5.88290691f, -0.95225358f, + -0.807212889f, 0.896836042f, -5.52221918f, -0.883055389f, 5.76438808f, 2.91977286f, + -0.737576127f, 3.96150422f, 2.62355852f, 2.82569313f, 1.87354696f, 0.573091149f, + -4.94552422f, 1.46844411f, -4.03369808f, -1.94093609f, -0.226558819f, 0.372553796f, + 1.73995268f, 0.235248923f, -0.0726867765f, -2.75010419f, 2.56369042f, 7.78646708f, + 6.28976583f, -3.80329323f, -0.334204108f, -2.63799977f, 1.57533872f, 4.18232536f, + 4.90967083f, 1.50934064f, -2.53220987f, -1.60658717f, -2.75976205f, -8.08213615f, + 4.07237244f, 2.625211f, 0.057020247f, 5.65304136f, -3.61695147f, -0.144273624f, + 2.59894228f, -1.71338904f, -4.14071417f, 1.03777111f, -3.63474011f, -7.47971439f, + -0.725398242f, -1.64404643f, 0.542665124f, -1.81714034f, 1.28913617f, -2.43218207f, + 2.75481558f, 4.08647728f, 7.22620058f, -5.24879885f, 0.268845081f, -0.285437882f, + 0.387204051f, 5.03215122f, 3.382936f, -0.41858077f, 2.86642313f, 2.09229732f, + -0.398557842f, 3.09662843f, 7.78116083f, -0.624533236f, 3.68102646f, -0.39580071f, + 1.86606407f, -3.64419079f, -3.75393152f, -0.822769403f, -4.92856503f, -2.58866525f, + -3.12310767f, 3.63605928f, -3.27885342f, 0.702775538f, 0.246456608f, 1.74175799f, + 1.24937034f, -1.92460334f, 1.81406796f, 3.4456706f, -0.0334208533f, -4.26519156f, + 0.176377892f, -1.59957206f, 0.0692838505f, 2.38320446f, 1.51618767f, 3.88784552f, + 1.56893206f, 0.29196018f, -2.29108858f, -2.9675324f, -0.0545736887f, 2.86586452f, + -2.89277506f, 4.10185242f, 0.555392623f, 6.98011732f, 3.33629036f, 0.380735636f, + 0.837032616f, 0.0588827804f, -1.67276871f, 0.230851173f, 2.2229867f, -4.84079695f, + -1.75561345f, -3.5021739f, -1.55019319f, -1.99959838f, 3.2161727f, 1.91920662f, + 1.70505393f, -0.00844826084f, -3.32572937f, -0.00563750416f, 1.85428095f, -0.108705454f, + -1.72008741f, -1.55906963f, -1.44399703f, 0.0397970378f, 3.47484255f, -2.0743618f, + -1.46815979f, -1.81692314f, -0.916010261f, 4.7950592f, -2.48546767f, -0.0582672767f, + 4.27826405f, 3.53852797f, -0.943232358f, 2.7613914f, 2.48359585f, 2.00232005f, + 0.882658005f, -1.30558801f, -2.25073051f, -4.49488115f, -0.10470105f, -2.13306546f, + 4.44581795f, 2.5255506f, -0.756203115f, -0.522532821f, -0.981387973f, 1.50030053f, + 3.51949f, 2.56651211f, -1.27313566f, 3.92623806f, -4.20914745f, 6.46449614f, + 4.59504175f, -2.2454443f, -4.69393206f, -1.30671525f, 8.60472679f, 0.655759931f, + -2.61844063f, -4.05181551f, -0.866610765f, -2.70959759f, 0.697725832f, -3.64417982f, + 4.2500267f, -0.571166635f, -0.145374596f, 1.26256323f, -1.98723865f, 4.23757601f, + -3.9381721f, -2.02071571f, -7.42495823f, -3.97785258f, 3.15230823f, -0.801289558f, + 3.11705923f, 2.0806067f, 1.2781868f, 4.42019558f, 3.09221268f, 0.933647096f, + 0.885742366f, -2.74886417f, 1.22407436f, 6.67368507f, 6.03192282f, 3.08989668f, + 0.657745242f, 1.20196378f, -2.040308f, -3.55700636f, -8.61368179f, -1.03550828f, + -2.41515422f, -1.12571335f, -0.152706638f, 0.971631527f, -1.11852372f, -2.47933078f, + 0.872603178f, 5.17396355f, 1.48110271f, -2.13338971f, -2.66797614f, 1.08610225f, + 3.76035976f, -2.13583422f, 1.907094f, -3.20744014f, -0.51924324f, 1.99709404f, + 0.778767467f, 5.46775055f, 0.915839016f, 0.250280082f, +}; + +inline constexpr float kLtxTowerPaddedStateF32_5[] = { + 1.14668226f, 1.75532305f, 2.29767275f, 0.906521976f, -1.90105069f, -0.561201155f, + 0.711975753f, -2.71241856f, -1.19429719f, -2.03620338f, 0.830003798f, -4.56849718f, + -0.00639008591f, -0.312803984f, -2.21442556f, 1.13124299f, 1.25901496f, -2.84291148f, + 1.03871489f, -0.537494898f, 0.371922791f, -1.17774379f, 2.90994549f, -1.62092268f, + 0.0430995524f, -2.32696033f, -3.22561932f, 1.11406398f, 0.133632064f, -0.273544401f, + 2.34395242f, -2.94559979f, 1.14668226f, 1.75532305f, 2.29767275f, 0.906521976f, + -1.90105069f, -0.561201155f, 0.711975753f, -2.71241856f, -1.19429719f, -2.03620338f, + 0.830003798f, -4.56849718f, -0.00639008591f, -0.312803984f, -2.21442556f, 1.13124299f, + 1.25901496f, -2.84291148f, 1.03871489f, -0.537494898f, 0.371922791f, -1.17774379f, + 2.90994549f, -1.62092268f, 0.0430995524f, -2.32696033f, -3.22561932f, 1.11406398f, + 0.133632064f, -0.273544401f, 2.34395242f, -2.94559979f, 1.14668226f, 1.75532305f, + 2.29767275f, 0.906521976f, -1.90105069f, -0.561201155f, 0.711975753f, -2.71241856f, + -1.19429719f, -2.03620338f, 0.830003798f, -4.56849718f, -0.00639008591f, -0.312803984f, + -2.21442556f, 1.13124299f, 1.25901496f, -2.84291148f, 1.03871489f, -0.537494898f, + 0.371922791f, -1.17774379f, 2.90994549f, -1.62092268f, 0.0430995524f, -2.32696033f, + -3.22561932f, 1.11406398f, 0.133632064f, -0.273544401f, 2.34395242f, -2.94559979f, + 1.14668226f, 1.75532305f, 2.29767275f, 0.906521976f, -1.90105069f, -0.561201155f, + 0.711975753f, -2.71241856f, -1.19429719f, -2.03620338f, 0.830003798f, -4.56849718f, + -0.00639008591f, -0.312803984f, -2.21442556f, 1.13124299f, 1.25901496f, -2.84291148f, + 1.03871489f, -0.537494898f, 0.371922791f, -1.17774379f, 2.90994549f, -1.62092268f, + 0.0430995524f, -2.32696033f, -3.22561932f, 1.11406398f, 0.133632064f, -0.273544401f, + 2.34395242f, -2.94559979f, 1.14668226f, 1.75532305f, 2.29767275f, 0.906521976f, + -1.90105069f, -0.561201155f, 0.711975753f, -2.71241856f, -1.19429719f, -2.03620338f, + 0.830003798f, -4.56849718f, -0.00639008591f, -0.312803984f, -2.21442556f, 1.13124299f, + 1.25901496f, -2.84291148f, 1.03871489f, -0.537494898f, 0.371922791f, -1.17774379f, + 2.90994549f, -1.62092268f, 0.0430995524f, -2.32696033f, -3.22561932f, 1.11406398f, + 0.133632064f, -0.273544401f, 2.34395242f, -2.94559979f, 1.14668226f, 1.75532305f, + 2.29767275f, 0.906521976f, -1.90105069f, -0.561201155f, 0.711975753f, -2.71241856f, + -1.19429719f, -2.03620338f, 0.830003798f, -4.56849718f, -0.00639008591f, -0.312803984f, + -2.21442556f, 1.13124299f, 1.25901496f, -2.84291148f, 1.03871489f, -0.537494898f, + 0.371922791f, -1.17774379f, 2.90994549f, -1.62092268f, 0.0430995524f, -2.32696033f, + -3.22561932f, 1.11406398f, 0.133632064f, -0.273544401f, 2.34395242f, -2.94559979f, + 1.14668226f, 1.75532305f, 2.29767275f, 0.906521976f, -1.90105069f, -0.561201155f, + 0.711975753f, -2.71241856f, -1.19429719f, -2.03620338f, 0.830003798f, -4.56849718f, + -0.00639008591f, -0.312803984f, -2.21442556f, 1.13124299f, 1.25901496f, -2.84291148f, + 1.03871489f, -0.537494898f, 0.371922791f, -1.17774379f, 2.90994549f, -1.62092268f, + 0.0430995524f, -2.32696033f, -3.22561932f, 1.11406398f, 0.133632064f, -0.273544401f, + 2.34395242f, -2.94559979f, 1.14668226f, 1.75532305f, 2.29767275f, 0.906521976f, + -1.90105069f, -0.561201155f, 0.711975753f, -2.71241856f, -1.19429719f, -2.03620338f, + 0.830003798f, -4.56849718f, -0.00639008591f, -0.312803984f, -2.21442556f, 1.13124299f, + 1.25901496f, -2.84291148f, 1.03871489f, -0.537494898f, 0.371922791f, -1.17774379f, + 2.90994549f, -1.62092268f, 0.0430995524f, -2.32696033f, -3.22561932f, 1.11406398f, + 0.133632064f, -0.273544401f, 2.34395242f, -2.94559979f, 1.14668226f, 1.75532305f, + 2.29767275f, 0.906521976f, -1.90105069f, -0.561201155f, 0.711975753f, -2.71241856f, + -1.19429719f, -2.03620338f, 0.830003798f, -4.56849718f, -0.00639008591f, -0.312803984f, + -2.21442556f, 1.13124299f, 1.25901496f, -2.84291148f, 1.03871489f, -0.537494898f, + 0.371922791f, -1.17774379f, 2.90994549f, -1.62092268f, 0.0430995524f, -2.32696033f, + -3.22561932f, 1.11406398f, 0.133632064f, -0.273544401f, 2.34395242f, -2.94559979f, + 1.14668226f, 1.75532305f, 2.29767275f, 0.906521976f, -1.90105069f, -0.561201155f, + 0.711975753f, -2.71241856f, -1.19429719f, -2.03620338f, 0.830003798f, -4.56849718f, + -0.00639008591f, -0.312803984f, -2.21442556f, 1.13124299f, 1.25901496f, -2.84291148f, + 1.03871489f, -0.537494898f, 0.371922791f, -1.17774379f, 2.90994549f, -1.62092268f, + 0.0430995524f, -2.32696033f, -3.22561932f, 1.11406398f, 0.133632064f, -0.273544401f, + 2.34395242f, -2.94559979f, 1.14668226f, 1.75532305f, 2.29767275f, 0.906521976f, + -1.90105069f, -0.561201155f, 0.711975753f, -2.71241856f, -1.19429719f, -2.03620338f, + 0.830003798f, -4.56849718f, -0.00639008591f, -0.312803984f, -2.21442556f, 1.13124299f, + 1.25901496f, -2.84291148f, 1.03871489f, -0.537494898f, 0.371922791f, -1.17774379f, + 2.90994549f, -1.62092268f, 0.0430995524f, -2.32696033f, -3.22561932f, 1.11406398f, + 0.133632064f, -0.273544401f, 2.34395242f, -2.94559979f, 1.14668226f, 1.75532305f, + 2.29767275f, 0.906521976f, -1.90105069f, -0.561201155f, 0.711975753f, -2.71241856f, + -1.19429719f, -2.03620338f, 0.830003798f, -4.56849718f, -0.00639008591f, -0.312803984f, + -2.21442556f, 1.13124299f, 1.25901496f, -2.84291148f, 1.03871489f, -0.537494898f, + 0.371922791f, -1.17774379f, 2.90994549f, -1.62092268f, 0.0430995524f, -2.32696033f, + -3.22561932f, 1.11406398f, 0.133632064f, -0.273544401f, 2.34395242f, -2.94559979f, + -6.64045811f, 0.258258611f, 2.66247058f, 1.69855809f, -0.580469966f, 4.99917841f, + 2.92916846f, -3.13593745f, -0.705907643f, 1.01345515f, -3.65989399f, 1.28651237f, + -7.21720505f, -4.94238472f, 0.438347757f, 1.15158808f, 4.75012589f, 3.38233805f, + 3.07190537f, -2.9253068f, -5.14442635f, 6.62584019f, 2.60874295f, -5.67679214f, + -0.16155155f, -1.90863144f, 0.220604479f, 3.13170433f, 6.78018332f, -1.25791955f, + -1.23095798f, 2.8856144f, -4.38342428f, -1.15595543f, 7.75659561f, 1.43472052f, + -2.11272407f, 5.37975502f, 1.60549569f, 0.898965836f, 0.416307777f, 1.41776955f, + -3.93824792f, 0.61253792f, -2.77709746f, -2.60962939f, -1.04304433f, 1.09372866f, + 4.44895029f, 0.0581415892f, -1.95350993f, -2.91123962f, 1.59314179f, 8.97336578f, + 5.49827528f, -5.31196785f, -0.28285107f, -2.07479358f, 5.25243187f, 3.47390461f, + 6.82101154f, 0.296510607f, -2.90637565f, -0.326196969f, -1.2483114f, -9.34625244f, + 3.31225228f, 1.1867125f, -2.188483f, 6.29560232f, -1.3760885f, -2.41931462f, + 2.55500054f, -2.01292801f, -2.53840828f, -0.176213413f, -5.0007081f, -8.38378048f, + -0.500828862f, -1.81483698f, 2.32053471f, -1.19444346f, 0.960556269f, -3.91199827f, + 0.545077622f, 4.08968687f, 6.90071535f, -6.74091911f, 2.52348566f, 0.592425942f, + 3.55463171f, 6.10247898f, 3.69316792f, -0.731817603f, 1.74486959f, 3.50307608f, + 0.636058331f, 1.94092238f, 7.2247076f, -0.522594571f, 4.83031034f, -0.339906931f, + 1.13211703f, -4.42644978f, -5.11565113f, -3.49176121f, -3.14565277f, -3.96445155f, + -3.62873125f, 2.85556149f, -1.94978118f, 1.83774459f, 2.85438013f, 1.8596431f, + 0.530085862f, -2.34312868f, 0.0583982021f, 4.45716524f, -0.915875733f, -7.0653863f, + 2.77440929f, 0.214101255f, 0.760411441f, 3.9241116f, 2.0086956f, 4.58963633f, + -0.463187188f, 3.66827679f, -2.75750089f, -4.37182236f, 0.220027834f, 4.63323927f, + -2.42771506f, 5.76118183f, 0.320355177f, 3.26989579f, 4.09666634f, -0.610923529f, + 1.90143049f, -1.55221462f, -2.98382521f, -0.207821518f, 0.982245564f, -5.9425292f, + 1.71089935f, -5.10667372f, -3.1624229f, -1.29679072f, 3.71646547f, 3.62488747f, + 1.13710546f, -2.88557005f, -2.76500797f, -1.17562401f, 5.92213106f, -1.01140404f, + -2.5153594f, -0.891808152f, -1.88841021f, 2.11562061f, 3.03247166f, -1.73402739f, + 1.19234049f, 0.0772434697f, -1.75286746f, 6.44293547f, -2.10665178f, -0.937098086f, + 5.17234707f, 6.80885315f, 1.90475845f, 3.64359784f, 2.48577738f, 0.960491657f, + -2.13669395f, -1.08501887f, -1.22050774f, -4.50039101f, -1.65626252f, -1.29414105f, + 4.48028278f, 2.86600661f, -0.653114676f, -1.50594652f, -0.771973848f, 3.37180901f, + 6.64894152f, 2.96160173f, -1.25561833f, 2.09331727f, -2.90798426f, 8.10996342f, + 5.84412766f, -4.66857624f, -3.74128985f, -0.226936117f, 9.9902668f, 2.46613503f, + -4.07856655f, -2.50687432f, -1.8571732f, -1.9378041f, 1.96499109f, -3.05020666f, + 2.08599734f, 0.176328138f, 0.0773129687f, 1.24267638f, -1.88251293f, 4.99279165f, + -5.80391026f, -2.88170433f, -7.23230743f, -3.71371222f, 4.20253372f, -3.30496788f, + 4.53338575f, 4.87305689f, 3.18596172f, 5.21779108f, 0.745883942f, 2.42793822f, + 0.959595919f, -1.71931338f, 0.428876519f, 6.03571367f, 5.16225433f, 4.81443357f, + -1.16711235f, 1.98434019f, -2.50921655f, -2.55381393f, -7.70589828f, 0.440256536f, + -1.12338853f, -0.103212975f, -1.9037075f, 0.557589769f, -2.49411225f, -2.34628987f, + 2.33746576f, 2.11325216f, 2.1859858f, -2.43311286f, -2.81187367f, 0.062556535f, + 4.29197979f, -1.57762051f, 4.18522263f, -2.76206112f, -0.761086822f, 0.0476746187f, + 0.124127425f, 7.05953884f, 1.89967191f, -0.225420445f, +}; + +inline constexpr float kLtxTowerPaddedStateF32_6[] = { + 1.36753035f, 1.92279971f, 0.614734709f, 2.28638363f, -2.55599833f, -0.601136804f, + -0.563420892f, -3.6254518f, 0.261661679f, -1.47598851f, -1.08026755f, -4.74338341f, + 0.14171049f, -0.633600175f, -0.832457066f, -0.106438495f, 0.858573139f, -2.60525012f, + 2.47637367f, -0.31097433f, 0.499286205f, -2.01379848f, 3.23912859f, -1.63853371f, + 2.30360961f, -1.86471879f, -3.93406892f, 2.14677286f, -0.205314413f, 0.967164516f, + 3.86121607f, -1.31768668f, 1.36753035f, 1.92279971f, 0.614734709f, 2.28638363f, + -2.55599833f, -0.601136804f, -0.563420892f, -3.6254518f, 0.261661679f, -1.47598851f, + -1.08026755f, -4.74338341f, 0.14171049f, -0.633600175f, -0.832457066f, -0.106438495f, + 0.858573139f, -2.60525012f, 2.47637367f, -0.31097433f, 0.499286205f, -2.01379848f, + 3.23912859f, -1.63853371f, 2.30360961f, -1.86471879f, -3.93406892f, 2.14677286f, + -0.205314413f, 0.967164516f, 3.86121607f, -1.31768668f, 1.36753035f, 1.92279971f, + 0.614734709f, 2.28638363f, -2.55599833f, -0.601136804f, -0.563420892f, -3.6254518f, + 0.261661679f, -1.47598851f, -1.08026755f, -4.74338341f, 0.14171049f, -0.633600175f, + -0.832457066f, -0.106438495f, 0.858573139f, -2.60525012f, 2.47637367f, -0.31097433f, + 0.499286205f, -2.01379848f, 3.23912859f, -1.63853371f, 2.30360961f, -1.86471879f, + -3.93406892f, 2.14677286f, -0.205314413f, 0.967164516f, 3.86121607f, -1.31768668f, + 1.36753035f, 1.92279971f, 0.614734709f, 2.28638363f, -2.55599833f, -0.601136804f, + -0.563420892f, -3.6254518f, 0.261661679f, -1.47598851f, -1.08026755f, -4.74338341f, + 0.14171049f, -0.633600175f, -0.832457066f, -0.106438495f, 0.858573139f, -2.60525012f, + 2.47637367f, -0.31097433f, 0.499286205f, -2.01379848f, 3.23912859f, -1.63853371f, + 2.30360961f, -1.86471879f, -3.93406892f, 2.14677286f, -0.205314413f, 0.967164516f, + 3.86121607f, -1.31768668f, 1.36753035f, 1.92279971f, 0.614734709f, 2.28638363f, + -2.55599833f, -0.601136804f, -0.563420892f, -3.6254518f, 0.261661679f, -1.47598851f, + -1.08026755f, -4.74338341f, 0.14171049f, -0.633600175f, -0.832457066f, -0.106438495f, + 0.858573139f, -2.60525012f, 2.47637367f, -0.31097433f, 0.499286205f, -2.01379848f, + 3.23912859f, -1.63853371f, 2.30360961f, -1.86471879f, -3.93406892f, 2.14677286f, + -0.205314413f, 0.967164516f, 3.86121607f, -1.31768668f, 1.36753035f, 1.92279971f, + 0.614734709f, 2.28638363f, -2.55599833f, -0.601136804f, -0.563420892f, -3.6254518f, + 0.261661679f, -1.47598851f, -1.08026755f, -4.74338341f, 0.14171049f, -0.633600175f, + -0.832457066f, -0.106438495f, 0.858573139f, -2.60525012f, 2.47637367f, -0.31097433f, + 0.499286205f, -2.01379848f, 3.23912859f, -1.63853371f, 2.30360961f, -1.86471879f, + -3.93406892f, 2.14677286f, -0.205314413f, 0.967164516f, 3.86121607f, -1.31768668f, + 1.36753035f, 1.92279971f, 0.614734709f, 2.28638363f, -2.55599833f, -0.601136804f, + -0.563420892f, -3.6254518f, 0.261661679f, -1.47598851f, -1.08026755f, -4.74338341f, + 0.14171049f, -0.633600175f, -0.832457066f, -0.106438495f, 0.858573139f, -2.60525012f, + 2.47637367f, -0.31097433f, 0.499286205f, -2.01379848f, 3.23912859f, -1.63853371f, + 2.30360961f, -1.86471879f, -3.93406892f, 2.14677286f, -0.205314413f, 0.967164516f, + 3.86121607f, -1.31768668f, 1.36753035f, 1.92279971f, 0.614734709f, 2.28638363f, + -2.55599833f, -0.601136804f, -0.563420892f, -3.6254518f, 0.261661679f, -1.47598851f, + -1.08026755f, -4.74338341f, 0.14171049f, -0.633600175f, -0.832457066f, -0.106438495f, + 0.858573139f, -2.60525012f, 2.47637367f, -0.31097433f, 0.499286205f, -2.01379848f, + 3.23912859f, -1.63853371f, 2.30360961f, -1.86471879f, -3.93406892f, 2.14677286f, + -0.205314413f, 0.967164516f, 3.86121607f, -1.31768668f, 1.36753035f, 1.92279971f, + 0.614734709f, 2.28638363f, -2.55599833f, -0.601136804f, -0.563420892f, -3.6254518f, + 0.261661679f, -1.47598851f, -1.08026755f, -4.74338341f, 0.14171049f, -0.633600175f, + -0.832457066f, -0.106438495f, 0.858573139f, -2.60525012f, 2.47637367f, -0.31097433f, + 0.499286205f, -2.01379848f, 3.23912859f, -1.63853371f, 2.30360961f, -1.86471879f, + -3.93406892f, 2.14677286f, -0.205314413f, 0.967164516f, 3.86121607f, -1.31768668f, + 1.36753035f, 1.92279971f, 0.614734709f, 2.28638363f, -2.55599833f, -0.601136804f, + -0.563420892f, -3.6254518f, 0.261661679f, -1.47598851f, -1.08026755f, -4.74338341f, + 0.14171049f, -0.633600175f, -0.832457066f, -0.106438495f, 0.858573139f, -2.60525012f, + 2.47637367f, -0.31097433f, 0.499286205f, -2.01379848f, 3.23912859f, -1.63853371f, + 2.30360961f, -1.86471879f, -3.93406892f, 2.14677286f, -0.205314413f, 0.967164516f, + 3.86121607f, -1.31768668f, 1.36753035f, 1.92279971f, 0.614734709f, 2.28638363f, + -2.55599833f, -0.601136804f, -0.563420892f, -3.6254518f, 0.261661679f, -1.47598851f, + -1.08026755f, -4.74338341f, 0.14171049f, -0.633600175f, -0.832457066f, -0.106438495f, + 0.858573139f, -2.60525012f, 2.47637367f, -0.31097433f, 0.499286205f, -2.01379848f, + 3.23912859f, -1.63853371f, 2.30360961f, -1.86471879f, -3.93406892f, 2.14677286f, + -0.205314413f, 0.967164516f, 3.86121607f, -1.31768668f, 1.36753035f, 1.92279971f, + 0.614734709f, 2.28638363f, -2.55599833f, -0.601136804f, -0.563420892f, -3.6254518f, + 0.261661679f, -1.47598851f, -1.08026755f, -4.74338341f, 0.14171049f, -0.633600175f, + -0.832457066f, -0.106438495f, 0.858573139f, -2.60525012f, 2.47637367f, -0.31097433f, + 0.499286205f, -2.01379848f, 3.23912859f, -1.63853371f, 2.30360961f, -1.86471879f, + -3.93406892f, 2.14677286f, -0.205314413f, 0.967164516f, 3.86121607f, -1.31768668f, + -7.62095928f, -0.981662273f, 2.282161f, 3.13395262f, -0.466449618f, 6.39862156f, + 4.43844318f, -5.81806707f, 2.1706543f, 2.20054436f, -2.85642481f, 1.33196759f, + -9.07043457f, -3.79968309f, 1.70141912f, -2.23640442f, 4.04678345f, 2.16642451f, + 2.09990692f, -4.59141541f, -6.26420307f, 6.33999586f, 3.22913218f, -5.65510654f, + 1.49053919f, -1.13045537f, -0.995037556f, 4.60238886f, 7.50435448f, -0.878966987f, + -0.658555984f, 1.81321383f, -4.87572479f, -2.57473373f, 9.40959454f, 1.91815126f, + -3.23440719f, 8.24659348f, 1.00636506f, 1.27789092f, 1.38714802f, 1.39751172f, + -3.74306941f, 1.33327472f, -3.06646633f, -0.302383095f, 0.440241098f, -0.566164851f, + 4.91932487f, -0.403979748f, -2.3572197f, -3.31523609f, 0.604812086f, 7.9307704f, + 6.26776552f, -3.89018416f, 3.42065811f, 1.79288924f, 5.32630348f, 3.3461926f, + 6.87708378f, 2.15490794f, -3.77654648f, -1.98674083f, -2.04223275f, -12.5902176f, + 3.54838872f, 1.6669004f, -3.06000161f, 8.95376015f, 0.546741903f, -4.05431652f, + 3.43372488f, -1.955392f, -2.220191f, 0.218411326f, -4.72772884f, -5.26104164f, + 0.852751434f, -2.74239755f, 2.02191186f, -0.702738345f, 0.358006775f, -3.76469326f, + 0.64410156f, 2.97347522f, 6.39888096f, -8.54838943f, 4.45121241f, 2.11879873f, + 3.87578392f, 6.67159271f, 3.25345802f, -0.246178761f, 1.54886925f, 3.64983392f, + 2.75313854f, 4.10550833f, 9.79015541f, -0.0757613778f, 7.07746983f, 0.71642673f, + 0.966490149f, -7.04842949f, -5.04568243f, -5.13150406f, -3.60170889f, -3.94570827f, + -2.48838973f, 1.22158635f, -1.94795382f, 0.685796499f, 2.56352758f, 2.11258793f, + 0.621080041f, -0.332539916f, -0.276778966f, 2.63898015f, 0.180467054f, -10.8158255f, + 8.15343475f, -0.201765627f, 1.54086769f, 5.3896966f, 1.02324915f, 5.26263952f, + -0.60806179f, 4.50116301f, -3.31418777f, -5.27573156f, -0.0512382872f, 6.2414422f, + -0.684185863f, 7.91886044f, 1.61038959f, 2.09997106f, 7.41365957f, -1.30285931f, + 1.34405351f, -3.09119916f, -2.75167394f, 1.57163382f, 2.71946001f, -9.29221916f, + 1.13888717f, -6.92693472f, -1.69699275f, -1.74134219f, 2.75594139f, 3.65537739f, + -0.881403863f, -3.02388525f, -2.95219994f, 0.789129138f, 4.91436577f, 0.358551234f, + -1.83975112f, -0.563111484f, -4.74274206f, 3.27011323f, 4.56181812f, -2.48833728f, + 1.82832026f, -0.0513854027f, -1.73050141f, 7.52430344f, -2.95446825f, -2.87600708f, + 6.77123547f, 7.0275569f, 2.4963634f, 2.56495571f, 2.45432091f, 2.01542068f, + -1.12632358f, -4.66091108f, -3.03301287f, -5.54162264f, -3.07758307f, -1.660097f, + 4.72629786f, 0.657624006f, 0.463557005f, 0.476383865f, 0.909147322f, 5.22724533f, + 7.42252111f, 3.12048697f, -2.97128868f, 1.73025441f, -4.31245565f, 9.31009293f, + 10.0366697f, -4.08731222f, -3.89576888f, -0.916624069f, 10.3654699f, 4.93031454f, + -3.3720746f, -4.38020945f, -3.24626923f, -1.34792233f, 3.23296714f, -1.78128624f, + 0.709621072f, 0.366084546f, -0.441351324f, 4.24912167f, -3.02324152f, 5.27349997f, + -7.71658897f, -2.57882786f, -10.3356581f, -7.52807045f, 4.90593481f, -2.69372964f, + 8.68119431f, 5.71097612f, 2.7106595f, 4.9094038f, 0.558706284f, 2.46755004f, + 0.605221808f, -0.759842336f, 1.11137867f, 6.66116714f, 5.77082634f, 5.08882141f, + 0.738193035f, 4.62489939f, -2.64719105f, -4.9086709f, -5.08125162f, 0.394842505f, + -2.58741474f, 0.796130657f, -0.000276245177f, -0.528544784f, -1.54526818f, -5.18882179f, + 3.05486917f, 0.647397459f, -0.136299729f, -0.867723048f, -1.74609923f, 2.49515104f, + 5.35535622f, -2.99347067f, 6.35402298f, -2.56251359f, -0.0330619961f, 0.922917783f, + -1.1273371f, 7.74917746f, 1.44131303f, -1.14886987f, +}; + +inline constexpr float kLtxTowerPaddedStateF32_7[] = { + 0.754528999f, 1.72158957f, 0.1906856f, 2.97102976f, -2.21459174f, -1.58756256f, + -0.910393953f, -4.1252284f, 1.32978559f, -0.277440935f, -0.90653348f, -4.70160484f, + -1.0916729f, -0.980955124f, -0.759516776f, 0.71583122f, 0.715089023f, -1.77052307f, + 0.461134613f, -0.443521321f, 0.847528934f, -1.09604681f, 1.23185587f, -2.74011612f, + 2.51724672f, -0.488595277f, -2.4943254f, 2.38171911f, -1.00899577f, 2.39694619f, + 3.69342399f, -0.72208482f, 0.754528999f, 1.72158957f, 0.1906856f, 2.97102976f, + -2.21459174f, -1.58756256f, -0.910393953f, -4.1252284f, 1.32978559f, -0.277440935f, + -0.90653348f, -4.70160484f, -1.0916729f, -0.980955124f, -0.759516776f, 0.71583122f, + 0.715089023f, -1.77052307f, 0.461134613f, -0.443521321f, 0.847528934f, -1.09604681f, + 1.23185587f, -2.74011612f, 2.51724672f, -0.488595277f, -2.4943254f, 2.38171911f, + -1.00899577f, 2.39694619f, 3.69342399f, -0.72208482f, 0.754528999f, 1.72158957f, + 0.1906856f, 2.97102976f, -2.21459174f, -1.58756256f, -0.910393953f, -4.1252284f, + 1.32978559f, -0.277440935f, -0.90653348f, -4.70160484f, -1.0916729f, -0.980955124f, + -0.759516776f, 0.71583122f, 0.715089023f, -1.77052307f, 0.461134613f, -0.443521321f, + 0.847528934f, -1.09604681f, 1.23185587f, -2.74011612f, 2.51724672f, -0.488595277f, + -2.4943254f, 2.38171911f, -1.00899577f, 2.39694619f, 3.69342399f, -0.72208482f, + 0.754528999f, 1.72158957f, 0.1906856f, 2.97102976f, -2.21459174f, -1.58756256f, + -0.910393953f, -4.1252284f, 1.32978559f, -0.277440935f, -0.90653348f, -4.70160484f, + -1.0916729f, -0.980955124f, -0.759516776f, 0.71583122f, 0.715089023f, -1.77052307f, + 0.461134613f, -0.443521321f, 0.847528934f, -1.09604681f, 1.23185587f, -2.74011612f, + 2.51724672f, -0.488595277f, -2.4943254f, 2.38171911f, -1.00899577f, 2.39694619f, + 3.69342399f, -0.72208482f, 0.754528999f, 1.72158957f, 0.1906856f, 2.97102976f, + -2.21459174f, -1.58756256f, -0.910393953f, -4.1252284f, 1.32978559f, -0.277440935f, + -0.90653348f, -4.70160484f, -1.0916729f, -0.980955124f, -0.759516776f, 0.71583122f, + 0.715089023f, -1.77052307f, 0.461134613f, -0.443521321f, 0.847528934f, -1.09604681f, + 1.23185587f, -2.74011612f, 2.51724672f, -0.488595277f, -2.4943254f, 2.38171911f, + -1.00899577f, 2.39694619f, 3.69342399f, -0.72208482f, 0.754528999f, 1.72158957f, + 0.1906856f, 2.97102976f, -2.21459174f, -1.58756256f, -0.910393953f, -4.1252284f, + 1.32978559f, -0.277440935f, -0.90653348f, -4.70160484f, -1.0916729f, -0.980955124f, + -0.759516776f, 0.71583122f, 0.715089023f, -1.77052307f, 0.461134613f, -0.443521321f, + 0.847528934f, -1.09604681f, 1.23185587f, -2.74011612f, 2.51724672f, -0.488595277f, + -2.4943254f, 2.38171911f, -1.00899577f, 2.39694619f, 3.69342399f, -0.72208482f, + 0.754528999f, 1.72158957f, 0.1906856f, 2.97102976f, -2.21459174f, -1.58756256f, + -0.910393953f, -4.1252284f, 1.32978559f, -0.277440935f, -0.90653348f, -4.70160484f, + -1.0916729f, -0.980955124f, -0.759516776f, 0.71583122f, 0.715089023f, -1.77052307f, + 0.461134613f, -0.443521321f, 0.847528934f, -1.09604681f, 1.23185587f, -2.74011612f, + 2.51724672f, -0.488595277f, -2.4943254f, 2.38171911f, -1.00899577f, 2.39694619f, + 3.69342399f, -0.72208482f, 0.754528999f, 1.72158957f, 0.1906856f, 2.97102976f, + -2.21459174f, -1.58756256f, -0.910393953f, -4.1252284f, 1.32978559f, -0.277440935f, + -0.90653348f, -4.70160484f, -1.0916729f, -0.980955124f, -0.759516776f, 0.71583122f, + 0.715089023f, -1.77052307f, 0.461134613f, -0.443521321f, 0.847528934f, -1.09604681f, + 1.23185587f, -2.74011612f, 2.51724672f, -0.488595277f, -2.4943254f, 2.38171911f, + -1.00899577f, 2.39694619f, 3.69342399f, -0.72208482f, 0.754528999f, 1.72158957f, + 0.1906856f, 2.97102976f, -2.21459174f, -1.58756256f, -0.910393953f, -4.1252284f, + 1.32978559f, -0.277440935f, -0.90653348f, -4.70160484f, -1.0916729f, -0.980955124f, + -0.759516776f, 0.71583122f, 0.715089023f, -1.77052307f, 0.461134613f, -0.443521321f, + 0.847528934f, -1.09604681f, 1.23185587f, -2.74011612f, 2.51724672f, -0.488595277f, + -2.4943254f, 2.38171911f, -1.00899577f, 2.39694619f, 3.69342399f, -0.72208482f, + 0.754528999f, 1.72158957f, 0.1906856f, 2.97102976f, -2.21459174f, -1.58756256f, + -0.910393953f, -4.1252284f, 1.32978559f, -0.277440935f, -0.90653348f, -4.70160484f, + -1.0916729f, -0.980955124f, -0.759516776f, 0.71583122f, 0.715089023f, -1.77052307f, + 0.461134613f, -0.443521321f, 0.847528934f, -1.09604681f, 1.23185587f, -2.74011612f, + 2.51724672f, -0.488595277f, -2.4943254f, 2.38171911f, -1.00899577f, 2.39694619f, + 3.69342399f, -0.72208482f, 0.754528999f, 1.72158957f, 0.1906856f, 2.97102976f, + -2.21459174f, -1.58756256f, -0.910393953f, -4.1252284f, 1.32978559f, -0.277440935f, + -0.90653348f, -4.70160484f, -1.0916729f, -0.980955124f, -0.759516776f, 0.71583122f, + 0.715089023f, -1.77052307f, 0.461134613f, -0.443521321f, 0.847528934f, -1.09604681f, + 1.23185587f, -2.74011612f, 2.51724672f, -0.488595277f, -2.4943254f, 2.38171911f, + -1.00899577f, 2.39694619f, 3.69342399f, -0.72208482f, 0.754528999f, 1.72158957f, + 0.1906856f, 2.97102976f, -2.21459174f, -1.58756256f, -0.910393953f, -4.1252284f, + 1.32978559f, -0.277440935f, -0.90653348f, -4.70160484f, -1.0916729f, -0.980955124f, + -0.759516776f, 0.71583122f, 0.715089023f, -1.77052307f, 0.461134613f, -0.443521321f, + 0.847528934f, -1.09604681f, 1.23185587f, -2.74011612f, 2.51724672f, -0.488595277f, + -2.4943254f, 2.38171911f, -1.00899577f, 2.39694619f, 3.69342399f, -0.72208482f, + -8.49834442f, -0.873637855f, 1.17466438f, 2.65314245f, -0.25795427f, 4.23031902f, + 1.7094239f, -3.2902925f, 1.16402686f, 2.7514677f, -2.84108019f, 0.178414404f, + -8.80039024f, -4.86490774f, 2.11539364f, -1.48792613f, 1.58716655f, 2.26404047f, + 3.78828692f, -4.93216801f, -5.80612373f, 4.66260719f, 2.46323276f, -5.69036388f, + 6.96226454f, -0.842600882f, -0.506489158f, 4.39151859f, 6.89374018f, -0.951885462f, + -1.93642688f, 1.89574707f, -6.93885088f, -1.23513818f, 7.53849077f, -0.361427218f, + -3.49958873f, 6.57434797f, -0.694813848f, 3.20516133f, 0.26939252f, 1.1307745f, + -3.40721321f, -1.21056795f, -3.6231482f, -2.61259818f, 0.883084834f, 0.502160311f, + 3.04941797f, 0.0806214213f, -0.958598435f, -2.6265738f, 0.063270852f, 7.47034836f, + 6.11368322f, -2.84194684f, 6.22265339f, 0.375247806f, 5.25876236f, 2.83968663f, + 6.95172358f, 2.35087967f, -4.07687616f, -0.866275251f, -3.3506391f, -11.5040884f, + 1.86788571f, 0.450057298f, -2.09284639f, 6.96747208f, -1.21645355f, -1.3330406f, + 1.93183589f, -0.658494115f, -1.88829255f, -2.40661931f, -4.26679802f, -6.68300152f, + 1.02008748f, -1.54480815f, 1.22997272f, -0.388556778f, 2.33966208f, -3.13669705f, + 0.810261428f, 2.44886136f, 4.7748909f, -7.22295666f, 7.17419052f, 1.54769337f, + 2.86878967f, 7.25178051f, 2.09226942f, 0.13172628f, 1.12164378f, 3.66344428f, + 1.92370057f, 4.35771942f, 6.81426477f, -1.27188289f, 7.05842733f, 1.57225013f, + 0.0664821416f, -5.70083427f, -6.21801138f, -4.02051163f, -2.70243716f, -4.99630356f, + -1.67496371f, -1.76583326f, -2.25999117f, 2.76113153f, 1.07818198f, 3.50492597f, + 3.25037479f, 1.41975665f, 0.227603272f, 3.30585337f, 1.3970623f, -9.38093567f, + 11.3226032f, -0.782681346f, 0.657562673f, 5.40665245f, 0.802208662f, 6.50211239f, + -2.43462968f, 3.96253777f, -3.86583591f, -4.46838474f, -2.103055f, 3.81532025f, + -0.100216947f, 6.58816814f, -0.298821837f, 3.941926f, 4.78704834f, -0.507340789f, + 0.853075147f, -4.30768919f, -3.89315271f, 0.0797340348f, 2.20090818f, -8.00170612f, + 0.445127279f, -5.21146393f, -0.0481277555f, -0.0593089163f, 2.31064296f, 2.83773351f, + 0.11456199f, -4.26582623f, 0.0672142878f, 0.440063208f, 2.87507224f, 1.52231395f, + -3.62165022f, 0.819242835f, -6.6385622f, 1.76045072f, 2.11889529f, -0.896693826f, + 0.999615371f, -1.81941545f, -0.415672958f, 7.35383749f, -5.01929379f, -2.41931129f, + 7.16053724f, 5.83183146f, 2.56919289f, 0.979370475f, 2.69053698f, 2.76513624f, + -0.897895694f, -4.6160078f, -4.02729988f, -4.45959949f, -1.83336985f, -0.447972417f, + 6.09321547f, 1.03330469f, 1.40856457f, -0.913030803f, 0.280604273f, 3.97018623f, + 5.95963097f, 4.78161192f, -3.80230737f, 2.43369722f, -5.83831167f, 7.74067116f, + 8.09461784f, -3.0706656f, -3.4397521f, -2.98105168f, 9.56237411f, 4.69830704f, + -3.2967f, -3.72760367f, -4.2592082f, -0.979867518f, 2.20561194f, -1.23098159f, + 2.37144375f, 0.96524781f, 0.664879799f, 6.42963648f, -5.84395266f, 3.13960624f, + -4.41618252f, -2.52774549f, -9.79688263f, -8.6899128f, 4.01515675f, -2.38777852f, + 7.57077456f, 3.16125011f, 4.66394424f, 3.71544981f, 0.443372011f, 4.03598595f, + 0.0367292538f, 1.19378543f, 0.796876669f, 7.01853991f, 4.43945456f, 3.58787918f, + 0.734538734f, 6.57387781f, -2.83132076f, -3.80614877f, -4.66461229f, -0.66234386f, + -2.38758659f, -1.22790754f, 0.771459818f, -1.37459373f, -0.580323756f, -2.12085104f, + 3.24007297f, 0.457853019f, -0.416602522f, -2.58957791f, -2.50939631f, 2.21478796f, + 3.14249873f, -1.43336189f, 7.3964467f, -0.89691031f, -0.293006659f, 2.12257075f, + -1.98576748f, 7.2410059f, 1.71666658f, 0.387147576f, +}; + +inline constexpr float kLtxTowerPaddedStateF32_8[] = { + 1.47570634f, 2.4479084f, -0.492631137f, 2.57236838f, -0.211978078f, -1.46624637f, + -0.62227124f, -4.72054625f, 2.29061317f, 0.371976346f, -0.854629815f, -4.98152208f, + -0.724153638f, -1.01580751f, 0.125687137f, -2.70465994f, -0.533367455f, -2.3939538f, + 1.54473627f, -1.28461504f, 0.307547361f, -0.790890455f, 1.23079634f, -3.94205856f, + 3.22905159f, -1.14966881f, -2.74790978f, 3.68355107f, -1.54296541f, 2.39617634f, + 3.60593271f, -1.09535182f, 1.47570634f, 2.4479084f, -0.492631137f, 2.57236838f, + -0.211978078f, -1.46624637f, -0.62227124f, -4.72054625f, 2.29061317f, 0.371976346f, + -0.854629815f, -4.98152208f, -0.724153638f, -1.01580751f, 0.125687137f, -2.70465994f, + -0.533367455f, -2.3939538f, 1.54473627f, -1.28461504f, 0.307547361f, -0.790890455f, + 1.23079634f, -3.94205856f, 3.22905159f, -1.14966881f, -2.74790978f, 3.68355107f, + -1.54296541f, 2.39617634f, 3.60593271f, -1.09535182f, 1.47570634f, 2.4479084f, + -0.492631137f, 2.57236838f, -0.211978078f, -1.46624637f, -0.62227124f, -4.72054625f, + 2.29061317f, 0.371976346f, -0.854629815f, -4.98152208f, -0.724153638f, -1.01580751f, + 0.125687137f, -2.70465994f, -0.533367455f, -2.3939538f, 1.54473627f, -1.28461504f, + 0.307547361f, -0.790890455f, 1.23079634f, -3.94205856f, 3.22905159f, -1.14966881f, + -2.74790978f, 3.68355107f, -1.54296541f, 2.39617634f, 3.60593271f, -1.09535182f, + 1.47570634f, 2.4479084f, -0.492631137f, 2.57236838f, -0.211978078f, -1.46624637f, + -0.62227124f, -4.72054625f, 2.29061317f, 0.371976346f, -0.854629815f, -4.98152208f, + -0.724153638f, -1.01580751f, 0.125687137f, -2.70465994f, -0.533367455f, -2.3939538f, + 1.54473627f, -1.28461504f, 0.307547361f, -0.790890455f, 1.23079634f, -3.94205856f, + 3.22905159f, -1.14966881f, -2.74790978f, 3.68355107f, -1.54296541f, 2.39617634f, + 3.60593271f, -1.09535182f, 1.47570634f, 2.4479084f, -0.492631137f, 2.57236838f, + -0.211978078f, -1.46624637f, -0.62227124f, -4.72054625f, 2.29061317f, 0.371976346f, + -0.854629815f, -4.98152208f, -0.724153638f, -1.01580751f, 0.125687137f, -2.70465994f, + -0.533367455f, -2.3939538f, 1.54473627f, -1.28461504f, 0.307547361f, -0.790890455f, + 1.23079634f, -3.94205856f, 3.22905159f, -1.14966881f, -2.74790978f, 3.68355107f, + -1.54296541f, 2.39617634f, 3.60593271f, -1.09535182f, 1.47570634f, 2.4479084f, + -0.492631137f, 2.57236838f, -0.211978078f, -1.46624637f, -0.62227124f, -4.72054625f, + 2.29061317f, 0.371976346f, -0.854629815f, -4.98152208f, -0.724153638f, -1.01580751f, + 0.125687137f, -2.70465994f, -0.533367455f, -2.3939538f, 1.54473627f, -1.28461504f, + 0.307547361f, -0.790890455f, 1.23079634f, -3.94205856f, 3.22905159f, -1.14966881f, + -2.74790978f, 3.68355107f, -1.54296541f, 2.39617634f, 3.60593271f, -1.09535182f, + 1.47570634f, 2.4479084f, -0.492631137f, 2.57236838f, -0.211978078f, -1.46624637f, + -0.62227124f, -4.72054625f, 2.29061317f, 0.371976346f, -0.854629815f, -4.98152208f, + -0.724153638f, -1.01580751f, 0.125687137f, -2.70465994f, -0.533367455f, -2.3939538f, + 1.54473627f, -1.28461504f, 0.307547361f, -0.790890455f, 1.23079634f, -3.94205856f, + 3.22905159f, -1.14966881f, -2.74790978f, 3.68355107f, -1.54296541f, 2.39617634f, + 3.60593271f, -1.09535182f, 1.47570634f, 2.4479084f, -0.492631137f, 2.57236838f, + -0.211978078f, -1.46624637f, -0.62227124f, -4.72054625f, 2.29061317f, 0.371976346f, + -0.854629815f, -4.98152208f, -0.724153638f, -1.01580751f, 0.125687137f, -2.70465994f, + -0.533367455f, -2.3939538f, 1.54473627f, -1.28461504f, 0.307547361f, -0.790890455f, + 1.23079634f, -3.94205856f, 3.22905159f, -1.14966881f, -2.74790978f, 3.68355107f, + -1.54296541f, 2.39617634f, 3.60593271f, -1.09535182f, 1.47570634f, 2.4479084f, + -0.492631137f, 2.57236838f, -0.211978078f, -1.46624637f, -0.62227124f, -4.72054625f, + 2.29061317f, 0.371976346f, -0.854629815f, -4.98152208f, -0.724153638f, -1.01580751f, + 0.125687137f, -2.70465994f, -0.533367455f, -2.3939538f, 1.54473627f, -1.28461504f, + 0.307547361f, -0.790890455f, 1.23079634f, -3.94205856f, 3.22905159f, -1.14966881f, + -2.74790978f, 3.68355107f, -1.54296541f, 2.39617634f, 3.60593271f, -1.09535182f, + 1.47570634f, 2.4479084f, -0.492631137f, 2.57236838f, -0.211978078f, -1.46624637f, + -0.62227124f, -4.72054625f, 2.29061317f, 0.371976346f, -0.854629815f, -4.98152208f, + -0.724153638f, -1.01580751f, 0.125687137f, -2.70465994f, -0.533367455f, -2.3939538f, + 1.54473627f, -1.28461504f, 0.307547361f, -0.790890455f, 1.23079634f, -3.94205856f, + 3.22905159f, -1.14966881f, -2.74790978f, 3.68355107f, -1.54296541f, 2.39617634f, + 3.60593271f, -1.09535182f, 1.47570634f, 2.4479084f, -0.492631137f, 2.57236838f, + -0.211978078f, -1.46624637f, -0.62227124f, -4.72054625f, 2.29061317f, 0.371976346f, + -0.854629815f, -4.98152208f, -0.724153638f, -1.01580751f, 0.125687137f, -2.70465994f, + -0.533367455f, -2.3939538f, 1.54473627f, -1.28461504f, 0.307547361f, -0.790890455f, + 1.23079634f, -3.94205856f, 3.22905159f, -1.14966881f, -2.74790978f, 3.68355107f, + -1.54296541f, 2.39617634f, 3.60593271f, -1.09535182f, 1.47570634f, 2.4479084f, + -0.492631137f, 2.57236838f, -0.211978078f, -1.46624637f, -0.62227124f, -4.72054625f, + 2.29061317f, 0.371976346f, -0.854629815f, -4.98152208f, -0.724153638f, -1.01580751f, + 0.125687137f, -2.70465994f, -0.533367455f, -2.3939538f, 1.54473627f, -1.28461504f, + 0.307547361f, -0.790890455f, 1.23079634f, -3.94205856f, 3.22905159f, -1.14966881f, + -2.74790978f, 3.68355107f, -1.54296541f, 2.39617634f, 3.60593271f, -1.09535182f, + -8.89666748f, 1.47443414f, 0.113001645f, 0.999195695f, -0.978735447f, 1.46556187f, + 1.03754544f, -0.1596549f, 3.12240124f, 3.11176109f, -0.159532368f, 0.626370132f, + -9.10763073f, -2.18295288f, 1.65931785f, -1.64609313f, 1.79899406f, 0.0894851163f, + 1.94550753f, -6.26336813f, -8.74751759f, 5.05050468f, 2.27574468f, -5.87296057f, + 4.15928221f, -0.321590841f, -0.582106233f, 4.14281797f, 4.34223223f, -2.66388583f, + -2.21306324f, 2.19005322f, -8.96580887f, 0.402224034f, 5.87610674f, -2.29230928f, + -4.40222168f, 4.80449295f, -0.955129147f, 4.04992771f, 0.65723151f, 1.5021112f, + -1.75275779f, -0.397763759f, -5.0988512f, -0.66036582f, 1.61716092f, -0.580977619f, + 1.74968112f, -1.07324004f, -3.69329548f, -2.76634169f, -1.89972031f, 8.24284267f, + 5.31531334f, -3.09758425f, 5.91198015f, 3.08064675f, 2.95033288f, 2.0363462f, + 4.08051395f, 0.710809231f, -3.99574184f, -0.501211107f, -4.88118458f, -10.1398602f, + -0.0593197085f, -1.42227101f, -4.1800375f, 5.16751003f, -0.563788056f, -0.262233406f, + 2.56738424f, -0.827025175f, -1.25396109f, -2.76287079f, -5.04602098f, -4.98765516f, + 2.83674979f, -1.95524502f, 1.88831615f, -2.20686913f, 0.848729551f, -3.9295764f, + -0.603290677f, -0.209433377f, 3.61951041f, -8.93008423f, 6.93347836f, 4.39115524f, + 2.79344487f, 9.01331711f, 2.32400918f, -3.00219059f, 1.16304994f, 3.09822321f, + 1.26457238f, 7.97808552f, 3.95785213f, -2.72609448f, 6.3107748f, 1.42337883f, + 1.12728834f, -6.17893076f, -4.70256662f, -4.92957067f, -1.59597707f, -3.73986292f, + -1.702793f, 0.529446959f, -0.774914622f, 0.764226735f, 1.6552844f, 1.42293584f, + 1.66213441f, 1.05041027f, -1.11995304f, 1.69235384f, 0.587706447f, -8.93205929f, + 10.9409285f, -0.111243494f, 2.64671278f, 6.02337074f, -0.53215605f, 7.07659292f, + -3.05452251f, 5.64585066f, -4.80555677f, -3.70772576f, -1.81062102f, 4.15403032f, + -1.48972726f, 5.00532675f, -0.404292971f, 5.62148046f, 7.12647772f, -1.81207085f, + 2.43871069f, -6.90882063f, -3.43069863f, 3.16812801f, 4.59321451f, -7.1171546f, + 0.761886418f, -6.15627909f, -1.89964998f, -2.62311411f, 0.756455541f, 1.34253812f, + 0.847121596f, -4.99784517f, 1.45380414f, 1.48304331f, 2.61501288f, 1.03896546f, + -2.30297351f, -1.06201649f, -8.67164707f, 2.16556668f, 2.2217164f, 0.944667995f, + 2.02824616f, -1.28017712f, -0.240201846f, 7.23263121f, -6.77200937f, -1.22154105f, + 7.56324434f, 4.0449338f, 1.9132421f, 2.10675049f, 2.73855615f, 3.2937727f, + -0.523383796f, -4.15722179f, -1.97966218f, -2.63692236f, -3.55398464f, -1.80574071f, + 4.54202795f, -0.465849102f, 2.30764866f, -3.35933566f, 0.207542658f, 5.30934334f, + 6.98481846f, 3.59414673f, -4.8866663f, 1.89887166f, -6.55064201f, 8.98200798f, + 7.33795881f, 0.911767066f, -3.07373118f, -1.65058112f, 9.87658215f, 4.42282248f, + -4.33662319f, -1.41493881f, -3.5409596f, -2.69988179f, 2.52093744f, -0.441765338f, + 1.6403774f, 4.24094868f, 0.392781258f, 6.43150616f, -5.9339304f, 4.80007315f, + -5.41856337f, -1.54067719f, -8.46905231f, -7.86352682f, 5.66554976f, -2.4852109f, + 6.37024069f, 4.18795681f, 4.63525343f, 3.44285727f, -1.88618994f, 2.85931182f, + -0.816832304f, 0.728140175f, 1.7042836f, 10.6137381f, 2.90230989f, 2.98235822f, + 0.817629635f, 6.94309998f, -2.70680141f, -5.44154406f, -4.81726694f, -2.25688267f, + -2.27300429f, -1.05039704f, 2.2591238f, 0.826315701f, -0.701942623f, -3.45002627f, + 4.5378437f, 1.10647321f, -1.3264854f, -0.921284139f, -2.83257651f, 2.49841142f, + 4.64022827f, -2.76605725f, 7.86112881f, -0.646013916f, 1.09402275f, 3.27622962f, + -3.27321863f, 6.67669821f, -0.60309124f, 0.900751233f, +}; + +inline constexpr float kLtxTowerPaddedStateF32_9[] = { + 1.77527249f, 3.05008364f, -0.310450286f, 1.56941378f, 0.864331841f, -2.78051877f, + -0.262544394f, -6.03421593f, 0.677797616f, 1.75279713f, 0.191902384f, -4.33927965f, + -0.363019556f, -0.0792832747f, 1.25277925f, -0.941821218f, 0.724803448f, -3.2774477f, + 2.2957716f, -0.569039702f, 0.353085697f, -0.349209517f, 1.67639112f, -3.9178412f, + 2.55498266f, -2.08293605f, -2.8751502f, 2.41129971f, -0.393715054f, 2.55238271f, + 2.75660157f, -0.0948334113f, 1.77527249f, 3.05008364f, -0.310450286f, 1.56941378f, + 0.864331841f, -2.78051877f, -0.262544394f, -6.03421593f, 0.677797616f, 1.75279713f, + 0.191902384f, -4.33927965f, -0.363019556f, -0.0792832747f, 1.25277925f, -0.941821218f, + 0.724803448f, -3.2774477f, 2.2957716f, -0.569039702f, 0.353085697f, -0.349209517f, + 1.67639112f, -3.9178412f, 2.55498266f, -2.08293605f, -2.8751502f, 2.41129971f, + -0.393715054f, 2.55238271f, 2.75660157f, -0.0948334113f, 1.77527249f, 3.05008364f, + -0.310450286f, 1.56941378f, 0.864331841f, -2.78051877f, -0.262544394f, -6.03421593f, + 0.677797616f, 1.75279713f, 0.191902384f, -4.33927965f, -0.363019556f, -0.0792832747f, + 1.25277925f, -0.941821218f, 0.724803448f, -3.2774477f, 2.2957716f, -0.569039702f, + 0.353085697f, -0.349209517f, 1.67639112f, -3.9178412f, 2.55498266f, -2.08293605f, + -2.8751502f, 2.41129971f, -0.393715054f, 2.55238271f, 2.75660157f, -0.0948334113f, + 1.77527249f, 3.05008364f, -0.310450286f, 1.56941378f, 0.864331841f, -2.78051877f, + -0.262544394f, -6.03421593f, 0.677797616f, 1.75279713f, 0.191902384f, -4.33927965f, + -0.363019556f, -0.0792832747f, 1.25277925f, -0.941821218f, 0.724803448f, -3.2774477f, + 2.2957716f, -0.569039702f, 0.353085697f, -0.349209517f, 1.67639112f, -3.9178412f, + 2.55498266f, -2.08293605f, -2.8751502f, 2.41129971f, -0.393715054f, 2.55238271f, + 2.75660157f, -0.0948334113f, 1.77527249f, 3.05008364f, -0.310450286f, 1.56941378f, + 0.864331841f, -2.78051877f, -0.262544394f, -6.03421593f, 0.677797616f, 1.75279713f, + 0.191902384f, -4.33927965f, -0.363019556f, -0.0792832747f, 1.25277925f, -0.941821218f, + 0.724803448f, -3.2774477f, 2.2957716f, -0.569039702f, 0.353085697f, -0.349209517f, + 1.67639112f, -3.9178412f, 2.55498266f, -2.08293605f, -2.8751502f, 2.41129971f, + -0.393715054f, 2.55238271f, 2.75660157f, -0.0948334113f, 1.77527249f, 3.05008364f, + -0.310450286f, 1.56941378f, 0.864331841f, -2.78051877f, -0.262544394f, -6.03421593f, + 0.677797616f, 1.75279713f, 0.191902384f, -4.33927965f, -0.363019556f, -0.0792832747f, + 1.25277925f, -0.941821218f, 0.724803448f, -3.2774477f, 2.2957716f, -0.569039702f, + 0.353085697f, -0.349209517f, 1.67639112f, -3.9178412f, 2.55498266f, -2.08293605f, + -2.8751502f, 2.41129971f, -0.393715054f, 2.55238271f, 2.75660157f, -0.0948334113f, + 1.77527249f, 3.05008364f, -0.310450286f, 1.56941378f, 0.864331841f, -2.78051877f, + -0.262544394f, -6.03421593f, 0.677797616f, 1.75279713f, 0.191902384f, -4.33927965f, + -0.363019556f, -0.0792832747f, 1.25277925f, -0.941821218f, 0.724803448f, -3.2774477f, + 2.2957716f, -0.569039702f, 0.353085697f, -0.349209517f, 1.67639112f, -3.9178412f, + 2.55498266f, -2.08293605f, -2.8751502f, 2.41129971f, -0.393715054f, 2.55238271f, + 2.75660157f, -0.0948334113f, 1.77527249f, 3.05008364f, -0.310450286f, 1.56941378f, + 0.864331841f, -2.78051877f, -0.262544394f, -6.03421593f, 0.677797616f, 1.75279713f, + 0.191902384f, -4.33927965f, -0.363019556f, -0.0792832747f, 1.25277925f, -0.941821218f, + 0.724803448f, -3.2774477f, 2.2957716f, -0.569039702f, 0.353085697f, -0.349209517f, + 1.67639112f, -3.9178412f, 2.55498266f, -2.08293605f, -2.8751502f, 2.41129971f, + -0.393715054f, 2.55238271f, 2.75660157f, -0.0948334113f, 1.77527249f, 3.05008364f, + -0.310450286f, 1.56941378f, 0.864331841f, -2.78051877f, -0.262544394f, -6.03421593f, + 0.677797616f, 1.75279713f, 0.191902384f, -4.33927965f, -0.363019556f, -0.0792832747f, + 1.25277925f, -0.941821218f, 0.724803448f, -3.2774477f, 2.2957716f, -0.569039702f, + 0.353085697f, -0.349209517f, 1.67639112f, -3.9178412f, 2.55498266f, -2.08293605f, + -2.8751502f, 2.41129971f, -0.393715054f, 2.55238271f, 2.75660157f, -0.0948334113f, + 1.77527249f, 3.05008364f, -0.310450286f, 1.56941378f, 0.864331841f, -2.78051877f, + -0.262544394f, -6.03421593f, 0.677797616f, 1.75279713f, 0.191902384f, -4.33927965f, + -0.363019556f, -0.0792832747f, 1.25277925f, -0.941821218f, 0.724803448f, -3.2774477f, + 2.2957716f, -0.569039702f, 0.353085697f, -0.349209517f, 1.67639112f, -3.9178412f, + 2.55498266f, -2.08293605f, -2.8751502f, 2.41129971f, -0.393715054f, 2.55238271f, + 2.75660157f, -0.0948334113f, 1.77527249f, 3.05008364f, -0.310450286f, 1.56941378f, + 0.864331841f, -2.78051877f, -0.262544394f, -6.03421593f, 0.677797616f, 1.75279713f, + 0.191902384f, -4.33927965f, -0.363019556f, -0.0792832747f, 1.25277925f, -0.941821218f, + 0.724803448f, -3.2774477f, 2.2957716f, -0.569039702f, 0.353085697f, -0.349209517f, + 1.67639112f, -3.9178412f, 2.55498266f, -2.08293605f, -2.8751502f, 2.41129971f, + -0.393715054f, 2.55238271f, 2.75660157f, -0.0948334113f, 1.77527249f, 3.05008364f, + -0.310450286f, 1.56941378f, 0.864331841f, -2.78051877f, -0.262544394f, -6.03421593f, + 0.677797616f, 1.75279713f, 0.191902384f, -4.33927965f, -0.363019556f, -0.0792832747f, + 1.25277925f, -0.941821218f, 0.724803448f, -3.2774477f, 2.2957716f, -0.569039702f, + 0.353085697f, -0.349209517f, 1.67639112f, -3.9178412f, 2.55498266f, -2.08293605f, + -2.8751502f, 2.41129971f, -0.393715054f, 2.55238271f, 2.75660157f, -0.0948334113f, + -7.98905897f, 1.07012022f, 1.19448471f, -0.168709204f, -4.15389872f, 2.86906886f, + 1.27955115f, 0.408624649f, 4.16084051f, 4.67889118f, -1.44683444f, 0.189235747f, + -9.41539288f, -3.21791267f, 2.46761465f, -0.129669294f, 2.1088903f, 0.446422815f, + 3.13126969f, -4.06435061f, -9.45978832f, 5.5650177f, 0.769539416f, -5.90411139f, + 5.13654423f, -0.319432467f, 0.758417785f, 5.06055832f, 2.68431973f, -2.65829706f, + -0.660979867f, 0.987872839f, -7.67150259f, 0.643167317f, 5.74502563f, -2.95759678f, + -8.08774185f, 6.25484562f, -0.241304621f, 2.7627902f, 0.876072705f, 3.17129683f, + -3.42475176f, -0.197382346f, -5.08726549f, -1.52660263f, 2.29195452f, 0.958854616f, + 1.72880995f, -0.767128706f, -2.6348114f, -1.00532019f, -2.13766646f, 8.26471901f, + 3.94305229f, -2.46654558f, 6.4319768f, 3.21981049f, 4.98324299f, 3.07139945f, + 2.2177515f, 0.811169684f, -3.94560099f, -1.0547682f, -4.30961084f, -6.91310024f, + -2.61510277f, -1.76354933f, -6.04874086f, 3.91933298f, 0.263273001f, -0.867836118f, + 2.17170572f, -0.193242997f, -1.0908438f, -0.739084601f, -5.10515594f, -4.95321894f, + 3.87039852f, -0.318408579f, 1.48042834f, -3.77579045f, 0.289962709f, -2.12128639f, + -1.12821209f, 0.0341949202f, 3.95418763f, -10.6329985f, 6.59719038f, 5.60995436f, + 4.79320908f, 10.2210121f, 3.70216417f, -4.68351936f, 1.25988817f, 2.39871407f, + 1.81124258f, 6.63322735f, 3.20519161f, -2.46089578f, 5.38631344f, 1.24171305f, + 1.25905311f, -5.95293999f, -7.33143044f, -5.07118702f, -2.20297027f, -3.89829874f, + -3.77383471f, 0.430526167f, -0.315758914f, 2.79644561f, 1.68690991f, -1.05229104f, + 2.01595259f, 1.5548749f, -1.07118714f, 4.07565975f, 0.14050661f, -8.12673187f, + 11.0483046f, -2.15383768f, 4.49366045f, 7.01211452f, -0.597829759f, 5.14258718f, + -4.5844903f, 3.85675144f, -1.30029905f, -1.8599664f, -4.02640581f, 3.70488453f, + -1.59436774f, 5.17573166f, 0.373488575f, 5.13692236f, 4.29778624f, -0.83383894f, + 1.63380611f, -4.04556036f, -2.23220921f, 3.0226748f, 4.28462315f, -4.07088995f, + 1.76567459f, -6.86711407f, 0.0716523379f, -0.058796037f, 1.46619296f, 0.872004092f, + -0.0252493843f, -5.36626196f, 1.03184021f, 2.91668129f, 5.0266819f, 2.2033143f, + -4.19885206f, -0.810671806f, -9.19921684f, 1.97324657f, 4.16573715f, 1.44949365f, + 1.19004726f, -1.77794909f, -3.10038495f, 7.07435274f, -6.13624907f, -1.24591768f, + 7.40163374f, 4.56154346f, 1.59572029f, 3.11537838f, 2.66523576f, 3.2964592f, + -1.98626173f, -1.2262578f, -2.43333101f, -4.59958124f, -3.37576795f, 0.0782872215f, + 4.45073175f, -0.638530076f, 2.10426593f, -4.61067104f, 0.372735113f, 4.99672747f, + 6.44558287f, 4.95810318f, -3.53180885f, -0.270193726f, -3.37528181f, 8.98018551f, + 7.76609802f, 4.20482445f, -1.30723655f, -0.287961423f, 11.2429733f, 1.75975835f, + -3.69972849f, -1.67073417f, -2.12870574f, -1.9937377f, 3.73860264f, -1.74882197f, + 0.57954818f, 5.95223045f, 0.336499184f, 7.57776785f, -5.9131217f, 6.00866222f, + -3.93735504f, -0.791872621f, -7.21986723f, -5.99231958f, 5.19560337f, -1.63746238f, + 2.86522174f, 3.18311548f, 4.32468843f, 3.89604068f, -2.76666164f, 2.85873818f, + -0.15784806f, 0.720757127f, 2.96551538f, 11.3587322f, 0.573656023f, 0.388863504f, + 1.95281422f, 6.46769762f, -2.63912845f, -6.02555847f, -4.97968197f, -0.642936051f, + -0.564658582f, 1.34927571f, 1.12826979f, 2.33937526f, 0.948639989f, -3.13693738f, + 5.79861355f, 0.926389277f, -0.166503221f, 0.607437074f, -1.31628466f, 4.58770323f, + 6.73905277f, -3.54981208f, 7.82219887f, -0.879952371f, 2.00372386f, 4.32768631f, + -3.16756177f, 5.10808277f, -0.98144716f, -1.29989374f, +}; + +inline constexpr float kLtxTowerPaddedStateF32_10[] = { + 3.41198683f, 2.43720818f, 0.76479429f, 3.32348967f, 1.41367483f, -3.44894075f, + 0.634648204f, -6.9244132f, -0.0402011722f, 0.840222716f, -1.47001386f, -5.60868692f, + -0.963606119f, 1.66755605f, 2.71319389f, -0.238339618f, 0.50602144f, -3.09030652f, + 1.59111106f, -0.0517496876f, -0.557746232f, -0.0230283737f, 1.98797059f, -4.30692625f, + 2.67475462f, -3.13374448f, -2.84884548f, 2.77193379f, 0.415070772f, 2.77019644f, + 3.63640308f, 1.82852483f, 3.41198683f, 2.43720818f, 0.76479429f, 3.32348967f, + 1.41367483f, -3.44894075f, 0.634648204f, -6.9244132f, -0.0402011722f, 0.840222716f, + -1.47001386f, -5.60868692f, -0.963606119f, 1.66755605f, 2.71319389f, -0.238339618f, + 0.50602144f, -3.09030652f, 1.59111106f, -0.0517496876f, -0.557746232f, -0.0230283737f, + 1.98797059f, -4.30692625f, 2.67475462f, -3.13374448f, -2.84884548f, 2.77193379f, + 0.415070772f, 2.77019644f, 3.63640308f, 1.82852483f, 3.41198683f, 2.43720818f, + 0.76479429f, 3.32348967f, 1.41367483f, -3.44894075f, 0.634648204f, -6.9244132f, + -0.0402011722f, 0.840222716f, -1.47001386f, -5.60868692f, -0.963606119f, 1.66755605f, + 2.71319389f, -0.238339618f, 0.50602144f, -3.09030652f, 1.59111106f, -0.0517496876f, + -0.557746232f, -0.0230283737f, 1.98797059f, -4.30692625f, 2.67475462f, -3.13374448f, + -2.84884548f, 2.77193379f, 0.415070772f, 2.77019644f, 3.63640308f, 1.82852483f, + 3.41198683f, 2.43720818f, 0.76479429f, 3.32348967f, 1.41367483f, -3.44894075f, + 0.634648204f, -6.9244132f, -0.0402011722f, 0.840222716f, -1.47001386f, -5.60868692f, + -0.963606119f, 1.66755605f, 2.71319389f, -0.238339618f, 0.50602144f, -3.09030652f, + 1.59111106f, -0.0517496876f, -0.557746232f, -0.0230283737f, 1.98797059f, -4.30692625f, + 2.67475462f, -3.13374448f, -2.84884548f, 2.77193379f, 0.415070772f, 2.77019644f, + 3.63640308f, 1.82852483f, 3.41198683f, 2.43720818f, 0.76479429f, 3.32348967f, + 1.41367483f, -3.44894075f, 0.634648204f, -6.9244132f, -0.0402011722f, 0.840222716f, + -1.47001386f, -5.60868692f, -0.963606119f, 1.66755605f, 2.71319389f, -0.238339618f, + 0.50602144f, -3.09030652f, 1.59111106f, -0.0517496876f, -0.557746232f, -0.0230283737f, + 1.98797059f, -4.30692625f, 2.67475462f, -3.13374448f, -2.84884548f, 2.77193379f, + 0.415070772f, 2.77019644f, 3.63640308f, 1.82852483f, 3.41198683f, 2.43720818f, + 0.76479429f, 3.32348967f, 1.41367483f, -3.44894075f, 0.634648204f, -6.9244132f, + -0.0402011722f, 0.840222716f, -1.47001386f, -5.60868692f, -0.963606119f, 1.66755605f, + 2.71319389f, -0.238339618f, 0.50602144f, -3.09030652f, 1.59111106f, -0.0517496876f, + -0.557746232f, -0.0230283737f, 1.98797059f, -4.30692625f, 2.67475462f, -3.13374448f, + -2.84884548f, 2.77193379f, 0.415070772f, 2.77019644f, 3.63640308f, 1.82852483f, + 3.41198683f, 2.43720818f, 0.76479429f, 3.32348967f, 1.41367483f, -3.44894075f, + 0.634648204f, -6.9244132f, -0.0402011722f, 0.840222716f, -1.47001386f, -5.60868692f, + -0.963606119f, 1.66755605f, 2.71319389f, -0.238339618f, 0.50602144f, -3.09030652f, + 1.59111106f, -0.0517496876f, -0.557746232f, -0.0230283737f, 1.98797059f, -4.30692625f, + 2.67475462f, -3.13374448f, -2.84884548f, 2.77193379f, 0.415070772f, 2.77019644f, + 3.63640308f, 1.82852483f, 3.41198683f, 2.43720818f, 0.76479429f, 3.32348967f, + 1.41367483f, -3.44894075f, 0.634648204f, -6.9244132f, -0.0402011722f, 0.840222716f, + -1.47001386f, -5.60868692f, -0.963606119f, 1.66755605f, 2.71319389f, -0.238339618f, + 0.50602144f, -3.09030652f, 1.59111106f, -0.0517496876f, -0.557746232f, -0.0230283737f, + 1.98797059f, -4.30692625f, 2.67475462f, -3.13374448f, -2.84884548f, 2.77193379f, + 0.415070772f, 2.77019644f, 3.63640308f, 1.82852483f, 3.41198683f, 2.43720818f, + 0.76479429f, 3.32348967f, 1.41367483f, -3.44894075f, 0.634648204f, -6.9244132f, + -0.0402011722f, 0.840222716f, -1.47001386f, -5.60868692f, -0.963606119f, 1.66755605f, + 2.71319389f, -0.238339618f, 0.50602144f, -3.09030652f, 1.59111106f, -0.0517496876f, + -0.557746232f, -0.0230283737f, 1.98797059f, -4.30692625f, 2.67475462f, -3.13374448f, + -2.84884548f, 2.77193379f, 0.415070772f, 2.77019644f, 3.63640308f, 1.82852483f, + 3.41198683f, 2.43720818f, 0.76479429f, 3.32348967f, 1.41367483f, -3.44894075f, + 0.634648204f, -6.9244132f, -0.0402011722f, 0.840222716f, -1.47001386f, -5.60868692f, + -0.963606119f, 1.66755605f, 2.71319389f, -0.238339618f, 0.50602144f, -3.09030652f, + 1.59111106f, -0.0517496876f, -0.557746232f, -0.0230283737f, 1.98797059f, -4.30692625f, + 2.67475462f, -3.13374448f, -2.84884548f, 2.77193379f, 0.415070772f, 2.77019644f, + 3.63640308f, 1.82852483f, 3.41198683f, 2.43720818f, 0.76479429f, 3.32348967f, + 1.41367483f, -3.44894075f, 0.634648204f, -6.9244132f, -0.0402011722f, 0.840222716f, + -1.47001386f, -5.60868692f, -0.963606119f, 1.66755605f, 2.71319389f, -0.238339618f, + 0.50602144f, -3.09030652f, 1.59111106f, -0.0517496876f, -0.557746232f, -0.0230283737f, + 1.98797059f, -4.30692625f, 2.67475462f, -3.13374448f, -2.84884548f, 2.77193379f, + 0.415070772f, 2.77019644f, 3.63640308f, 1.82852483f, 3.41198683f, 2.43720818f, + 0.76479429f, 3.32348967f, 1.41367483f, -3.44894075f, 0.634648204f, -6.9244132f, + -0.0402011722f, 0.840222716f, -1.47001386f, -5.60868692f, -0.963606119f, 1.66755605f, + 2.71319389f, -0.238339618f, 0.50602144f, -3.09030652f, 1.59111106f, -0.0517496876f, + -0.557746232f, -0.0230283737f, 1.98797059f, -4.30692625f, 2.67475462f, -3.13374448f, + -2.84884548f, 2.77193379f, 0.415070772f, 2.77019644f, 3.63640308f, 1.82852483f, + -8.52307224f, 1.10527396f, 1.78683031f, 2.90404677f, -4.35291004f, 3.03260446f, + 1.82637274f, 0.639061034f, 6.466434f, 5.93906546f, -0.706212997f, 0.425357282f, + -9.81959152f, -4.4940567f, 3.27147007f, 2.92910361f, 1.10508645f, -1.71333182f, + 6.56148815f, -3.95104432f, -12.8597584f, 4.39411736f, -0.138561472f, -6.2195363f, + 5.64308929f, 0.44396773f, 0.605854452f, 4.83758545f, 3.75780487f, -0.980947554f, + -0.10482654f, 2.67226958f, -8.71560097f, 1.15856838f, 5.68391466f, 1.44166744f, + -9.43969059f, 8.50172043f, -0.912139595f, 3.33707523f, 2.06523395f, 4.56964302f, + -2.60918713f, -0.0348035321f, -4.85170746f, -3.20843053f, 4.35588312f, 3.63455749f, + 1.63123345f, -2.66728163f, 0.120158255f, -0.836102903f, -4.92555141f, 7.94207144f, + 2.69203067f, -2.43038487f, 6.41482019f, 3.14020491f, 5.03237581f, 2.67947459f, + 3.18261099f, 2.80264735f, -2.97319007f, 0.0178108644f, -6.36221266f, -4.33498192f, + -3.37221241f, -0.140348122f, -7.45824051f, 4.70948935f, 0.54272455f, -2.41908622f, + 3.07212853f, 0.424789608f, -1.53393281f, 0.637811422f, -5.52330017f, -7.59293747f, + 3.8204596f, 0.214623377f, 3.02930546f, -4.58302498f, 1.3218627f, -1.73219478f, + -1.72003114f, -1.69076014f, 4.19020176f, -10.6886959f, 7.65370464f, 7.77021217f, + 5.52832317f, 10.5101461f, 3.77356553f, -3.00501943f, 2.35680819f, 3.7947526f, + 1.58181965f, 8.6747036f, 1.57725179f, -0.241350234f, 5.89169502f, -0.613854647f, + 2.4338243f, -8.51373291f, -7.57148218f, -3.52645922f, -3.34064889f, -6.26339912f, + -3.89664531f, -0.426029235f, 0.94037503f, 2.25122666f, 1.70227349f, -0.131403014f, + 3.07712913f, 2.99763012f, -3.03327131f, 3.25344014f, -1.03305638f, -10.3859673f, + 11.769104f, -0.824490011f, 5.2857008f, 7.69731474f, 0.527998328f, 5.14401817f, + -3.61631584f, 4.28267956f, -3.02899647f, -0.249358967f, -4.35161734f, 7.97448492f, + -1.21993899f, 7.50264311f, 1.79126203f, 5.55331039f, 4.66712046f, -2.02364683f, + 2.54988647f, -4.81048965f, -1.14183867f, 0.94774282f, 6.27718163f, -3.80280757f, + 3.14343262f, -6.71192169f, 1.5611583f, 1.32365751f, -0.153946817f, -0.403985947f, + -0.579913974f, -6.40792131f, 1.80746615f, 4.4978466f, 5.64353609f, 1.53104067f, + -3.92614031f, 1.2499938f, -8.24410725f, 1.20976138f, 4.63189363f, 3.24145389f, + 2.63279128f, 1.46484661f, -4.18165255f, 7.34664488f, -5.82988787f, -1.67284429f, + 10.1357718f, 4.4629364f, 0.922057331f, 2.20665073f, 2.21271825f, 1.28745329f, + -0.493269324f, -0.513631165f, -0.887152493f, -3.36502171f, -2.36804891f, 0.941769421f, + 3.04302216f, -1.96978533f, 2.2857635f, -3.23394203f, -0.239285499f, 4.53762579f, + 8.26843548f, 4.68438911f, -1.6300981f, 3.45182347f, -2.76690054f, 10.7650251f, + 8.71631718f, 4.736444f, -3.18021798f, -0.256393075f, 13.0049295f, -1.81585181f, + -5.3054347f, -3.25520492f, 0.0510792024f, -2.47938919f, 1.24809504f, -4.47247934f, + 0.0437133908f, 4.57214069f, 1.12135243f, 6.01977968f, -7.2627573f, 5.06950808f, + -2.15192032f, 1.11115742f, -6.71810818f, -4.78780746f, 5.10318089f, -3.31369734f, + 3.26128197f, 2.61802864f, 6.1873126f, 6.07846308f, -1.5938096f, 3.48768091f, + -0.0703490376f, 0.543764889f, 3.56111073f, 13.3205462f, -0.181255206f, 1.25001442f, + 1.37158203f, 4.62317801f, -2.91592717f, -7.58690739f, -4.26948547f, -0.821265757f, + -2.38568974f, 0.546114504f, 2.65365815f, -0.305452079f, 1.98464811f, -4.73073244f, + 4.56215239f, 1.23554468f, 0.431498379f, -0.170910791f, -0.339073241f, 5.52192068f, + 6.69706774f, -4.16263008f, 7.35558653f, -1.51313782f, 2.40459085f, 6.98451376f, + -3.37214756f, 4.96741772f, -1.29108572f, -1.91056776f, +}; + +inline constexpr float kLtxTowerPaddedStateF32_11[] = { + 3.42727518f, 2.90548015f, 2.01855278f, 2.93839979f, 3.54888725f, -3.49904418f, + 0.634403527f, -6.53481245f, -0.193163797f, -0.647185087f, -1.03758585f, -4.98448038f, + -0.207696125f, 1.23268521f, 3.45181179f, -1.38858378f, 0.601995349f, -1.33041418f, + 2.78149748f, 0.338498771f, -1.71215212f, -1.6425277f, 1.29907405f, -3.76800442f, + 3.37623382f, -2.81731915f, -2.06774402f, 3.37959766f, 0.509137809f, 4.55495596f, + 3.32078528f, 0.61680603f, 3.42727518f, 2.90548015f, 2.01855278f, 2.93839979f, + 3.54888725f, -3.49904418f, 0.634403527f, -6.53481245f, -0.193163797f, -0.647185087f, + -1.03758585f, -4.98448038f, -0.207696125f, 1.23268521f, 3.45181179f, -1.38858378f, + 0.601995349f, -1.33041418f, 2.78149748f, 0.338498771f, -1.71215212f, -1.6425277f, + 1.29907405f, -3.76800442f, 3.37623382f, -2.81731915f, -2.06774402f, 3.37959766f, + 0.509137809f, 4.55495596f, 3.32078528f, 0.61680603f, 3.42727518f, 2.90548015f, + 2.01855278f, 2.93839979f, 3.54888725f, -3.49904418f, 0.634403527f, -6.53481245f, + -0.193163797f, -0.647185087f, -1.03758585f, -4.98448038f, -0.207696125f, 1.23268521f, + 3.45181179f, -1.38858378f, 0.601995349f, -1.33041418f, 2.78149748f, 0.338498771f, + -1.71215212f, -1.6425277f, 1.29907405f, -3.76800442f, 3.37623382f, -2.81731915f, + -2.06774402f, 3.37959766f, 0.509137809f, 4.55495596f, 3.32078528f, 0.61680603f, + 3.42727518f, 2.90548015f, 2.01855278f, 2.93839979f, 3.54888725f, -3.49904418f, + 0.634403527f, -6.53481245f, -0.193163797f, -0.647185087f, -1.03758585f, -4.98448038f, + -0.207696125f, 1.23268521f, 3.45181179f, -1.38858378f, 0.601995349f, -1.33041418f, + 2.78149748f, 0.338498771f, -1.71215212f, -1.6425277f, 1.29907405f, -3.76800442f, + 3.37623382f, -2.81731915f, -2.06774402f, 3.37959766f, 0.509137809f, 4.55495596f, + 3.32078528f, 0.61680603f, 3.42727518f, 2.90548015f, 2.01855278f, 2.93839979f, + 3.54888725f, -3.49904418f, 0.634403527f, -6.53481245f, -0.193163797f, -0.647185087f, + -1.03758585f, -4.98448038f, -0.207696125f, 1.23268521f, 3.45181179f, -1.38858378f, + 0.601995349f, -1.33041418f, 2.78149748f, 0.338498771f, -1.71215212f, -1.6425277f, + 1.29907405f, -3.76800442f, 3.37623382f, -2.81731915f, -2.06774402f, 3.37959766f, + 0.509137809f, 4.55495596f, 3.32078528f, 0.61680603f, 3.42727518f, 2.90548015f, + 2.01855278f, 2.93839979f, 3.54888725f, -3.49904418f, 0.634403527f, -6.53481245f, + -0.193163797f, -0.647185087f, -1.03758585f, -4.98448038f, -0.207696125f, 1.23268521f, + 3.45181179f, -1.38858378f, 0.601995349f, -1.33041418f, 2.78149748f, 0.338498771f, + -1.71215212f, -1.6425277f, 1.29907405f, -3.76800442f, 3.37623382f, -2.81731915f, + -2.06774402f, 3.37959766f, 0.509137809f, 4.55495596f, 3.32078528f, 0.61680603f, + 3.42727518f, 2.90548015f, 2.01855278f, 2.93839979f, 3.54888725f, -3.49904418f, + 0.634403527f, -6.53481245f, -0.193163797f, -0.647185087f, -1.03758585f, -4.98448038f, + -0.207696125f, 1.23268521f, 3.45181179f, -1.38858378f, 0.601995349f, -1.33041418f, + 2.78149748f, 0.338498771f, -1.71215212f, -1.6425277f, 1.29907405f, -3.76800442f, + 3.37623382f, -2.81731915f, -2.06774402f, 3.37959766f, 0.509137809f, 4.55495596f, + 3.32078528f, 0.61680603f, 3.42727518f, 2.90548015f, 2.01855278f, 2.93839979f, + 3.54888725f, -3.49904418f, 0.634403527f, -6.53481245f, -0.193163797f, -0.647185087f, + -1.03758585f, -4.98448038f, -0.207696125f, 1.23268521f, 3.45181179f, -1.38858378f, + 0.601995349f, -1.33041418f, 2.78149748f, 0.338498771f, -1.71215212f, -1.6425277f, + 1.29907405f, -3.76800442f, 3.37623382f, -2.81731915f, -2.06774402f, 3.37959766f, + 0.509137809f, 4.55495596f, 3.32078528f, 0.61680603f, 3.42727518f, 2.90548015f, + 2.01855278f, 2.93839979f, 3.54888725f, -3.49904418f, 0.634403527f, -6.53481245f, + -0.193163797f, -0.647185087f, -1.03758585f, -4.98448038f, -0.207696125f, 1.23268521f, + 3.45181179f, -1.38858378f, 0.601995349f, -1.33041418f, 2.78149748f, 0.338498771f, + -1.71215212f, -1.6425277f, 1.29907405f, -3.76800442f, 3.37623382f, -2.81731915f, + -2.06774402f, 3.37959766f, 0.509137809f, 4.55495596f, 3.32078528f, 0.61680603f, + 3.42727518f, 2.90548015f, 2.01855278f, 2.93839979f, 3.54888725f, -3.49904418f, + 0.634403527f, -6.53481245f, -0.193163797f, -0.647185087f, -1.03758585f, -4.98448038f, + -0.207696125f, 1.23268521f, 3.45181179f, -1.38858378f, 0.601995349f, -1.33041418f, + 2.78149748f, 0.338498771f, -1.71215212f, -1.6425277f, 1.29907405f, -3.76800442f, + 3.37623382f, -2.81731915f, -2.06774402f, 3.37959766f, 0.509137809f, 4.55495596f, + 3.32078528f, 0.61680603f, 3.42727518f, 2.90548015f, 2.01855278f, 2.93839979f, + 3.54888725f, -3.49904418f, 0.634403527f, -6.53481245f, -0.193163797f, -0.647185087f, + -1.03758585f, -4.98448038f, -0.207696125f, 1.23268521f, 3.45181179f, -1.38858378f, + 0.601995349f, -1.33041418f, 2.78149748f, 0.338498771f, -1.71215212f, -1.6425277f, + 1.29907405f, -3.76800442f, 3.37623382f, -2.81731915f, -2.06774402f, 3.37959766f, + 0.509137809f, 4.55495596f, 3.32078528f, 0.61680603f, 3.42727518f, 2.90548015f, + 2.01855278f, 2.93839979f, 3.54888725f, -3.49904418f, 0.634403527f, -6.53481245f, + -0.193163797f, -0.647185087f, -1.03758585f, -4.98448038f, -0.207696125f, 1.23268521f, + 3.45181179f, -1.38858378f, 0.601995349f, -1.33041418f, 2.78149748f, 0.338498771f, + -1.71215212f, -1.6425277f, 1.29907405f, -3.76800442f, 3.37623382f, -2.81731915f, + -2.06774402f, 3.37959766f, 0.509137809f, 4.55495596f, 3.32078528f, 0.61680603f, + -10.4740276f, 0.437290102f, 2.24770164f, 4.01959515f, -5.66471004f, 1.91573715f, + 1.07405579f, 0.951644063f, 4.8576436f, 8.86246395f, -1.30542302f, 1.14762485f, + -9.0353775f, -5.09133434f, 2.99516034f, 1.2989912f, 1.02667689f, -1.35771024f, + 4.10051966f, -5.11249971f, -14.3474884f, 3.33703589f, -0.486126631f, -5.90158272f, + 6.8576932f, 1.98699152f, -0.396765739f, 7.69790554f, 1.59108329f, 0.919567466f, + -2.03158998f, 0.711704075f, -10.3877859f, -1.31962562f, 6.39246178f, 1.0515976f, + -10.3229322f, 7.5520916f, -1.67549145f, 4.46362829f, 0.709875047f, 7.01930428f, + -3.7043376f, -0.134693831f, -5.26708937f, -3.44427228f, 5.37965918f, 2.06768203f, + 1.74756467f, -3.02755427f, -1.97741723f, -0.973179817f, -4.6875062f, 8.60925007f, + 4.14784098f, -2.732584f, 7.19731379f, 3.23814344f, 5.16963196f, 6.43130827f, + 0.240472719f, 3.99888134f, -5.65125847f, -1.36780798f, -8.46560764f, -7.05430079f, + -5.20627546f, -2.23479486f, -7.97986174f, 3.80986738f, 0.61800307f, -2.80251026f, + 4.63140821f, 0.89822346f, 0.0755415931f, 0.934909284f, -5.70480394f, -7.89502907f, + 3.0786469f, -0.249098212f, 4.58073521f, -3.88358521f, -0.904957056f, -2.9685328f, + -2.2367897f, -1.96490157f, 3.64106154f, -11.6475143f, 6.32664442f, 8.41845989f, + 6.22322941f, 12.1318741f, 3.1087513f, -3.41468215f, 1.28740788f, 4.61097956f, + 0.928772986f, 7.94565392f, 1.3576206f, -0.662978053f, 3.8712132f, -0.917520881f, + 4.45765877f, -9.03753853f, -5.00454426f, -4.43963051f, -2.30917978f, -5.39179182f, + -2.51833749f, -4.33348131f, -1.51930237f, -0.94201982f, -1.41358554f, 1.22146034f, + 4.17381763f, 2.73774052f, -3.21300483f, 4.24195671f, -0.949455678f, -11.6483765f, + 10.8230028f, 1.62298787f, 6.8906498f, 9.15462685f, -0.576156378f, 4.65218544f, + -7.10053587f, 4.31332493f, -3.09361982f, 0.281839609f, -3.41008019f, 6.88802195f, + -2.61557007f, 6.52700377f, 2.32888412f, 3.40236735f, 6.73129988f, -0.850880682f, + 3.27160311f, -4.71819258f, -1.38680041f, 0.425177872f, 4.92645311f, -5.1742301f, + 3.21023989f, -6.20494413f, -1.17002296f, 0.505255163f, -2.08124638f, 1.93000579f, + -0.194101229f, -7.22816706f, 2.31304526f, 3.84029675f, 6.58723068f, 3.20652819f, + -4.15768957f, 2.00904059f, -7.96108913f, 0.785572708f, 4.27958918f, 1.72429609f, + 2.2623105f, 1.66874862f, -5.41250801f, 6.41716957f, -6.90256119f, -1.6186868f, + 11.1009989f, 6.25351191f, 1.86715949f, 2.94386888f, 2.22492361f, 2.19609976f, + -2.316293f, -1.03377259f, 0.172304213f, -5.06168604f, -3.5409236f, 0.647434175f, + 1.6167742f, -1.70384514f, 2.94659877f, -5.66172218f, -1.0659219f, 3.27498364f, + 7.51903725f, 6.50902081f, -2.06071734f, 2.98929453f, -3.71027207f, 10.7182531f, + 10.9853086f, 4.6521697f, -5.40753126f, -1.18296003f, 11.5126247f, -1.0509696f, + -3.52282667f, -4.67655563f, 4.11761093f, -3.36638951f, 3.00510311f, -4.10413027f, + 0.804985285f, 2.58839059f, -0.249291807f, 3.9379077f, -8.73401165f, 5.58823824f, + -0.283520937f, 1.37050605f, -5.45151377f, -3.45755982f, 6.27406645f, -2.83341384f, + 3.26758456f, 1.78446782f, 7.36382723f, 6.04614973f, -2.95160437f, 2.31532955f, + -1.55720806f, 0.939495444f, 4.99243212f, 11.9807377f, -1.26893532f, 2.18998504f, + 0.475568265f, 4.15029669f, 0.237803444f, -6.24599266f, -0.391187549f, -1.48575079f, + -0.374416053f, 2.18618059f, 3.75482988f, -2.30727482f, 1.30930555f, -4.41220427f, + 6.46405172f, 2.14554763f, 3.02957916f, -1.49258912f, -0.603358626f, 5.68947697f, + 7.2358098f, -5.93220949f, 7.50483894f, 0.10200686f, 1.67535591f, 4.91259432f, + -3.25572181f, 3.46846914f, 0.212181389f, -2.52899957f, +}; + +inline constexpr float kLtxTowerPaddedStateF32_12[] = { + 0.869327426f, 0.9686414f, 0.54643923f, 0.749640167f, 1.03335738f, -0.572432935f, + 0.110472001f, -2.6498518f, -0.139905825f, -0.263871998f, -0.480561912f, -2.27395654f, + -0.155180693f, -0.121275581f, 0.729579628f, -1.07919812f, 0.461865276f, -0.287372351f, + 0.883831024f, 0.224392891f, -0.819879055f, -0.563893497f, 1.53321111f, -1.45203006f, + 1.40448868f, -1.10659838f, -0.662867725f, 1.14598703f, -0.0183202215f, 1.41993117f, + 1.14741087f, -0.173478276f, 0.869327426f, 0.9686414f, 0.54643923f, 0.749640167f, + 1.03335738f, -0.572432935f, 0.110472001f, -2.6498518f, -0.139905825f, -0.263871998f, + -0.480561912f, -2.27395654f, -0.155180693f, -0.121275581f, 0.729579628f, -1.07919812f, + 0.461865276f, -0.287372351f, 0.883831024f, 0.224392891f, -0.819879055f, -0.563893497f, + 1.53321111f, -1.45203006f, 1.40448868f, -1.10659838f, -0.662867725f, 1.14598703f, + -0.0183202215f, 1.41993117f, 1.14741087f, -0.173478276f, 0.869327426f, 0.9686414f, + 0.54643923f, 0.749640167f, 1.03335738f, -0.572432935f, 0.110472001f, -2.6498518f, + -0.139905825f, -0.263871998f, -0.480561912f, -2.27395654f, -0.155180693f, -0.121275581f, + 0.729579628f, -1.07919812f, 0.461865276f, -0.287372351f, 0.883831024f, 0.224392891f, + -0.819879055f, -0.563893497f, 1.53321111f, -1.45203006f, 1.40448868f, -1.10659838f, + -0.662867725f, 1.14598703f, -0.0183202215f, 1.41993117f, 1.14741087f, -0.173478276f, + 0.869327426f, 0.9686414f, 0.54643923f, 0.749640167f, 1.03335738f, -0.572432935f, + 0.110472001f, -2.6498518f, -0.139905825f, -0.263871998f, -0.480561912f, -2.27395654f, + -0.155180693f, -0.121275581f, 0.729579628f, -1.07919812f, 0.461865276f, -0.287372351f, + 0.883831024f, 0.224392891f, -0.819879055f, -0.563893497f, 1.53321111f, -1.45203006f, + 1.40448868f, -1.10659838f, -0.662867725f, 1.14598703f, -0.0183202215f, 1.41993117f, + 1.14741087f, -0.173478276f, 0.869327426f, 0.9686414f, 0.54643923f, 0.749640167f, + 1.03335738f, -0.572432935f, 0.110472001f, -2.6498518f, -0.139905825f, -0.263871998f, + -0.480561912f, -2.27395654f, -0.155180693f, -0.121275581f, 0.729579628f, -1.07919812f, + 0.461865276f, -0.287372351f, 0.883831024f, 0.224392891f, -0.819879055f, -0.563893497f, + 1.53321111f, -1.45203006f, 1.40448868f, -1.10659838f, -0.662867725f, 1.14598703f, + -0.0183202215f, 1.41993117f, 1.14741087f, -0.173478276f, 0.869327426f, 0.9686414f, + 0.54643923f, 0.749640167f, 1.03335738f, -0.572432935f, 0.110472001f, -2.6498518f, + -0.139905825f, -0.263871998f, -0.480561912f, -2.27395654f, -0.155180693f, -0.121275581f, + 0.729579628f, -1.07919812f, 0.461865276f, -0.287372351f, 0.883831024f, 0.224392891f, + -0.819879055f, -0.563893497f, 1.53321111f, -1.45203006f, 1.40448868f, -1.10659838f, + -0.662867725f, 1.14598703f, -0.0183202215f, 1.41993117f, 1.14741087f, -0.173478276f, + 0.869327426f, 0.9686414f, 0.54643923f, 0.749640167f, 1.03335738f, -0.572432935f, + 0.110472001f, -2.6498518f, -0.139905825f, -0.263871998f, -0.480561912f, -2.27395654f, + -0.155180693f, -0.121275581f, 0.729579628f, -1.07919812f, 0.461865276f, -0.287372351f, + 0.883831024f, 0.224392891f, -0.819879055f, -0.563893497f, 1.53321111f, -1.45203006f, + 1.40448868f, -1.10659838f, -0.662867725f, 1.14598703f, -0.0183202215f, 1.41993117f, + 1.14741087f, -0.173478276f, 0.869327426f, 0.9686414f, 0.54643923f, 0.749640167f, + 1.03335738f, -0.572432935f, 0.110472001f, -2.6498518f, -0.139905825f, -0.263871998f, + -0.480561912f, -2.27395654f, -0.155180693f, -0.121275581f, 0.729579628f, -1.07919812f, + 0.461865276f, -0.287372351f, 0.883831024f, 0.224392891f, -0.819879055f, -0.563893497f, + 1.53321111f, -1.45203006f, 1.40448868f, -1.10659838f, -0.662867725f, 1.14598703f, + -0.0183202215f, 1.41993117f, 1.14741087f, -0.173478276f, 0.869327426f, 0.9686414f, + 0.54643923f, 0.749640167f, 1.03335738f, -0.572432935f, 0.110472001f, -2.6498518f, + -0.139905825f, -0.263871998f, -0.480561912f, -2.27395654f, -0.155180693f, -0.121275581f, + 0.729579628f, -1.07919812f, 0.461865276f, -0.287372351f, 0.883831024f, 0.224392891f, + -0.819879055f, -0.563893497f, 1.53321111f, -1.45203006f, 1.40448868f, -1.10659838f, + -0.662867725f, 1.14598703f, -0.0183202215f, 1.41993117f, 1.14741087f, -0.173478276f, + 0.869327426f, 0.9686414f, 0.54643923f, 0.749640167f, 1.03335738f, -0.572432935f, + 0.110472001f, -2.6498518f, -0.139905825f, -0.263871998f, -0.480561912f, -2.27395654f, + -0.155180693f, -0.121275581f, 0.729579628f, -1.07919812f, 0.461865276f, -0.287372351f, + 0.883831024f, 0.224392891f, -0.819879055f, -0.563893497f, 1.53321111f, -1.45203006f, + 1.40448868f, -1.10659838f, -0.662867725f, 1.14598703f, -0.0183202215f, 1.41993117f, + 1.14741087f, -0.173478276f, 0.869327426f, 0.9686414f, 0.54643923f, 0.749640167f, + 1.03335738f, -0.572432935f, 0.110472001f, -2.6498518f, -0.139905825f, -0.263871998f, + -0.480561912f, -2.27395654f, -0.155180693f, -0.121275581f, 0.729579628f, -1.07919812f, + 0.461865276f, -0.287372351f, 0.883831024f, 0.224392891f, -0.819879055f, -0.563893497f, + 1.53321111f, -1.45203006f, 1.40448868f, -1.10659838f, -0.662867725f, 1.14598703f, + -0.0183202215f, 1.41993117f, 1.14741087f, -0.173478276f, 0.869327426f, 0.9686414f, + 0.54643923f, 0.749640167f, 1.03335738f, -0.572432935f, 0.110472001f, -2.6498518f, + -0.139905825f, -0.263871998f, -0.480561912f, -2.27395654f, -0.155180693f, -0.121275581f, + 0.729579628f, -1.07919812f, 0.461865276f, -0.287372351f, 0.883831024f, 0.224392891f, + -0.819879055f, -0.563893497f, 1.53321111f, -1.45203006f, 1.40448868f, -1.10659838f, + -0.662867725f, 1.14598703f, -0.0183202215f, 1.41993117f, 1.14741087f, -0.173478276f, + -1.95430505f, -0.110438295f, 0.516875148f, 0.972905457f, -1.3906244f, 0.394593f, + -0.0994492546f, 0.210273683f, 1.26857543f, 1.85849893f, -0.16672194f, 0.583491623f, + -1.42908251f, -0.713450074f, 0.68597424f, -0.208518654f, 0.44005242f, -0.342173755f, + 0.835361302f, -0.726223171f, -2.705369f, 0.480481118f, -0.140720487f, -1.39041114f, + 0.983665049f, 0.116292492f, 0.307106793f, 1.38160169f, 0.49981299f, 0.812870264f, + -0.164643705f, 0.179613307f, -1.74931729f, -0.288579166f, 1.39409387f, 0.197409436f, + -2.19801092f, 1.5883621f, -0.839703262f, 1.12294638f, 0.373400658f, 1.54720688f, + -0.512911856f, -0.00649692351f, -0.820076227f, -0.219174877f, 1.059443f, 0.243720219f, + 0.370759666f, -0.740036964f, 0.118275516f, -0.215984136f, -0.964957714f, 1.3907032f, + 0.565508723f, -1.03241801f, 1.58022642f, 0.338675231f, 1.14462376f, 1.07853806f, + 0.0277207978f, 1.27413118f, -0.899445653f, -0.149894878f, -1.32032967f, -1.14739561f, + -1.02280176f, -0.296710372f, -2.02581477f, 0.772616267f, 0.0339149237f, -0.297675937f, + 1.01899791f, 0.236974478f, 0.015459924f, -0.133215383f, -0.711078286f, -1.28036368f, + 0.706687808f, -0.109366961f, 0.87863332f, -0.38571012f, 0.251589239f, -0.320376903f, + -0.77396518f, -0.744703352f, 0.801452041f, -2.18043184f, 1.28679931f, 1.29488564f, + 1.43232191f, 2.05494833f, 0.635779023f, -0.0990467444f, 0.21703057f, 0.960917592f, + 0.21538201f, 1.21963596f, 0.251858801f, -0.160778031f, 0.421952337f, -0.120693445f, + 0.626841962f, -1.54097927f, -0.945828974f, -0.863064051f, -0.278157324f, -1.11969793f, + -0.455500007f, -0.91548562f, -0.811382413f, -0.019283833f, -0.275045961f, 0.074324891f, + 1.11826909f, 0.855544388f, -0.574066401f, 0.679834068f, -0.143765897f, -2.49237037f, + 1.80941761f, 0.174940571f, 1.61162531f, 1.24727082f, -0.095103927f, 1.28048623f, + -1.48414147f, 1.26868761f, -0.727487803f, 0.0142007088f, -0.145832911f, 1.21034789f, + -0.996479511f, 1.69371426f, 0.574038744f, 1.26877367f, 1.28407049f, 0.404159099f, + 0.182630435f, -1.32910168f, -0.521365285f, -0.00485751173f, 1.00215781f, -1.42715132f, + 0.563561618f, -1.52634013f, 0.2296087f, 0.203723088f, -0.339092433f, -0.226484075f, + 0.153143346f, -2.25564027f, 0.45634979f, 0.705762088f, 2.01022077f, 0.706697345f, + -0.664827168f, 1.11195898f, -1.60040665f, 0.435713023f, 0.804510057f, 0.297252476f, + 0.492954433f, 0.364438623f, -1.40678561f, 1.0582248f, -1.77628899f, -0.131722033f, + 2.59635496f, 1.21546376f, 0.371164739f, 0.75448209f, 0.044356212f, 0.818067074f, + -0.410108387f, -0.282752603f, -0.223242834f, -1.19084907f, -0.383880496f, 0.251906693f, + 0.461940229f, -0.624655306f, 0.527876318f, -1.24935436f, -0.44257009f, 0.573611856f, + 1.83284628f, 0.963337541f, -0.0949202552f, 0.681271434f, -0.587772608f, 2.28307176f, + 2.11212635f, 1.40161717f, -1.41692102f, 0.421009779f, 2.07975245f, -0.226825386f, + -0.0522198193f, -1.0211736f, 0.910592616f, -0.461224198f, 0.0656973273f, -0.811019421f, + 0.128312021f, 0.154903635f, 0.0809641257f, 0.551514804f, -2.03809667f, 0.854551554f, + -0.394816846f, 0.861900032f, -1.23810601f, -1.15227199f, 1.2461431f, -0.148462608f, + 0.595833719f, 0.667150259f, 1.45398331f, 1.32830942f, -0.893478096f, 0.759214759f, + -0.331326723f, 0.351397723f, 1.01019847f, 2.37378669f, 0.134113938f, 0.850483f, + -0.499429137f, 1.46495295f, 0.166226998f, -1.32651544f, 0.33374992f, -0.576195002f, + -0.14517498f, 1.04183507f, 0.902168512f, -0.627131999f, -0.0235508941f, -1.03166604f, + 1.32513845f, -0.0976271778f, 1.14109504f, -0.224171206f, 0.116981119f, 1.24365127f, + 1.95854449f, -1.30697942f, 1.66969609f, -0.0354429074f, 0.54967463f, 0.890598416f, + -0.408949643f, 1.14590847f, -0.252561748f, -0.0290292297f, +}; + +// --- section 5: the equivalence, measured INSIDE the oracle --- +// Per state, max|short-run-at-absolute-positions - padded-run's valid rows|, +// both f32, so this number carries NO dtype noise. It is upstream's own +// answer to 'is dropping the pads free?'. Our port inherits it; the C++ +// gate checks the two claims separately so a failure says which one broke. +inline constexpr float kLtxTowerPadEquivalence[] = { + 0.0f, 1.1920929e-06f, 5.7220459e-06f, 5.48362732e-06f, 7.86781311e-06f, 1.23977661e-05f, + 1.87158585e-05f, 2.12192535e-05f, 1.90734863e-05f, 1.8954277e-05f, 2.25305557e-05f, 3.21865082e-05f, + 7.33137131e-06f, +}; + +} // namespace vllm_test diff --git a/tests/vllm/models/ltx2_prompt_tokens_goldens.inc b/tests/vllm/models/ltx2_prompt_tokens_goldens.inc new file mode 100644 index 000000000..003c6c086 --- /dev/null +++ b/tests/vllm/models/ltx2_prompt_tokens_goldens.inc @@ -0,0 +1,574 @@ +// GENERATED by scripts/gen-ltx2-prompt-tokens-goldens.py — DO NOT EDIT. +// +// `LTXGemmaTokenizer.tokenize_with_weights` (tokenizer.py:31-59) over the +// tokenizer the LTX-2.5 text encoder SHIPS AS A TENSOR, run by HuggingFace +// `tokenizers` 0.22.2. +// +// tokenizer_json sha256: cc8d3a0ce36466ccc1278bf987df5f71db1719b9ca6b4118264f45cb627bfe0f +// source: /mnt/nas_share/checkpoints/ltx-2.5/vonkaiser-fp8-nvfp4/text_encoders/gemma4-12b-with-proj-nvfp4-torchao.safetensors +// +// MEASURED on that tokenizer, and the reason upstream prepends BOS by hand +// (tokenizer.py:12-15): its post_processor is `TemplateProcessing` with +// 0 special_tokens, so `add_special_tokens=True` adds NOTHING. +// diffusers relies on exactly that flag (pipeline_ltx2.py:339) and would +// therefore produce a prompt with no BOS; `ltx_core` is followed here. +#pragma once + +#include + +namespace vllm_test { + +inline constexpr int64_t kLtxPromptMaxLength = 1024; +inline constexpr int32_t kLtxPromptBosId = 2; +inline constexpr int32_t kLtxPromptPadId = 0; +inline constexpr int64_t kLtxPromptCount = 4; +inline constexpr const char* kLtxPromptTokenizerSha256 = "cc8d3a0ce36466ccc1278bf987df5f71db1719b9ca6b4118264f45cb627bfe0f"; + +inline constexpr const char* kLtxPromptText[] = { + "a red fox running through deep snow at sunrise", + " a cat sits on a windowsill, watching rain fall ", + "", + "Cinematic wide shot, 35mm: two astronauts walk across a rust-coloured dune field while a ringed planet rises behind them; slow dolly-in, volumetric light, 24 fps.", +}; + +inline constexpr int32_t kLtxPromptValidCount[] = { + 10, 11, 1, 43, +}; + +inline constexpr int32_t kLtxPromptIds_0[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 2, 236746, 2604, 37423, 4710, 1343, 5268, 7613, 657, 36597, +}; + +inline constexpr int32_t kLtxPromptMask_0[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, +}; + +inline constexpr int32_t kLtxPromptIds_1[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 2, 236746, 5866, 23378, 580, 496, 191646, 236764, 10685, 6927, 3798, +}; + +inline constexpr int32_t kLtxPromptMask_1[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, +}; + +inline constexpr int32_t kLtxPromptIds_2[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, +}; + +inline constexpr int32_t kLtxPromptMask_2[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, +}; + +inline constexpr int32_t kLtxPromptIds_3[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 2, 68212, 36340, 5777, 5719, 236764, 236743, 236800, 236810, 3951, 236787, + 1156, 101195, 3727, 3418, 496, 16432, 236772, 84213, 93379, 2135, 1651, 496, 7610, 524, 13401, 33358, + 4977, 1091, 236793, 5111, 153256, 236772, 495, 236764, 94314, 2214, 236764, 236743, 236778, 236812, 51451, 236761, +}; + +inline constexpr int32_t kLtxPromptMask_3[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, +}; + +} // namespace vllm_test diff --git a/tests/vllm/models/test_ltx2_text_encoder.cpp b/tests/vllm/models/test_ltx2_text_encoder.cpp index 70977f361..0b746c502 100644 --- a/tests/vllm/models/test_ltx2_text_encoder.cpp +++ b/tests/vllm/models/test_ltx2_text_encoder.cpp @@ -38,12 +38,16 @@ #include "support/max_abs_diff.h" #include "vllm/model_executor/model_loader/safetensors_reader.h" #include "vllm/model_executor/models/gemma4.h" +#include "vllm/model_executor/models/ltx2_loader.h" #include "vllm/model_executor/models/ltx2_text_encoder.h" +#include "vllm/tokenizer/tokenizer.h" #include "vllm/transformers_utils/hf_config.h" #include "vt/backend.h" #include "vt/dtype.h" #include "ltx2_text_goldens.inc" +#include "ltx2_gemma_tower_goldens.inc" +#include "ltx2_prompt_tokens_goldens.inc" namespace fs = std::filesystem; @@ -369,6 +373,212 @@ vllm::Gemma4Weights TinyGemma4Weights(const vllm::HfConfig& c) { return w; } +// --------------------------------------------------------------------------- +// The Gemma-4 TOWER fixture — the mirror of +// scripts/gen-ltx2-gemma-tower-goldens.py. +// +// Every tensor is rebuilt from the deterministic stream keyed by the same +// HuggingFace parameter NAME the oracle filled, so this side and the oracle +// cannot drift by reordering, and a port that reads the wrong tensor name reads +// different numbers rather than the same numbers in the wrong slot. +// --------------------------------------------------------------------------- + +std::string TowerParam(int64_t layer, const char* suffix) { + return "language_model.layers." + std::to_string(layer) + "." + suffix; +} + +// The generator's `gemma_param_spec`, verbatim. The OFFSETS are the load-bearing +// part: Gemma-4's RMSNorm multiplies by `weight` directly rather than by +// `1 + weight` (modeling_gemma4_unified.py:181-185) and initializes it to ones, +// and `layer_scalar` is a buffer initialized to ones and applied as +// `hidden_states *= layer_scalar` (:501, :535). Centring either on 0 would make a +// port that ignores it pass. +std::vector TowerRand(const std::string& name, int64_t count) { + double scale = 0.05; + double offset = 0.0; + if (EndsWith(name, "layer_scalar") || EndsWith(name, "_layernorm.weight") || + EndsWith(name, "norm.weight")) { + scale = 0.1; + offset = 1.0; + } else if (EndsWith(name, ".bias")) { + scale = 0.02; + } + return Ltx2Make(name, count, scale, offset); +} + +vllm::OwnedTensor TowerTensor(const std::string& name, + const std::vector& shape, bool nk) { + int64_t numel = 1; + for (int64_t d : shape) numel *= d; + const std::vector values = TowerRand(name, numel); + vllm::OwnedTensor o; + o.dtype = vt::DType::kBF16; + o.nk = nk; + o.rank = static_cast(shape.size()); + for (int i = 0; i < o.rank; ++i) o.shape[i] = shape[static_cast(i)]; + o.bytes.resize(static_cast(numel) * sizeof(uint16_t)); + auto* p = reinterpret_cast(o.bytes.data()); + for (int64_t i = 0; i < numel; ++i) + p[i] = vt::F32ToBF16(values[static_cast(i)]); + return o; +} + +// Concatenate several named [rows_i, H] tensors into one raw-NK block, which is +// how `Gemma4Weights` carries q/k/v and gate/up (gemma4_weights.cpp:290-296). +vllm::OwnedTensor TowerConcatNk( + const std::vector>& parts, int64_t H) { + int64_t rows = 0; + for (const auto& part : parts) rows += part.second; + vllm::OwnedTensor o; + o.dtype = vt::DType::kBF16; + o.nk = true; + o.rank = 2; + o.shape[0] = rows; + o.shape[1] = H; + o.bytes.resize(static_cast(rows * H) * sizeof(uint16_t)); + auto* p = reinterpret_cast(o.bytes.data()); + int64_t at = 0; + for (const auto& part : parts) { + const std::vector values = TowerRand(part.first, part.second * H); + for (int64_t i = 0; i < part.second * H; ++i) + p[at + i] = vt::F32ToBF16(values[static_cast(i)]); + at += part.second * H; + } + return o; +} + +vllm::HfConfig TowerConfig() { + // PARSED from the very JSON the oracle was configured with, rather than + // reconstructed field by field. `attention_k_eq_v`, `final_logit_softcapping`, + // both `rope_parameters` entries and `rms_norm_eps` all reach the forward + // through `cfg.raw`, and a hand-built config would silently disagree with the + // run that produced the goldens about any field nobody remembered. + return vllm::ParseHfConfig(nlohmann::json::parse(vllm_test::kLtxTowerTextConfigJson), + "ltx2_gemma_tower_goldens.inc"); +} + +vllm::Gemma4Weights TowerWeights(const vllm::HfConfig& c) { + const int64_t H = c.hidden_size; + const int64_t I = c.intermediate_size, V = c.vocab_size; + const int64_t Hq = vllm_test::kLtxTowerNumHeads; + vllm::Gemma4Weights w; + w.tie_word_embeddings = true; + w.embed_tokens = TowerTensor("language_model.embed_tokens.weight", {V, H}, false); + w.final_norm = TowerTensor("language_model.norm.weight", {H}, false); + for (int64_t l = 0; l < c.num_hidden_layers; ++l) { + const bool full = vllm_test::kLtxTowerLayerIsFull[static_cast(l)] != 0; + // The two geometries the shipped tower actually mixes. + const int64_t Dh = full ? vllm_test::kLtxTowerGlobalHeadDim + : vllm_test::kLtxTowerHeadDim; + const int64_t Hkv = full ? vllm_test::kLtxTowerNumGlobalKvHeads + : vllm_test::kLtxTowerNumKvHeads; + vllm::Gemma4LayerWeights lw; + lw.is_full_attention = full; + lw.is_kv_shared = false; + lw.kv_target_layer = -1; + lw.head_dim = Dh; + lw.num_kv_heads = Hkv; + // `attention_k_eq_v` is true and the FULL layers are where it bites: they + // ship no `v_proj` at all, so V aliases K. Duplicating the K rows is exactly + // what gemma4_weights.cpp:289-292 does for that case. + lw.k_eq_v = full; + const std::string q = TowerParam(l, "self_attn.q_proj.weight"); + const std::string k = TowerParam(l, "self_attn.k_proj.weight"); + const std::string v = TowerParam(l, "self_attn.v_proj.weight"); + lw.attn.qkv_proj = + full ? TowerConcatNk({{q, Hq * Dh}, {k, Hkv * Dh}, {k, Hkv * Dh}}, H) + : TowerConcatNk({{q, Hq * Dh}, {k, Hkv * Dh}, {v, Hkv * Dh}}, H); + lw.attn.o_proj = + TowerTensor(TowerParam(l, "self_attn.o_proj.weight"), {H, Hq * Dh}, true); + lw.attn.q_norm = TowerTensor(TowerParam(l, "self_attn.q_norm.weight"), {Dh}, false); + lw.attn.k_norm = TowerTensor(TowerParam(l, "self_attn.k_norm.weight"), {Dh}, false); + lw.mlp.gate_up_proj = TowerConcatNk({{TowerParam(l, "mlp.gate_proj.weight"), I}, + {TowerParam(l, "mlp.up_proj.weight"), I}}, + H); + lw.mlp.down_proj = TowerTensor(TowerParam(l, "mlp.down_proj.weight"), {H, I}, true); + lw.input_layernorm = + TowerTensor(TowerParam(l, "input_layernorm.weight"), {H}, false); + lw.post_attention_layernorm = + TowerTensor(TowerParam(l, "post_attention_layernorm.weight"), {H}, false); + lw.pre_feedforward_layernorm = + TowerTensor(TowerParam(l, "pre_feedforward_layernorm.weight"), {H}, false); + lw.post_feedforward_layernorm = + TowerTensor(TowerParam(l, "post_feedforward_layernorm.weight"), {H}, false); + lw.layer_scalar = TowerTensor(TowerParam(l, "layer_scalar"), {1}, false); + w.layers.push_back(std::move(lw)); + } + return w; +} + +// A KV pool whose layers do NOT share one geometry. The shipped tower's sliding +// layers are 8 kv heads x 256 and its full layers 1 x 512, and the runner's +// single-uniform-head_dim allocation (gemma4.h, G1 HONEST STATUS) is exactly +// what cannot express that — so the LTX text path builds its own, and so does +// this gate. +struct TowerCachePool { + std::vector> buf; + std::vector attn_kv; + TowerCachePool(const vllm::HfConfig& c, int64_t num_blocks, int64_t block_size) { + buf.reserve(static_cast(c.num_hidden_layers)); + for (int64_t l = 0; l < c.num_hidden_layers; ++l) { + const bool full = vllm_test::kLtxTowerLayerIsFull[static_cast(l)] != 0; + const int64_t Dh = full ? vllm_test::kLtxTowerGlobalHeadDim + : vllm_test::kLtxTowerHeadDim; + const int64_t Hkv = full ? vllm_test::kLtxTowerNumGlobalKvHeads + : vllm_test::kLtxTowerNumKvHeads; + buf.emplace_back( + static_cast(num_blocks * 2 * block_size * Hkv * Dh), 0.0f); + vllm::PagedKvCache kv; + kv.data = buf.back().data(); + kv.dtype = vt::DType::kF32; + kv.num_blocks = num_blocks; + kv.block_size = block_size; + kv.num_kv_heads = Hkv; + kv.head_size = Dh; + attn_kv.push_back(kv); + } + } +}; + +const float* TowerGoldenF32(int64_t state) { + static const float* const kStates[] = { + vllm_test::kLtxTowerStateF32_0, vllm_test::kLtxTowerStateF32_1, + vllm_test::kLtxTowerStateF32_2, vllm_test::kLtxTowerStateF32_3, + vllm_test::kLtxTowerStateF32_4, vllm_test::kLtxTowerStateF32_5, + vllm_test::kLtxTowerStateF32_6, vllm_test::kLtxTowerStateF32_7, + vllm_test::kLtxTowerStateF32_8, vllm_test::kLtxTowerStateF32_9, + vllm_test::kLtxTowerStateF32_10, vllm_test::kLtxTowerStateF32_11, + vllm_test::kLtxTowerStateF32_12, + }; + return kStates[static_cast(state)]; +} + +const float* TowerGoldenBf16(int64_t state) { + static const float* const kStates[] = { + vllm_test::kLtxTowerStateBf16_0, vllm_test::kLtxTowerStateBf16_1, + vllm_test::kLtxTowerStateBf16_2, vllm_test::kLtxTowerStateBf16_3, + vllm_test::kLtxTowerStateBf16_4, vllm_test::kLtxTowerStateBf16_5, + vllm_test::kLtxTowerStateBf16_6, vllm_test::kLtxTowerStateBf16_7, + vllm_test::kLtxTowerStateBf16_8, vllm_test::kLtxTowerStateBf16_9, + vllm_test::kLtxTowerStateBf16_10, vllm_test::kLtxTowerStateBf16_11, + vllm_test::kLtxTowerStateBf16_12, + }; + return kStates[static_cast(state)]; +} + +const float* TowerGoldenPadded(int64_t state) { + static const float* const kStates[] = { + vllm_test::kLtxTowerPaddedStateF32_0, vllm_test::kLtxTowerPaddedStateF32_1, + vllm_test::kLtxTowerPaddedStateF32_2, vllm_test::kLtxTowerPaddedStateF32_3, + vllm_test::kLtxTowerPaddedStateF32_4, vllm_test::kLtxTowerPaddedStateF32_5, + vllm_test::kLtxTowerPaddedStateF32_6, vllm_test::kLtxTowerPaddedStateF32_7, + vllm_test::kLtxTowerPaddedStateF32_8, vllm_test::kLtxTowerPaddedStateF32_9, + vllm_test::kLtxTowerPaddedStateF32_10, vllm_test::kLtxTowerPaddedStateF32_11, + vllm_test::kLtxTowerPaddedStateF32_12, + }; + return kStates[static_cast(state)]; +} + struct Gemma4CachePool { std::vector> buf; std::vector attn_kv; @@ -1259,3 +1469,630 @@ TEST_CASE("gemma4 -> ltx2: the captured stack feeds the conditioning path") { vllm::Ltx2TextEncoderConditioning(short_stack, mask.data(), w, fcfg), std::runtime_error); } + +// ─────────── the TOWER, against the oracle phase L3 could not run ──────────── +// +// L3 recorded that this comparison was impossible: the `transformers` on the box +// had no `gemma4_unified` in CONFIG_MAPPING, so the tower could not be built at +// reduced dims and there was nothing to compare against. It is possible now, and +// these cases are the first time `Gemma4Model::ForwardHiddenStates` is held to a +// RUNNING upstream rather than to invariants derived from its own output. +// +// The fixture keeps every geometry the shipped 12B mixes — a (sliding x 5, full) +// pattern twice over, two head widths, 2 kv heads against 1, `attention_k_eq_v` +// on the full layers only, two rope types at two thetas — because a fixture with +// one uniform layer type cannot separate a port that handles both from one that +// handles the first and applies it twice. + +TEST_CASE("gemma4 tower: the config the oracle ran PARSES into HfConfig") { + const vllm::HfConfig c = TowerConfig(); + CHECK(c.hidden_size == vllm_test::kLtxTowerHidden); + CHECK(c.num_hidden_layers == vllm_test::kLtxTowerNumLayers); + CHECK(c.head_dim == vllm_test::kLtxTowerHeadDim); + CHECK(c.num_attention_heads == vllm_test::kLtxTowerNumHeads); + CHECK(c.num_key_value_heads == vllm_test::kLtxTowerNumKvHeads); + CHECK(c.intermediate_size == vllm_test::kLtxTowerIntermediate); + CHECK(c.vocab_size == vllm_test::kLtxTowerVocab); + REQUIRE(c.sliding_window.has_value()); + CHECK(*c.sliding_window == vllm_test::kLtxTowerSlidingWindow); + + // The fields that reach the forward through `raw` and that NO shape encodes. + // Each one moves every hidden state while leaving every tensor byte identical, + // which is why they are read from the config rather than defaulted. + CHECK(c.raw["global_head_dim"] == vllm_test::kLtxTowerGlobalHeadDim); + CHECK(c.raw["num_global_key_value_heads"] == vllm_test::kLtxTowerNumGlobalKvHeads); + CHECK(c.raw["attention_k_eq_v"] == true); + CHECK(c.raw["num_kv_shared_layers"] == 0); + CHECK(c.raw["hidden_size_per_layer_input"] == 0); // no PLE on this tower + CHECK(c.raw["tie_word_embeddings"] == true); + CHECK(c.raw["enable_moe_block"] == false); + + // `layer_types` is what decides which of the two geometries each layer gets, + // and it must agree with the pattern the goldens were produced under. + REQUIRE(static_cast(c.layer_types.size()) == vllm_test::kLtxTowerNumLayers); + int64_t full_count = 0; + for (int64_t l = 0; l < vllm_test::kLtxTowerNumLayers; ++l) { + const bool want_full = vllm_test::kLtxTowerLayerIsFull[static_cast(l)] != 0; + CHECK((c.layer_types[static_cast(l)] == "full_attention") == want_full); + if (want_full) ++full_count; + } + // Both kinds are present, so neither branch can be dead in this fixture. + CHECK(full_count == 2); + CHECK(full_count < vllm_test::kLtxTowerNumLayers); + + // The nested per-layer-type rope: two thetas, and partial rotary on the full + // arm only (the shipped config's `rope_parameters`, carried over unreduced). + const nlohmann::json& rope = c.raw["rope_parameters"]; + CHECK(rope["full_attention"]["rope_type"] == "proportional"); + CHECK(rope["full_attention"]["rope_theta"] == 1000000.0); + CHECK(rope["full_attention"]["partial_rotary_factor"] == 0.25); + CHECK(rope["sliding_attention"]["rope_type"] == "default"); + CHECK(rope["sliding_attention"]["rope_theta"] == 10000.0); +} + +TEST_CASE("gemma4 tower: EVERY hidden state matches the RUNNING upstream tower") { + const vllm::HfConfig cfg = TowerConfig(); + const vllm::Gemma4Weights weights = TowerWeights(cfg); + const int64_t T = vllm_test::kLtxTowerSeq; + const int64_t H = vllm_test::kLtxTowerHidden; + const int64_t S = vllm_test::kLtxTowerNumStates; + + std::vector tokens(static_cast(T)); + std::vector positions(static_cast(T)); + for (int64_t t = 0; t < T; ++t) { + tokens[static_cast(t)] = vllm_test::kLtxTowerTokens[static_cast(t)]; + positions[static_cast(t)] = static_cast(t); + } + + TowerCachePool pool(cfg, /*num_blocks=*/4, /*block_size=*/8); + const vllm::v1::CommonAttentionMetadata meta = PrefillMeta(T, 8); + vt::Queue q = Qcpu(); + const vllm::Gemma4HiddenStatesResult got = vllm::Gemma4Model::ForwardHiddenStates( + tokens, positions, meta, pool.attn_kv, weights, cfg, q); + + REQUIRE(static_cast(got.hidden_states.size()) == S); + + // THE TOLERANCE IS A MEASUREMENT, NOT A NUMBER SOMEBODY PICKED. + // + // Our stream carries bf16 and widens only on the way out (gemma4.h, + // Gemma4HiddenStatesResult); bf16 is also upstream's own resolved model dtype + // (base_encoder.py:41). So the dtype-MATCHED arm is bf16-vs-bf16, and the + // question "is a difference a defect?" has a measurable answer: how much does + // UPSTREAM's own answer move when the same upstream code runs at bf16 instead + // of f32? That is `kLtxTowerDtypeNoise`, emitted by the generator from the two + // oracle runs, and it is the smallest difference this comparison can resolve. + // + // A port inside it is indistinguishable from upstream at upstream's arithmetic + // width. A port outside it has something bf16 rounding does not explain. And + // the bound cannot be loosened to rescue a failure, because loosening it means + // regenerating it, which means the oracle moved. + // + // The f32 arm is gated too, at the triangle-inequality bound (our distance to + // the bf16 oracle plus the bf16 oracle's distance to the f32 one, so 2x the + // floor). A bf16 store is exactly what absorbs a reduction-order defect, so the + // wider arm is the one that would show one moving; reporting it without gating + // it would be the "report-only is not a result" failure. + double worst_bf16_ratio = 0.0; + double worst_f32_ratio = 0.0; + for (int64_t s = 0; s < S; ++s) { + REQUIRE(static_cast(got.hidden_states[static_cast(s)].size()) == + T * H); + const double d_bf16 = MaxAbsDiff(got.hidden_states[static_cast(s)], + TowerGoldenBf16(s), static_cast(T * H)); + const double d_f32 = MaxAbsDiff(got.hidden_states[static_cast(s)], + TowerGoldenF32(s), static_cast(T * H)); + const double floor = + static_cast(vllm_test::kLtxTowerDtypeNoise[static_cast(s)]); + const double state_scale = + static_cast(vllm_test::kLtxTowerStateScale[static_cast(s)]); + REQUIRE(floor > 0.0); + MESSAGE("gemma4 tower state " + << static_cast(s) << ": max|diff| vs bf16 oracle = " << d_bf16 + << " (" << (d_bf16 / floor) << "x the oracle's own f32-vs-bf16 floor " + << floor << "), vs f32 oracle = " << d_f32 << ", over max|value| = " + << state_scale); + CHECK(d_bf16 <= floor); + CHECK(d_f32 <= 2.0 * floor); + worst_bf16_ratio = std::max(worst_bf16_ratio, d_bf16 / floor); + worst_f32_ratio = std::max(worst_f32_ratio, d_f32 / (2.0 * floor)); + } + MESSAGE("gemma4 tower: WORST over all " + << static_cast(S) << " states — bf16 arm reached " + << worst_bf16_ratio << "x its floor, f32 arm " << worst_f32_ratio + << "x its floor (1.0 = at the bound)"); + + // The states are not all the same buffer pushed S times — the check every + // other assertion here would still pass under. + for (int64_t s = 0; s + 1 < S; ++s) { + double gap = 0.0; + for (size_t i = 0; i < got.hidden_states[static_cast(s)].size(); ++i) + gap = std::max(gap, + std::abs(static_cast( + got.hidden_states[static_cast(s)][i]) - + static_cast( + got.hidden_states[static_cast(s + 1)][i]))); + CHECK(gap > 0.0); + } +} + +TEST_CASE("gemma4 tower: LEFT PADDING is equivalent to running the valid tokens") { + // What this buys, stated because it is the difference between a prompt costing + // 1024 tower rows and costing its own length. Upstream pads EVERY prompt to + // 1024 (gemma_assets.py:162, base_encoder.py:231-236) and runs all 1024 rows + // through a 12B tower. Pads are masked out of attention and sit causally + // BEFORE every valid token, so a valid row cannot depend on one; the feature + // extractor then zeroes the pad rows anyway (feature_extractor.py:63-64). + // + // That is an argument, and an argument is not a measurement. Here the oracle + // runs the FULL left-padded sequence and our short run's rows are held to its + // VALID rows. If the equivalence is ever false — a mask that leaks, a position + // that is derived from the mask rather than from the cache position, a sliding + // window that counts pads — this is what says so. + const vllm::HfConfig cfg = TowerConfig(); + const vllm::Gemma4Weights weights = TowerWeights(cfg); + const int64_t T = vllm_test::kLtxTowerSeq; + const int64_t H = vllm_test::kLtxTowerHidden; + const int64_t S = vllm_test::kLtxTowerNumStates; + const int64_t P = vllm_test::kLtxTowerNumPad; + const int64_t PT = vllm_test::kLtxTowerPaddedSeq; + + // The pads are real pad ids in a real left-padded batch, so the fixture is the + // layout the tokenizer produces rather than a convenient one. + REQUIRE(P > 0); + REQUIRE(P + T == PT); + for (int64_t i = 0; i < P; ++i) { + CHECK(vllm_test::kLtxTowerPaddedTokens[static_cast(i)] == + vllm_test::kLtxTowerPadId); + CHECK(vllm_test::kLtxTowerPaddedMask[static_cast(i)] == 0); + } + + // Positions are the ORIGINAL absolute ones — P..P+T-1, not 0..T-1. That is + // what transformers does: with no explicit position_ids it uses the cache + // position, which counts pad rows (modeling_gemma4_unified.py, the + // `cache_position` default), so a port that renumbers from zero after dropping + // the pads rotates every query by the wrong angle. + std::vector tokens(static_cast(T)); + std::vector positions(static_cast(T)); + for (int64_t t = 0; t < T; ++t) { + tokens[static_cast(t)] = + vllm_test::kLtxTowerPaddedTokens[static_cast(P + t)]; + positions[static_cast(t)] = static_cast(P + t); + } + + // Only the T VALID tokens are given to the tower, and their KV occupies slots + // 0..T-1. The pads get no cache entry at all, which is the point: a run that + // declared seq_len = P + T while writing only T keys would have attention read + // P slots of zeroes and call them keys — the same wrong answer as attending to + // the pads, arrived at by a different route. Measured, when this gate was + // first written that way: max|diff| 17.97 against a max|value| of 14.35. + TowerCachePool pool(cfg, /*num_blocks=*/4, /*block_size=*/8); + const vllm::v1::CommonAttentionMetadata meta = PrefillMeta(T, 8); + + vt::Queue q = Qcpu(); + const vllm::Gemma4HiddenStatesResult got = vllm::Gemma4Model::ForwardHiddenStates( + tokens, positions, meta, pool.attn_kv, weights, cfg, q); + REQUIRE(static_cast(got.hidden_states.size()) == S); + + // CLAIM 1, and it is UPSTREAM'S, not ours: dropping the pads is free. The + // generator measured it inside the oracle in f32 — the same valid tokens told + // their absolute positions, run with and without the pads — so this number + // carries no dtype noise at all. Asserting it here keeps the claim from + // quietly becoming untrue if the oracle ever moves. + double worst_oracle = 0.0; + double scale = 0.0; + for (int64_t s = 0; s < S; ++s) { + worst_oracle = std::max( + worst_oracle, + static_cast(vllm_test::kLtxTowerPadEquivalence[static_cast(s)])); + scale = std::max(scale, + static_cast( + vllm_test::kLtxTowerStateScale[static_cast(s)])); + } + MESSAGE("gemma4 tower: UPSTREAM's own padded-vs-short f32 spread = " + << worst_oracle << " over max|value| = " << scale << " (" + << (worst_oracle / scale) << " relative)"); + // f32 round-off on values of this magnitude, and nothing more. + CHECK(worst_oracle < 1e-5 * scale); + + // CLAIM 2, and this one IS ours: our short run reproduces the padded run's + // valid rows. Held to twice the dtype floor, because our stream is bf16 and + // the padded golden is f32 — the same triangle bound the parity case uses. + double worst = 0.0; + double worst_ratio = 0.0; + for (int64_t s = 0; s < S; ++s) { + const std::vector& mine = got.hidden_states[static_cast(s)]; + REQUIRE(static_cast(mine.size()) == T * H); + const float* want = TowerGoldenPadded(s); + double d = 0.0; + for (int64_t t = 0; t < T; ++t) + for (int64_t h = 0; h < H; ++h) { + const double w = static_cast(want[static_cast((P + t) * H + h)]); + const double m = static_cast(mine[static_cast(t * H + h)]); + d = std::max(d, std::abs(m - w)); + } + const double floor = + static_cast(vllm_test::kLtxTowerDtypeNoise[static_cast(s)]); + REQUIRE(floor > 0.0); + CHECK(d <= 2.0 * floor); + worst = std::max(worst, d); + worst_ratio = std::max(worst_ratio, d / (2.0 * floor)); + } + MESSAGE("gemma4 tower left-pad equivalence: OUR max|diff| over the VALID rows of all " + << static_cast(S) << " states = " << worst << ", worst state reached " + << worst_ratio << "x its bound"); +} + +// ──────────────────── a real prompt becomes real tokens ────────────────────── + +namespace { + +// The env-gated path to the shipped text encoder. The tokenizer it carries is a +// 32 MB TENSOR, so this cannot be a committed fixture; the GOLDENS are committed +// and the asset is opt-in. +std::string Ltx2TextEncoderPathOrEmpty() { + const char* explicit_path = std::getenv("VLLM_CPP_LTX2_TEXT_ENCODER"); + if (explicit_path != nullptr && *explicit_path != '\0') return explicit_path; + const char* root = std::getenv("CHECKPOINT_ROOT"); + if (root == nullptr || *root == '\0') return {}; + const fs::path p = fs::path(root) / "ltx-2.5" / "vonkaiser-fp8-nvfp4" / + "text_encoders" / "gemma4-12b-with-proj-nvfp4-torchao.safetensors"; + std::error_code ec; + return fs::exists(p, ec) ? p.string() : std::string(); +} + +const int32_t* PromptIds(int64_t i) { + static const int32_t* const kIds[] = { + vllm_test::kLtxPromptIds_0, vllm_test::kLtxPromptIds_1, + vllm_test::kLtxPromptIds_2, vllm_test::kLtxPromptIds_3}; + return kIds[static_cast(i)]; +} + +const int32_t* PromptMask(int64_t i) { + static const int32_t* const kMask[] = { + vllm_test::kLtxPromptMask_0, vllm_test::kLtxPromptMask_1, + vllm_test::kLtxPromptMask_2, vllm_test::kLtxPromptMask_3}; + return kMask[static_cast(i)]; +} + +} // namespace + +TEST_CASE("ltx2 prompt: the tokenizer WRAPPER, on a fixture that needs no asset") { + // A tiny SentencePiece-flavoured tokenizer.json in the shipped tokenizer's own + // form — `Replace(" " -> U+2581)` normalizer plus `Split(" ", + // MergedWithPrevious)` pre-tokenizer — so the wrapper's behaviour is gated in + // CI without the 32 MB tensor. What is checked here is the WRAPPER + // (tokenizer.py:31-59); the real vocab is the next case. + const std::string tokenizer_json = R"JSON({ + "version": "1.0", + "added_tokens": [ + {"id": 0, "content": "", "special": true}, + {"id": 1, "content": "", "special": true}, + {"id": 2, "content": "", "special": true} + ], + "normalizer": {"type": "Replace", "pattern": {"String": " "}, "content": "▁"}, + "pre_tokenizer": {"type": "Split", "pattern": {"String": " "}, + "behavior": "MergedWithPrevious", "invert": false}, + "post_processor": {"type": "TemplateProcessing", + "single": [{"Sequence": {"id": "A", "type_id": 0}}], + "special_tokens": {}}, + "decoder": {"type": "Sequence", "decoders": [ + {"type": "Replace", "pattern": {"String": "▁"}, "content": " "}, + {"type": "ByteFallback"}, {"type": "Fuse"}]}, + "model": {"type": "BPE", "byte_fallback": true, + "vocab": {"": 0, "": 1, "": 2, + "▁a": 3, "▁b": 4, "▁c": 5, + "a": 6, "b": 7, "c": 8, "▁": 9, + "▁ab": 10, "ab": 11}, + "merges": ["▁ a", "▁ b", "▁ c", "a b", "▁a b"]} + })JSON"; + + const vllm::tok::Tokenizer tok = + vllm::tok::Tokenizer::FromHfJsonBytes(tokenizer_json, ""); + const int32_t kBos = 2, kPad = 0; + const int64_t kMax = 8; + + SUBCASE("the BOS is PREPENDED and the padding is on the LEFT") { + const vllm::Ltx2GemmaPromptTokens t = + vllm::Ltx2TokenizeGemmaPrompt(tok, "a b c", kBos, kPad, kMax); + REQUIRE(static_cast(t.input_ids.size()) == kMax); + REQUIRE(static_cast(t.attention_mask.size()) == kMax); + // LEFT padding (base_encoder.py:235): the valid run is the TAIL, and its + // first index is the pad count — which is why the caller cannot assume the + // prompt starts at position 0. + CHECK(t.first_valid == kMax - t.num_valid); + CHECK(t.num_valid > 1); + CHECK(t.input_ids[static_cast(t.first_valid)] == kBos); + CHECK_FALSE(t.truncated); + for (int64_t i = 0; i < kMax; ++i) { + const bool valid = i >= t.first_valid; + CHECK(t.attention_mask[static_cast(i)] == (valid ? 1 : 0)); + if (!valid) CHECK(t.input_ids[static_cast(i)] == kPad); + } + } + + SUBCASE("the prompt is STRIPPED before tokenizing") { + // tokenizer.py:33, and diffusers strips too (pipeline_ltx2.py:333). Without + // it the leading run becomes real metaspace tokens and the prompt differs. + const vllm::Ltx2GemmaPromptTokens bare = + vllm::Ltx2TokenizeGemmaPrompt(tok, "a b", kBos, kPad, kMax); + const vllm::Ltx2GemmaPromptTokens padded = + vllm::Ltx2TokenizeGemmaPrompt(tok, " \n a b \t ", kBos, kPad, kMax); + CHECK(bare.num_valid == padded.num_valid); + CHECK(bare.input_ids == padded.input_ids); + CHECK(bare.attention_mask == padded.attention_mask); + } + + SUBCASE("an EMPTY prompt still carries a BOS, and exactly one token") { + const vllm::Ltx2GemmaPromptTokens t = + vllm::Ltx2TokenizeGemmaPrompt(tok, " ", kBos, kPad, kMax); + CHECK(t.num_valid == 1); + CHECK(t.input_ids[static_cast(kMax - 1)] == kBos); + CHECK(t.attention_mask[static_cast(kMax - 1)] == 1); + } + + SUBCASE("a BOS already present is NOT doubled") { + // Upstream's guard is `if not input_ids or input_ids[0] != bos_id` + // (tokenizer.py:44), i.e. conditional. A port that prepends unconditionally + // produces two BOS and drops the prompt's last token to fit. + const vllm::Ltx2GemmaPromptTokens t = + vllm::Ltx2TokenizeGemmaPrompt(tok, " a b", kBos, kPad, kMax); + REQUIRE(t.num_valid >= 2); + CHECK(t.input_ids[static_cast(t.first_valid)] == kBos); + CHECK(t.input_ids[static_cast(t.first_valid + 1)] != kBos); + } + + SUBCASE("truncation costs the LAST token, never the BOS") { + // tokenizer.py:39-46 truncates, prepends, then re-slices, so the BOS wins. + const int64_t tiny = 3; + const vllm::Ltx2GemmaPromptTokens t = + vllm::Ltx2TokenizeGemmaPrompt(tok, "a b c a b c a b c", kBos, kPad, tiny); + REQUIRE(static_cast(t.input_ids.size()) == tiny); + CHECK(t.num_valid == tiny); + CHECK(t.first_valid == 0); + CHECK(t.input_ids[0] == kBos); + CHECK(t.truncated); + for (int64_t i = 0; i < tiny; ++i) + CHECK(t.attention_mask[static_cast(i)] == 1); + } + + SUBCASE("RIGHT padding puts the valid run at the FRONT") { + const vllm::Ltx2GemmaPromptTokens t = vllm::Ltx2TokenizeGemmaPrompt( + tok, "a b", kBos, kPad, kMax, vllm::Ltx2GemmaPaddingSide::kRight); + CHECK(t.first_valid == 0); + CHECK(t.input_ids[0] == kBos); + CHECK(t.attention_mask[static_cast(kMax - 1)] == 0); + } + + SUBCASE("a missing BOS id is REFUSED, not defaulted") { + CHECK_THROWS_AS(vllm::Ltx2TokenizeGemmaPrompt(tok, "a b", -1, kPad, kMax), + std::runtime_error); + } +} + +TEST_CASE("ltx2 prompt: REAL prompts through the SHIPPED 262144-entry vocab") { + const std::string path = Ltx2TextEncoderPathOrEmpty(); + if (path.empty()) { + MESSAGE( + "SKIPPED: set CHECKPOINT_ROOT (or VLLM_CPP_LTX2_TEXT_ENCODER) to gate the " + "real vocab. The tokenizer ships as a 32 MB TENSOR inside the checkpoint, " + "so it cannot be a committed fixture; the goldens beside this test are."); + return; + } + + const vllm::SafetensorsFile file = vllm::SafetensorsFile::Open(path); + // require_config=false: the shipped vonkaiser build has NO __metadata__ at all, + // which is exactly the case ltx2_text_encoder.h:366-373 records. + const vllm::Ltx2GemmaAssets assets = vllm::Ltx2LoadGemmaAssets(file, false); + CHECK_FALSE(assets.has_config); + REQUIRE(!assets.tokenizer_json.empty()); + + const vllm::tok::Tokenizer tok = vllm::tok::Tokenizer::FromHfJsonBytes( + std::string_view(reinterpret_cast(assets.tokenizer_json.data()), + assets.tokenizer_json.size()), + path + "::tokenizer_json"); + + // The ids come from the checkpoint's own generation_config, not from a + // hardcoded pair, and they must be the ones the goldens were built with. + const vllm::Ltx2GemmaSpecialIds ids = vllm::Ltx2ResolveGemmaSpecialIds(assets, tok); + CHECK(ids.bos_id == vllm_test::kLtxPromptBosId); + CHECK(ids.pad_id == vllm_test::kLtxPromptPadId); + + for (int64_t p = 0; p < vllm_test::kLtxPromptCount; ++p) { + const vllm::Ltx2GemmaPromptTokens t = vllm::Ltx2TokenizeGemmaPrompt( + tok, vllm_test::kLtxPromptText[p], ids.bos_id, ids.pad_id, + vllm_test::kLtxPromptMaxLength); + REQUIRE(static_cast(t.input_ids.size()) == + vllm_test::kLtxPromptMaxLength); + const int64_t want_valid = vllm_test::kLtxPromptValidCount[static_cast(p)]; + // The count first, because a count mismatch makes every id comparison + // meaningless and its message is the readable one. + CHECK(t.num_valid == want_valid); + int64_t first_bad = -1; + for (int64_t i = 0; i < vllm_test::kLtxPromptMaxLength && first_bad < 0; ++i) { + if (t.input_ids[static_cast(i)] != + PromptIds(p)[static_cast(i)] || + t.attention_mask[static_cast(i)] != + PromptMask(p)[static_cast(i)]) + first_bad = i; + } + MESSAGE("ltx2 prompt " << static_cast(p) << " (" + << static_cast(want_valid) + << " valid tokens): first mismatching index = " + << static_cast(first_bad) << " (-1 = EXACT)"); + // Token ids are EXACT or they are wrong; there is no tolerance here. + CHECK(first_bad == -1); + } +} + +// ────────────── a real prompt, the real 12B tower, real conditioning ───────── +// +// The whole point of phase L10, and the one case that cannot be run from a +// fixture: 7.4 GB of NVFP4 off the NAS, dequantized to ~24 GB of bf16, a real +// English sentence tokenized with the embedded 262144-entry vocab, 49 hidden +// states, both caption projections, and conditioning the DiT's two streams +// accept. Env-gated on the checkpoint and on an explicit opt-in, because it +// wants ~33 GB of host memory and minutes of CPU — a gate nobody can run by +// accident is worse than useless, and one that runs by accident in CI is worse +// still. + +TEST_CASE("ltx2 e2e: a PROMPT drives the real Gemma-4 12B tower to conditioning") { + const std::string path = Ltx2TextEncoderPathOrEmpty(); + if (path.empty() || std::getenv("VLLM_CPP_LTX2_TOWER_E2E") == nullptr) { + MESSAGE( + "SKIPPED: needs CHECKPOINT_ROOT (or VLLM_CPP_LTX2_TEXT_ENCODER) AND " + "VLLM_CPP_LTX2_TOWER_E2E=1. It dequantizes a 12B NVFP4 tower to ~24 GB of " + "host bf16 and runs it, so it is opt-in rather than checkpoint-presence " + "gated."); + return; + } + + const vllm::SafetensorsFile file = vllm::SafetensorsFile::Open(path); + + // 1. THE ASSETS. `require_config=false` because the shipped vonkaiser build + // has no `__metadata__` at all — upstream's own `from_single_file` raises + // here (gemma_assets.py:110-114), which is precisely why the Gemma config + // has to be supplied out of band. + const vllm::Ltx2GemmaAssets assets = vllm::Ltx2LoadGemmaAssets(file, false); + CHECK_FALSE(assets.has_config); + + const vllm::tok::Tokenizer tokenizer = vllm::tok::Tokenizer::FromHfJsonBytes( + std::string_view(reinterpret_cast(assets.tokenizer_json.data()), + assets.tokenizer_json.size()), + path + "::tokenizer_json"); + const vllm::Ltx2GemmaSpecialIds ids = + vllm::Ltx2ResolveGemmaSpecialIds(assets, tokenizer); + + // 2. THE CONFIG, out of band and committed with its provenance: it is the + // `__metadata__["gemma_config"]` of the OFFICIAL bf16 text encoder. + const fs::path config_path = + fs::path(__FILE__).parent_path() / "ltx2_gemma4_text_config.json"; + std::ifstream cfg_in(config_path); + REQUIRE(cfg_in.good()); + const nlohmann::json gemma_config = nlohmann::json::parse(cfg_in); + CHECK(gemma_config["gemma_version"] == "gemma4-12b-ltx-v1"); + + // 3. THE TOWER. This is the ~24 GB step. + const vllm::Ltx2GemmaTower tower = + vllm::Ltx2LoadGemmaTowerFromSafetensors(file, gemma_config); + CHECK(tower.config.hidden_size == 3840); + CHECK(tower.config.num_hidden_layers == 48); + CHECK(tower.config.vocab_size == 262144); + CHECK(static_cast(tower.weights.layers.size()) == 48); + // Every one of the 337 quantized modules on the text path arrived NVFP4 and + // was dequantized — a tower that silently found bf16 tensors instead would be + // a different checkpoint. + MESSAGE("ltx2 e2e: dequantized " << tower.dequantized_modules.size() + << " torchao-NVFP4 modules"); + CHECK(tower.dequantized_modules.size() > 300); + + // The mixed geometry, READ BACK off what was actually built rather than off + // the config that asked for it. + int64_t full_layers = 0; + for (const vllm::Gemma4LayerWeights& lw : tower.weights.layers) { + if (lw.is_full_attention) { + ++full_layers; + CHECK(lw.head_dim == 512); + CHECK(lw.num_kv_heads == 1); + CHECK(lw.k_eq_v); // no v_proj: V aliases K + CHECK(lw.attn.qkv_proj.shape[0] == 16 * 512 + 2 * 1 * 512); + } else { + CHECK(lw.head_dim == 256); + CHECK(lw.num_kv_heads == 8); + CHECK_FALSE(lw.k_eq_v); + CHECK(lw.attn.qkv_proj.shape[0] == 16 * 256 + 2 * 8 * 256); + } + CHECK(lw.attn.qkv_proj.shape[1] == 3840); + CHECK(lw.mlp.gate_up_proj.shape[0] == 2 * 15360); + } + CHECK(full_layers == 8); + + // 4. THE CAPTION PROJECTIONS and the V1/V2 selection. + const vllm::Ltx2TextEncoderCheckpoint te = + vllm::Ltx2LoadTextEncoderFromSafetensors(file); + CHECK(te.gemma_hidden_size == 3840); + CHECK(te.gemma_num_hidden_layers == 48); + CHECK(te.video.out_features == 4096); + CHECK(te.audio.out_features == 2048); + // 188160 = 3840 x 49 — the width §1.4 had to correct once, confirmed here off + // the file rather than off the spec. + CHECK(te.video.in_features == 3840 * 49); + CHECK(te.audio.in_features == 3840 * 49); + + vllm::Ltx2TextFeatureConfig fcfg; + fcfg.variant = vllm::Ltx2TextNormVariant::kPerTokenRmsV2; + fcfg.embedding_dim = te.gemma_hidden_size; + fcfg.num_layers = te.gemma_num_hidden_layers + 1; + fcfg.video_out_features = te.video.out_features; + fcfg.audio_out_features = te.audio.out_features; + fcfg.aggregate_bias = true; // V2: both Linears carry one (encoder_configurator.py:206-208) + const vllm::Ltx2TextEncoderWeights proj = vllm::Ltx2WidenTextProjectionsToF32(te); + REQUIRE(!proj.video.bias.empty()); + REQUIRE(!proj.audio.bias.empty()); + + // 5. THE PROMPT. + const std::string prompt = "a red fox running through deep snow at sunrise"; + vt::Queue q = Qcpu(); + const vllm::Ltx2PromptConditioning out = vllm::Ltx2EncodePromptToConditioning( + tower, tokenizer, ids, proj, fcfg, prompt, q); + + // The tokens: the same 10 the HF oracle produced for this exact prompt. + CHECK(out.tokens.num_valid == vllm_test::kLtxPromptValidCount[0]); + CHECK(out.seq == vllm_test::kLtxPromptMaxLength); + for (int64_t i = 0; i < out.seq; ++i) + CHECK(out.tokens.input_ids[static_cast(i)] == + vllm_test::kLtxPromptIds_0[static_cast(i)]); + + // The conditioning: two streams at the two widths the DiT cross-attends over. + REQUIRE(out.conditioning.video.size() == + static_cast(out.seq * fcfg.video_out_features)); + REQUIRE(out.conditioning.audio.size() == + static_cast(out.seq * fcfg.audio_out_features)); + REQUIRE(out.conditioning.additive_mask.size() == static_cast(out.seq)); + REQUIRE(out.conditioning.sort_index.size() == static_cast(out.seq)); + + double vmax = 0.0, amax = 0.0, vsum = 0.0; + for (float x : out.conditioning.video) { + REQUIRE(std::isfinite(x)); + vmax = std::max(vmax, std::abs(static_cast(x))); + vsum += std::abs(static_cast(x)); + } + for (float x : out.conditioning.audio) { + REQUIRE(std::isfinite(x)); + amax = std::max(amax, std::abs(static_cast(x))); + } + MESSAGE("ltx2 e2e: prompt \"" << prompt << "\" -> " << out.tokens.num_valid + << " tokens -> video [" + << out.seq << ", " << fcfg.video_out_features + << "] max|v| = " << vmax << " mean|v| = " + << (vsum / static_cast(out.conditioning.video.size())) + << ", audio [" << out.seq << ", " + << fcfg.audio_out_features << "] max|v| = " << amax); + // VALUES, not just isfinite: a conditioning tensor that reduced to zeros would + // satisfy every shape and finiteness check above and render an unconditioned + // clip. §7.0(3) — a golden reduced to `isfinite` once hid a 23842x error. + CHECK(vmax > 1e-3); + CHECK(amax > 1e-3); + + // The RIGHT-PAD REORDER put the valid tokens at the FRONT. Upstream's + // connector assumes right-padded input (embeddings_processor.py:82-92) while + // the tokenizer LEFT-pads, so this reordering is load-bearing: without it every + // valid token would sit behind 1014 pad rows. + for (int64_t i = 0; i < out.tokens.num_valid; ++i) + CHECK(out.conditioning.sort_index[static_cast(i)] == + static_cast(out.tokens.first_valid + i)); + + // A DIFFERENT prompt must produce DIFFERENT conditioning. Without this the + // whole case would pass for a tower that ignored its input entirely — which is + // exactly the failure "the model advertises text-to-video and we cannot type + // text" would become if it were fixed carelessly. + const vllm::Ltx2PromptConditioning other = vllm::Ltx2EncodePromptToConditioning( + tower, tokenizer, ids, proj, fcfg, "a blue whale diving under thick pack ice", + q, vllm_test::kLtxPromptMaxLength); + REQUIRE(other.conditioning.video.size() == out.conditioning.video.size()); + double gap = 0.0; + for (size_t i = 0; i < out.conditioning.video.size(); ++i) + gap = std::max(gap, std::abs(static_cast(out.conditioning.video[i]) - + static_cast(other.conditioning.video[i]))); + MESSAGE("ltx2 e2e: two different prompts differ by max|diff| = " << gap); + CHECK(gap > 1e-3); +} From 9fbc6825667e8a09714f87c84bdd0e0d281109d4 Mon Sep 17 00:00:00 2001 From: Ettore Di Giacinto Date: Thu, 13 Aug 2026 09:09:44 +0000 Subject: [PATCH 2/4] =?UTF-8?q?fix(ltx-2.5):=20close=20the=20L10=20review?= =?UTF-8?q?=20=E2=80=94=20and=20two=20of=20its=20premises=20did=20not=20su?= =?UTF-8?q?rvive=20measurement=20(#435)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Eight findings from the L10 fresh review. Six close as written; two close differently, because the thing they prescribed does not work and the oracle says so. Both are recorded here rather than quietly worked around, since an implementer who accepts a prescription that fails is the failure this protocol exists to catch. ──────────────────────────────────────────────────────────────────────────────── F3 — THE PRESCRIBED FIX IS REFUTED; THE ROPE TABLE IS THE INSTRUMENT The finding is real: `g.rope_partial_full = 1.0` (full rotary on the full- attention layers instead of the config's 0.25) left the suite green at 23 cases / 3583 assertions. Reproduced here before touching anything. The prescription was "a fixture whose global_head_dim/seq keep the rope contribution above the floor". MEASURED against the oracle, per state, as signal = max|bf16 @0.25 - bf16 @1.00| over floor = max|f32 - bf16|: committed head_dim 8/16 seq 8 worst signal/floor 1.095 wider full head head_dim 16/32 seq 8 0.258 longer seq head_dim 8/16 seq 24 0.764 wider + longer head_dim 16/32 seq 24 0.523 wider + longer head_dim 16/32 seq 32 0.650 Enlarging the fixture makes it WORSE. bf16 accumulation noise grows at least as fast as the rope contribution, so no reachable fixture size separates them: the hidden states are the wrong instrument, not a badly sized one. The right instrument is the table. `BuildProportionalRopeCache`'s host computation is split out and exported as `Gemma4ProportionalRopeCosSin`, the generator emits the oracle's own `Gemma4UnifiedTextRotaryEmbedding` cos|sin for the full-attention layer type (section 6), and the new case compares them in f32 with nothing accumulating. Measured agreement 1.267e-07 against a 1e-6 bound, plus an EXACT structural check that pairs at and beyond `int(partial*head_dim//2)` are cos=1, sin=0 and that the pairs below it really rotate. RED under the mutation: 202 assertions fail, worst 0.56533 vs 1e-6, exit 1 GREEN restored: 26 cases / 4115 assertions, exit 0 ──────────────────────────────────────────────────────────────────────────────── F2 — THE VALUE GATE AND THE LOADER, IN CI; AND M6 IS NOT WHAT IT LOOKED LIKE `Ltx2EncodePromptToConditioning`, `Ltx2LoadGemmaTowerFromSafetensors` and all four documented refusals were reachable from exactly ONE place — the opt-in 24 GB case — so none had CI coverage. They do now. The reduced tower fixture, which is already held to a running oracle, is written out as a real .safetensors under the CHECKPOINT's tensor names, loaded back, and compared to the fixture byte for byte; then a tokenizer whose added tokens spell the oracle's own token ids drives the whole prompt path and its conditioning is held to the committed LEFT-PADDED oracle run at a floor propagated through the identical projection. concat order q,k,v -> q,v,k RED 14 assertions, exit 1 PLE refusal disabled RED 1 assertion, exit 1 missing-v_proj refusal disabled RED 1 assertion, exit 1 module dtype F16 read as bf16 RED 1 assertion, exit 1 norm vector F16 read as bf16 RED 1 assertion, exit 1 conditioning at 0.565x / 0.688x of its propagated floor Now the part that did not survive. The review called `positions[i] = i` "the exact defect the surrounding comment warns about". It is not a defect at all. Rotary embedding is RELATIVE and the pads are masked out of attention, so shifting every position by the pad count cancels. MEASURED in the oracle, same 8 tokens told 12..19 and told 0..7: f32 max|diff| 5.11e-05 over max|value| 14.35 3.6e-06 relative bf16 max|diff| 1.09 0.65-1.70x the dtype floor f32 round-off, and at bf16 the rounding of different absolute angles. So the comment at ltx2_text_encoder.cpp — "a port that renumbers from zero rotates every query by the wrong angle" — was an overclaim, and so was its twin in the left-pad case. Both now carry the measurement. The numbering is still mirrored, because transformers derives positions from `cache_position` and fidelity is the reason; arithmetic is not. The new case does red under the renumbering, at 1.10x the audio floor, and says in its own comment that the narrow margin is a property of the defect rather than of the gate. ──────────────────────────────────────────────────────────────────────────────── F4 — THE GENERATOR'S LEGS WERE COUPLED, AND NOT WHERE IT LOOKED `run_tower` did `inner.to(dtype)`, which converts IN PLACE, so every leg after the bf16 one ran downstream of it. Each leg now runs on a `copy.deepcopy`. The mechanism is narrower than "bf16-rounded weights": MEASURED on this transformers build, the parameters round-trip unchanged, and it is the rotary embedding's non-persistent `inv_freq` BUFFERS that do not — 9.36e-05 on the full-attention table, 9.77e-05 on the sliding one. Regenerating moved 12 of the 13 padded f32 states (state 12 by 1.03e-02 on values of 2.705) and every entry of the pad-equivalence vector, while sections 2, 3 and 3b are byte-identical — which is exactly the partition the in-place conversion predicts. The header's claims about sections 4 and 5 are corrected to match. ──────────────────────────────────────────────────────────────────────────────── F5, F7, F8, F9 F5 337 -> 329, and pinned exactly rather than `> 300`. The count is arithmetic and now says so: 40*7 + 8*6 + 1. A lower bound is satisfied by a loader that quietly took a third of the layers from a bf16 fallback. F7 The rationale was inverted. Upstream calls `self.tokenizer(text, ...)` — `__call__` with its default `add_special_tokens=True` — so upstream DOES run the post-processor and we do not. Identical on this checkpoint because its `special_tokens` map is empty, measured. "THE TWO REFERENCES DISAGREE" also overstated it: both let the post-processor run, and only the explicit BOS prepend differs. Both corrected. F8 `kv.dtype` on the production prompt path was f32 where upstream resolves bf16 and where the attention itself runs bf16. Narrowed, not annotated. It was never wrong — it was WIDER, which is why nothing could see it: with the cache back at f32 the new conditioning gate reproduces 0.0617859 / 0.0394362 byte for byte. Half the cache bytes, and it stops taking `Gemma4AttnBlock`'s two-cast-buffers-plus-CastF32 arm on every layer. F9 The dropped `docs/FEATURES.md` edit is reapplied onto the campaign's rewritten row, truthfully: "Text tower RUNS" alongside the `encoder_path` refusal, which another change owns and this one does not touch. Row 533 chars, cells 60/28/217/215. `docs/USAGE.md` is owed too, and the debt turned out to be real rather than procedural: line 372 still said "the Gemma-4 12B text tower is not ported", which is false and which the paragraph 85 lines below it already contradicted. One document, two answers about one model. Corrected to state that the tower runs and to defer to that paragraph for what still blocks a prompt. The `encoder_path` passage itself is untouched — it belongs to the change that owns F1. ──────────────────────────────────────────────────────────────────────────────── NOT CLOSED HERE, AND OWED F1 and F6 are out of scope by instruction — another implementer owns whether the `encoder_path` refusal can be lifted now that L9c landed the connector weights. The spec is operator-owned, so this reports rather than edits it. Two things it needs. First, §4.2's open question stands and should not be narrowed by anything above: the shipped NVFP4 tower's output is still never compared to an independent oracle, so "all 49 hidden states within the oracle's bf16 noise floor" is proven for the SYNTHETIC reduced tower with bf16 weights and not for the quantized one that ships. PR #571 built the independent-oracle correlation technique that would close it. Second, the position-numbering claim appears in the spec in the same overclaiming form corrected here. ──────────────────────────────────────────────────────────────────────────────── GATE cmake -S . -B bld -G Ninja -DCMAKE_BUILD_TYPE=Release -DVLLM_CPP_BUILD_EXAMPLES=OFF cmake --build bld -j 12 BUILD_EXIT=0, no ENOSPC/BFD, df 88% ctest -N 409 tests ctest -j 8 --output-on-failure 409/409 passed, exit 0 ./bld/tests/test_ltx2_text_encoder 26 cases / 4115 assertions, exit 0 (baseline was 23 / 3583) `scripts/agent-preflight.sh` fails `doc-checkpoint range` on commits b0aa475a3, d67f8125e and aa6aa0ecd. All three are ancestors of the branch head this work started from and none is touched here. Issue: #435 FOLLOWING_AGENTS_PROTOCOL Following-Agents-Protocol: true AI-Assisted: true Assisted-by: AGENT:claude-opus-5 [Claude Code] --- docs/FEATURES.md | 2 +- docs/USAGE.md | 10 +- include/vllm/model_executor/models/gemma4.h | 22 + .../model_executor/models/ltx2_text_encoder.h | 35 +- scripts/gen-ltx2-gemma-tower-goldens.py | 132 +- src/vllm/model_executor/models/gemma4.cpp | 34 +- .../models/ltx2_text_encoder.cpp | 32 +- .../vllm/models/ltx2_gemma_tower_goldens.inc | 2428 +++++++++++++---- tests/vllm/models/test_ltx2_text_encoder.cpp | 578 +++- 9 files changed, 2751 insertions(+), 522 deletions(-) diff --git a/docs/FEATURES.md b/docs/FEATURES.md index 3935cc1c9..c02775371 100644 --- a/docs/FEATURES.md +++ b/docs/FEATURES.md @@ -153,7 +153,7 @@ they sit outside the gated list above. | Voxtral audio (`VoxtralForConditionalGeneration`) | Voxtral-Mini-3B-2507 | near-tie-robust 16/16 vs vLLM 0.25.0 | decode 0.97x (beats vLLM); encoder FORWARD 15.90x of vLLM's whole TTFT (pin 46.02 ms), or 2.89x with opt-in `VT_WHISPER_ENC_FA2=1` (costs 3 near-tie divergences vs 0). Not a TTFT ratio. Pending | | Whisper audio encoder | openai/whisper-small; whisper-large-v3 (Voxtral cfg) | encoder tower 77/77; large-v3 tower 203/203 | pending | | MiniMax-H3 DiT (`MiniMaxH3DiTModel`, vllm-omni lane) | MiniMax-H3 (33.1B video+audio) | portable 79/79; all three modalities COHERENT on Q4_K_M (§8.20); PRUNED ckpts run, Q8_0 seam 0.9941 (§8.21); ref2va grid was NVFP4 quant error, §8.9 REFUTED; GGUF/NVFP4/bf16 shards stream | FP4/Marlin landed; speed pending; no bf16 render yet. Render from the Q4_K_M GGUF, not the NVFP4 arm. Krea 2 text-to-image (roadmap C11) is scoped to reuse these DiT seams | -| LTX-2.5 DiT (`LTX2VideoTransformer3DModel`, Lightricks lane) | LTX-2.5 (21.00B video+audio) | `SPIKE`. DiT, both VAE decoders and ENCODERS, conditioning items, pipeline and quantized loaders gated vs upstream at reduced dims. With the connector wired, renders e2e at 320x192/25f: a coherent scene, valid MP4+WAV | Family `ltx-2.5` via `ltx2-gen`. ~29 GB NVFP4/GB10, FP8 ~44 GB. FP8 and torchao-NVFP4 load, first-party NVFP4 does not. Text tower, DiffVAE, LoRA, image conditioning refused AT THE ENGINE. Speed PENDING | +| LTX-2.5 DiT (`LTX2VideoTransformer3DModel`, Lightricks lane) | LTX-2.5 (21.00B video+audio) | `SPIKE`. DiT, both VAE decoders and ENCODERS, conditioning items, pipeline and quantized loaders gated vs upstream at reduced dims. With the connector wired, renders e2e at 320x192/25f: a coherent scene, valid MP4+WAV | Family `ltx-2.5` via `ltx2-gen`. ~29 GB NVFP4/GB10, FP8 ~44 GB. FP8 and torchao-NVFP4 load, first-party NVFP4 does not. Text tower RUNS; `encoder_path`, DiffVAE, LoRA, image cond refused AT THE ENGINE. Speed PENDING | | MTP speculator | Qwen3.6-27B, Qwen3.6-35B-A3B | token-identical to vLLM `mtp` at c1 | ~4% faster c1; +16% output tput (MoE) | | DFlash block-diffusion | Qwen3 (DFlash draft) | near-tie e2e 27/27 vs vLLM | 2.9x over spec-off, 1.003x vs vLLM DFlash-on | | DeepSeek-V4 MTP | DeepSeek-V4-Flash (nextn head) | lossless 5/5; real-model weight-blocked | pending | diff --git a/docs/USAGE.md b/docs/USAGE.md index 8bfc7185c..69508491c 100644 --- a/docs/USAGE.md +++ b/docs/USAGE.md @@ -369,8 +369,14 @@ the audio VAE's is refused rather than resampled, since upstream uses a polyphas kaiser resampler this project does not carry. And a VAE configured with `latent_log_var: none` is refused, because upstream itself raises on it. -**There is no prompt.** The Gemma-4 12B text tower is not ported, so nothing can -turn words into the conditioning the caption projections consume. Conditioning +**There is no prompt**, and this page said the wrong reason for it. The Gemma-4 +12B text tower IS ported and RUNS: a prompt string tokenizes with the tokenizer +the checkpoint ships as a tensor, the tower is materialized and forwarded, and +both caption projections emit their conditioning streams — all of it gated in CI +against a running upstream tower rather than against invariants derived from its +own output. What still blocks a prompt is the hop from there into +cross-attention, which "A second behaviour changed" below states precisely. +Conditioning therefore still comes from `--prompt-embeds` plus `--audio-prompt-embeds`: rows of little-endian f32, 4096 wide for the video stream and 2048 for the audio stream, with the same row count in both. Supplying a `--prompt` is refused, and supplying diff --git a/include/vllm/model_executor/models/gemma4.h b/include/vllm/model_executor/models/gemma4.h index c65a09034..7d386b9fe 100644 --- a/include/vllm/model_executor/models/gemma4.h +++ b/include/vllm/model_executor/models/gemma4.h @@ -251,6 +251,28 @@ std::vector Gemma4GenerateGreedyViaRegistry( vt::Queue& queue, int max_new_tokens, std::vector* out_margins = nullptr); +// The FULL-attention layers' "proportional" rope cos|sin table, on host in f32 — +// the exact values the forward builds (BuildProportionalRopeCache rounds them to +// bf16 to match the q/k it rotates; nothing else differs). Returns +// [max_pos + 1, head_dim]: the first head_dim/2 columns are cos and the second +// half sin, over the head_dim/2 DISTINCT angle pairs, mirroring upstream's +// `emb = cat((freqs, freqs))` with each angle stored once +// (modeling_gemma4_unified.py:257-274, modeling_rope_utils.py:187-245). +// +// This is a GATE SURFACE, and it exists because of a measurement rather than a +// preference. `partial_rotary_factor` decides how many angle pairs are rotated +// and how many are zero-padded to identity, and it is the one field on this path +// that the tower's hidden states cannot resolve: on the reduced LTX tower +// fixture, forcing it from the config's 0.25 to 1.0 displaces the worst hidden +// state by 1.09e-01 against that state's measured bf16 noise floor of 9.99e-02 +// — a ratio of 1.09, inside the tolerance the states are gated at — and a LARGER +// fixture makes it worse, not better (0.65 at head_dim 16/32, seq 32), because +// bf16 accumulation noise grows at least as fast as the rope contribution. So +// the states are the wrong instrument and this table is the right one: f32, no +// accumulation, compared element-wise against the oracle's own rotary embedding. +std::vector Gemma4ProportionalRopeCosSin(const HfConfig& config, + int64_t head_dim, int64_t max_pos); + // Wrap already-loaded Gemma-4 weights in the registered LoadedModel so a caller // that owns the weights (the mm e2e gate) can drive ModelRegistry::Forward without // re-reading the checkpoint. `Make` OWNS the moved weights; `Borrow` does NOT own diff --git a/include/vllm/model_executor/models/ltx2_text_encoder.h b/include/vllm/model_executor/models/ltx2_text_encoder.h index 4b5236efe..883d4cf23 100644 --- a/include/vllm/model_executor/models/ltx2_text_encoder.h +++ b/include/vllm/model_executor/models/ltx2_text_encoder.h @@ -418,19 +418,28 @@ struct Ltx2GemmaPromptTokens { // tokenizer.py:31-59, mirrored including the parts that look like details: // // * `text.strip()` first (:33). diffusers strips too (pipeline_ltx2.py:333). -// * encode with NO special tokens added by the post_processor. The shipped -// tokenizer's `post_processor` is a TemplateProcessing whose `special_tokens` -// map is EMPTY, so it would add nothing anyway — measured on the shipped -// file, not assumed. -// * then PREPEND BOS unconditionally if it is not already first (:44-46). -// THIS IS WHERE THE TWO REFERENCES DISAGREE and upstream is followed: -// `ltx_core` prepends explicitly and says why — "Gemma 3 already emits it -// via post_processor; Gemma 4 does not, so we prepend" (tokenizer.py:12-15) -// — while diffusers passes `add_special_tokens=True` and relies on the -// post_processor (pipeline_ltx2.py:339), which for THIS tokenizer.json adds -// nothing. Following diffusers would drop token 0 of every prompt. Recorded -// rather than silently resolved: `ltx_core` is the model author's own -// runtime and is explicit about the case. +// * encode, then PREPEND BOS unconditionally if it is not already first +// (:44-46). +// +// Two things about that, and the first one is a KNOWN DIVERGENCE rather than +// a mirrored default. Upstream calls `self.tokenizer(text, ...)` — `__call__` +// with its default `add_special_tokens=True` (tokenizer.py:37-43) — so +// upstream DOES run the post_processor and we call plain `Encode`, which +// does not. On THIS checkpoint the two are identical, because the shipped +// `post_processor` is a TemplateProcessing whose `special_tokens` map is +// EMPTY and whose template is the bare sequence, so it has nothing to add: +// measured on the shipped file, not assumed. If a future checkpoint ships a +// post_processor that DOES add something, upstream would emit it and we +// would not — so this is the line to change, not a property to rely on. +// +// What the two references actually disagree about is narrower than "one +// runs the post-processor": both let it run. `ltx_core` ALSO prepends BOS +// explicitly and says why — "Gemma 3 already emits it via post_processor; +// Gemma 4 does not, so we prepend" (tokenizer.py:12-15) — while diffusers +// relies on the post_processor alone (pipeline_ltx2.py:339), which for this +// tokenizer.json adds nothing, so following diffusers would drop token 0 of +// every prompt. `ltx_core` is the model author's own runtime and is explicit +// about the case, so it is the one followed. // * EOS is never appended (:14). // * truncation happens BEFORE the BOS prepend and again after (:41, :46), so a // maximal prompt loses its LAST token to make room for BOS rather than diff --git a/scripts/gen-ltx2-gemma-tower-goldens.py b/scripts/gen-ltx2-gemma-tower-goldens.py index 93a69041d..08cb5ead7 100644 --- a/scripts/gen-ltx2-gemma-tower-goldens.py +++ b/scripts/gen-ltx2-gemma-tower-goldens.py @@ -35,17 +35,28 @@ 12B tower. Our port runs only the VALID tokens at their ORIGINAL absolute positions. That is equivalent -- pads are masked out of attention and are causally before every valid token, and the feature extractor zeroes their - rows anyway -- but "is equivalent" is a claim, so section 3 emits the full + rows anyway -- but "is equivalent" is a claim, so section 4 emits the full left-padded oracle run and the C++ suite holds the short run's valid rows to the padded run's valid rows. If the equivalence is ever false, that gate is what says so, and a 100x cost claim stops resting on an argument. * ONE arithmetic width per state, both ways round. Section 2 is the oracle in - float32 and section 4 the SAME oracle in bfloat16. Our forward carries the - stream in bf16 and widens only on the way out (gemma4.h, - Gemma4HiddenStatesResult), so bf16 is the dtype-MATCHED arm and f32 is the - arm that would catch a reduction-order defect a bf16 store absorbs. Gating - only one of them has burned this project before. + float32 and section 3 the SAME oracle in bfloat16; sections 4 and 4b are + that pair again for the left-padded run. Our forward carries the stream in + bf16 and widens only on the way out (gemma4.h, Gemma4HiddenStatesResult), + so bf16 is the dtype-MATCHED arm and f32 is the arm that would catch a + reduction-order defect a bf16 store absorbs. Gating only one of them has + burned this project before. + + Every leg runs on a DEEP COPY of the module. `nn.Module.to(dtype)` converts + in place and bf16 rounding is destructive, so before that fix the two + "float32" legs after the bf16 one were executing over bf16-ROUNDED weights + -- MEASURED at up to 3.90e-02 per state, of the same order as the noise + floor the tolerance itself is derived from. + + * The ROPE TABLES, in f32 (section 6), because `partial_rotary_factor` is not + resolvable from the hidden states at any fixture size this generator can + build. Section 6's note carries the measurement that establishes it. Both sides rebuild every weight from one deterministic FNV-1a + splitmix64 stream keyed by the parameter's own HuggingFace NAME, exactly as @@ -84,6 +95,7 @@ from __future__ import annotations import argparse +import copy import json import os import subprocess @@ -317,7 +329,20 @@ def build_tower(real_config: dict): def run_tower(inner, ids, mask, dtype, positions=None): - m = inner.to(dtype).eval() + """One oracle leg, on a DEEP COPY of the module. + + `nn.Module.to(dtype)` converts parameters and buffers IN PLACE, so the + obvious `inner.to(dtype)` / `inner.to(torch.float32)` round trip does not + restore anything: bf16 rounding is destructive, and every leg after the + first bf16 one would run over bf16-ROUNDED weights while calling itself + float32. MEASURED on this fixture before the fix: re-running the identical + f32 call after the bf16 leg moved a state by up to 3.90e-02, which is + ~40x the f32 legs' own round-off and of the same order as the bf16 noise + floor the gate is calibrated on. Sections 4 and 5 were silently + order-dependent because of it. Copying is cheap here -- the reduced tower + is a few hundred KB -- and it makes every leg independent of leg order. + """ + m = copy.deepcopy(inner).to(dtype).eval() kwargs = {} if positions is not None: # The absolute positions the tokens occupy in the padded batch. Left @@ -332,9 +357,44 @@ def run_tower(inner, ids, mask, dtype, positions=None): output_hidden_states=True, **kwargs, ) - states = [h[0].to(torch.float32).contiguous().numpy() for h in out.hidden_states] - inner.to(torch.float32) - return states + return [h[0].to(torch.float32).contiguous().numpy() for h in out.hidden_states] + + +def rope_cos_sin(config, layer_type: str, head_dim: int, positions) -> np.ndarray: + """The oracle's OWN cos|sin table for one layer type, in float32. + + Why this is emitted at all: `partial_rotary_factor` is NOT resolvable from + the hidden states. MEASURED on this fixture, the whole difference between + the config's 0.25 and a port that ignored it and rotated fully is 1.09e-01 + at the worst state against a bf16 noise floor of 9.99e-02 -- a ratio of + 1.09, i.e. inside the tolerance the same states are gated at. Enlarging the + fixture does not rescue it: at (head_dim 16/32, seq 32) the ratio FALLS to + 0.65, because bf16 accumulation noise grows at least as fast as the rope + contribution does. So the end-to-end states are the wrong instrument, and + the right one is the table itself, in f32, with no accumulation in it. + + Built by the real `Gemma4UnifiedTextRotaryEmbedding`, which is what routes + `rope_type: "proportional"` to `_compute_proportional_rope_parameters` + (modeling_gemma4_unified.py:214-218, modeling_rope_utils.py:187-245) and so + is the only thing that decides how many angle pairs are zero-padded. + + Returns [len(positions), head_dim]: the first head_dim/2 columns are cos + over the distinct angle pairs and the second half is sin, which is the + layout `BuildProportionalRopeCache` writes. + """ + from transformers.models.gemma4_unified.modeling_gemma4_unified import ( # noqa: PLC0415 + Gemma4UnifiedTextRotaryEmbedding, + ) + + rope = Gemma4UnifiedTextRotaryEmbedding(config) + pos = torch.tensor([list(positions)], dtype=torch.long) + x = torch.zeros(1, len(positions), head_dim, dtype=torch.float32) + cos, sin = rope(x, pos, layer_type=layer_type) + pairs = head_dim // 2 + # Upstream duplicates each angle (`emb = cat((freqs, freqs))`) so cos/sin are + # head_dim wide over head_dim/2 DISTINCT angles; take one copy of each. + table = torch.cat((cos[0, :, :pairs], sin[0, :, :pairs]), dim=-1) + return table.to(torch.float32).contiguous().numpy() # --------------------------------------------------------------------------- @@ -408,6 +468,11 @@ def main() -> int: plain_f32 = run_tower(inner, TOKENS, [1] * SEQ, torch.float32) plain_bf16 = run_tower(inner, TOKENS, [1] * SEQ, torch.bfloat16) padded_f32 = run_tower(inner, padded_ids, padded_mask, torch.float32) + # The padded run at the SHIPPED dtype too. Without it the left-padded rows + # have no dtype-matched oracle, and anything gated against them -- the + # prompt-to-conditioning path, which is left-padded by construction -- has + # no measured floor to be held to, only a borrowed one. + padded_bf16 = run_tower(inner, padded_ids, padded_mask, torch.bfloat16) # The equivalence claim, isolated INSIDE the oracle and in f32 so no dtype # noise is mixed into it: the same valid tokens, told their absolute # positions, run WITHOUT the pads. If upstream's own two answers agree, the @@ -523,19 +588,60 @@ def main() -> int: "// [state][padded_seq * hidden]. Rows 0..kLtxTowerNumPad-1 are pad rows and\n" "// their contents are upstream's garbage-but-masked values; the gate reads\n" "// only the VALID tail and holds section 2 to it.\n" + "// Every leg runs on a DEEP COPY of the module, so this one is not\n" + "// downstream of the bf16 leg's rounding and the sections are independent\n" + "// of the order they are produced in.\n" ) for i, s in enumerate(padded_f32): emit_f32(out, f"kLtxTowerPaddedStateF32_{i}", s) + out.write( + "// --- section 4b: the LEFT-PADDED run, BFLOAT16 (the SHIPPED dtype) ---\n" + "// The dtype-MATCHED arm for anything gated on the left-padded rows, and\n" + "// with section 4 it is also the padded run's own measured noise floor.\n" + ) + for i, s in enumerate(padded_bf16): + emit_f32(out, f"kLtxTowerPaddedStateBf16_{i}", s) + out.write( "// --- section 5: the equivalence, measured INSIDE the oracle ---\n" "// Per state, max|short-run-at-absolute-positions - padded-run's valid rows|,\n" - "// both f32, so this number carries NO dtype noise. It is upstream's own\n" - "// answer to 'is dropping the pads free?'. Our port inherits it; the C++\n" - "// gate checks the two claims separately so a failure says which one broke.\n" + "// both f32 and both on independently deep-copied modules, so this number\n" + "// carries NO dtype noise. It is upstream's own answer to 'is dropping the\n" + "// pads free?'. Our port inherits it; the C++ gate checks the two claims\n" + "// separately so a failure says which one broke.\n" ) emit_f32(out, "kLtxTowerPadEquivalence", equivalence) + # SECTION 6 -- the rope table, because the hidden states cannot see it. + # + # `partial_rotary_factor` decides how many of the full-attention layers' + # angle pairs are rotated and how many are zero-padded to identity. It is + # config-carried, shape-invisible, and -- MEASURED, not assumed -- also + # invisible in the gated hidden states: setting it to 1.0 displaces the + # worst state by 1.09e-01 against a bf16 floor of 9.99e-02 (ratio 1.09), + # and a larger fixture makes that WORSE, not better (0.65 at head_dim + # 16/32, seq 32), because bf16 accumulation noise grows at least as fast. + # A gate whose tolerance is bf16 noise cannot resolve it, so the table + # itself is emitted and compared in f32. + full_head_dim = GLOBAL_HEAD_DIM + rope_positions = list(range(PADDED_SEQ)) + rope_full = rope_cos_sin(config.text_config, "full_attention", + full_head_dim, rope_positions) + out.write( + "// --- section 6: the ORACLE's FULL-attention rope cos|sin table, f32 ---\n" + "// [position][global_head_dim]: first half cos, second half sin, over the\n" + "// global_head_dim/2 DISTINCT angle pairs (upstream stores each twice).\n" + "// `rope_type: proportional` at theta 1e6 and partial_rotary_factor 0.25,\n" + "// so the trailing pairs are cos=1, sin=0. Emitted because the partial\n" + "// factor is NOT resolvable from the hidden states -- see the note above --\n" + "// and because a table that silently rotated every pair would still produce\n" + "// 13 finite, plausibly-scaled states.\n" + ) + emit_scalar(out, "kLtxTowerRopePositions", len(rope_positions)) + out.write("\n") + emit_f32(out, "kLtxTowerRopeFullCosSin", rope_full) + out.write("} // namespace vllm_test\n") sys.stderr.write( diff --git a/src/vllm/model_executor/models/gemma4.cpp b/src/vllm/model_executor/models/gemma4.cpp index 02ec38894..59cedfa62 100644 --- a/src/vllm/model_executor/models/gemma4.cpp +++ b/src/vllm/model_executor/models/gemma4.cpp @@ -157,8 +157,8 @@ Gemma4Layout MakeLayout(const HfConfig& cfg) { // identity; angle denominator is Dh (not rotary_dim). Layout matches // RopeCosSinCache: cos_sin[t, i]=cos, cos_sin[t, Dh/2 + i]=sin, over Dh pairs... // stored as [P, Dh] with first Dh/2 = cos, second Dh/2 = sin. Double angle -> f32. -DBuf BuildProportionalRopeCache(Dev d, const Gemma4Layout& g, int64_t Dh, - int64_t max_pos) { +std::vector ProportionalRopeCosSinHost(const Gemma4Layout& g, int64_t Dh, + int64_t max_pos) { const int64_t pairs = Dh / 2; const int64_t rope_angles = static_cast(g.rope_partial_full * static_cast(Dh)) / 2; @@ -169,21 +169,27 @@ DBuf BuildProportionalRopeCache(Dev d, const Gemma4Layout& g, int64_t Dh, inv_freq[static_cast(j)] = 1.0 / std::pow(base, exponent); } const int64_t P = max_pos + 1; - std::vector host(static_cast(P) * static_cast(Dh)); - // NOTE: cache dtype bf16 to match the bf16 q/k it rotates (RopeFromCache wants - // q/k/cache same dtype). vLLM keeps f32 cos/sin — a named bf16-rounding nuance. + std::vector host(static_cast(P) * static_cast(Dh), 0.0f); for (int64_t t = 0; t < P; ++t) { for (int64_t i = 0; i < pairs; ++i) { const double angle = static_cast(t) * inv_freq[static_cast(i)]; - const float c = static_cast(std::cos(angle)); - const float s = static_cast(std::sin(angle)); host[static_cast(t) * static_cast(Dh) + static_cast(i)] = - vt::F32ToBF16(c); + static_cast(std::cos(angle)); host[static_cast(t) * static_cast(Dh) + - static_cast(pairs + i)] = vt::F32ToBF16(s); + static_cast(pairs + i)] = static_cast(std::sin(angle)); } } - DBuf cache(d, DType::kBF16, {P, Dh}, host.data()); + return host; +} + +DBuf BuildProportionalRopeCache(Dev d, const Gemma4Layout& g, int64_t Dh, + int64_t max_pos) { + const std::vector f32 = ProportionalRopeCosSinHost(g, Dh, max_pos); + // NOTE: cache dtype bf16 to match the bf16 q/k it rotates (RopeFromCache wants + // q/k/cache same dtype). vLLM keeps f32 cos/sin — a named bf16-rounding nuance. + std::vector host(f32.size()); + for (size_t i = 0; i < f32.size(); ++i) host[i] = vt::F32ToBF16(f32[i]); + DBuf cache(d, DType::kBF16, {max_pos + 1, Dh}, host.data()); return cache; } @@ -804,4 +810,12 @@ std::vector Gemma4Model::ForwardMm( return logits; } +std::vector Gemma4ProportionalRopeCosSin(const HfConfig& config, int64_t head_dim, + int64_t max_pos) { + VT_CHECK(head_dim > 0 && head_dim % 2 == 0 && max_pos >= 0, + "gemma4: proportional rope table wants an even positive head_dim and a " + "non-negative max_pos"); + return ProportionalRopeCosSinHost(MakeLayout(config), head_dim, max_pos); +} + } // namespace vllm diff --git a/src/vllm/model_executor/models/ltx2_text_encoder.cpp b/src/vllm/model_executor/models/ltx2_text_encoder.cpp index 37aea68ad..2b9b79549 100644 --- a/src/vllm/model_executor/models/ltx2_text_encoder.cpp +++ b/src/vllm/model_executor/models/ltx2_text_encoder.cpp @@ -1016,7 +1016,18 @@ Ltx2PromptConditioning Ltx2EncodePromptToConditioning( out.tokens.input_ids[static_cast(out.tokens.first_valid + i)]; // The ORIGINAL absolute position, not a renumbering from zero: transformers // derives positions from the cache position, which counts the pad rows, so a - // left-padded prompt's first real token sits at `first_valid`. + // left-padded prompt's first real token sits at `first_valid`. This mirrors + // upstream because upstream does it, and for no stronger reason than that — + // MEASURED against the running oracle rather than argued: rotary position + // embedding is RELATIVE and the pads are masked out of attention, so shifting + // every position by the same amount is a no-op. Upstream's own f32 answers + // for positions 12..19 and 0..7 on the same 8 tokens differ by 5.11e-05 on + // values of magnitude 14.35, i.e. 3.6e-06 relative — f32 round-off and + // nothing else. At bf16 they differ by 1.09, but that is the rounding of + // different absolute angles and is 0.65-1.70x the per-state dtype floor, so + // no tolerance separates the two cleanly either. Renumbering here would + // therefore NOT rotate a query by the wrong angle; it would simply stop + // matching what transformers passes. Keep it matching. positions[static_cast(i)] = static_cast(out.tokens.first_valid + i); } @@ -1025,18 +1036,31 @@ Ltx2PromptConditioning Ltx2EncodePromptToConditioning( // geometry, and the runner's single-uniform-head_dim allocation cannot express // that (gemma4.h, G1 HONEST STATUS) — so this path builds its own rather than // routing through a seam that would have to lie about one of the two. + // + // BF16, which is upstream's ONE resolved model dtype for this tower + // (base_encoder.py:41 `dtype: torch.dtype = torch.bfloat16`) and the dtype the + // attention itself runs in (gemma4.cpp, `adt = DType::kBF16`). This was f32 + // until the L10 review: nothing was wrong with the numbers — an f32 KV cache + // is strictly WIDER, so every token gate and every golden still passed — it + // simply held twice the bytes and made `Gemma4AttnBlock` allocate two extra + // per-layer cast buffers and run a CastF32 on every K and V it wrote + // (gemma4.cpp:300-312, the `kv.dtype != adt` arm). That is exactly the defect + // class AGENTS.md names: a token gate cannot see a dtype that is too wide. + // At the shipped 48 layers x 1024 positions this is ~2x on a cache that peaks + // near 200 MB for one prompt. const int64_t block = 16; const int64_t blocks = (T + block - 1) / block; - std::vector> kv_storage; + std::vector> kv_storage; std::vector attn_kv; kv_storage.reserve(static_cast(L)); for (int64_t l = 0; l < L; ++l) { const Gemma4LayerWeights& lw = tower.weights.layers[static_cast(l)]; kv_storage.emplace_back( - static_cast(blocks * 2 * block * lw.num_kv_heads * lw.head_dim), 0.0f); + static_cast(blocks * 2 * block * lw.num_kv_heads * lw.head_dim), + static_cast(0)); PagedKvCache kv; kv.data = kv_storage.back().data(); - kv.dtype = vt::DType::kF32; + kv.dtype = vt::DType::kBF16; kv.num_blocks = blocks; kv.block_size = block; kv.num_kv_heads = lw.num_kv_heads; diff --git a/tests/vllm/models/ltx2_gemma_tower_goldens.inc b/tests/vllm/models/ltx2_gemma_tower_goldens.inc index e3b049174..0cd54c941 100644 --- a/tests/vllm/models/ltx2_gemma_tower_goldens.inc +++ b/tests/vllm/models/ltx2_gemma_tower_goldens.inc @@ -1340,6 +1340,9 @@ inline constexpr float kLtxTowerStateScale[] = { // [state][padded_seq * hidden]. Rows 0..kLtxTowerNumPad-1 are pad rows and // their contents are upstream's garbage-but-masked values; the gate reads // only the VALID tail and holds section 2 to it. +// Every leg runs on a DEEP COPY of the module, so this one is not +// downstream of the bf16 leg's rounding and the sections are independent +// of the order they are produced in. inline constexpr float kLtxTowerPaddedStateF32_0[] = { -0.109783173f, 0.197471619f, 0.0835456848f, 0.2029953f, -0.0555820465f, 0.277565002f, 0.0393562317f, -0.0189013481f, -0.0070772171f, 0.212661743f, 0.191947937f, -0.160186768f, @@ -1520,44 +1523,44 @@ inline constexpr float kLtxTowerPaddedStateF32_1[] = { 0.293569535f, -0.274536461f, 1.60135472f, 0.0462248959f, 0.673270881f, -0.301604062f, 2.34471965f, 0.0311507694f, -1.75879371f, 0.420391083f, 2.8137219f, -1.24765635f, -1.49731588f, -1.04393268f, 0.095809713f, -2.37909365f, -0.265560567f, -1.05342603f, - 1.31991398f, -0.289815426f, -0.30631578f, -1.25914049f, 1.54125512f, 1.15922856f, - -0.265958905f, -0.175289124f, 1.48632967f, 2.41660357f, 0.612802684f, -1.56944323f, - -0.801020563f, 1.46623468f, 1.68214548f, -0.310023785f, 0.498262644f, -1.61938691f, - -1.16377735f, -0.151860133f, 1.07389152f, -3.25862741f, -1.21410131f, 0.991703808f, - 1.15240383f, -1.05130494f, -3.23364806f, -1.45446396f, -0.431719571f, -0.717480958f, - 1.04536748f, 0.436771333f, -0.476053506f, 0.203860834f, -0.0265636593f, -2.84084225f, - 1.28741896f, 0.774901688f, -0.0671837702f, 0.77377665f, -0.940532625f, 1.33604848f, - 0.642396808f, -0.47878471f, -0.436206907f, 0.219888717f, 0.255922556f, -0.973073244f, - 0.68038857f, -1.11182797f, 0.667417169f, -3.12759757f, 1.32684743f, -0.449378729f, - 1.92889833f, 0.0183931794f, 3.44997644f, -0.291030198f, -2.73255825f, -1.49776995f, - 1.5917964f, -0.166809529f, -0.158464953f, -0.45457083f, 2.4870863f, 0.639203668f, - 1.49144256f, -1.00002253f, 1.75339353f, 0.632306457f, -0.606394529f, 0.130232751f, - -0.901771665f, -2.7071867f, -1.22307718f, 3.02341795f, -1.13129365f, 0.149112016f, - -0.345503896f, 2.54521394f, 0.104782209f, 0.311388195f, -0.709555864f, -0.135203704f, - 2.01142311f, -1.20674562f, -0.165327236f, 0.508106291f, -1.99352217f, 1.15098381f, - 0.572008848f, -0.979201794f, -0.675259173f, 0.133523166f, 0.677297294f, 2.28855944f, - 1.65192556f, 1.79343069f, -1.63667917f, -1.16576838f, -0.32033807f, -0.205367506f, - -0.0302636214f, 0.121686734f, 0.630567789f, 2.34748912f, 1.83828008f, -0.763331592f, - -0.109890327f, 0.847685575f, 1.90958405f, -1.47753549f, -0.133232683f, -2.06883883f, - -0.908194721f, -0.784403682f, -1.20181692f, -3.06987381f, -1.51086128f, -0.36165604f, - -0.902179122f, -0.292360902f, -1.38245881f, 1.33951604f, -0.571103394f, -1.25618947f, - 0.476130038f, -1.61207187f, -0.283086628f, 0.602477252f, 0.637224555f, 0.437164336f, - 0.667343438f, 2.33977318f, -0.851174474f, 1.28994226f, -1.11364388f, -0.108714893f, - 2.08834529f, 3.30353713f, -1.98507571f, 1.28553224f, 1.44864535f, -0.33821708f, - -0.600777805f, 0.447428674f, -2.02474713f, 0.08626239f, 1.5738132f, -1.51757777f, - -0.664806366f, 0.080807291f, -2.50854897f, -0.283403039f, 1.64871252f, -0.477891505f, - 0.203556404f, -1.64373922f, 0.593579113f, 2.26764321f, 0.13872619f, 1.8034035f, - 1.15324223f, -1.42396784f, -1.44539225f, -0.182933956f, 2.97036314f, -0.631644607f, - -1.90151179f, 0.168508962f, -1.37633598f, -2.41606283f, 1.68950546f, -1.09449983f, - 1.09316671f, 2.02546191f, -0.0919578895f, -1.32638228f, -1.19337904f, -0.208551168f, - 0.968132734f, 0.866139114f, 0.140985519f, -1.13251209f, 0.316421896f, -0.96377331f, - 0.53603071f, 2.82450986f, -0.491189718f, 0.266211689f, 0.954997003f, 0.257930756f, - -1.1217463f, 0.30886963f, 1.60884786f, 3.2613101f, -0.518345296f, 1.96768546f, - 1.15511143f, -0.415646017f, -1.04215598f, -1.94319618f, -1.80034959f, 0.970089734f, - 0.811318457f, -1.86345124f, 0.20103991f, -0.00109709799f, -0.0157570411f, -0.655511439f, - -0.649728f, 2.91500592f, 0.744466424f, -0.521453917f, -1.05356979f, -0.344881296f, - -1.82803059f, -0.468131989f, 0.245427758f, 1.62624073f, 0.788545191f, 0.835015178f, - 0.952632129f, 2.09937024f, 0.599630117f, -0.38810128f, + 1.31991398f, -0.289815426f, -0.306324005f, -1.25913596f, 1.54124975f, 1.15922952f, + -0.26595071f, -0.175295934f, 1.48632336f, 2.41660428f, 0.612804949f, -1.56943905f, + -0.801014483f, 1.46623635f, 1.68214798f, -0.310024142f, 0.498268664f, -1.6193819f, + -1.16377878f, -0.151858285f, 1.07389331f, -3.25863051f, -1.21410775f, 0.991699696f, + 1.15239644f, -1.05131328f, -3.23364329f, -1.45446229f, -0.431717217f, -0.717489779f, + 1.04536307f, 0.436770707f, -0.476055026f, 0.203867182f, -0.0265903641f, -2.8408339f, + 1.28742123f, 0.774915695f, -0.0671817511f, 0.773777664f, -0.940563381f, 1.33605671f, + 0.642416f, -0.478788227f, -0.43618542f, 0.219910696f, 0.255948633f, -0.973068178f, + 0.680380821f, -1.11183798f, 0.667416334f, -3.12762165f, 1.32686067f, -0.449385077f, + 1.92885792f, 0.0183844902f, 3.4499445f, -0.29104802f, -2.73255301f, -1.49775052f, + 1.59177852f, -0.166832656f, -0.158490017f, -0.454606622f, 2.48707485f, 0.639238536f, + 1.49145246f, -1.00018072f, 1.75359583f, 0.632275045f, -0.606270134f, 0.130294353f, + -0.901580334f, -2.70690346f, -1.22284973f, 3.02373505f, -1.13127685f, 0.148767307f, + -0.345613837f, 2.54525065f, 0.104475945f, 0.311318249f, -0.709546268f, -0.135166749f, + 2.01163936f, -1.20645809f, -0.165860176f, 0.50821203f, -1.99371672f, 1.15101147f, + 0.572166145f, -0.978789687f, -0.675006628f, 0.133933142f, 0.677437663f, 2.28857994f, + 1.65163219f, 1.79313791f, -1.63658333f, -1.16572046f, -0.320199609f, -0.205226094f, + -0.0303110275f, 0.121651739f, 0.630501747f, 2.34752297f, 1.83826816f, -0.763303816f, + -0.109862641f, 0.847837448f, 1.90964174f, -1.47741401f, -0.133201495f, -2.06875229f, + -0.908203542f, -0.784467757f, -1.20175362f, -3.07011032f, -1.51081741f, -0.361627638f, + -0.902172267f, -0.292488039f, -1.38242018f, 1.3394053f, -0.571171165f, -1.25617325f, + 0.476146072f, -1.61201012f, -0.28301391f, 0.602500379f, 0.637001872f, 0.437475801f, + 0.667067587f, 2.33962774f, -0.851365566f, 1.29004908f, -1.11395419f, -0.108941093f, + 2.08845401f, 3.30334735f, -1.98544383f, 1.28557611f, 1.44853818f, -0.338534355f, + -0.600629389f, 0.447395742f, -2.02487063f, 0.0862875655f, 1.57380033f, -1.51752198f, + -0.664628565f, 0.0803939998f, -2.50829911f, -0.283353567f, 1.64878726f, -0.478527665f, + 0.202981636f, -1.64396346f, 0.593567193f, 2.26732898f, 0.138388112f, 1.80372655f, + 1.1533668f, -1.42335486f, -1.4453001f, -0.182661071f, 2.97099829f, -0.632361829f, + -1.8996824f, 0.168847978f, -1.37503386f, -2.41509891f, 1.6901598f, -1.09445715f, + 1.09429646f, 2.02528596f, -0.0923796892f, -1.32578146f, -1.19390798f, -0.208321616f, + 0.968699336f, 0.866376579f, 0.140281409f, -1.13199484f, 0.315516829f, -0.964632094f, + 0.536807239f, 2.82521677f, -0.491432816f, 0.266447991f, 0.956912875f, 0.257664502f, + -1.12140048f, 0.308237523f, 1.60896885f, 3.26095772f, -0.518111765f, 1.96797693f, + 1.15453529f, -0.415153146f, -1.04181957f, -1.94303882f, -1.80022299f, 0.971408784f, + 0.810593665f, -1.86375463f, 0.200901628f, -0.00160476565f, -0.0159313064f, -0.655396581f, + -0.650143445f, 2.91487336f, 0.744380176f, -0.521372795f, -1.05467725f, -0.344257653f, + -1.8283726f, -0.46798107f, 0.244996414f, 1.62551904f, 0.789781928f, 0.834817588f, + 0.953185976f, 2.10035419f, 0.599633396f, -0.387934238f, }; inline constexpr float kLtxTowerPaddedStateF32_2[] = { @@ -1630,44 +1633,44 @@ inline constexpr float kLtxTowerPaddedStateF32_2[] = { -2.18246293f, -1.98946178f, 4.15764332f, 1.26136172f, -1.06169498f, 2.0369215f, 2.66516733f, -1.03545225f, -2.71756887f, 0.345697939f, 2.78603292f, -1.61341357f, -0.416000634f, -1.53710818f, -2.1350317f, 0.647517264f, 1.31271732f, -2.18382716f, - 1.52610838f, 0.529773831f, -3.03355598f, -1.35667944f, 2.11285591f, 1.76925611f, - -1.32635832f, -1.17310393f, 1.33510387f, 4.43243313f, 2.82520199f, 0.275970906f, - -1.98885691f, 0.949353874f, -0.811743855f, 0.450002164f, 1.37089264f, -2.00190234f, - -2.07053161f, -0.194285318f, 1.59363163f, -4.95765352f, 0.237132743f, 0.68529439f, - 2.40496421f, -1.84623432f, -2.22342873f, -1.79952109f, 0.522076488f, 2.18993759f, - 3.02512026f, -0.143188015f, -0.753290832f, -1.11415732f, -0.770203233f, -5.0472312f, - 1.14643049f, 1.68933463f, 0.211407617f, 0.286591023f, -3.60934496f, 1.69267952f, - 1.30492687f, -2.13472104f, -2.05770898f, -1.01953828f, -2.550457f, -3.80489397f, - 0.755630732f, -1.05458236f, -1.36714804f, -2.93418813f, 2.78120923f, -2.76251531f, - 1.71678412f, 0.855482876f, 4.7215519f, -1.447873f, -1.30497622f, -0.789352417f, - 1.16152573f, 3.42396855f, -0.200219035f, -2.46305513f, 2.41207194f, 0.979083478f, - 0.350380868f, -0.166144758f, 3.42020965f, -1.49596655f, 1.83858812f, -2.14805102f, - 0.621272743f, -4.49891615f, -0.828520715f, 0.647504091f, -1.44480515f, -2.37227893f, - -0.998114526f, 2.70375681f, -0.656378031f, 2.30941153f, -0.922689497f, 1.25135922f, - -1.05960643f, -2.89404321f, 0.00986304972f, 0.748238385f, -2.22822762f, 0.476626694f, - -0.18835938f, 0.381056011f, -1.1764791f, 0.108974919f, 3.1238451f, 4.5676322f, - 0.328201652f, 1.45811903f, -1.07248294f, -3.28176928f, -0.710666299f, 0.532594979f, - -0.261217892f, 0.516261876f, -0.258798063f, 4.00530958f, 3.4207828f, 2.82841158f, - 0.417595208f, 1.43562615f, 0.0262823366f, -1.79211664f, 1.31350088f, -4.89044762f, - -0.894658148f, -1.88089383f, -0.132363856f, -3.5623951f, 0.099839136f, 0.26791507f, - -0.632604241f, -2.22200298f, -2.18963718f, 1.81562281f, 1.28787374f, 1.23317623f, - 0.00617384445f, -2.21373153f, -2.30115056f, -0.371310323f, 2.73077822f, -1.39894426f, - 2.13341665f, 0.598042846f, 0.738605857f, 2.82453609f, -1.73271763f, -2.33198643f, - 2.68565893f, 2.8065722f, -0.246829286f, 0.714734316f, 0.284567297f, 0.253949523f, - 0.312478542f, -0.779141009f, -2.50853372f, -1.02553332f, 1.47277629f, -1.91645873f, - 2.0836134f, -1.27143753f, -2.25192595f, -1.90554309f, 0.571509302f, 2.33204532f, - 1.79024482f, -1.26949811f, -1.72168481f, 3.15852284f, 0.0678512901f, 3.67820454f, - 3.21147847f, -0.458659053f, -3.03419805f, -1.29854405f, 2.34733653f, -1.12480497f, - -2.84915543f, -1.06289124f, -0.304517925f, -2.28788686f, -0.241911173f, -0.749902189f, - -0.763695121f, 0.889834642f, 1.26291049f, 0.232054681f, -3.64003611f, 2.22192764f, - -0.2252855f, -1.09948242f, -2.50494957f, -2.24995327f, 1.75262547f, -0.169535592f, - 2.58954978f, 4.06241941f, -0.00502433255f, 2.56465054f, 2.51882195f, 0.309558779f, - -0.0309196152f, 0.245810539f, 2.87697554f, 3.65372944f, 0.816191435f, 1.35332179f, - 0.479074776f, -1.67067742f, -1.4906863f, -4.03290176f, -5.56160831f, 0.34615472f, - -0.327657729f, -0.525365472f, 0.750033617f, 0.786531746f, 0.087211147f, 0.462557614f, - -0.793803453f, 4.78909636f, 0.109938323f, -3.1718998f, -2.6276176f, -2.00504351f, - 2.53156614f, 0.383899391f, 2.17760181f, -0.931892514f, -1.00043201f, 0.579354882f, - 1.26393747f, 2.19797206f, 0.552204072f, 0.546010911f, + 1.52610838f, 0.529773831f, -3.03355432f, -1.35661829f, 2.11288095f, 1.76929188f, + -1.32637262f, -1.1731168f, 1.33504581f, 4.43245649f, 2.82521224f, 0.275986671f, + -1.98884964f, 0.949342549f, -0.811730981f, 0.44994095f, 1.37091708f, -2.00187469f, + -2.07055259f, -0.194292113f, 1.59364927f, -4.95764256f, 0.237190008f, 0.685322225f, + 2.40491843f, -1.84622228f, -2.22343779f, -1.7995019f, 0.522072673f, 2.18992877f, + 3.02510738f, -0.143185526f, -0.753311932f, -1.11410773f, -0.770243883f, -5.04726648f, + 1.14634001f, 1.689381f, 0.211433113f, 0.286621571f, -3.60937166f, 1.69264293f, + 1.30486119f, -2.134763f, -2.05765367f, -1.01949918f, -2.55044723f, -3.80488753f, + 0.755643249f, -1.05458999f, -1.36714768f, -2.93426347f, 2.78113174f, -2.76256561f, + 1.71680617f, 0.855420411f, 4.72154713f, -1.44789338f, -1.30497432f, -0.789305568f, + 1.16152394f, 3.42392921f, -0.200295448f, -2.46315694f, 2.41203594f, 0.979190528f, + 0.350706071f, -0.166044578f, 3.42161441f, -1.49679756f, 1.83753228f, -2.14757133f, + 0.622547984f, -4.49984598f, -0.827749908f, 0.648490965f, -1.44455218f, -2.37235785f, + -0.998303235f, 2.70399427f, -0.657004595f, 2.30982637f, -0.921416521f, 1.25141037f, + -1.06015134f, -2.89452791f, 0.00888093375f, 0.747651041f, -2.22776604f, 0.476961493f, + -0.188264698f, 0.380526006f, -1.17640507f, 0.108856015f, 3.12309527f, 4.5671401f, + 0.327921957f, 1.45854425f, -1.07232893f, -3.28218818f, -0.710650682f, 0.532570124f, + -0.261207998f, 0.516385555f, -0.259078205f, 4.00530291f, 3.42084312f, 2.82871819f, + 0.417563826f, 1.43597674f, 0.0262906104f, -1.79207397f, 1.31346273f, -4.89049196f, + -0.89489609f, -1.88119113f, -0.132272333f, -3.56273174f, 0.100121468f, 0.26775685f, + -0.632735014f, -2.22207355f, -2.18956828f, 1.81542623f, 1.28781104f, 1.23305428f, + 0.00589978695f, -2.21388865f, -2.30106711f, -0.371244818f, 2.73057294f, -1.39848375f, + 2.13347459f, 0.59804821f, 0.738049924f, 2.82423472f, -1.73250008f, -2.33199883f, + 2.68605709f, 2.80688143f, -0.247047409f, 0.714339495f, 0.284152329f, 0.254234225f, + 0.313443273f, -0.779784441f, -2.50863338f, -1.02531934f, 1.47264957f, -1.91602397f, + 2.08412409f, -1.27137232f, -2.25216436f, -1.90579879f, 0.571214557f, 2.33153105f, + 1.78978431f, -1.26980674f, -1.72148204f, 3.15862465f, 0.0669083744f, 3.67808175f, + 3.2101295f, -0.456763506f, -3.03391504f, -1.29744411f, 2.34820294f, -1.12553525f, + -2.8481214f, -1.06300342f, -0.302982986f, -2.28643751f, -0.242186695f, -0.749161661f, + -0.761653244f, 0.887721777f, 1.2619133f, 0.233692259f, -3.63975835f, 2.22317147f, + -0.225643739f, -1.10077202f, -2.50560093f, -2.24941587f, 1.75155091f, -0.170507208f, + 2.59194303f, 4.06068182f, -0.00505524129f, 2.56501174f, 2.52117395f, 0.30842486f, + -0.0322846174f, 0.246648341f, 2.87685609f, 3.65094185f, 0.814969182f, 1.35474598f, + 0.478886604f, -1.66722238f, -1.48925364f, -4.03605318f, -5.55857038f, 0.347446322f, + -0.328560382f, -0.521032274f, 0.752090812f, 0.785018861f, 0.0857216567f, 0.465832263f, + -0.792842627f, 4.7875905f, 0.113955393f, -3.17228007f, -2.62993455f, -2.0068171f, + 2.52796459f, 0.385290235f, 2.17790174f, -0.934795022f, -0.999927521f, 0.579318881f, + 1.26110339f, 2.19630504f, 0.550615251f, 0.547041595f, }; inline constexpr float kLtxTowerPaddedStateF32_3[] = { @@ -1740,44 +1743,44 @@ inline constexpr float kLtxTowerPaddedStateF32_3[] = { -4.78617048f, -4.08878136f, 3.98168635f, 0.87554419f, 1.49893427f, 4.53367138f, 3.95623779f, -1.91546273f, -3.01503682f, 3.40431356f, 4.44517899f, -3.78030872f, 1.53354096f, -0.567785203f, -4.26043558f, 0.916204691f, 2.81639576f, -2.52821851f, - -0.520380497f, 0.734793663f, -2.95599771f, -1.85245013f, 3.06701136f, 2.39221907f, - 0.379837334f, 0.801000655f, 2.90783024f, 2.41729593f, 1.05457997f, -1.10409021f, - -3.47040701f, 1.52326465f, -2.259758f, -0.937417746f, 0.638614237f, -1.54408085f, - 1.18064678f, 1.96129322f, 1.32688177f, -4.60422325f, 0.469833463f, 3.86535454f, - 5.02937126f, -3.1551671f, -1.4783504f, -0.878624201f, -0.0994565263f, 1.77965188f, - 3.93133092f, 0.497385025f, -2.34844351f, -1.25530839f, -1.25624371f, -7.00368214f, - 2.6584487f, 1.55193996f, 1.8789885f, 3.12138629f, -2.63576078f, -0.522408187f, - 0.13223657f, -2.26665878f, -2.18062639f, 0.0747165978f, -3.62868977f, -6.29519939f, - -0.279996872f, -2.37196779f, 1.2901094f, -0.827016354f, 2.20898914f, -4.4509654f, - 2.60748196f, 1.94536436f, 7.39381933f, -3.66375923f, 0.873686492f, -0.241233781f, - 0.636552811f, 3.76143479f, 1.90901804f, -0.0342381187f, 1.49700689f, 1.64508259f, - 1.45100141f, 1.13833642f, 6.38964796f, -2.22645283f, 2.09769106f, -0.535243809f, - 1.08840775f, -5.24708271f, -3.14094377f, 0.0691219419f, -3.509758f, -2.66271996f, - -2.59777856f, 2.4748559f, -1.34081316f, 0.355470121f, -0.145867273f, 1.96931911f, - 0.358712763f, -3.21990943f, 1.25791836f, 1.39949656f, 1.25224793f, -1.90373576f, - -0.618343174f, -0.356607884f, -0.0751636997f, 0.588063776f, 1.0832026f, 4.71839857f, - 0.913038194f, 0.37490347f, 0.0997419059f, -3.19986057f, -0.80578059f, 3.84246206f, - -2.87999296f, 0.800070405f, 1.38343561f, 6.19318867f, 2.19088435f, 0.590590358f, - 2.09620762f, 0.236692294f, 0.538163841f, -0.42029047f, 0.782603681f, -5.10916615f, - -2.96164036f, -1.6167475f, 0.0725620985f, -2.96585751f, 2.6776607f, -1.77616739f, - 1.09871697f, -0.472761214f, -4.04857254f, 2.03864503f, 1.79774821f, 0.33365038f, - -1.37170899f, -2.32835984f, -0.758737922f, -0.283138037f, 5.24659443f, -2.30188584f, - -0.231487125f, 0.740843117f, -2.17022657f, 2.08424401f, -1.52083576f, 0.00668700971f, - 3.45457935f, 3.63822055f, -0.14963533f, 0.981996775f, 1.54970896f, 2.15139985f, - -0.894924104f, -2.78573656f, -3.0529654f, -1.05774605f, 0.82830739f, -0.0112429354f, - 4.10028887f, -1.42147434f, 0.0773144141f, -0.362290829f, -1.95927048f, 3.55703425f, - 2.6894629f, -0.12657471f, -1.35866261f, 3.31139421f, -1.45877612f, 6.22298336f, - 4.73708391f, -1.96700728f, -3.61718726f, -1.93594444f, 5.86519909f, -1.25871825f, - -1.99339366f, -4.52848625f, 1.01141608f, -3.12320638f, 1.28890777f, -2.48972344f, - 1.81892312f, 0.970252514f, 1.59880316f, -1.21354795f, -4.3056488f, 3.31475949f, - -1.77675283f, -2.01017189f, -4.0715766f, -4.05385828f, 4.55550098f, -0.33587113f, - 1.32094955f, 3.84346938f, 0.77734071f, 2.24306178f, 2.04568243f, 0.651385963f, - 0.0991551057f, -2.11703205f, 2.13421106f, 4.24084234f, 4.1594882f, 0.755002916f, - -0.367522597f, 0.034127675f, -2.38654065f, -4.07276678f, -7.40186119f, -0.428712547f, - -0.859261215f, -3.04533625f, 0.0684274435f, 0.703714788f, -1.25547159f, -1.6428411f, - -1.37262607f, 6.34524345f, 0.829199195f, -2.27742314f, -1.63645589f, -1.51034212f, - 4.39880371f, 0.0113883298f, 1.23504627f, -1.59028864f, -0.220352367f, 1.01576102f, - 0.76365149f, 4.87786961f, 0.328210533f, 1.08531308f, + -0.520380497f, 0.734793663f, -2.95599222f, -1.85244679f, 3.06702209f, 2.39222646f, + 0.379887372f, 0.800961435f, 2.90772772f, 2.4173038f, 1.05462742f, -1.10404539f, + -3.47042513f, 1.52323353f, -2.25982308f, -0.937530041f, 0.638689995f, -1.5440501f, + 1.18063366f, 1.96123958f, 1.32690477f, -4.60424757f, 0.469889641f, 3.86540675f, + 5.02931833f, -3.1551764f, -1.47835827f, -0.87859118f, -0.0995057598f, 1.77965844f, + 3.93136668f, 0.497425854f, -2.34846163f, -1.25529397f, -1.25628102f, -7.00377321f, + 2.65834785f, 1.55195534f, 1.87900412f, 3.1213932f, -2.63576603f, -0.522454739f, + 0.132165626f, -2.26670146f, -2.18054318f, 0.0747697651f, -3.62865758f, -6.29518318f, + -0.280042917f, -2.37198687f, 1.29008579f, -0.827112854f, 2.20892429f, -4.4510293f, + 2.60752654f, 1.94525719f, 7.39378023f, -3.66374278f, 0.873648345f, -0.24116227f, + 0.636563659f, 3.76137757f, 1.90893805f, -0.0343148708f, 1.49699998f, 1.64521027f, + 1.45159912f, 1.13905203f, 6.39156818f, -2.22731638f, 2.09590244f, -0.53562057f, + 1.09016514f, -5.24967909f, -3.13929343f, 0.0689896494f, -3.51119971f, -2.66153812f, + -2.59894419f, 2.4746201f, -1.34113634f, 0.355490595f, -0.144487604f, 1.96874881f, + 0.35971579f, -3.21898699f, 1.25713289f, 1.4001472f, 1.25112784f, -1.90323114f, + -0.618414938f, -0.35751754f, -0.0742096752f, 0.588298559f, 1.08245623f, 4.7184f, + 0.912319124f, 0.375116616f, 0.100280002f, -3.19975686f, -0.805854023f, 3.8424027f, + -2.88034487f, 0.799630165f, 1.38343239f, 6.19320583f, 2.19099998f, 0.590758979f, + 2.09597278f, 0.23762989f, 0.537999451f, -0.420642823f, 0.782651722f, -5.10959911f, + -2.9620831f, -1.61699593f, 0.0727609023f, -2.96610403f, 2.67828918f, -1.77714801f, + 1.09870136f, -0.472750843f, -4.04855442f, 2.03833365f, 1.79762232f, 0.333738238f, + -1.37219048f, -2.32875562f, -0.758468747f, -0.282896101f, 5.24552965f, -2.30156255f, + -0.231540531f, 0.741680324f, -2.17069578f, 2.08346605f, -1.52045441f, 0.0063276561f, + 3.45526028f, 3.63812566f, -0.150116026f, 0.982470393f, 1.54951024f, 2.15077567f, + -0.894323111f, -2.78702998f, -3.05326843f, -1.05728495f, 0.828606904f, -0.0103127807f, + 4.10025978f, -1.42179883f, 0.0770527571f, -0.362043023f, -1.96013367f, 3.5560298f, + 2.68822503f, -0.12746951f, -1.35870504f, 3.31202173f, -1.46062136f, 6.22333622f, + 4.7356472f, -1.96383643f, -3.61689019f, -1.93562567f, 5.86663723f, -1.26087451f, + -1.99297345f, -4.52770042f, 1.01269686f, -3.12209487f, 1.28939998f, -2.48918152f, + 1.8202399f, 0.967495084f, 1.59786785f, -1.21273649f, -4.30623341f, 3.31614017f, + -1.77630806f, -2.01201153f, -4.07224655f, -4.05496979f, 4.55474806f, -0.337013423f, + 1.32252204f, 3.84242511f, 0.777474582f, 2.24292159f, 2.04792857f, 0.650741756f, + 0.0977203771f, -2.11515474f, 2.13438845f, 4.24094439f, 4.16001272f, 0.758548498f, + -0.370567143f, 0.0387008041f, -2.38278055f, -4.0764842f, -7.39979649f, -0.425554931f, + -0.864875436f, -3.03831649f, 0.065811567f, 0.701538086f, -1.2549547f, -1.64132941f, + -1.37363899f, 6.3436842f, 0.834846675f, -2.27600718f, -1.63849747f, -1.51055157f, + 4.39526558f, 0.0115852505f, 1.23822522f, -1.59053147f, -0.216212407f, 1.01388466f, + 0.75936085f, 4.87487698f, 0.326843381f, 1.08901191f, }; inline constexpr float kLtxTowerPaddedStateF32_4[] = { @@ -1850,44 +1853,44 @@ inline constexpr float kLtxTowerPaddedStateF32_4[] = { -5.70593643f, -6.23454905f, 1.36526835f, 2.05749822f, 4.10939264f, 3.15098763f, 3.1633873f, -0.664293528f, -3.54874873f, 5.16659737f, 3.27077365f, -4.87856627f, 0.580941558f, -2.15387249f, -1.6979475f, 2.77348185f, 5.88290691f, -0.95225358f, - -0.807212889f, 0.896836042f, -5.52221918f, -0.883055389f, 5.76438808f, 2.91977286f, - -0.737576127f, 3.96150422f, 2.62355852f, 2.82569313f, 1.87354696f, 0.573091149f, - -4.94552422f, 1.46844411f, -4.03369808f, -1.94093609f, -0.226558819f, 0.372553796f, - 1.73995268f, 0.235248923f, -0.0726867765f, -2.75010419f, 2.56369042f, 7.78646708f, - 6.28976583f, -3.80329323f, -0.334204108f, -2.63799977f, 1.57533872f, 4.18232536f, - 4.90967083f, 1.50934064f, -2.53220987f, -1.60658717f, -2.75976205f, -8.08213615f, - 4.07237244f, 2.625211f, 0.057020247f, 5.65304136f, -3.61695147f, -0.144273624f, - 2.59894228f, -1.71338904f, -4.14071417f, 1.03777111f, -3.63474011f, -7.47971439f, - -0.725398242f, -1.64404643f, 0.542665124f, -1.81714034f, 1.28913617f, -2.43218207f, - 2.75481558f, 4.08647728f, 7.22620058f, -5.24879885f, 0.268845081f, -0.285437882f, - 0.387204051f, 5.03215122f, 3.382936f, -0.41858077f, 2.86642313f, 2.09229732f, - -0.398557842f, 3.09662843f, 7.78116083f, -0.624533236f, 3.68102646f, -0.39580071f, - 1.86606407f, -3.64419079f, -3.75393152f, -0.822769403f, -4.92856503f, -2.58866525f, - -3.12310767f, 3.63605928f, -3.27885342f, 0.702775538f, 0.246456608f, 1.74175799f, - 1.24937034f, -1.92460334f, 1.81406796f, 3.4456706f, -0.0334208533f, -4.26519156f, - 0.176377892f, -1.59957206f, 0.0692838505f, 2.38320446f, 1.51618767f, 3.88784552f, - 1.56893206f, 0.29196018f, -2.29108858f, -2.9675324f, -0.0545736887f, 2.86586452f, - -2.89277506f, 4.10185242f, 0.555392623f, 6.98011732f, 3.33629036f, 0.380735636f, - 0.837032616f, 0.0588827804f, -1.67276871f, 0.230851173f, 2.2229867f, -4.84079695f, - -1.75561345f, -3.5021739f, -1.55019319f, -1.99959838f, 3.2161727f, 1.91920662f, - 1.70505393f, -0.00844826084f, -3.32572937f, -0.00563750416f, 1.85428095f, -0.108705454f, - -1.72008741f, -1.55906963f, -1.44399703f, 0.0397970378f, 3.47484255f, -2.0743618f, - -1.46815979f, -1.81692314f, -0.916010261f, 4.7950592f, -2.48546767f, -0.0582672767f, - 4.27826405f, 3.53852797f, -0.943232358f, 2.7613914f, 2.48359585f, 2.00232005f, - 0.882658005f, -1.30558801f, -2.25073051f, -4.49488115f, -0.10470105f, -2.13306546f, - 4.44581795f, 2.5255506f, -0.756203115f, -0.522532821f, -0.981387973f, 1.50030053f, - 3.51949f, 2.56651211f, -1.27313566f, 3.92623806f, -4.20914745f, 6.46449614f, - 4.59504175f, -2.2454443f, -4.69393206f, -1.30671525f, 8.60472679f, 0.655759931f, - -2.61844063f, -4.05181551f, -0.866610765f, -2.70959759f, 0.697725832f, -3.64417982f, - 4.2500267f, -0.571166635f, -0.145374596f, 1.26256323f, -1.98723865f, 4.23757601f, - -3.9381721f, -2.02071571f, -7.42495823f, -3.97785258f, 3.15230823f, -0.801289558f, - 3.11705923f, 2.0806067f, 1.2781868f, 4.42019558f, 3.09221268f, 0.933647096f, - 0.885742366f, -2.74886417f, 1.22407436f, 6.67368507f, 6.03192282f, 3.08989668f, - 0.657745242f, 1.20196378f, -2.040308f, -3.55700636f, -8.61368179f, -1.03550828f, - -2.41515422f, -1.12571335f, -0.152706638f, 0.971631527f, -1.11852372f, -2.47933078f, - 0.872603178f, 5.17396355f, 1.48110271f, -2.13338971f, -2.66797614f, 1.08610225f, - 3.76035976f, -2.13583422f, 1.907094f, -3.20744014f, -0.51924324f, 1.99709404f, - 0.778767467f, 5.46775055f, 0.915839016f, 0.250280082f, + -0.807212889f, 0.896836042f, -5.52220726f, -0.883061469f, 5.76442146f, 2.91979074f, + -0.73756063f, 3.96142197f, 2.6234324f, 2.82571602f, 1.87364221f, 0.573143065f, + -4.94557476f, 1.46841431f, -4.03376436f, -1.94103098f, -0.226456821f, 0.372619212f, + 1.74001694f, 0.235140622f, -0.0726385191f, -2.75018144f, 2.56372643f, 7.78648949f, + 6.28969955f, -3.80327821f, -0.334173501f, -2.63793111f, 1.57528174f, 4.18233395f, + 4.90970182f, 1.50939679f, -2.5322156f, -1.60665333f, -2.75980043f, -8.08221436f, + 4.07224083f, 2.62519312f, 0.0570051745f, 5.65306759f, -3.61701226f, -0.144306034f, + 2.59889674f, -1.71343875f, -4.14062262f, 1.03784871f, -3.63472867f, -7.47968388f, + -0.725452542f, -1.64410126f, 0.542616189f, -1.81725264f, 1.28904331f, -2.43226814f, + 2.75481868f, 4.08635855f, 7.22616005f, -5.24877691f, 0.268829763f, -0.28533265f, + 0.387225062f, 5.03208733f, 3.38283205f, -0.418687701f, 2.86640668f, 2.09243345f, + -0.398094177f, 3.09688091f, 7.78251886f, -0.626020968f, 3.68024731f, -0.39616257f, + 1.86912942f, -3.64718986f, -3.75140595f, -0.822824359f, -4.92838097f, -2.58722806f, + -3.12394166f, 3.63575649f, -3.28017426f, 0.701404214f, 0.247738153f, 1.74261844f, + 1.2522583f, -1.92253125f, 1.81276739f, 3.44589972f, -0.0340099484f, -4.26487923f, + 0.175242767f, -1.60103607f, 0.0704483017f, 2.38339281f, 1.51479816f, 3.88791442f, + 1.56852925f, 0.29295212f, -2.2903235f, -2.96778584f, -0.0547405146f, 2.8654058f, + -2.89289832f, 4.10175705f, 0.555796802f, 6.98050356f, 3.3361063f, 0.380703151f, + 0.836640179f, 0.0599441901f, -1.67267561f, 0.230495751f, 2.22266912f, -4.84137583f, + -1.75605452f, -3.50261426f, -1.55031002f, -2.00038362f, 3.21677566f, 1.91771412f, + 1.70449984f, -0.0077397828f, -3.32507801f, -0.00677516311f, 1.85394621f, -0.108259611f, + -1.72079694f, -1.55997777f, -1.44400716f, 0.0400001369f, 3.47325468f, -2.07407713f, + -1.46817231f, -1.81626761f, -0.916265845f, 4.79381847f, -2.48494768f, -0.0581852645f, + 4.27908564f, 3.53844118f, -0.943953156f, 2.76223278f, 2.48304343f, 2.00144529f, + 0.883090496f, -1.30753136f, -2.25114346f, -4.49406719f, -0.104432628f, -2.13201427f, + 4.44555283f, 2.52515602f, -0.756389976f, -0.522009075f, -0.982367456f, 1.49938917f, + 3.51814461f, 2.56618071f, -1.27339625f, 3.92712522f, -4.21127129f, 6.4650898f, + 4.59246159f, -2.24168134f, -4.6931181f, -1.30543363f, 8.60545254f, 0.655607641f, + -2.61526847f, -4.05005121f, -0.86329329f, -2.70658255f, 0.69638294f, -3.64124227f, + 4.25085115f, -0.572359979f, -0.148256004f, 1.2645694f, -1.98901951f, 4.24055004f, + -3.93666863f, -2.02401447f, -7.42632389f, -3.98101878f, 3.15226293f, -0.801099181f, + 3.11644459f, 2.07886767f, 1.2769891f, 4.4207654f, 3.09379053f, 0.932343125f, + 0.88484621f, -2.74771643f, 1.22384524f, 6.67199898f, 6.02827215f, 3.09431744f, + 0.65601325f, 1.20505893f, -2.0334065f, -3.55972695f, -8.61177349f, -1.03223443f, + -2.41653132f, -1.11986113f, -0.155667573f, 0.969348013f, -1.12272906f, -2.47904396f, + 0.87300694f, 5.17176294f, 1.49147415f, -2.12953544f, -2.67013645f, 1.08429289f, + 3.75805354f, -2.13662577f, 1.90940702f, -3.20818615f, -0.511548817f, 1.99236119f, + 0.776497185f, 5.46193409f, 0.912946463f, 0.257180721f, }; inline constexpr float kLtxTowerPaddedStateF32_5[] = { @@ -1960,44 +1963,44 @@ inline constexpr float kLtxTowerPaddedStateF32_5[] = { -7.21720505f, -4.94238472f, 0.438347757f, 1.15158808f, 4.75012589f, 3.38233805f, 3.07190537f, -2.9253068f, -5.14442635f, 6.62584019f, 2.60874295f, -5.67679214f, -0.16155155f, -1.90863144f, 0.220604479f, 3.13170433f, 6.78018332f, -1.25791955f, - -1.23095798f, 2.8856144f, -4.38342428f, -1.15595543f, 7.75659561f, 1.43472052f, - -2.11272407f, 5.37975502f, 1.60549569f, 0.898965836f, 0.416307777f, 1.41776955f, - -3.93824792f, 0.61253792f, -2.77709746f, -2.60962939f, -1.04304433f, 1.09372866f, - 4.44895029f, 0.0581415892f, -1.95350993f, -2.91123962f, 1.59314179f, 8.97336578f, - 5.49827528f, -5.31196785f, -0.28285107f, -2.07479358f, 5.25243187f, 3.47390461f, - 6.82101154f, 0.296510607f, -2.90637565f, -0.326196969f, -1.2483114f, -9.34625244f, - 3.31225228f, 1.1867125f, -2.188483f, 6.29560232f, -1.3760885f, -2.41931462f, - 2.55500054f, -2.01292801f, -2.53840828f, -0.176213413f, -5.0007081f, -8.38378048f, - -0.500828862f, -1.81483698f, 2.32053471f, -1.19444346f, 0.960556269f, -3.91199827f, - 0.545077622f, 4.08968687f, 6.90071535f, -6.74091911f, 2.52348566f, 0.592425942f, - 3.55463171f, 6.10247898f, 3.69316792f, -0.731817603f, 1.74486959f, 3.50307608f, - 0.636058331f, 1.94092238f, 7.2247076f, -0.522594571f, 4.83031034f, -0.339906931f, - 1.13211703f, -4.42644978f, -5.11565113f, -3.49176121f, -3.14565277f, -3.96445155f, - -3.62873125f, 2.85556149f, -1.94978118f, 1.83774459f, 2.85438013f, 1.8596431f, - 0.530085862f, -2.34312868f, 0.0583982021f, 4.45716524f, -0.915875733f, -7.0653863f, - 2.77440929f, 0.214101255f, 0.760411441f, 3.9241116f, 2.0086956f, 4.58963633f, - -0.463187188f, 3.66827679f, -2.75750089f, -4.37182236f, 0.220027834f, 4.63323927f, - -2.42771506f, 5.76118183f, 0.320355177f, 3.26989579f, 4.09666634f, -0.610923529f, - 1.90143049f, -1.55221462f, -2.98382521f, -0.207821518f, 0.982245564f, -5.9425292f, - 1.71089935f, -5.10667372f, -3.1624229f, -1.29679072f, 3.71646547f, 3.62488747f, - 1.13710546f, -2.88557005f, -2.76500797f, -1.17562401f, 5.92213106f, -1.01140404f, - -2.5153594f, -0.891808152f, -1.88841021f, 2.11562061f, 3.03247166f, -1.73402739f, - 1.19234049f, 0.0772434697f, -1.75286746f, 6.44293547f, -2.10665178f, -0.937098086f, - 5.17234707f, 6.80885315f, 1.90475845f, 3.64359784f, 2.48577738f, 0.960491657f, - -2.13669395f, -1.08501887f, -1.22050774f, -4.50039101f, -1.65626252f, -1.29414105f, - 4.48028278f, 2.86600661f, -0.653114676f, -1.50594652f, -0.771973848f, 3.37180901f, - 6.64894152f, 2.96160173f, -1.25561833f, 2.09331727f, -2.90798426f, 8.10996342f, - 5.84412766f, -4.66857624f, -3.74128985f, -0.226936117f, 9.9902668f, 2.46613503f, - -4.07856655f, -2.50687432f, -1.8571732f, -1.9378041f, 1.96499109f, -3.05020666f, - 2.08599734f, 0.176328138f, 0.0773129687f, 1.24267638f, -1.88251293f, 4.99279165f, - -5.80391026f, -2.88170433f, -7.23230743f, -3.71371222f, 4.20253372f, -3.30496788f, - 4.53338575f, 4.87305689f, 3.18596172f, 5.21779108f, 0.745883942f, 2.42793822f, - 0.959595919f, -1.71931338f, 0.428876519f, 6.03571367f, 5.16225433f, 4.81443357f, - -1.16711235f, 1.98434019f, -2.50921655f, -2.55381393f, -7.70589828f, 0.440256536f, - -1.12338853f, -0.103212975f, -1.9037075f, 0.557589769f, -2.49411225f, -2.34628987f, - 2.33746576f, 2.11325216f, 2.1859858f, -2.43311286f, -2.81187367f, 0.062556535f, - 4.29197979f, -1.57762051f, 4.18522263f, -2.76206112f, -0.761086822f, 0.0476746187f, - 0.124127425f, 7.05953884f, 1.89967191f, -0.225420445f, + -1.23095798f, 2.8856144f, -4.38339043f, -1.15598178f, 7.75670767f, 1.43476486f, + -2.11274457f, 5.37971258f, 1.60535705f, 0.89899689f, 0.41642952f, 1.41785598f, + -3.93825054f, 0.612452269f, -2.7771771f, -2.60971618f, -1.04285574f, 1.09381831f, + 4.44897032f, 0.0579791702f, -1.95348251f, -2.91131544f, 1.59318733f, 8.97343063f, + 5.49821949f, -5.31195593f, -0.282791346f, -2.07471228f, 5.2523284f, 3.4739356f, + 6.8210206f, 0.296511948f, -2.90641975f, -0.326225907f, -1.24838006f, -9.34633064f, + 3.31207323f, 1.18673873f, -2.18857574f, 6.2956357f, -1.37613392f, -2.4192822f, + 2.55490351f, -2.01294136f, -2.53836894f, -0.176113725f, -5.00076294f, -8.38374805f, + -0.500872731f, -1.81493175f, 2.32042766f, -1.19453692f, 0.960483253f, -3.91206455f, + 0.545099378f, 4.0895896f, 6.90070248f, -6.74092197f, 2.52353716f, 0.592549026f, + 3.55457234f, 6.10243273f, 3.69302821f, -0.731859326f, 1.74487054f, 3.50318933f, + 0.636626601f, 1.94069862f, 7.22660398f, -0.523864985f, 4.83030415f, -0.339311242f, + 1.13631856f, -4.42943764f, -5.11327267f, -3.49207783f, -3.14545274f, -3.96305108f, + -3.62993908f, 2.85470915f, -1.95036936f, 1.83606172f, 2.85544276f, 1.86199844f, + 0.532652199f, -2.34022379f, 0.0567902438f, 4.45600271f, -0.915767074f, -7.06522703f, + 2.77338743f, 0.212454185f, 0.762412608f, 3.92422819f, 2.00806451f, 4.58874655f, + -0.463765204f, 3.66994476f, -2.75634432f, -4.37249613f, 0.219371334f, 4.63318729f, + -2.42925572f, 5.76155043f, 0.321088731f, 3.26956964f, 4.09680176f, -0.61145252f, + 1.90063381f, -1.55128491f, -2.98252058f, -0.207329467f, 0.981950521f, -5.94469881f, + 1.70992136f, -5.10749531f, -3.16104078f, -1.29736984f, 3.71641302f, 3.62378621f, + 1.13639188f, -2.88479352f, -2.76372695f, -1.17571533f, 5.92213488f, -1.0109508f, + -2.51534414f, -0.892831802f, -1.88865387f, 2.11595297f, 3.02989888f, -1.73219097f, + 1.19213617f, 0.0774187818f, -1.75198674f, 6.44073534f, -2.10677123f, -0.938620925f, + 5.17381001f, 6.80740404f, 1.9040885f, 3.6441586f, 2.48482084f, 0.959943235f, + -2.13620186f, -1.0875231f, -1.2200129f, -4.49827051f, -1.65654397f, -1.29317737f, + 4.48115635f, 2.86725283f, -0.653137147f, -1.50640655f, -0.774148703f, 3.3694787f, + 6.64984512f, 2.96174788f, -1.25764143f, 2.09292006f, -2.90981865f, 8.11131191f, + 5.84355593f, -4.66171265f, -3.73883033f, -0.22493358f, 9.98898602f, 2.46471262f, + -4.07140112f, -2.50167608f, -1.85392833f, -1.93972468f, 1.96037078f, -3.04948545f, + 2.08472061f, 0.177212805f, 0.0744151101f, 1.24735498f, -1.884372f, 4.99504042f, + -5.80410337f, -2.88982797f, -7.23470879f, -3.71495438f, 4.20570135f, -3.30500364f, + 4.53426981f, 4.87243891f, 3.18710709f, 5.21848392f, 0.750815213f, 2.42431998f, + 0.958469808f, -1.71749675f, 0.428036034f, 6.03560209f, 5.16328907f, 4.81914616f, + -1.16976237f, 1.99182379f, -2.49854708f, -2.55476046f, -7.70520496f, 0.44512859f, + -1.13054872f, -0.0970956981f, -1.90999162f, 0.556086838f, -2.50501466f, -2.34510875f, + 2.33598089f, 2.11226058f, 2.19587445f, -2.42968869f, -2.81562591f, 0.0614080504f, + 4.29044485f, -1.57668948f, 4.18833637f, -2.76709676f, -0.750115275f, 0.0431244895f, + 0.126471683f, 7.05369139f, 1.89863002f, -0.216906548f, }; inline constexpr float kLtxTowerPaddedStateF32_6[] = { @@ -2070,44 +2073,44 @@ inline constexpr float kLtxTowerPaddedStateF32_6[] = { -9.07043457f, -3.79968309f, 1.70141912f, -2.23640442f, 4.04678345f, 2.16642451f, 2.09990692f, -4.59141541f, -6.26420307f, 6.33999586f, 3.22913218f, -5.65510654f, 1.49053919f, -1.13045537f, -0.995037556f, 4.60238886f, 7.50435448f, -0.878966987f, - -0.658555984f, 1.81321383f, -4.87572479f, -2.57473373f, 9.40959454f, 1.91815126f, - -3.23440719f, 8.24659348f, 1.00636506f, 1.27789092f, 1.38714802f, 1.39751172f, - -3.74306941f, 1.33327472f, -3.06646633f, -0.302383095f, 0.440241098f, -0.566164851f, - 4.91932487f, -0.403979748f, -2.3572197f, -3.31523609f, 0.604812086f, 7.9307704f, - 6.26776552f, -3.89018416f, 3.42065811f, 1.79288924f, 5.32630348f, 3.3461926f, - 6.87708378f, 2.15490794f, -3.77654648f, -1.98674083f, -2.04223275f, -12.5902176f, - 3.54838872f, 1.6669004f, -3.06000161f, 8.95376015f, 0.546741903f, -4.05431652f, - 3.43372488f, -1.955392f, -2.220191f, 0.218411326f, -4.72772884f, -5.26104164f, - 0.852751434f, -2.74239755f, 2.02191186f, -0.702738345f, 0.358006775f, -3.76469326f, - 0.64410156f, 2.97347522f, 6.39888096f, -8.54838943f, 4.45121241f, 2.11879873f, - 3.87578392f, 6.67159271f, 3.25345802f, -0.246178761f, 1.54886925f, 3.64983392f, - 2.75313854f, 4.10550833f, 9.79015541f, -0.0757613778f, 7.07746983f, 0.71642673f, - 0.966490149f, -7.04842949f, -5.04568243f, -5.13150406f, -3.60170889f, -3.94570827f, - -2.48838973f, 1.22158635f, -1.94795382f, 0.685796499f, 2.56352758f, 2.11258793f, - 0.621080041f, -0.332539916f, -0.276778966f, 2.63898015f, 0.180467054f, -10.8158255f, - 8.15343475f, -0.201765627f, 1.54086769f, 5.3896966f, 1.02324915f, 5.26263952f, - -0.60806179f, 4.50116301f, -3.31418777f, -5.27573156f, -0.0512382872f, 6.2414422f, - -0.684185863f, 7.91886044f, 1.61038959f, 2.09997106f, 7.41365957f, -1.30285931f, - 1.34405351f, -3.09119916f, -2.75167394f, 1.57163382f, 2.71946001f, -9.29221916f, - 1.13888717f, -6.92693472f, -1.69699275f, -1.74134219f, 2.75594139f, 3.65537739f, - -0.881403863f, -3.02388525f, -2.95219994f, 0.789129138f, 4.91436577f, 0.358551234f, - -1.83975112f, -0.563111484f, -4.74274206f, 3.27011323f, 4.56181812f, -2.48833728f, - 1.82832026f, -0.0513854027f, -1.73050141f, 7.52430344f, -2.95446825f, -2.87600708f, - 6.77123547f, 7.0275569f, 2.4963634f, 2.56495571f, 2.45432091f, 2.01542068f, - -1.12632358f, -4.66091108f, -3.03301287f, -5.54162264f, -3.07758307f, -1.660097f, - 4.72629786f, 0.657624006f, 0.463557005f, 0.476383865f, 0.909147322f, 5.22724533f, - 7.42252111f, 3.12048697f, -2.97128868f, 1.73025441f, -4.31245565f, 9.31009293f, - 10.0366697f, -4.08731222f, -3.89576888f, -0.916624069f, 10.3654699f, 4.93031454f, - -3.3720746f, -4.38020945f, -3.24626923f, -1.34792233f, 3.23296714f, -1.78128624f, - 0.709621072f, 0.366084546f, -0.441351324f, 4.24912167f, -3.02324152f, 5.27349997f, - -7.71658897f, -2.57882786f, -10.3356581f, -7.52807045f, 4.90593481f, -2.69372964f, - 8.68119431f, 5.71097612f, 2.7106595f, 4.9094038f, 0.558706284f, 2.46755004f, - 0.605221808f, -0.759842336f, 1.11137867f, 6.66116714f, 5.77082634f, 5.08882141f, - 0.738193035f, 4.62489939f, -2.64719105f, -4.9086709f, -5.08125162f, 0.394842505f, - -2.58741474f, 0.796130657f, -0.000276245177f, -0.528544784f, -1.54526818f, -5.18882179f, - 3.05486917f, 0.647397459f, -0.136299729f, -0.867723048f, -1.74609923f, 2.49515104f, - 5.35535622f, -2.99347067f, 6.35402298f, -2.56251359f, -0.0330619961f, 0.922917783f, - -1.1273371f, 7.74917746f, 1.44131303f, -1.14886987f, + -0.658555984f, 1.81321383f, -4.87577009f, -2.57472968f, 9.40969372f, 1.9182328f, + -3.23441911f, 8.24658966f, 1.00620115f, 1.27793348f, 1.38728893f, 1.39769006f, + -3.74314642f, 1.33322835f, -3.06646442f, -0.302462876f, 0.440438032f, -0.56610781f, + 4.91932011f, -0.40408963f, -2.3571806f, -3.31529999f, 0.604917526f, 7.93081665f, + 6.26774311f, -3.89024568f, 3.42063427f, 1.79299462f, 5.32616568f, 3.34620142f, + 6.87704515f, 2.15493822f, -3.77659345f, -1.98675156f, -2.04230785f, -12.5902777f, + 3.5481813f, 1.66695273f, -3.06009912f, 8.95375824f, 0.546763182f, -4.05433035f, + 3.43355846f, -1.95542169f, -2.22007418f, 0.218481287f, -4.72780752f, -5.2610383f, + 0.852732658f, -2.74248528f, 2.02177787f, -0.702834129f, 0.357966304f, -3.76474786f, + 0.644139051f, 2.97337127f, 6.39885473f, -8.54845715f, 4.4512291f, 2.11893034f, + 3.87574983f, 6.67150927f, 3.25328612f, -0.246317148f, 1.54884899f, 3.64997983f, + 2.75412297f, 4.10560417f, 9.79255295f, -0.0770478472f, 7.07832432f, 0.717390776f, + 0.97212708f, -7.05186415f, -5.04230499f, -5.13266516f, -3.60082626f, -3.94363284f, + -2.49090362f, 1.22013462f, -1.94966781f, 0.684178352f, 2.56451893f, 2.11440778f, + 0.621890545f, -0.330244333f, -0.279531211f, 2.63900137f, 0.180350468f, -10.8166943f, + 8.15256405f, -0.204464182f, 1.54138553f, 5.3911109f, 1.02309346f, 5.2620182f, + -0.609068036f, 4.50339222f, -3.3126688f, -5.27713108f, -0.0519482791f, 6.24016619f, + -0.6857149f, 7.91884279f, 1.61114693f, 2.09856677f, 7.41386986f, -1.30307269f, + 1.34318995f, -3.09071565f, -2.74977303f, 1.57180715f, 2.71960211f, -9.29376411f, + 1.1372596f, -6.9279151f, -1.69592524f, -1.74221599f, 2.75648689f, 3.65439796f, + -0.882519722f, -3.02235365f, -2.9508307f, 0.788441718f, 4.91456413f, 0.359272182f, + -1.83933973f, -0.564958751f, -4.74281549f, 3.27098703f, 4.55890083f, -2.48625278f, + 1.82623768f, -0.0501834005f, -1.72813725f, 7.52305555f, -2.95553517f, -2.87899137f, + 6.7748313f, 7.02661419f, 2.49488282f, 2.56563187f, 2.45345736f, 2.01499319f, + -1.12570798f, -4.66371632f, -3.0319488f, -5.53936815f, -3.07800484f, -1.6575433f, + 4.72685385f, 0.660622537f, 0.463682771f, 0.475653648f, 0.907409787f, 5.22579193f, + 7.42294455f, 3.12048197f, -2.97350192f, 1.73003578f, -4.31428957f, 9.31255627f, + 10.0360126f, -4.08131742f, -3.89415264f, -0.913606346f, 10.3652506f, 4.92859077f, + -3.36163521f, -4.37665796f, -3.24140811f, -1.34864497f, 3.22894311f, -1.78101921f, + 0.706118584f, 0.36558491f, -0.445116222f, 4.25244713f, -3.02808213f, 5.27496338f, + -7.71826887f, -2.58702207f, -10.3369255f, -7.53081179f, 4.91268921f, -2.69295311f, + 8.68275356f, 5.7092638f, 2.71127677f, 4.90983105f, 0.562994182f, 2.46401858f, + 0.6059798f, -0.758043885f, 1.11307693f, 6.66028786f, 5.77146769f, 5.09688187f, + 0.733126163f, 4.63740587f, -2.63855839f, -4.90740967f, -5.08221722f, 0.398801476f, + -2.59627056f, 0.80352366f, -0.00656946748f, -0.535688937f, -1.55816114f, -5.18216419f, + 3.04948139f, 0.64848119f, -0.129550248f, -0.857050002f, -1.75285256f, 2.49846673f, + 5.36100292f, -2.98962688f, 6.36073446f, -2.5688374f, -0.0264882669f, 0.921174407f, + -1.12412524f, 7.73642921f, 1.4429754f, -1.14173436f, }; inline constexpr float kLtxTowerPaddedStateF32_7[] = { @@ -2180,44 +2183,44 @@ inline constexpr float kLtxTowerPaddedStateF32_7[] = { -8.80039024f, -4.86490774f, 2.11539364f, -1.48792613f, 1.58716655f, 2.26404047f, 3.78828692f, -4.93216801f, -5.80612373f, 4.66260719f, 2.46323276f, -5.69036388f, 6.96226454f, -0.842600882f, -0.506489158f, 4.39151859f, 6.89374018f, -0.951885462f, - -1.93642688f, 1.89574707f, -6.93885088f, -1.23513818f, 7.53849077f, -0.361427218f, - -3.49958873f, 6.57434797f, -0.694813848f, 3.20516133f, 0.26939252f, 1.1307745f, - -3.40721321f, -1.21056795f, -3.6231482f, -2.61259818f, 0.883084834f, 0.502160311f, - 3.04941797f, 0.0806214213f, -0.958598435f, -2.6265738f, 0.063270852f, 7.47034836f, - 6.11368322f, -2.84194684f, 6.22265339f, 0.375247806f, 5.25876236f, 2.83968663f, - 6.95172358f, 2.35087967f, -4.07687616f, -0.866275251f, -3.3506391f, -11.5040884f, - 1.86788571f, 0.450057298f, -2.09284639f, 6.96747208f, -1.21645355f, -1.3330406f, - 1.93183589f, -0.658494115f, -1.88829255f, -2.40661931f, -4.26679802f, -6.68300152f, - 1.02008748f, -1.54480815f, 1.22997272f, -0.388556778f, 2.33966208f, -3.13669705f, - 0.810261428f, 2.44886136f, 4.7748909f, -7.22295666f, 7.17419052f, 1.54769337f, - 2.86878967f, 7.25178051f, 2.09226942f, 0.13172628f, 1.12164378f, 3.66344428f, - 1.92370057f, 4.35771942f, 6.81426477f, -1.27188289f, 7.05842733f, 1.57225013f, - 0.0664821416f, -5.70083427f, -6.21801138f, -4.02051163f, -2.70243716f, -4.99630356f, - -1.67496371f, -1.76583326f, -2.25999117f, 2.76113153f, 1.07818198f, 3.50492597f, - 3.25037479f, 1.41975665f, 0.227603272f, 3.30585337f, 1.3970623f, -9.38093567f, - 11.3226032f, -0.782681346f, 0.657562673f, 5.40665245f, 0.802208662f, 6.50211239f, - -2.43462968f, 3.96253777f, -3.86583591f, -4.46838474f, -2.103055f, 3.81532025f, - -0.100216947f, 6.58816814f, -0.298821837f, 3.941926f, 4.78704834f, -0.507340789f, - 0.853075147f, -4.30768919f, -3.89315271f, 0.0797340348f, 2.20090818f, -8.00170612f, - 0.445127279f, -5.21146393f, -0.0481277555f, -0.0593089163f, 2.31064296f, 2.83773351f, - 0.11456199f, -4.26582623f, 0.0672142878f, 0.440063208f, 2.87507224f, 1.52231395f, - -3.62165022f, 0.819242835f, -6.6385622f, 1.76045072f, 2.11889529f, -0.896693826f, - 0.999615371f, -1.81941545f, -0.415672958f, 7.35383749f, -5.01929379f, -2.41931129f, - 7.16053724f, 5.83183146f, 2.56919289f, 0.979370475f, 2.69053698f, 2.76513624f, - -0.897895694f, -4.6160078f, -4.02729988f, -4.45959949f, -1.83336985f, -0.447972417f, - 6.09321547f, 1.03330469f, 1.40856457f, -0.913030803f, 0.280604273f, 3.97018623f, - 5.95963097f, 4.78161192f, -3.80230737f, 2.43369722f, -5.83831167f, 7.74067116f, - 8.09461784f, -3.0706656f, -3.4397521f, -2.98105168f, 9.56237411f, 4.69830704f, - -3.2967f, -3.72760367f, -4.2592082f, -0.979867518f, 2.20561194f, -1.23098159f, - 2.37144375f, 0.96524781f, 0.664879799f, 6.42963648f, -5.84395266f, 3.13960624f, - -4.41618252f, -2.52774549f, -9.79688263f, -8.6899128f, 4.01515675f, -2.38777852f, - 7.57077456f, 3.16125011f, 4.66394424f, 3.71544981f, 0.443372011f, 4.03598595f, - 0.0367292538f, 1.19378543f, 0.796876669f, 7.01853991f, 4.43945456f, 3.58787918f, - 0.734538734f, 6.57387781f, -2.83132076f, -3.80614877f, -4.66461229f, -0.66234386f, - -2.38758659f, -1.22790754f, 0.771459818f, -1.37459373f, -0.580323756f, -2.12085104f, - 3.24007297f, 0.457853019f, -0.416602522f, -2.58957791f, -2.50939631f, 2.21478796f, - 3.14249873f, -1.43336189f, 7.3964467f, -0.89691031f, -0.293006659f, 2.12257075f, - -1.98576748f, 7.2410059f, 1.71666658f, 0.387147576f, + -1.93642688f, 1.89574707f, -6.93889666f, -1.23520958f, 7.53861523f, -0.361385405f, + -3.49966693f, 6.57432508f, -0.694969416f, 3.20522785f, 0.269505322f, 1.13088405f, + -3.40727901f, -1.21068633f, -3.62305665f, -2.61257553f, 0.883218348f, 0.502230048f, + 3.04939055f, 0.0804866776f, -0.958585262f, -2.62659883f, 0.0633425862f, 7.47036648f, + 6.11367321f, -2.84202504f, 6.2226162f, 0.375267327f, 5.25862932f, 2.8396976f, + 6.95168066f, 2.35091758f, -4.0769186f, -0.866215169f, -3.35073972f, -11.5040913f, + 1.86765885f, 0.450118631f, -2.09285402f, 6.96746302f, -1.21641982f, -1.33300829f, + 1.9316442f, -0.658451736f, -1.88817418f, -2.40654111f, -4.26687908f, -6.68298674f, + 1.02009118f, -1.5449301f, 1.22988963f, -0.388666332f, 2.33958244f, -3.13675094f, + 0.810291111f, 2.44879508f, 4.7748785f, -7.22301292f, 7.17418289f, 1.54781723f, + 2.86882257f, 7.25169134f, 2.09206939f, 0.13158676f, 1.12162089f, 3.66356874f, + 1.92293429f, 4.35820246f, 6.81576204f, -1.27211571f, 7.05986023f, 1.57275391f, + 0.0727318078f, -5.70369959f, -6.21478653f, -4.02051449f, -2.70171714f, -4.9944067f, + -1.67808998f, -1.76748931f, -2.26095033f, 2.75878167f, 1.07824183f, 3.50779057f, + 3.25063133f, 1.42178023f, 0.224160567f, 3.30605745f, 1.39648175f, -9.38075924f, + 11.3223076f, -0.785043716f, 0.659720898f, 5.40761805f, 0.803942978f, 6.50185442f, + -2.43570638f, 3.96475959f, -3.86472964f, -4.46943521f, -2.10375977f, 3.81339908f, + -0.101655409f, 6.58825064f, -0.298537165f, 3.94105744f, 4.7875042f, -0.507420778f, + 0.852113605f, -4.30703974f, -3.89200068f, 0.079916209f, 2.20116735f, -8.0032196f, + 0.44380945f, -5.21188354f, -0.047750935f, -0.0606063902f, 2.3108418f, 2.83686042f, + 0.112855352f, -4.26349401f, 0.068462722f, 0.439763576f, 2.87586832f, 1.5229193f, + -3.62064791f, 0.817337751f, -6.63829231f, 1.76103079f, 2.11458683f, -0.895293891f, + 0.99704808f, -1.8169328f, -0.414702147f, 7.35224724f, -5.01954651f, -2.42031121f, + 7.16340065f, 5.83196783f, 2.56851983f, 0.978822947f, 2.69182754f, 2.76491666f, + -0.898058474f, -4.619555f, -4.02682018f, -4.45842266f, -1.83433533f, -0.445200294f, + 6.09528971f, 1.03628051f, 1.40738702f, -0.911986589f, 0.280340463f, 3.97058773f, + 5.96301746f, 4.77970982f, -3.8016994f, 2.4344008f, -5.84114265f, 7.74407911f, + 8.09362698f, -3.06557393f, -3.43919754f, -2.97823858f, 9.56221104f, 4.69717073f, + -3.28704858f, -3.72267771f, -4.25506783f, -0.979712844f, 2.19881153f, -1.23262f, + 2.36890578f, 0.963974178f, 0.662114799f, 6.431777f, -5.84802723f, 3.13944292f, + -4.41906786f, -2.53415465f, -9.79856682f, -8.69124603f, 4.02036572f, -2.38570333f, + 7.57376385f, 3.15760541f, 4.66583967f, 3.71530342f, 0.44766137f, 4.03252172f, + 0.0345822535f, 1.19508481f, 0.797556996f, 7.02616882f, 4.43591118f, 3.59847713f, + 0.728805423f, 6.59305191f, -2.8157084f, -3.80692649f, -4.66345644f, -0.658974171f, + -2.3936348f, -1.22481894f, 0.764421344f, -1.382774f, -0.597900331f, -2.11538982f, + 3.23552537f, 0.462098747f, -0.416418582f, -2.57916689f, -2.51404834f, 2.21760178f, + 3.14963746f, -1.42789149f, 7.40686035f, -0.897337437f, -0.285801709f, 2.11376143f, + -1.97640574f, 7.23277855f, 1.71334291f, 0.390789777f, }; inline constexpr float kLtxTowerPaddedStateF32_8[] = { @@ -2290,44 +2293,44 @@ inline constexpr float kLtxTowerPaddedStateF32_8[] = { -9.10763073f, -2.18295288f, 1.65931785f, -1.64609313f, 1.79899406f, 0.0894851163f, 1.94550753f, -6.26336813f, -8.74751759f, 5.05050468f, 2.27574468f, -5.87296057f, 4.15928221f, -0.321590841f, -0.582106233f, 4.14281797f, 4.34223223f, -2.66388583f, - -2.21306324f, 2.19005322f, -8.96580887f, 0.402224034f, 5.87610674f, -2.29230928f, - -4.40222168f, 4.80449295f, -0.955129147f, 4.04992771f, 0.65723151f, 1.5021112f, - -1.75275779f, -0.397763759f, -5.0988512f, -0.66036582f, 1.61716092f, -0.580977619f, - 1.74968112f, -1.07324004f, -3.69329548f, -2.76634169f, -1.89972031f, 8.24284267f, - 5.31531334f, -3.09758425f, 5.91198015f, 3.08064675f, 2.95033288f, 2.0363462f, - 4.08051395f, 0.710809231f, -3.99574184f, -0.501211107f, -4.88118458f, -10.1398602f, - -0.0593197085f, -1.42227101f, -4.1800375f, 5.16751003f, -0.563788056f, -0.262233406f, - 2.56738424f, -0.827025175f, -1.25396109f, -2.76287079f, -5.04602098f, -4.98765516f, - 2.83674979f, -1.95524502f, 1.88831615f, -2.20686913f, 0.848729551f, -3.9295764f, - -0.603290677f, -0.209433377f, 3.61951041f, -8.93008423f, 6.93347836f, 4.39115524f, - 2.79344487f, 9.01331711f, 2.32400918f, -3.00219059f, 1.16304994f, 3.09822321f, - 1.26457238f, 7.97808552f, 3.95785213f, -2.72609448f, 6.3107748f, 1.42337883f, - 1.12728834f, -6.17893076f, -4.70256662f, -4.92957067f, -1.59597707f, -3.73986292f, - -1.702793f, 0.529446959f, -0.774914622f, 0.764226735f, 1.6552844f, 1.42293584f, - 1.66213441f, 1.05041027f, -1.11995304f, 1.69235384f, 0.587706447f, -8.93205929f, - 10.9409285f, -0.111243494f, 2.64671278f, 6.02337074f, -0.53215605f, 7.07659292f, - -3.05452251f, 5.64585066f, -4.80555677f, -3.70772576f, -1.81062102f, 4.15403032f, - -1.48972726f, 5.00532675f, -0.404292971f, 5.62148046f, 7.12647772f, -1.81207085f, - 2.43871069f, -6.90882063f, -3.43069863f, 3.16812801f, 4.59321451f, -7.1171546f, - 0.761886418f, -6.15627909f, -1.89964998f, -2.62311411f, 0.756455541f, 1.34253812f, - 0.847121596f, -4.99784517f, 1.45380414f, 1.48304331f, 2.61501288f, 1.03896546f, - -2.30297351f, -1.06201649f, -8.67164707f, 2.16556668f, 2.2217164f, 0.944667995f, - 2.02824616f, -1.28017712f, -0.240201846f, 7.23263121f, -6.77200937f, -1.22154105f, - 7.56324434f, 4.0449338f, 1.9132421f, 2.10675049f, 2.73855615f, 3.2937727f, - -0.523383796f, -4.15722179f, -1.97966218f, -2.63692236f, -3.55398464f, -1.80574071f, - 4.54202795f, -0.465849102f, 2.30764866f, -3.35933566f, 0.207542658f, 5.30934334f, - 6.98481846f, 3.59414673f, -4.8866663f, 1.89887166f, -6.55064201f, 8.98200798f, - 7.33795881f, 0.911767066f, -3.07373118f, -1.65058112f, 9.87658215f, 4.42282248f, - -4.33662319f, -1.41493881f, -3.5409596f, -2.69988179f, 2.52093744f, -0.441765338f, - 1.6403774f, 4.24094868f, 0.392781258f, 6.43150616f, -5.9339304f, 4.80007315f, - -5.41856337f, -1.54067719f, -8.46905231f, -7.86352682f, 5.66554976f, -2.4852109f, - 6.37024069f, 4.18795681f, 4.63525343f, 3.44285727f, -1.88618994f, 2.85931182f, - -0.816832304f, 0.728140175f, 1.7042836f, 10.6137381f, 2.90230989f, 2.98235822f, - 0.817629635f, 6.94309998f, -2.70680141f, -5.44154406f, -4.81726694f, -2.25688267f, - -2.27300429f, -1.05039704f, 2.2591238f, 0.826315701f, -0.701942623f, -3.45002627f, - 4.5378437f, 1.10647321f, -1.3264854f, -0.921284139f, -2.83257651f, 2.49841142f, - 4.64022827f, -2.76605725f, 7.86112881f, -0.646013916f, 1.09402275f, 3.27622962f, - -3.27321863f, 6.67669821f, -0.60309124f, 0.900751233f, + -2.21306324f, 2.19005322f, -8.96586227f, 0.402097374f, 5.87622499f, -2.29227972f, + -4.40230894f, 4.80448484f, -0.955379009f, 4.04993916f, 0.657328844f, 1.50221121f, + -1.75278819f, -0.39792785f, -5.09878063f, -0.660340846f, 1.61729586f, -0.580872595f, + 1.74966502f, -1.07339644f, -3.69334435f, -2.76639557f, -1.89973962f, 8.24287891f, + 5.31526804f, -3.09768939f, 5.91194248f, 3.08062148f, 2.95019126f, 2.03635001f, + 4.08052444f, 0.710774302f, -3.99575734f, -0.501144648f, -4.88123608f, -10.1398821f, + -0.0594863966f, -1.42214334f, -4.1799593f, 5.16755486f, -0.563808024f, -0.262183458f, + 2.56712365f, -0.826997876f, -1.25387609f, -2.76285625f, -5.04603624f, -4.987638f, + 2.83675146f, -1.95541489f, 1.88831413f, -2.20704937f, 0.848623037f, -3.92971039f, + -0.603256941f, -0.209418118f, 3.61950302f, -8.9301939f, 6.93355083f, 4.39131784f, + 2.79347348f, 9.01317883f, 2.32381177f, -3.00228524f, 1.16290808f, 3.09832954f, + 1.2643913f, 7.97917032f, 3.96017241f, -2.72606969f, 6.31140709f, 1.4231385f, + 1.1334269f, -6.18063068f, -4.69985723f, -4.92954063f, -1.59554839f, -3.73837876f, + -1.70634317f, 0.528440237f, -0.776168942f, 0.763162434f, 1.65481865f, 1.42519343f, + 1.66258788f, 1.0519191f, -1.12366891f, 1.69234622f, 0.587722421f, -8.93082142f, + 10.9405499f, -0.114068046f, 2.64867544f, 6.02424002f, -0.530431509f, 7.07654905f, + -3.05626869f, 5.64795446f, -4.80422068f, -3.70804501f, -1.8124938f, 4.15021849f, + -1.4916842f, 5.00554466f, -0.403895497f, 5.61924505f, 7.12678432f, -1.81187797f, + 2.43807459f, -6.9076519f, -3.42890739f, 3.1685257f, 4.59258604f, -7.11897278f, + 0.75993222f, -6.15730619f, -1.90000606f, -2.62459636f, 0.755879581f, 1.34103811f, + 0.846355677f, -4.99675655f, 1.45592833f, 1.4828552f, 2.61561632f, 1.03962922f, + -2.30277181f, -1.0642525f, -8.67167664f, 2.16669226f, 2.21693921f, 0.94453454f, + 2.02493215f, -1.27836537f, -0.238697603f, 7.23182106f, -6.77246714f, -1.22375774f, + 7.56546307f, 4.04469776f, 1.91318595f, 2.10669422f, 2.74039793f, 3.29453206f, + -0.522693455f, -4.15895891f, -1.97957337f, -2.6372838f, -3.55455923f, -1.80351949f, + 4.5436945f, -0.463766903f, 2.30622864f, -3.35908365f, 0.208209336f, 5.31032562f, + 6.98699713f, 3.59219575f, -4.88545704f, 1.90018094f, -6.55318642f, 8.98570919f, + 7.33709097f, 0.915290773f, -3.07204914f, -1.6459887f, 9.87949944f, 4.41819477f, + -4.32651138f, -1.41130185f, -3.53711128f, -2.7018342f, 2.51145959f, -0.443962902f, + 1.63425791f, 4.23555517f, 0.392282575f, 6.43338776f, -5.93971825f, 4.80419302f, + -5.41933727f, -1.548383f, -8.47144508f, -7.86641359f, 5.67211819f, -2.48103714f, + 6.37353325f, 4.18409109f, 4.63562584f, 3.44346499f, -1.8793385f, 2.85633993f, + -0.81964767f, 0.731914937f, 1.70473015f, 10.6216898f, 2.90465951f, 2.99204993f, + 0.805511534f, 6.96130037f, -2.69047165f, -5.44529438f, -4.81665897f, -2.25944996f, + -2.27988029f, -1.03605437f, 2.25907588f, 0.816522479f, -0.719116271f, -3.44559145f, + 4.53947449f, 1.11305285f, -1.32202339f, -0.912073255f, -2.84467578f, 2.49752808f, + 4.65311623f, -2.75545859f, 7.8757925f, -0.647500455f, 1.09566295f, 3.26080036f, + -3.26450133f, 6.67054367f, -0.606341958f, 0.904663324f, }; inline constexpr float kLtxTowerPaddedStateF32_9[] = { @@ -2400,44 +2403,44 @@ inline constexpr float kLtxTowerPaddedStateF32_9[] = { -9.41539288f, -3.21791267f, 2.46761465f, -0.129669294f, 2.1088903f, 0.446422815f, 3.13126969f, -4.06435061f, -9.45978832f, 5.5650177f, 0.769539416f, -5.90411139f, 5.13654423f, -0.319432467f, 0.758417785f, 5.06055832f, 2.68431973f, -2.65829706f, - -0.660979867f, 0.987872839f, -7.67150259f, 0.643167317f, 5.74502563f, -2.95759678f, - -8.08774185f, 6.25484562f, -0.241304621f, 2.7627902f, 0.876072705f, 3.17129683f, - -3.42475176f, -0.197382346f, -5.08726549f, -1.52660263f, 2.29195452f, 0.958854616f, - 1.72880995f, -0.767128706f, -2.6348114f, -1.00532019f, -2.13766646f, 8.26471901f, - 3.94305229f, -2.46654558f, 6.4319768f, 3.21981049f, 4.98324299f, 3.07139945f, - 2.2177515f, 0.811169684f, -3.94560099f, -1.0547682f, -4.30961084f, -6.91310024f, - -2.61510277f, -1.76354933f, -6.04874086f, 3.91933298f, 0.263273001f, -0.867836118f, - 2.17170572f, -0.193242997f, -1.0908438f, -0.739084601f, -5.10515594f, -4.95321894f, - 3.87039852f, -0.318408579f, 1.48042834f, -3.77579045f, 0.289962709f, -2.12128639f, - -1.12821209f, 0.0341949202f, 3.95418763f, -10.6329985f, 6.59719038f, 5.60995436f, - 4.79320908f, 10.2210121f, 3.70216417f, -4.68351936f, 1.25988817f, 2.39871407f, - 1.81124258f, 6.63322735f, 3.20519161f, -2.46089578f, 5.38631344f, 1.24171305f, - 1.25905311f, -5.95293999f, -7.33143044f, -5.07118702f, -2.20297027f, -3.89829874f, - -3.77383471f, 0.430526167f, -0.315758914f, 2.79644561f, 1.68690991f, -1.05229104f, - 2.01595259f, 1.5548749f, -1.07118714f, 4.07565975f, 0.14050661f, -8.12673187f, - 11.0483046f, -2.15383768f, 4.49366045f, 7.01211452f, -0.597829759f, 5.14258718f, - -4.5844903f, 3.85675144f, -1.30029905f, -1.8599664f, -4.02640581f, 3.70488453f, - -1.59436774f, 5.17573166f, 0.373488575f, 5.13692236f, 4.29778624f, -0.83383894f, - 1.63380611f, -4.04556036f, -2.23220921f, 3.0226748f, 4.28462315f, -4.07088995f, - 1.76567459f, -6.86711407f, 0.0716523379f, -0.058796037f, 1.46619296f, 0.872004092f, - -0.0252493843f, -5.36626196f, 1.03184021f, 2.91668129f, 5.0266819f, 2.2033143f, - -4.19885206f, -0.810671806f, -9.19921684f, 1.97324657f, 4.16573715f, 1.44949365f, - 1.19004726f, -1.77794909f, -3.10038495f, 7.07435274f, -6.13624907f, -1.24591768f, - 7.40163374f, 4.56154346f, 1.59572029f, 3.11537838f, 2.66523576f, 3.2964592f, - -1.98626173f, -1.2262578f, -2.43333101f, -4.59958124f, -3.37576795f, 0.0782872215f, - 4.45073175f, -0.638530076f, 2.10426593f, -4.61067104f, 0.372735113f, 4.99672747f, - 6.44558287f, 4.95810318f, -3.53180885f, -0.270193726f, -3.37528181f, 8.98018551f, - 7.76609802f, 4.20482445f, -1.30723655f, -0.287961423f, 11.2429733f, 1.75975835f, - -3.69972849f, -1.67073417f, -2.12870574f, -1.9937377f, 3.73860264f, -1.74882197f, - 0.57954818f, 5.95223045f, 0.336499184f, 7.57776785f, -5.9131217f, 6.00866222f, - -3.93735504f, -0.791872621f, -7.21986723f, -5.99231958f, 5.19560337f, -1.63746238f, - 2.86522174f, 3.18311548f, 4.32468843f, 3.89604068f, -2.76666164f, 2.85873818f, - -0.15784806f, 0.720757127f, 2.96551538f, 11.3587322f, 0.573656023f, 0.388863504f, - 1.95281422f, 6.46769762f, -2.63912845f, -6.02555847f, -4.97968197f, -0.642936051f, - -0.564658582f, 1.34927571f, 1.12826979f, 2.33937526f, 0.948639989f, -3.13693738f, - 5.79861355f, 0.926389277f, -0.166503221f, 0.607437074f, -1.31628466f, 4.58770323f, - 6.73905277f, -3.54981208f, 7.82219887f, -0.879952371f, 2.00372386f, 4.32768631f, - -3.16756177f, 5.10808277f, -0.98144716f, -1.29989374f, + -0.660979867f, 0.987872839f, -7.67157841f, 0.643079638f, 5.74514818f, -2.95755935f, + -8.08782196f, 6.25476789f, -0.241490945f, 2.76279521f, 0.876179457f, 3.17139101f, + -3.42478943f, -0.197525308f, -5.08722782f, -1.52657771f, 2.29209852f, 0.958931148f, + 1.72877634f, -0.767239749f, -2.63483191f, -1.00536764f, -2.13769794f, 8.26473904f, + 3.94305992f, -2.46664643f, 6.4319396f, 3.21983337f, 4.98314714f, 3.07138538f, + 2.21780229f, 0.811145782f, -3.94567871f, -1.05466509f, -4.30965471f, -6.91315699f, + -2.61526823f, -1.7634722f, -6.0486989f, 3.91941357f, 0.26326704f, -0.867766142f, + 2.17146873f, -0.193176746f, -1.0907743f, -0.739106178f, -5.10510254f, -4.95326805f, + 3.87040997f, -0.318578184f, 1.48050106f, -3.77590871f, 0.289932638f, -2.12141538f, + -1.12818038f, 0.034174446f, 3.95419717f, -10.6331196f, 6.59723377f, 5.61022282f, + 4.7932353f, 10.2208357f, 3.70198131f, -4.68362045f, 1.25972831f, 2.39876103f, + 1.81174457f, 6.63287735f, 3.2079165f, -2.46075511f, 5.38671732f, 1.24200356f, + 1.26430082f, -5.95467234f, -7.32837772f, -5.07036734f, -2.20266247f, -3.89838338f, + -3.77679396f, 0.430505186f, -0.316909999f, 2.79611325f, 1.68703485f, -1.04929256f, + 2.0169282f, 1.55579329f, -1.07488894f, 4.07556677f, 0.139839113f, -8.12611866f, + 11.0480547f, -2.15695667f, 4.49498415f, 7.01230001f, -0.596127629f, 5.14263678f, + -4.58548689f, 3.85867119f, -1.29925823f, -1.86024106f, -4.02736044f, 3.7013638f, + -1.59719789f, 5.17664623f, 0.374102861f, 5.13427401f, 4.29770184f, -0.832967997f, + 1.63416755f, -4.04448795f, -2.2302413f, 3.02391768f, 4.28402567f, -4.07153177f, + 1.76518261f, -6.86800909f, 0.0719797537f, -0.0605915934f, 1.46702981f, 0.871920109f, + -0.0263418816f, -5.36560059f, 1.03366256f, 2.91752386f, 5.02619028f, 2.20366406f, + -4.19801188f, -0.812758982f, -9.19816875f, 1.97473049f, 4.16007519f, 1.44928956f, + 1.18782341f, -1.77651572f, -3.09951949f, 7.07375097f, -6.13747263f, -1.24794304f, + 7.40373182f, 4.56146669f, 1.59538221f, 3.11497307f, 2.6690042f, 3.29797268f, + -1.98497534f, -1.22799134f, -2.43315554f, -4.59993458f, -3.37540412f, 0.0787627548f, + 4.45215225f, -0.63565743f, 2.10225558f, -4.60948563f, 0.374539167f, 4.99755144f, + 6.4466424f, 4.95611429f, -3.52951336f, -0.268923104f, -3.37786484f, 8.98293209f, + 7.76644182f, 4.2071476f, -1.30277514f, -0.284400135f, 11.2446356f, 1.75482595f, + -3.6898427f, -1.667575f, -2.12750173f, -1.99463201f, 3.72827578f, -1.75569963f, + 0.573994696f, 5.94897699f, 0.333548129f, 7.58212137f, -5.91927862f, 6.01274586f, + -3.9386549f, -0.798282921f, -7.22116852f, -5.99381351f, 5.20278215f, -1.63386941f, + 2.87024117f, 3.17610908f, 4.32253456f, 3.89654446f, -2.76097488f, 2.85952115f, + -0.163392007f, 0.726251781f, 2.96555042f, 11.3621778f, 0.579103708f, 0.397732079f, + 1.94122803f, 6.48857927f, -2.62827325f, -6.02985239f, -4.98078918f, -0.645178556f, + -0.572472274f, 1.36025155f, 1.12749505f, 2.3370018f, 0.93255794f, -3.13388538f, + 5.80395651f, 0.932892084f, -0.164065197f, 0.614211679f, -1.32706285f, 4.58676195f, + 6.75547171f, -3.54309869f, 7.83796787f, -0.881023824f, 2.00171494f, 4.31599951f, + -3.15998983f, 5.10213566f, -0.985050857f, -1.29464304f, }; inline constexpr float kLtxTowerPaddedStateF32_10[] = { @@ -2510,44 +2513,44 @@ inline constexpr float kLtxTowerPaddedStateF32_10[] = { -9.81959152f, -4.4940567f, 3.27147007f, 2.92910361f, 1.10508645f, -1.71333182f, 6.56148815f, -3.95104432f, -12.8597584f, 4.39411736f, -0.138561472f, -6.2195363f, 5.64308929f, 0.44396773f, 0.605854452f, 4.83758545f, 3.75780487f, -0.980947554f, - -0.10482654f, 2.67226958f, -8.71560097f, 1.15856838f, 5.68391466f, 1.44166744f, - -9.43969059f, 8.50172043f, -0.912139595f, 3.33707523f, 2.06523395f, 4.56964302f, - -2.60918713f, -0.0348035321f, -4.85170746f, -3.20843053f, 4.35588312f, 3.63455749f, - 1.63123345f, -2.66728163f, 0.120158255f, -0.836102903f, -4.92555141f, 7.94207144f, - 2.69203067f, -2.43038487f, 6.41482019f, 3.14020491f, 5.03237581f, 2.67947459f, - 3.18261099f, 2.80264735f, -2.97319007f, 0.0178108644f, -6.36221266f, -4.33498192f, - -3.37221241f, -0.140348122f, -7.45824051f, 4.70948935f, 0.54272455f, -2.41908622f, - 3.07212853f, 0.424789608f, -1.53393281f, 0.637811422f, -5.52330017f, -7.59293747f, - 3.8204596f, 0.214623377f, 3.02930546f, -4.58302498f, 1.3218627f, -1.73219478f, - -1.72003114f, -1.69076014f, 4.19020176f, -10.6886959f, 7.65370464f, 7.77021217f, - 5.52832317f, 10.5101461f, 3.77356553f, -3.00501943f, 2.35680819f, 3.7947526f, - 1.58181965f, 8.6747036f, 1.57725179f, -0.241350234f, 5.89169502f, -0.613854647f, - 2.4338243f, -8.51373291f, -7.57148218f, -3.52645922f, -3.34064889f, -6.26339912f, - -3.89664531f, -0.426029235f, 0.94037503f, 2.25122666f, 1.70227349f, -0.131403014f, - 3.07712913f, 2.99763012f, -3.03327131f, 3.25344014f, -1.03305638f, -10.3859673f, - 11.769104f, -0.824490011f, 5.2857008f, 7.69731474f, 0.527998328f, 5.14401817f, - -3.61631584f, 4.28267956f, -3.02899647f, -0.249358967f, -4.35161734f, 7.97448492f, - -1.21993899f, 7.50264311f, 1.79126203f, 5.55331039f, 4.66712046f, -2.02364683f, - 2.54988647f, -4.81048965f, -1.14183867f, 0.94774282f, 6.27718163f, -3.80280757f, - 3.14343262f, -6.71192169f, 1.5611583f, 1.32365751f, -0.153946817f, -0.403985947f, - -0.579913974f, -6.40792131f, 1.80746615f, 4.4978466f, 5.64353609f, 1.53104067f, - -3.92614031f, 1.2499938f, -8.24410725f, 1.20976138f, 4.63189363f, 3.24145389f, - 2.63279128f, 1.46484661f, -4.18165255f, 7.34664488f, -5.82988787f, -1.67284429f, - 10.1357718f, 4.4629364f, 0.922057331f, 2.20665073f, 2.21271825f, 1.28745329f, - -0.493269324f, -0.513631165f, -0.887152493f, -3.36502171f, -2.36804891f, 0.941769421f, - 3.04302216f, -1.96978533f, 2.2857635f, -3.23394203f, -0.239285499f, 4.53762579f, - 8.26843548f, 4.68438911f, -1.6300981f, 3.45182347f, -2.76690054f, 10.7650251f, - 8.71631718f, 4.736444f, -3.18021798f, -0.256393075f, 13.0049295f, -1.81585181f, - -5.3054347f, -3.25520492f, 0.0510792024f, -2.47938919f, 1.24809504f, -4.47247934f, - 0.0437133908f, 4.57214069f, 1.12135243f, 6.01977968f, -7.2627573f, 5.06950808f, - -2.15192032f, 1.11115742f, -6.71810818f, -4.78780746f, 5.10318089f, -3.31369734f, - 3.26128197f, 2.61802864f, 6.1873126f, 6.07846308f, -1.5938096f, 3.48768091f, - -0.0703490376f, 0.543764889f, 3.56111073f, 13.3205462f, -0.181255206f, 1.25001442f, - 1.37158203f, 4.62317801f, -2.91592717f, -7.58690739f, -4.26948547f, -0.821265757f, - -2.38568974f, 0.546114504f, 2.65365815f, -0.305452079f, 1.98464811f, -4.73073244f, - 4.56215239f, 1.23554468f, 0.431498379f, -0.170910791f, -0.339073241f, 5.52192068f, - 6.69706774f, -4.16263008f, 7.35558653f, -1.51313782f, 2.40459085f, 6.98451376f, - -3.37214756f, 4.96741772f, -1.29108572f, -1.91056776f, + -0.10482654f, 2.67226958f, -8.71569347f, 1.15850663f, 5.68400145f, 1.44172084f, + -9.43976688f, 8.50164604f, -0.912306428f, 3.3370986f, 2.06532955f, 4.56977129f, + -2.60920954f, -0.0349152572f, -4.85169077f, -3.20838046f, 4.3560462f, 3.63469481f, + 1.63121784f, -2.66743064f, 0.120120972f, -0.836145639f, -4.92555237f, 7.94207621f, + 2.6920166f, -2.43046975f, 6.41477299f, 3.14026976f, 5.03228664f, 2.6794467f, + 3.18262982f, 2.80261421f, -2.97326255f, 0.0179104526f, -6.36227798f, -4.33496094f, + -3.37245822f, -0.140300676f, -7.45821762f, 4.70963955f, 0.542718887f, -2.4190309f, + 3.0718832f, 0.424771369f, -1.53381491f, 0.637824655f, -5.52321339f, -7.59294987f, + 3.8204782f, 0.214419067f, 3.02935553f, -4.58320093f, 1.32184482f, -1.7322998f, + -1.71995711f, -1.6907047f, 4.19010925f, -10.6887741f, 7.65380669f, 7.77050352f, + 5.52828407f, 10.5099297f, 3.77335095f, -3.00513697f, 2.35665631f, 3.79471779f, + 1.58186781f, 8.6727066f, 1.58094716f, -0.240856007f, 5.89161921f, -0.613869131f, + 2.43912721f, -8.51510429f, -7.56772852f, -3.52561545f, -3.34028172f, -6.26344204f, + -3.90032578f, -0.425636798f, 0.939684033f, 2.25144315f, 1.70222199f, -0.12891455f, + 3.07821012f, 2.99892116f, -3.037503f, 3.25370502f, -1.03291297f, -10.3850918f, + 11.7690144f, -0.828621149f, 5.28730774f, 7.69729233f, 0.529996097f, 5.14428377f, + -3.61815381f, 4.28505325f, -3.02785587f, -0.24930948f, -4.35182762f, 7.96982765f, + -1.2226969f, 7.50339651f, 1.79279256f, 5.55062151f, 4.66778851f, -2.02346039f, + 2.55098605f, -4.80967617f, -1.14073598f, 0.949023545f, 6.2755127f, -3.80438638f, + 3.1425426f, -6.71389055f, 1.56238687f, 1.32243514f, -0.15334785f, -0.404019117f, + -0.579980493f, -6.40608454f, 1.81000388f, 4.49629641f, 5.64326382f, 1.53044438f, + -3.92477512f, 1.24696934f, -8.24374104f, 1.21226168f, 4.62543106f, 3.24167824f, + 2.62979817f, 1.46585226f, -4.18123341f, 7.34491253f, -5.83201599f, -1.67533183f, + 10.1371737f, 4.46221161f, 0.921533585f, 2.20669484f, 2.21608233f, 1.28917849f, + -0.493448138f, -0.515482247f, -0.887137234f, -3.36539888f, -2.36738849f, 0.942535698f, + 3.04549074f, -1.96591377f, 2.28402472f, -3.23087764f, -0.239650726f, 4.53751945f, + 8.26951599f, 4.68299532f, -1.62685549f, 3.45304155f, -2.76980758f, 10.7689495f, + 8.71771526f, 4.73885584f, -3.17616558f, -0.250521451f, 13.0098829f, -1.81996f, + -5.2950511f, -3.25702858f, 0.0543749034f, -2.48084879f, 1.23591053f, -4.47829628f, + 0.039034605f, 4.57036972f, 1.11613488f, 6.02355862f, -7.267766f, 5.07423115f, + -2.1522193f, 1.1018219f, -6.71939468f, -4.78730154f, 5.10910845f, -3.308007f, + 3.26789165f, 2.61278081f, 6.18807173f, 6.07982254f, -1.58793569f, 3.49098206f, + -0.0759316683f, 0.547790349f, 3.560112f, 13.3253336f, -0.17380251f, 1.25537741f, + 1.36291468f, 4.64588451f, -2.90526128f, -7.59574699f, -4.26922655f, -0.82823813f, + -2.40505266f, 0.55593884f, 2.64764071f, -0.303706944f, 1.95197892f, -4.72843122f, + 4.56665087f, 1.24489546f, 0.443052799f, -0.166658729f, -0.356186301f, 5.52630711f, + 6.70993996f, -4.14904737f, 7.36100006f, -1.52609801f, 2.40721035f, 6.97960472f, + -3.35795951f, 4.96084404f, -1.29949784f, -1.90696001f, }; inline constexpr float kLtxTowerPaddedStateF32_11[] = { @@ -2620,44 +2623,44 @@ inline constexpr float kLtxTowerPaddedStateF32_11[] = { -9.0353775f, -5.09133434f, 2.99516034f, 1.2989912f, 1.02667689f, -1.35771024f, 4.10051966f, -5.11249971f, -14.3474884f, 3.33703589f, -0.486126631f, -5.90158272f, 6.8576932f, 1.98699152f, -0.396765739f, 7.69790554f, 1.59108329f, 0.919567466f, - -2.03158998f, 0.711704075f, -10.3877859f, -1.31962562f, 6.39246178f, 1.0515976f, - -10.3229322f, 7.5520916f, -1.67549145f, 4.46362829f, 0.709875047f, 7.01930428f, - -3.7043376f, -0.134693831f, -5.26708937f, -3.44427228f, 5.37965918f, 2.06768203f, - 1.74756467f, -3.02755427f, -1.97741723f, -0.973179817f, -4.6875062f, 8.60925007f, - 4.14784098f, -2.732584f, 7.19731379f, 3.23814344f, 5.16963196f, 6.43130827f, - 0.240472719f, 3.99888134f, -5.65125847f, -1.36780798f, -8.46560764f, -7.05430079f, - -5.20627546f, -2.23479486f, -7.97986174f, 3.80986738f, 0.61800307f, -2.80251026f, - 4.63140821f, 0.89822346f, 0.0755415931f, 0.934909284f, -5.70480394f, -7.89502907f, - 3.0786469f, -0.249098212f, 4.58073521f, -3.88358521f, -0.904957056f, -2.9685328f, - -2.2367897f, -1.96490157f, 3.64106154f, -11.6475143f, 6.32664442f, 8.41845989f, - 6.22322941f, 12.1318741f, 3.1087513f, -3.41468215f, 1.28740788f, 4.61097956f, - 0.928772986f, 7.94565392f, 1.3576206f, -0.662978053f, 3.8712132f, -0.917520881f, - 4.45765877f, -9.03753853f, -5.00454426f, -4.43963051f, -2.30917978f, -5.39179182f, - -2.51833749f, -4.33348131f, -1.51930237f, -0.94201982f, -1.41358554f, 1.22146034f, - 4.17381763f, 2.73774052f, -3.21300483f, 4.24195671f, -0.949455678f, -11.6483765f, - 10.8230028f, 1.62298787f, 6.8906498f, 9.15462685f, -0.576156378f, 4.65218544f, - -7.10053587f, 4.31332493f, -3.09361982f, 0.281839609f, -3.41008019f, 6.88802195f, - -2.61557007f, 6.52700377f, 2.32888412f, 3.40236735f, 6.73129988f, -0.850880682f, - 3.27160311f, -4.71819258f, -1.38680041f, 0.425177872f, 4.92645311f, -5.1742301f, - 3.21023989f, -6.20494413f, -1.17002296f, 0.505255163f, -2.08124638f, 1.93000579f, - -0.194101229f, -7.22816706f, 2.31304526f, 3.84029675f, 6.58723068f, 3.20652819f, - -4.15768957f, 2.00904059f, -7.96108913f, 0.785572708f, 4.27958918f, 1.72429609f, - 2.2623105f, 1.66874862f, -5.41250801f, 6.41716957f, -6.90256119f, -1.6186868f, - 11.1009989f, 6.25351191f, 1.86715949f, 2.94386888f, 2.22492361f, 2.19609976f, - -2.316293f, -1.03377259f, 0.172304213f, -5.06168604f, -3.5409236f, 0.647434175f, - 1.6167742f, -1.70384514f, 2.94659877f, -5.66172218f, -1.0659219f, 3.27498364f, - 7.51903725f, 6.50902081f, -2.06071734f, 2.98929453f, -3.71027207f, 10.7182531f, - 10.9853086f, 4.6521697f, -5.40753126f, -1.18296003f, 11.5126247f, -1.0509696f, - -3.52282667f, -4.67655563f, 4.11761093f, -3.36638951f, 3.00510311f, -4.10413027f, - 0.804985285f, 2.58839059f, -0.249291807f, 3.9379077f, -8.73401165f, 5.58823824f, - -0.283520937f, 1.37050605f, -5.45151377f, -3.45755982f, 6.27406645f, -2.83341384f, - 3.26758456f, 1.78446782f, 7.36382723f, 6.04614973f, -2.95160437f, 2.31532955f, - -1.55720806f, 0.939495444f, 4.99243212f, 11.9807377f, -1.26893532f, 2.18998504f, - 0.475568265f, 4.15029669f, 0.237803444f, -6.24599266f, -0.391187549f, -1.48575079f, - -0.374416053f, 2.18618059f, 3.75482988f, -2.30727482f, 1.30930555f, -4.41220427f, - 6.46405172f, 2.14554763f, 3.02957916f, -1.49258912f, -0.603358626f, 5.68947697f, - 7.2358098f, -5.93220949f, 7.50483894f, 0.10200686f, 1.67535591f, 4.91259432f, - -3.25572181f, 3.46846914f, 0.212181389f, -2.52899957f, + -2.03158998f, 0.711704075f, -10.3879147f, -1.31965578f, 6.39247751f, 1.05162883f, + -10.3230858f, 7.55200529f, -1.67566597f, 4.46364069f, 0.709994495f, 7.01943111f, + -3.7043314f, -0.134768441f, -5.26701736f, -3.44417262f, 5.37974262f, 2.06776857f, + 1.74762249f, -3.02766395f, -1.97743583f, -0.97325176f, -4.68754005f, 8.60930729f, + 4.14788151f, -2.73269701f, 7.19721746f, 3.23823142f, 5.16952181f, 6.43129444f, + 0.240487963f, 3.99875283f, -5.65128851f, -1.36768699f, -8.46576595f, -7.05421162f, + -5.20638323f, -2.23480034f, -7.97974586f, 3.81003618f, 0.617889225f, -2.80249166f, + 4.6312027f, 0.898152649f, 0.075729318f, 0.934928596f, -5.70472145f, -7.89497375f, + 3.07880855f, -0.249307737f, 4.58067703f, -3.88368177f, -0.904987991f, -2.96855497f, + -2.23694015f, -1.96474087f, 3.64094353f, -11.6473236f, 6.32698011f, 8.41881752f, + 6.22317028f, 12.1317606f, 3.10857439f, -3.41473699f, 1.28725553f, 4.61093616f, + 0.928767979f, 7.94312906f, 1.36085498f, -0.663225889f, 3.87129545f, -0.917634606f, + 4.46279907f, -9.03922939f, -5.00054741f, -4.43932819f, -2.30886912f, -5.39179659f, + -2.52395606f, -4.33256149f, -1.51983368f, -0.941572785f, -1.41458762f, 1.22306919f, + 4.1748333f, 2.74037719f, -3.2167635f, 4.24135923f, -0.948691189f, -11.6470194f, + 10.8220987f, 1.61834657f, 6.89228439f, 9.1546278f, -0.57448113f, 4.65220833f, + -7.10378885f, 4.31602859f, -3.09226298f, 0.281259179f, -3.41113973f, 6.88357306f, + -2.61687803f, 6.5270195f, 2.33096027f, 3.39969611f, 6.73240566f, -0.850906134f, + 3.27274656f, -4.71687698f, -1.38627601f, 0.426596552f, 4.9253521f, -5.17605495f, + 3.20844007f, -6.20686007f, -1.16918075f, 0.505262613f, -2.08208203f, 1.92892432f, + -0.193905696f, -7.22648191f, 2.31564164f, 3.83774066f, 6.58813429f, 3.2071712f, + -4.15688276f, 2.00607228f, -7.96086073f, 0.7878685f, 4.27150869f, 1.72502184f, + 2.25896955f, 1.67194223f, -5.41219091f, 6.41696024f, -6.90700388f, -1.62065315f, + 11.1021671f, 6.25574446f, 1.86574292f, 2.9412775f, 2.22950959f, 2.20132613f, + -2.31459951f, -1.0333755f, 0.17222333f, -5.06513357f, -3.54184771f, 0.646074355f, + 1.61906159f, -1.70174015f, 2.94311833f, -5.66239166f, -1.0666759f, 3.27210259f, + 7.52059603f, 6.50908089f, -2.05643249f, 2.99036002f, -3.71024847f, 10.7238283f, + 10.9858036f, 4.65637207f, -5.40730238f, -1.17280853f, 11.5161276f, -1.0559516f, + -3.51127958f, -4.67582035f, 4.12159872f, -3.36471415f, 2.99046755f, -4.10896206f, + 0.797384381f, 2.58732295f, -0.257895738f, 3.9427762f, -8.73945045f, 5.58912754f, + -0.280672222f, 1.36038458f, -5.4500947f, -3.45344353f, 6.28264046f, -2.82867694f, + 3.27174115f, 1.77691126f, 7.35992193f, 6.0520525f, -2.94361663f, 2.3220427f, + -1.56125069f, 0.944330573f, 4.99124861f, 11.9856071f, -1.27040756f, 2.1918745f, + 0.470041573f, 4.18198299f, 0.246867374f, -6.25242472f, -0.392037958f, -1.50067914f, + -0.393692523f, 2.19859529f, 3.75391817f, -2.30169034f, 1.27035749f, -4.41588068f, + 6.46793938f, 2.15687752f, 3.03430772f, -1.48456395f, -0.62996465f, 5.69442844f, + 7.24986696f, -5.91886425f, 7.50897837f, 0.0952497125f, 1.68243206f, 4.91203165f, + -3.23988795f, 3.45393133f, 0.211070076f, -2.52413511f, }; inline constexpr float kLtxTowerPaddedStateF32_12[] = { @@ -2730,55 +2733,1556 @@ inline constexpr float kLtxTowerPaddedStateF32_12[] = { -1.42908251f, -0.713450074f, 0.68597424f, -0.208518654f, 0.44005242f, -0.342173755f, 0.835361302f, -0.726223171f, -2.705369f, 0.480481118f, -0.140720487f, -1.39041114f, 0.983665049f, 0.116292492f, 0.307106793f, 1.38160169f, 0.49981299f, 0.812870264f, - -0.164643705f, 0.179613307f, -1.74931729f, -0.288579166f, 1.39409387f, 0.197409436f, - -2.19801092f, 1.5883621f, -0.839703262f, 1.12294638f, 0.373400658f, 1.54720688f, - -0.512911856f, -0.00649692351f, -0.820076227f, -0.219174877f, 1.059443f, 0.243720219f, - 0.370759666f, -0.740036964f, 0.118275516f, -0.215984136f, -0.964957714f, 1.3907032f, - 0.565508723f, -1.03241801f, 1.58022642f, 0.338675231f, 1.14462376f, 1.07853806f, - 0.0277207978f, 1.27413118f, -0.899445653f, -0.149894878f, -1.32032967f, -1.14739561f, - -1.02280176f, -0.296710372f, -2.02581477f, 0.772616267f, 0.0339149237f, -0.297675937f, - 1.01899791f, 0.236974478f, 0.015459924f, -0.133215383f, -0.711078286f, -1.28036368f, - 0.706687808f, -0.109366961f, 0.87863332f, -0.38571012f, 0.251589239f, -0.320376903f, - -0.77396518f, -0.744703352f, 0.801452041f, -2.18043184f, 1.28679931f, 1.29488564f, - 1.43232191f, 2.05494833f, 0.635779023f, -0.0990467444f, 0.21703057f, 0.960917592f, - 0.21538201f, 1.21963596f, 0.251858801f, -0.160778031f, 0.421952337f, -0.120693445f, - 0.626841962f, -1.54097927f, -0.945828974f, -0.863064051f, -0.278157324f, -1.11969793f, - -0.455500007f, -0.91548562f, -0.811382413f, -0.019283833f, -0.275045961f, 0.074324891f, - 1.11826909f, 0.855544388f, -0.574066401f, 0.679834068f, -0.143765897f, -2.49237037f, - 1.80941761f, 0.174940571f, 1.61162531f, 1.24727082f, -0.095103927f, 1.28048623f, - -1.48414147f, 1.26868761f, -0.727487803f, 0.0142007088f, -0.145832911f, 1.21034789f, - -0.996479511f, 1.69371426f, 0.574038744f, 1.26877367f, 1.28407049f, 0.404159099f, - 0.182630435f, -1.32910168f, -0.521365285f, -0.00485751173f, 1.00215781f, -1.42715132f, - 0.563561618f, -1.52634013f, 0.2296087f, 0.203723088f, -0.339092433f, -0.226484075f, - 0.153143346f, -2.25564027f, 0.45634979f, 0.705762088f, 2.01022077f, 0.706697345f, - -0.664827168f, 1.11195898f, -1.60040665f, 0.435713023f, 0.804510057f, 0.297252476f, - 0.492954433f, 0.364438623f, -1.40678561f, 1.0582248f, -1.77628899f, -0.131722033f, - 2.59635496f, 1.21546376f, 0.371164739f, 0.75448209f, 0.044356212f, 0.818067074f, - -0.410108387f, -0.282752603f, -0.223242834f, -1.19084907f, -0.383880496f, 0.251906693f, - 0.461940229f, -0.624655306f, 0.527876318f, -1.24935436f, -0.44257009f, 0.573611856f, - 1.83284628f, 0.963337541f, -0.0949202552f, 0.681271434f, -0.587772608f, 2.28307176f, - 2.11212635f, 1.40161717f, -1.41692102f, 0.421009779f, 2.07975245f, -0.226825386f, - -0.0522198193f, -1.0211736f, 0.910592616f, -0.461224198f, 0.0656973273f, -0.811019421f, - 0.128312021f, 0.154903635f, 0.0809641257f, 0.551514804f, -2.03809667f, 0.854551554f, - -0.394816846f, 0.861900032f, -1.23810601f, -1.15227199f, 1.2461431f, -0.148462608f, - 0.595833719f, 0.667150259f, 1.45398331f, 1.32830942f, -0.893478096f, 0.759214759f, - -0.331326723f, 0.351397723f, 1.01019847f, 2.37378669f, 0.134113938f, 0.850483f, - -0.499429137f, 1.46495295f, 0.166226998f, -1.32651544f, 0.33374992f, -0.576195002f, - -0.14517498f, 1.04183507f, 0.902168512f, -0.627131999f, -0.0235508941f, -1.03166604f, - 1.32513845f, -0.0976271778f, 1.14109504f, -0.224171206f, 0.116981119f, 1.24365127f, - 1.95854449f, -1.30697942f, 1.66969609f, -0.0354429074f, 0.54967463f, 0.890598416f, - -0.408949643f, 1.14590847f, -0.252561748f, -0.0290292297f, + -0.164643705f, 0.179613307f, -1.7493391f, -0.288582504f, 1.39409709f, 0.197424814f, + -2.19802618f, 1.58833301f, -0.839731753f, 1.1229316f, 0.37341997f, 1.54722846f, + -0.512908816f, -0.00650794199f, -0.820044219f, -0.219146445f, 1.05945861f, 0.243722767f, + 0.370777309f, -0.740060091f, 0.118272446f, -0.215995371f, -0.964962363f, 1.39070129f, + 0.565507531f, -1.0324353f, 1.58020139f, 0.338692695f, 1.14460039f, 1.07852769f, + 0.0277310107f, 1.27410626f, -0.899437785f, -0.149869785f, -1.3203541f, -1.14738405f, + -1.02281547f, -0.296709239f, -2.025805f, 0.772643745f, 0.0338878818f, -0.29768914f, + 1.01897025f, 0.236964092f, 0.0154760601f, -0.133203506f, -0.711075604f, -1.28035331f, + 0.70671612f, -0.109417021f, 0.878618062f, -0.385746837f, 0.251567274f, -0.320364892f, + -0.773999691f, -0.744668841f, 0.801414847f, -2.18040705f, 1.2868464f, 1.29494298f, + 1.43230605f, 2.05493665f, 0.635743022f, -0.0990569666f, 0.217013791f, 0.960909784f, + 0.215385422f, 1.21915388f, 0.252415776f, -0.160854563f, 0.422010452f, -0.120809346f, + 0.627729595f, -1.54102969f, -0.945061266f, -0.863019764f, -0.278156161f, -1.11971438f, + -0.456743151f, -0.915051758f, -0.811585009f, -0.0191246755f, -0.275212467f, 0.0747533068f, + 1.11831689f, 0.855989933f, -0.574614704f, 0.679713607f, -0.143596709f, -2.49205327f, + 1.80915546f, 0.174202293f, 1.61180246f, 1.24724591f, -0.0947522521f, 1.28033197f, + -1.48456836f, 1.26913536f, -0.727237225f, 0.0140713993f, -0.145904616f, 1.20949447f, + -0.996573031f, 1.69373441f, 0.574402273f, 1.26811111f, 1.28485012f, 0.404163778f, + 0.182477161f, -1.32829738f, -0.5212363f, -0.00461293757f, 1.00245059f, -1.42755508f, + 0.562996924f, -1.52737296f, 0.229845583f, 0.203556165f, -0.33910954f, -0.227016002f, + 0.153265342f, -2.25530386f, 0.456832826f, 0.705510974f, 2.01019359f, 0.707206726f, + -0.664824665f, 1.11161435f, -1.6004715f, 0.436217427f, 0.802680731f, 0.297376752f, + 0.492484778f, 0.364806563f, -1.40622067f, 1.05801046f, -1.7767632f, -0.132054687f, + 2.59603524f, 1.21610463f, 0.37034446f, 0.754165113f, 0.0457169674f, 0.819229543f, + -0.410216123f, -0.282864511f, -0.223228514f, -1.19092584f, -0.383740097f, 0.251355052f, + 0.462008357f, -0.624758959f, 0.527447343f, -1.24961555f, -0.442323983f, 0.573104441f, + 1.83266664f, 0.963393331f, -0.0939990133f, 0.68135047f, -0.587372899f, 2.28392124f, + 2.11268663f, 1.40172791f, -1.41646433f, 0.42352131f, 2.07955265f, -0.228383526f, + -0.0499431267f, -1.02007294f, 0.911745965f, -0.461284935f, 0.0633363873f, -0.812260509f, + 0.126658693f, 0.15491873f, 0.0795611963f, 0.55250591f, -2.03955054f, 0.854219019f, + -0.395197928f, 0.860562027f, -1.23792207f, -1.15010166f, 1.24822521f, -0.147705257f, + 0.596216977f, 0.665461481f, 1.45141792f, 1.32918429f, -0.891045928f, 0.760291576f, + -0.332593769f, 0.352822155f, 1.00903738f, 2.37247276f, 0.133323476f, 0.847830534f, + -0.499667495f, 1.47127509f, 0.16921927f, -1.3305279f, 0.332017899f, -0.581712663f, + -0.150860012f, 1.04442048f, 0.898615777f, -0.626261532f, -0.0337993242f, -1.03032243f, + 1.32301354f, -0.094950825f, 1.1416496f, -0.222019449f, 0.112374529f, 1.2445755f, + 1.96146333f, -1.30386031f, 1.66888165f, -0.0367541946f, 0.548548043f, 0.890794754f, + -0.405506134f, 1.142542f, -0.254530013f, -0.027096564f, +}; + +// --- section 4b: the LEFT-PADDED run, BFLOAT16 (the SHIPPED dtype) --- +// The dtype-MATCHED arm for anything gated on the left-padded rows, and +// with section 4 it is also the padded run's own measured noise floor. +inline constexpr float kLtxTowerPaddedStateBf16_0[] = { + -0.109863281f, 0.197265625f, 0.0834960938f, 0.203125f, -0.0556640625f, 0.27734375f, + 0.0393066406f, -0.0189208984f, -0.00708007812f, 0.212890625f, 0.192382812f, -0.16015625f, + -0.12890625f, -0.126953125f, 0.2109375f, -0.0305175781f, 0.166015625f, -0.1796875f, + 0.0541992188f, -0.138671875f, -0.00915527344f, 0.0270996094f, -0.19921875f, 0.267578125f, + -0.17578125f, 0.0390625f, -0.203125f, -0.120117188f, 0.23046875f, 0.121582031f, + -0.2109375f, 0.149414062f, -0.109863281f, 0.197265625f, 0.0834960938f, 0.203125f, + -0.0556640625f, 0.27734375f, 0.0393066406f, -0.0189208984f, -0.00708007812f, 0.212890625f, + 0.192382812f, -0.16015625f, -0.12890625f, -0.126953125f, 0.2109375f, -0.0305175781f, + 0.166015625f, -0.1796875f, 0.0541992188f, -0.138671875f, -0.00915527344f, 0.0270996094f, + -0.19921875f, 0.267578125f, -0.17578125f, 0.0390625f, -0.203125f, -0.120117188f, + 0.23046875f, 0.121582031f, -0.2109375f, 0.149414062f, -0.109863281f, 0.197265625f, + 0.0834960938f, 0.203125f, -0.0556640625f, 0.27734375f, 0.0393066406f, -0.0189208984f, + -0.00708007812f, 0.212890625f, 0.192382812f, -0.16015625f, -0.12890625f, -0.126953125f, + 0.2109375f, -0.0305175781f, 0.166015625f, -0.1796875f, 0.0541992188f, -0.138671875f, + -0.00915527344f, 0.0270996094f, -0.19921875f, 0.267578125f, -0.17578125f, 0.0390625f, + -0.203125f, -0.120117188f, 0.23046875f, 0.121582031f, -0.2109375f, 0.149414062f, + -0.109863281f, 0.197265625f, 0.0834960938f, 0.203125f, -0.0556640625f, 0.27734375f, + 0.0393066406f, -0.0189208984f, -0.00708007812f, 0.212890625f, 0.192382812f, -0.16015625f, + -0.12890625f, -0.126953125f, 0.2109375f, -0.0305175781f, 0.166015625f, -0.1796875f, + 0.0541992188f, -0.138671875f, -0.00915527344f, 0.0270996094f, -0.19921875f, 0.267578125f, + -0.17578125f, 0.0390625f, -0.203125f, -0.120117188f, 0.23046875f, 0.121582031f, + -0.2109375f, 0.149414062f, -0.109863281f, 0.197265625f, 0.0834960938f, 0.203125f, + -0.0556640625f, 0.27734375f, 0.0393066406f, -0.0189208984f, -0.00708007812f, 0.212890625f, + 0.192382812f, -0.16015625f, -0.12890625f, -0.126953125f, 0.2109375f, -0.0305175781f, + 0.166015625f, -0.1796875f, 0.0541992188f, -0.138671875f, -0.00915527344f, 0.0270996094f, + -0.19921875f, 0.267578125f, -0.17578125f, 0.0390625f, -0.203125f, -0.120117188f, + 0.23046875f, 0.121582031f, -0.2109375f, 0.149414062f, -0.109863281f, 0.197265625f, + 0.0834960938f, 0.203125f, -0.0556640625f, 0.27734375f, 0.0393066406f, -0.0189208984f, + -0.00708007812f, 0.212890625f, 0.192382812f, -0.16015625f, -0.12890625f, -0.126953125f, + 0.2109375f, -0.0305175781f, 0.166015625f, -0.1796875f, 0.0541992188f, -0.138671875f, + -0.00915527344f, 0.0270996094f, -0.19921875f, 0.267578125f, -0.17578125f, 0.0390625f, + -0.203125f, -0.120117188f, 0.23046875f, 0.121582031f, -0.2109375f, 0.149414062f, + -0.109863281f, 0.197265625f, 0.0834960938f, 0.203125f, -0.0556640625f, 0.27734375f, + 0.0393066406f, -0.0189208984f, -0.00708007812f, 0.212890625f, 0.192382812f, -0.16015625f, + -0.12890625f, -0.126953125f, 0.2109375f, -0.0305175781f, 0.166015625f, -0.1796875f, + 0.0541992188f, -0.138671875f, -0.00915527344f, 0.0270996094f, -0.19921875f, 0.267578125f, + -0.17578125f, 0.0390625f, -0.203125f, -0.120117188f, 0.23046875f, 0.121582031f, + -0.2109375f, 0.149414062f, -0.109863281f, 0.197265625f, 0.0834960938f, 0.203125f, + -0.0556640625f, 0.27734375f, 0.0393066406f, -0.0189208984f, -0.00708007812f, 0.212890625f, + 0.192382812f, -0.16015625f, -0.12890625f, -0.126953125f, 0.2109375f, -0.0305175781f, + 0.166015625f, -0.1796875f, 0.0541992188f, -0.138671875f, -0.00915527344f, 0.0270996094f, + -0.19921875f, 0.267578125f, -0.17578125f, 0.0390625f, -0.203125f, -0.120117188f, + 0.23046875f, 0.121582031f, -0.2109375f, 0.149414062f, -0.109863281f, 0.197265625f, + 0.0834960938f, 0.203125f, -0.0556640625f, 0.27734375f, 0.0393066406f, -0.0189208984f, + -0.00708007812f, 0.212890625f, 0.192382812f, -0.16015625f, -0.12890625f, -0.126953125f, + 0.2109375f, -0.0305175781f, 0.166015625f, -0.1796875f, 0.0541992188f, -0.138671875f, + -0.00915527344f, 0.0270996094f, -0.19921875f, 0.267578125f, -0.17578125f, 0.0390625f, + -0.203125f, -0.120117188f, 0.23046875f, 0.121582031f, -0.2109375f, 0.149414062f, + -0.109863281f, 0.197265625f, 0.0834960938f, 0.203125f, -0.0556640625f, 0.27734375f, + 0.0393066406f, -0.0189208984f, -0.00708007812f, 0.212890625f, 0.192382812f, -0.16015625f, + -0.12890625f, -0.126953125f, 0.2109375f, -0.0305175781f, 0.166015625f, -0.1796875f, + 0.0541992188f, -0.138671875f, -0.00915527344f, 0.0270996094f, -0.19921875f, 0.267578125f, + -0.17578125f, 0.0390625f, -0.203125f, -0.120117188f, 0.23046875f, 0.121582031f, + -0.2109375f, 0.149414062f, -0.109863281f, 0.197265625f, 0.0834960938f, 0.203125f, + -0.0556640625f, 0.27734375f, 0.0393066406f, -0.0189208984f, -0.00708007812f, 0.212890625f, + 0.192382812f, -0.16015625f, -0.12890625f, -0.126953125f, 0.2109375f, -0.0305175781f, + 0.166015625f, -0.1796875f, 0.0541992188f, -0.138671875f, -0.00915527344f, 0.0270996094f, + -0.19921875f, 0.267578125f, -0.17578125f, 0.0390625f, -0.203125f, -0.120117188f, + 0.23046875f, 0.121582031f, -0.2109375f, 0.149414062f, -0.109863281f, 0.197265625f, + 0.0834960938f, 0.203125f, -0.0556640625f, 0.27734375f, 0.0393066406f, -0.0189208984f, + -0.00708007812f, 0.212890625f, 0.192382812f, -0.16015625f, -0.12890625f, -0.126953125f, + 0.2109375f, -0.0305175781f, 0.166015625f, -0.1796875f, 0.0541992188f, -0.138671875f, + -0.00915527344f, 0.0270996094f, -0.19921875f, 0.267578125f, -0.17578125f, 0.0390625f, + -0.203125f, -0.120117188f, 0.23046875f, 0.121582031f, -0.2109375f, 0.149414062f, + 0.234375f, 0.0556640625f, -0.0444335938f, -0.243164062f, 0.186523438f, -0.125976562f, + -0.0149536133f, -0.0810546875f, -0.0322265625f, -0.17578125f, 0.0383300781f, 0.0703125f, + -0.046875f, 0.0737304688f, 0.177734375f, -0.103515625f, 0.103515625f, 0.279296875f, + 0.104492188f, 0.0344238281f, -0.139648438f, -0.05859375f, 0.102050781f, -0.0397949219f, + 0.0805664062f, -0.0510253906f, -0.240234375f, -0.0107421875f, 0.208984375f, 0.0456542969f, + -0.28125f, 0.130859375f, -0.236328125f, 0.15234375f, -0.0568847656f, -0.0402832031f, + 0.0354003906f, -0.12890625f, 0.106933594f, 0.142578125f, -0.116699219f, -0.0854492188f, + 0.099609375f, 0.125976562f, 0.1796875f, 0.190429688f, 0.244140625f, -0.072265625f, + -0.19921875f, 0.0903320312f, 0.209960938f, -0.275390625f, 0.244140625f, 0.103027344f, + 0.209960938f, -0.227539062f, 0.20703125f, -0.170898438f, -0.232421875f, 0.109863281f, + 0.0219726562f, 0.099609375f, -0.206054688f, 0.00799560547f, -0.172851562f, -0.142578125f, + 0.24609375f, -0.137695312f, 0.0673828125f, 0.26171875f, 0.26171875f, 0.193359375f, + 0.00842285156f, -0.0732421875f, 0.203125f, -0.0698242188f, -0.106445312f, -0.19921875f, + -0.23046875f, 0.0830078125f, -0.106445312f, 0.26171875f, 0.275390625f, 0.083984375f, + 0.0834960938f, 0.06640625f, 0.0864257812f, -0.143554688f, 0.05859375f, 0.212890625f, + 0.267578125f, 0.206054688f, 0.0290527344f, 0.229492188f, -0.064453125f, -0.0708007812f, + 0.176757812f, 0.189453125f, -0.271484375f, 0.180664062f, -0.087890625f, 0.0262451172f, + 0.234375f, -0.072265625f, -0.251953125f, 0.056640625f, -0.259765625f, -0.1328125f, + 0.124511719f, 0.0234375f, 0.206054688f, 0.0727539062f, 0.208984375f, 0.0212402344f, + 0.0622558594f, 0.2265625f, -0.0986328125f, 0.237304688f, -0.012512207f, -0.20703125f, + -0.0573730469f, -0.124511719f, 0.237304688f, 0.244140625f, -0.0751953125f, -0.169921875f, + -0.126953125f, -0.1640625f, -0.0439453125f, 0.23046875f, 0.00302124023f, -0.25390625f, + 0.106933594f, 0.0522460938f, -0.120117188f, -0.14453125f, 0.155273438f, 0.00340270996f, + 0.220703125f, -0.223632812f, -0.18359375f, 0.197265625f, -0.194335938f, 0.244140625f, + -0.263671875f, -0.153320312f, 0.25390625f, -0.0270996094f, 0.241210938f, -0.166992188f, + 0.0732421875f, -0.223632812f, 0.0986328125f, 0.216796875f, 0.162109375f, -0.0385742188f, + -0.180664062f, -0.137695312f, -0.10546875f, -0.0727539062f, -0.251953125f, 0.243164062f, + -0.239257812f, -0.0510253906f, -0.09375f, 0.130859375f, -0.216796875f, -0.25f, + 0.0815429688f, 0.0805664062f, 0.172851562f, 0.0703125f, 0.122070312f, 0.100097656f, + -0.224609375f, 0.189453125f, 0.217773438f, -0.151367188f, -0.0568847656f, 0.0961914062f, + -0.151367188f, -0.0280761719f, -0.0844726562f, -0.259765625f, 0.140625f, -0.0600585938f, + 0.237304688f, -0.108398438f, -0.0593261719f, -0.0361328125f, 0.0573730469f, -0.201171875f, + -0.0251464844f, -0.0668945312f, -0.076171875f, 0.0192871094f, -0.1484375f, -0.166015625f, + -0.0123291016f, 0.180664062f, 0.194335938f, -0.170898438f, -0.0815429688f, -0.137695312f, + 0.0932617188f, 0.18359375f, 0.150390625f, 0.0456542969f, -0.0153808594f, -0.0869140625f, + -0.213867188f, -0.177734375f, -0.0708007812f, 0.1328125f, -0.204101562f, -0.159179688f, + -0.0150756836f, 0.237304688f, 0.0854492188f, -0.06640625f, 0.203125f, -0.247070312f, + 0.166992188f, -0.279296875f, -0.26953125f, -0.229492188f, 0.237304688f, 0.00230407715f, + 0.0363769531f, -0.190429688f, 0.176757812f, 0.076171875f, 0.259765625f, 0.16796875f, + 0.243164062f, -0.203125f, 0.220703125f, -0.116210938f, -0.0981445312f, -0.233398438f, + -0.265625f, 0.22265625f, -0.243164062f, 0.0737304688f, 0.00592041016f, -0.0291748047f, + -0.083984375f, -0.169921875f, -0.0397949219f, -0.182617188f, 0.1640625f, 0.0549316406f, + -0.111328125f, 0.265625f, -0.0756835938f, -0.196289062f, +}; + +inline constexpr float kLtxTowerPaddedStateBf16_1[] = { + -0.4296875f, 0.75f, 0.357421875f, -0.85546875f, 1.0234375f, -0.0737304688f, + -0.421875f, -1.984375f, 0.34375f, -1.21875f, -0.196289062f, -2.328125f, + -0.236328125f, -0.46484375f, 1.25f, -0.5234375f, 1.3984375f, -0.42578125f, + 0.9375f, -0.51953125f, 0.546875f, -0.44140625f, -0.0444335938f, -1.4296875f, + 0.984375f, -1.3828125f, -0.56640625f, 0.194335938f, -1.1015625f, -0.2265625f, + 0.3359375f, 0.59375f, -0.4296875f, 0.75f, 0.357421875f, -0.85546875f, + 1.0234375f, -0.0737304688f, -0.421875f, -1.984375f, 0.34375f, -1.21875f, + -0.196289062f, -2.328125f, -0.236328125f, -0.46484375f, 1.25f, -0.5234375f, + 1.3984375f, -0.42578125f, 0.9375f, -0.51953125f, 0.546875f, -0.44140625f, + -0.0444335938f, -1.4296875f, 0.984375f, -1.3828125f, -0.56640625f, 0.194335938f, + -1.1015625f, -0.2265625f, 0.3359375f, 0.59375f, -0.4296875f, 0.75f, + 0.357421875f, -0.85546875f, 1.0234375f, -0.0737304688f, -0.421875f, -1.984375f, + 0.34375f, -1.21875f, -0.196289062f, -2.328125f, -0.236328125f, -0.46484375f, + 1.25f, -0.5234375f, 1.3984375f, -0.42578125f, 0.9375f, -0.51953125f, + 0.546875f, -0.44140625f, -0.0444335938f, -1.4296875f, 0.984375f, -1.3828125f, + -0.56640625f, 0.194335938f, -1.1015625f, -0.2265625f, 0.3359375f, 0.59375f, + -0.4296875f, 0.75f, 0.357421875f, -0.85546875f, 1.0234375f, -0.0737304688f, + -0.421875f, -1.984375f, 0.34375f, -1.21875f, -0.196289062f, -2.328125f, + -0.236328125f, -0.46484375f, 1.25f, -0.5234375f, 1.3984375f, -0.42578125f, + 0.9375f, -0.51953125f, 0.546875f, -0.44140625f, -0.0444335938f, -1.4296875f, + 0.984375f, -1.3828125f, -0.56640625f, 0.194335938f, -1.1015625f, -0.2265625f, + 0.3359375f, 0.59375f, -0.4296875f, 0.75f, 0.357421875f, -0.85546875f, + 1.0234375f, -0.0737304688f, -0.421875f, -1.984375f, 0.34375f, -1.21875f, + -0.196289062f, -2.328125f, -0.236328125f, -0.46484375f, 1.25f, -0.5234375f, + 1.3984375f, -0.42578125f, 0.9375f, -0.51953125f, 0.546875f, -0.44140625f, + -0.0444335938f, -1.4296875f, 0.984375f, -1.3828125f, -0.56640625f, 0.194335938f, + -1.1015625f, -0.2265625f, 0.3359375f, 0.59375f, -0.4296875f, 0.75f, + 0.357421875f, -0.85546875f, 1.0234375f, -0.0737304688f, -0.421875f, -1.984375f, + 0.34375f, -1.21875f, -0.196289062f, -2.328125f, -0.236328125f, -0.46484375f, + 1.25f, -0.5234375f, 1.3984375f, -0.42578125f, 0.9375f, -0.51953125f, + 0.546875f, -0.44140625f, -0.0444335938f, -1.4296875f, 0.984375f, -1.3828125f, + -0.56640625f, 0.194335938f, -1.1015625f, -0.2265625f, 0.3359375f, 0.59375f, + -0.4296875f, 0.75f, 0.357421875f, -0.85546875f, 1.0234375f, -0.0737304688f, + -0.421875f, -1.984375f, 0.34375f, -1.21875f, -0.196289062f, -2.328125f, + -0.236328125f, -0.46484375f, 1.25f, -0.5234375f, 1.3984375f, -0.42578125f, + 0.9375f, -0.51953125f, 0.546875f, -0.44140625f, -0.0444335938f, -1.4296875f, + 0.984375f, -1.3828125f, -0.56640625f, 0.194335938f, -1.1015625f, -0.2265625f, + 0.3359375f, 0.59375f, -0.4296875f, 0.75f, 0.357421875f, -0.85546875f, + 1.0234375f, -0.0737304688f, -0.421875f, -1.984375f, 0.34375f, -1.21875f, + -0.196289062f, -2.328125f, -0.236328125f, -0.46484375f, 1.25f, -0.5234375f, + 1.3984375f, -0.42578125f, 0.9375f, -0.51953125f, 0.546875f, -0.44140625f, + -0.0444335938f, -1.4296875f, 0.984375f, -1.3828125f, -0.56640625f, 0.194335938f, + -1.1015625f, -0.2265625f, 0.3359375f, 0.59375f, -0.4296875f, 0.75f, + 0.357421875f, -0.85546875f, 1.0234375f, -0.0737304688f, -0.421875f, -1.984375f, + 0.34375f, -1.21875f, -0.196289062f, -2.328125f, -0.236328125f, -0.46484375f, + 1.25f, -0.5234375f, 1.3984375f, -0.42578125f, 0.9375f, -0.51953125f, + 0.546875f, -0.44140625f, -0.0444335938f, -1.4296875f, 0.984375f, -1.3828125f, + -0.56640625f, 0.194335938f, -1.1015625f, -0.2265625f, 0.3359375f, 0.59375f, + -0.4296875f, 0.75f, 0.357421875f, -0.85546875f, 1.0234375f, -0.0737304688f, + -0.421875f, -1.984375f, 0.34375f, -1.21875f, -0.196289062f, -2.328125f, + -0.236328125f, -0.46484375f, 1.25f, -0.5234375f, 1.3984375f, -0.42578125f, + 0.9375f, -0.51953125f, 0.546875f, -0.44140625f, -0.0444335938f, -1.4296875f, + 0.984375f, -1.3828125f, -0.56640625f, 0.194335938f, -1.1015625f, -0.2265625f, + 0.3359375f, 0.59375f, -0.4296875f, 0.75f, 0.357421875f, -0.85546875f, + 1.0234375f, -0.0737304688f, -0.421875f, -1.984375f, 0.34375f, -1.21875f, + -0.196289062f, -2.328125f, -0.236328125f, -0.46484375f, 1.25f, -0.5234375f, + 1.3984375f, -0.42578125f, 0.9375f, -0.51953125f, 0.546875f, -0.44140625f, + -0.0444335938f, -1.4296875f, 0.984375f, -1.3828125f, -0.56640625f, 0.194335938f, + -1.1015625f, -0.2265625f, 0.3359375f, 0.59375f, -0.4296875f, 0.75f, + 0.357421875f, -0.85546875f, 1.0234375f, -0.0737304688f, -0.421875f, -1.984375f, + 0.34375f, -1.21875f, -0.196289062f, -2.328125f, -0.236328125f, -0.46484375f, + 1.25f, -0.5234375f, 1.3984375f, -0.42578125f, 0.9375f, -0.51953125f, + 0.546875f, -0.44140625f, -0.0444335938f, -1.4296875f, 0.984375f, -1.3828125f, + -0.56640625f, 0.194335938f, -1.1015625f, -0.2265625f, 0.3359375f, 0.59375f, + -2.0f, -0.166015625f, -0.765625f, 1.03125f, 2.21875f, -0.23046875f, + 0.65234375f, 2.765625f, 0.671875f, -0.60546875f, -1.2578125f, 0.984375f, + 0.28515625f, -0.2734375f, 1.59375f, 0.0529785156f, 0.66796875f, -0.306640625f, + 2.328125f, 0.0302734375f, -1.7578125f, 0.423828125f, 2.796875f, -1.2578125f, + -1.5f, -1.046875f, 0.0991210938f, -2.375f, -0.2734375f, -1.0625f, + 1.3203125f, -0.279296875f, -0.314453125f, -1.25f, 1.5390625f, 1.1640625f, + -0.26953125f, -0.181640625f, 1.484375f, 2.40625f, 0.61328125f, -1.5703125f, + -0.80078125f, 1.4765625f, 1.671875f, -0.306640625f, 0.5078125f, -1.6015625f, + -1.171875f, -0.147460938f, 1.0703125f, -3.28125f, -1.2109375f, 0.984375f, + 1.140625f, -1.0625f, -3.21875f, -1.453125f, -0.439453125f, -0.71875f, + 1.046875f, 0.443359375f, -0.49609375f, 0.211914062f, -0.0227050781f, -2.84375f, + 1.2890625f, 0.78125f, -0.068359375f, 0.77734375f, -0.92578125f, 1.3359375f, + 0.63671875f, -0.466796875f, -0.447265625f, 0.21875f, 0.24609375f, -0.96875f, + 0.67578125f, -1.1015625f, 0.66796875f, -3.109375f, 1.328125f, -0.439453125f, + 1.953125f, 0.0255126953f, 3.46875f, -0.283203125f, -2.71875f, -1.5f, + 1.6015625f, -0.166015625f, -0.157226562f, -0.435546875f, 2.5f, 0.625f, + 1.484375f, -1.0078125f, 1.734375f, 0.65234375f, -0.63671875f, 0.11328125f, + -0.93359375f, -2.71875f, -1.2265625f, 3.015625f, -1.125f, 0.162109375f, + -0.33984375f, 2.546875f, 0.12890625f, 0.30078125f, -0.71484375f, -0.12890625f, + 2.0f, -1.2109375f, -0.12109375f, 0.46875f, -1.984375f, 1.15625f, + 0.5703125f, -1.0f, -0.7265625f, 0.119140625f, 0.66796875f, 2.25f, + 1.6484375f, 1.8125f, -1.6328125f, -1.1796875f, -0.3203125f, -0.211914062f, + -0.0302734375f, 0.11328125f, 0.62890625f, 2.34375f, 1.828125f, -0.76953125f, + -0.105957031f, 0.85546875f, 1.90625f, -1.46875f, -0.13671875f, -2.0625f, + -0.91015625f, -0.79296875f, -1.2109375f, -3.09375f, -1.5078125f, -0.3671875f, + -0.90625f, -0.294921875f, -1.3671875f, 1.3359375f, -0.56640625f, -1.2578125f, + 0.4765625f, -1.609375f, -0.294921875f, 0.609375f, 0.66015625f, 0.39453125f, + 0.703125f, 2.328125f, -0.80859375f, 1.28125f, -1.09375f, -0.09765625f, + 2.078125f, 3.34375f, -2.0f, 1.25f, 1.4453125f, -0.34375f, + -0.6484375f, 0.462890625f, -2.015625f, 0.0756835938f, 1.6015625f, -1.5078125f, + -0.703125f, 0.1171875f, -2.515625f, -0.263671875f, 1.6640625f, -0.4453125f, + 0.237304688f, -1.5859375f, 0.62109375f, 2.265625f, 0.141601562f, 1.7578125f, + 1.1484375f, -1.421875f, -1.453125f, -0.17578125f, 2.96875f, -0.63671875f, + -1.9140625f, 0.16796875f, -1.390625f, -2.421875f, 1.6953125f, -1.09375f, + 1.09375f, 2.03125f, -0.0908203125f, -1.3203125f, -1.1875f, -0.200195312f, + 0.96875f, 0.85546875f, 0.155273438f, -1.1484375f, 0.310546875f, -0.95703125f, + 0.546875f, 2.828125f, -0.49609375f, 0.26953125f, 0.953125f, 0.26953125f, + -1.109375f, 0.318359375f, 1.6015625f, 3.265625f, -0.515625f, 1.96875f, + 1.140625f, -0.4140625f, -1.03125f, -1.9375f, -1.78125f, 0.96875f, + 0.796875f, -1.8671875f, 0.215820312f, -0.0151367188f, -0.0246582031f, -0.65234375f, + -0.64453125f, 2.90625f, 0.74609375f, -0.5234375f, -1.0625f, -0.34375f, + -1.84375f, -0.458984375f, 0.2578125f, 1.640625f, 0.7890625f, 0.8359375f, + 0.94921875f, 2.09375f, 0.59765625f, -0.38671875f, +}; + +inline constexpr float kLtxTowerPaddedStateBf16_2[] = { + -0.79296875f, 1.78125f, 2.828125f, 0.3046875f, -2.203125f, -0.55859375f, + -1.4140625f, -2.5625f, 0.083984375f, -1.7265625f, -0.2265625f, -3.265625f, + -0.35546875f, 0.163085938f, 0.89453125f, -1.1875f, 2.6875f, -1.2890625f, + 1.203125f, 1.0546875f, 0.9765625f, 0.55859375f, 1.265625f, -1.53125f, + 0.93359375f, -2.3125f, -0.87890625f, 0.75f, -1.0390625f, 0.87890625f, + 1.515625f, -0.6640625f, -0.79296875f, 1.78125f, 2.828125f, 0.3046875f, + -2.203125f, -0.55859375f, -1.4140625f, -2.5625f, 0.083984375f, -1.7265625f, + -0.2265625f, -3.265625f, -0.35546875f, 0.163085938f, 0.89453125f, -1.1875f, + 2.6875f, -1.2890625f, 1.203125f, 1.0546875f, 0.9765625f, 0.55859375f, + 1.265625f, -1.53125f, 0.93359375f, -2.3125f, -0.87890625f, 0.75f, + -1.0390625f, 0.87890625f, 1.515625f, -0.6640625f, -0.79296875f, 1.78125f, + 2.828125f, 0.3046875f, -2.203125f, -0.55859375f, -1.4140625f, -2.5625f, + 0.083984375f, -1.7265625f, -0.2265625f, -3.265625f, -0.35546875f, 0.163085938f, + 0.89453125f, -1.1875f, 2.6875f, -1.2890625f, 1.203125f, 1.0546875f, + 0.9765625f, 0.55859375f, 1.265625f, -1.53125f, 0.93359375f, -2.3125f, + -0.87890625f, 0.75f, -1.0390625f, 0.87890625f, 1.515625f, -0.6640625f, + -0.79296875f, 1.78125f, 2.828125f, 0.3046875f, -2.203125f, -0.55859375f, + -1.4140625f, -2.5625f, 0.083984375f, -1.7265625f, -0.2265625f, -3.265625f, + -0.35546875f, 0.163085938f, 0.89453125f, -1.1875f, 2.6875f, -1.2890625f, + 1.203125f, 1.0546875f, 0.9765625f, 0.55859375f, 1.265625f, -1.53125f, + 0.93359375f, -2.3125f, -0.87890625f, 0.75f, -1.0390625f, 0.87890625f, + 1.515625f, -0.6640625f, -0.79296875f, 1.78125f, 2.828125f, 0.3046875f, + -2.203125f, -0.55859375f, -1.4140625f, -2.5625f, 0.083984375f, -1.7265625f, + -0.2265625f, -3.265625f, -0.35546875f, 0.163085938f, 0.89453125f, -1.1875f, + 2.6875f, -1.2890625f, 1.203125f, 1.0546875f, 0.9765625f, 0.55859375f, + 1.265625f, -1.53125f, 0.93359375f, -2.3125f, -0.87890625f, 0.75f, + -1.0390625f, 0.87890625f, 1.515625f, -0.6640625f, -0.79296875f, 1.78125f, + 2.828125f, 0.3046875f, -2.203125f, -0.55859375f, -1.4140625f, -2.5625f, + 0.083984375f, -1.7265625f, -0.2265625f, -3.265625f, -0.35546875f, 0.163085938f, + 0.89453125f, -1.1875f, 2.6875f, -1.2890625f, 1.203125f, 1.0546875f, + 0.9765625f, 0.55859375f, 1.265625f, -1.53125f, 0.93359375f, -2.3125f, + -0.87890625f, 0.75f, -1.0390625f, 0.87890625f, 1.515625f, -0.6640625f, + -0.79296875f, 1.78125f, 2.828125f, 0.3046875f, -2.203125f, -0.55859375f, + -1.4140625f, -2.5625f, 0.083984375f, -1.7265625f, -0.2265625f, -3.265625f, + -0.35546875f, 0.163085938f, 0.89453125f, -1.1875f, 2.6875f, -1.2890625f, + 1.203125f, 1.0546875f, 0.9765625f, 0.55859375f, 1.265625f, -1.53125f, + 0.93359375f, -2.3125f, -0.87890625f, 0.75f, -1.0390625f, 0.87890625f, + 1.515625f, -0.6640625f, -0.79296875f, 1.78125f, 2.828125f, 0.3046875f, + -2.203125f, -0.55859375f, -1.4140625f, -2.5625f, 0.083984375f, -1.7265625f, + -0.2265625f, -3.265625f, -0.35546875f, 0.163085938f, 0.89453125f, -1.1875f, + 2.6875f, -1.2890625f, 1.203125f, 1.0546875f, 0.9765625f, 0.55859375f, + 1.265625f, -1.53125f, 0.93359375f, -2.3125f, -0.87890625f, 0.75f, + -1.0390625f, 0.87890625f, 1.515625f, -0.6640625f, -0.79296875f, 1.78125f, + 2.828125f, 0.3046875f, -2.203125f, -0.55859375f, -1.4140625f, -2.5625f, + 0.083984375f, -1.7265625f, -0.2265625f, -3.265625f, -0.35546875f, 0.163085938f, + 0.89453125f, -1.1875f, 2.6875f, -1.2890625f, 1.203125f, 1.0546875f, + 0.9765625f, 0.55859375f, 1.265625f, -1.53125f, 0.93359375f, -2.3125f, + -0.87890625f, 0.75f, -1.0390625f, 0.87890625f, 1.515625f, -0.6640625f, + -0.79296875f, 1.78125f, 2.828125f, 0.3046875f, -2.203125f, -0.55859375f, + -1.4140625f, -2.5625f, 0.083984375f, -1.7265625f, -0.2265625f, -3.265625f, + -0.35546875f, 0.163085938f, 0.89453125f, -1.1875f, 2.6875f, -1.2890625f, + 1.203125f, 1.0546875f, 0.9765625f, 0.55859375f, 1.265625f, -1.53125f, + 0.93359375f, -2.3125f, -0.87890625f, 0.75f, -1.0390625f, 0.87890625f, + 1.515625f, -0.6640625f, -0.79296875f, 1.78125f, 2.828125f, 0.3046875f, + -2.203125f, -0.55859375f, -1.4140625f, -2.5625f, 0.083984375f, -1.7265625f, + -0.2265625f, -3.265625f, -0.35546875f, 0.163085938f, 0.89453125f, -1.1875f, + 2.6875f, -1.2890625f, 1.203125f, 1.0546875f, 0.9765625f, 0.55859375f, + 1.265625f, -1.53125f, 0.93359375f, -2.3125f, -0.87890625f, 0.75f, + -1.0390625f, 0.87890625f, 1.515625f, -0.6640625f, -0.79296875f, 1.78125f, + 2.828125f, 0.3046875f, -2.203125f, -0.55859375f, -1.4140625f, -2.5625f, + 0.083984375f, -1.7265625f, -0.2265625f, -3.265625f, -0.35546875f, 0.163085938f, + 0.89453125f, -1.1875f, 2.6875f, -1.2890625f, 1.203125f, 1.0546875f, + 0.9765625f, 0.55859375f, 1.265625f, -1.53125f, 0.93359375f, -2.3125f, + -0.87890625f, 0.75f, -1.0390625f, 0.87890625f, 1.515625f, -0.6640625f, + -3.375f, 1.390625f, -1.09375f, 0.408203125f, 2.109375f, 0.015625f, + -0.57421875f, 1.0078125f, 1.6640625f, -0.609375f, -2.921875f, 1.7890625f, + -2.203125f, -1.9765625f, 4.125f, 1.28125f, -1.078125f, 2.046875f, + 2.65625f, -1.03125f, -2.71875f, 0.34765625f, 2.765625f, -1.6171875f, + -0.4296875f, -1.546875f, -2.140625f, 0.6328125f, 1.3046875f, -2.203125f, + 1.53125f, 0.54296875f, -3.0625f, -1.3515625f, 2.078125f, 1.765625f, + -1.3046875f, -1.1875f, 1.34375f, 4.40625f, 2.8125f, 0.2578125f, + -2.0f, 0.98046875f, -0.828125f, 0.490234375f, 1.359375f, -2.0f, + -2.078125f, -0.170898438f, 1.5859375f, -5.0f, 0.267578125f, 0.66796875f, + 2.40625f, -1.84375f, -2.234375f, -1.7890625f, 0.515625f, 2.15625f, + 3.03125f, -0.12890625f, -0.765625f, -1.1328125f, -0.79296875f, -5.03125f, + 1.1796875f, 1.7109375f, 0.232421875f, 0.28125f, -3.609375f, 1.703125f, + 1.2890625f, -2.15625f, -2.078125f, -1.0234375f, -2.546875f, -3.828125f, + 0.73828125f, -1.03125f, -1.375f, -2.890625f, 2.78125f, -2.765625f, + 1.7265625f, 0.83984375f, 4.71875f, -1.4453125f, -1.2890625f, -0.7890625f, + 1.1796875f, 3.40625f, -0.171875f, -2.4375f, 2.40625f, 0.9765625f, + 0.322265625f, -0.193359375f, 3.34375f, -1.4375f, 1.875f, -2.171875f, + 0.490234375f, -4.5f, -0.8359375f, 0.6015625f, -1.515625f, -2.328125f, + -0.96484375f, 2.65625f, -0.59375f, 2.296875f, -0.95703125f, 1.2421875f, + -1.0234375f, -2.90625f, 0.0517578125f, 0.71484375f, -2.25f, 0.515625f, + -0.21484375f, 0.375f, -1.203125f, 0.0366210938f, 3.125f, 4.46875f, + 0.2578125f, 1.515625f, -1.1015625f, -3.265625f, -0.72265625f, 0.5234375f, + -0.25390625f, 0.5078125f, -0.247070312f, 4.0f, 3.40625f, 2.8125f, + 0.4296875f, 1.4453125f, 0.0172119141f, -1.75f, 1.2890625f, -4.875f, + -0.90234375f, -1.859375f, -0.146484375f, -3.578125f, 0.0991210938f, 0.2578125f, + -0.6171875f, -2.21875f, -2.171875f, 1.8046875f, 1.28125f, 1.21875f, + 0.0258789062f, -2.21875f, -2.3125f, -0.361328125f, 2.75f, -1.4296875f, + 2.171875f, 0.54296875f, 0.75390625f, 2.8125f, -1.6875f, -2.359375f, + 2.65625f, 2.78125f, -0.25f, 0.66796875f, 0.32421875f, 0.241210938f, + 0.2109375f, -0.671875f, -2.484375f, -1.015625f, 1.4765625f, -1.953125f, + 1.984375f, -1.2734375f, -2.21875f, -1.8515625f, 0.578125f, 2.375f, + 1.8515625f, -1.1796875f, -1.6875f, 3.125f, 0.180664062f, 3.6875f, + 3.234375f, -0.47265625f, -2.953125f, -1.2734375f, 2.34375f, -1.078125f, + -2.875f, -1.1015625f, -0.361328125f, -2.34375f, -0.25f, -0.74609375f, + -0.79296875f, 0.90234375f, 1.2890625f, 0.279296875f, -3.65625f, 2.203125f, + -0.275390625f, -1.1328125f, -2.5f, -2.328125f, 1.7734375f, -0.168945312f, + 2.640625f, 4.0625f, 0.0225830078f, 2.546875f, 2.515625f, 0.296875f, + -0.0172119141f, 0.25f, 2.9375f, 3.59375f, 0.81640625f, 1.3828125f, + 0.396484375f, -1.6015625f, -1.453125f, -4.0f, -5.5f, 0.4296875f, + -0.376953125f, -0.46484375f, 0.83203125f, 0.75390625f, 0.0571289062f, 0.55859375f, + -0.69140625f, 4.8125f, 0.122558594f, -3.171875f, -2.6875f, -2.046875f, + 2.46875f, 0.435546875f, 2.203125f, -0.96484375f, -0.98828125f, 0.58984375f, + 1.265625f, 2.15625f, 0.55859375f, 0.54296875f, +}; + +inline constexpr float kLtxTowerPaddedStateBf16_3[] = { + -0.3125f, 2.015625f, 2.65625f, 0.22265625f, -2.734375f, -0.85546875f, + -0.318359375f, -2.359375f, 0.08203125f, -0.63671875f, 0.98828125f, -3.953125f, + 0.88671875f, -0.255859375f, -2.390625f, -0.99609375f, 1.15625f, -1.75f, + 0.84375f, 0.6875f, 1.46875f, 0.859375f, 2.125f, -1.859375f, + 0.388671875f, -2.9375f, -0.380859375f, 1.0546875f, -1.8515625f, 0.474609375f, + -0.155273438f, -2.65625f, -0.3125f, 2.015625f, 2.65625f, 0.22265625f, + -2.734375f, -0.85546875f, -0.318359375f, -2.359375f, 0.08203125f, -0.63671875f, + 0.98828125f, -3.953125f, 0.88671875f, -0.255859375f, -2.390625f, -0.99609375f, + 1.15625f, -1.75f, 0.84375f, 0.6875f, 1.46875f, 0.859375f, + 2.125f, -1.859375f, 0.388671875f, -2.9375f, -0.380859375f, 1.0546875f, + -1.8515625f, 0.474609375f, -0.155273438f, -2.65625f, -0.3125f, 2.015625f, + 2.65625f, 0.22265625f, -2.734375f, -0.85546875f, -0.318359375f, -2.359375f, + 0.08203125f, -0.63671875f, 0.98828125f, -3.953125f, 0.88671875f, -0.255859375f, + -2.390625f, -0.99609375f, 1.15625f, -1.75f, 0.84375f, 0.6875f, + 1.46875f, 0.859375f, 2.125f, -1.859375f, 0.388671875f, -2.9375f, + -0.380859375f, 1.0546875f, -1.8515625f, 0.474609375f, -0.155273438f, -2.65625f, + -0.3125f, 2.015625f, 2.65625f, 0.22265625f, -2.734375f, -0.85546875f, + -0.318359375f, -2.359375f, 0.08203125f, -0.63671875f, 0.98828125f, -3.953125f, + 0.88671875f, -0.255859375f, -2.390625f, -0.99609375f, 1.15625f, -1.75f, + 0.84375f, 0.6875f, 1.46875f, 0.859375f, 2.125f, -1.859375f, + 0.388671875f, -2.9375f, -0.380859375f, 1.0546875f, -1.8515625f, 0.474609375f, + -0.155273438f, -2.65625f, -0.3125f, 2.015625f, 2.65625f, 0.22265625f, + -2.734375f, -0.85546875f, -0.318359375f, -2.359375f, 0.08203125f, -0.63671875f, + 0.98828125f, -3.953125f, 0.88671875f, -0.255859375f, -2.390625f, -0.99609375f, + 1.15625f, -1.75f, 0.84375f, 0.6875f, 1.46875f, 0.859375f, + 2.125f, -1.859375f, 0.388671875f, -2.9375f, -0.380859375f, 1.0546875f, + -1.8515625f, 0.474609375f, -0.155273438f, -2.65625f, -0.3125f, 2.015625f, + 2.65625f, 0.22265625f, -2.734375f, -0.85546875f, -0.318359375f, -2.359375f, + 0.08203125f, -0.63671875f, 0.98828125f, -3.953125f, 0.88671875f, -0.255859375f, + -2.390625f, -0.99609375f, 1.15625f, -1.75f, 0.84375f, 0.6875f, + 1.46875f, 0.859375f, 2.125f, -1.859375f, 0.388671875f, -2.9375f, + -0.380859375f, 1.0546875f, -1.8515625f, 0.474609375f, -0.155273438f, -2.65625f, + -0.3125f, 2.015625f, 2.65625f, 0.22265625f, -2.734375f, -0.85546875f, + -0.318359375f, -2.359375f, 0.08203125f, -0.63671875f, 0.98828125f, -3.953125f, + 0.88671875f, -0.255859375f, -2.390625f, -0.99609375f, 1.15625f, -1.75f, + 0.84375f, 0.6875f, 1.46875f, 0.859375f, 2.125f, -1.859375f, + 0.388671875f, -2.9375f, -0.380859375f, 1.0546875f, -1.8515625f, 0.474609375f, + -0.155273438f, -2.65625f, -0.3125f, 2.015625f, 2.65625f, 0.22265625f, + -2.734375f, -0.85546875f, -0.318359375f, -2.359375f, 0.08203125f, -0.63671875f, + 0.98828125f, -3.953125f, 0.88671875f, -0.255859375f, -2.390625f, -0.99609375f, + 1.15625f, -1.75f, 0.84375f, 0.6875f, 1.46875f, 0.859375f, + 2.125f, -1.859375f, 0.388671875f, -2.9375f, -0.380859375f, 1.0546875f, + -1.8515625f, 0.474609375f, -0.155273438f, -2.65625f, -0.3125f, 2.015625f, + 2.65625f, 0.22265625f, -2.734375f, -0.85546875f, -0.318359375f, -2.359375f, + 0.08203125f, -0.63671875f, 0.98828125f, -3.953125f, 0.88671875f, -0.255859375f, + -2.390625f, -0.99609375f, 1.15625f, -1.75f, 0.84375f, 0.6875f, + 1.46875f, 0.859375f, 2.125f, -1.859375f, 0.388671875f, -2.9375f, + -0.380859375f, 1.0546875f, -1.8515625f, 0.474609375f, -0.155273438f, -2.65625f, + -0.3125f, 2.015625f, 2.65625f, 0.22265625f, -2.734375f, -0.85546875f, + -0.318359375f, -2.359375f, 0.08203125f, -0.63671875f, 0.98828125f, -3.953125f, + 0.88671875f, -0.255859375f, -2.390625f, -0.99609375f, 1.15625f, -1.75f, + 0.84375f, 0.6875f, 1.46875f, 0.859375f, 2.125f, -1.859375f, + 0.388671875f, -2.9375f, -0.380859375f, 1.0546875f, -1.8515625f, 0.474609375f, + -0.155273438f, -2.65625f, -0.3125f, 2.015625f, 2.65625f, 0.22265625f, + -2.734375f, -0.85546875f, -0.318359375f, -2.359375f, 0.08203125f, -0.63671875f, + 0.98828125f, -3.953125f, 0.88671875f, -0.255859375f, -2.390625f, -0.99609375f, + 1.15625f, -1.75f, 0.84375f, 0.6875f, 1.46875f, 0.859375f, + 2.125f, -1.859375f, 0.388671875f, -2.9375f, -0.380859375f, 1.0546875f, + -1.8515625f, 0.474609375f, -0.155273438f, -2.65625f, -0.3125f, 2.015625f, + 2.65625f, 0.22265625f, -2.734375f, -0.85546875f, -0.318359375f, -2.359375f, + 0.08203125f, -0.63671875f, 0.98828125f, -3.953125f, 0.88671875f, -0.255859375f, + -2.390625f, -0.99609375f, 1.15625f, -1.75f, 0.84375f, 0.6875f, + 1.46875f, 0.859375f, 2.125f, -1.859375f, 0.388671875f, -2.9375f, + -0.380859375f, 1.0546875f, -1.8515625f, 0.474609375f, -0.155273438f, -2.65625f, + -4.6875f, 1.421875f, -1.265625f, 1.5390625f, 2.53125f, 2.65625f, + 1.453125f, 0.55859375f, -0.5078125f, 0.231445312f, -4.25f, 1.9453125f, + -4.8125f, -4.0625f, 3.9375f, 0.90234375f, 1.46875f, 4.5f, + 3.953125f, -1.9140625f, -3.03125f, 3.359375f, 4.40625f, -3.796875f, + 1.5078125f, -0.546875f, -4.25f, 0.89453125f, 2.8125f, -2.546875f, + -0.494140625f, 0.74609375f, -3.0f, -1.8515625f, 3.046875f, 2.359375f, + 0.384765625f, 0.80859375f, 2.875f, 2.421875f, 1.015625f, -1.109375f, + -3.5f, 1.5390625f, -2.28125f, -0.875f, 0.59375f, -1.4921875f, + 1.1796875f, 1.9609375f, 1.28125f, -4.625f, 0.53125f, 3.859375f, + 4.96875f, -3.15625f, -1.4921875f, -0.85546875f, -0.0776367188f, 1.75f, + 3.90625f, 0.498046875f, -2.328125f, -1.2734375f, -1.3125f, -6.96875f, + 2.71875f, 1.5625f, 1.921875f, 3.140625f, -2.6875f, -0.5078125f, + 0.0981445312f, -2.28125f, -2.21875f, 0.0654296875f, -3.640625f, -6.3125f, + -0.298828125f, -2.296875f, 1.265625f, -0.76953125f, 2.203125f, -4.40625f, + 2.640625f, 1.9140625f, 7.375f, -3.6875f, 0.8828125f, -0.249023438f, + 0.6796875f, 3.75f, 1.9140625f, -0.0163574219f, 1.5078125f, 1.6171875f, + 1.3515625f, 1.125f, 6.3125f, -2.203125f, 2.15625f, -0.5703125f, + 0.84765625f, -5.1875f, -3.140625f, 0.130859375f, -3.53125f, -2.6875f, + -2.59375f, 2.46875f, -1.25f, 0.41015625f, -0.147460938f, 1.953125f, + 0.3203125f, -3.28125f, 1.3125f, 1.4453125f, 1.3125f, -1.90625f, + -0.54296875f, -0.298828125f, -0.08984375f, 0.490234375f, 1.0859375f, 4.5625f, + 0.85546875f, 0.498046875f, 0.0510253906f, -3.1875f, -0.8046875f, 3.828125f, + -2.84375f, 0.83984375f, 1.359375f, 6.21875f, 2.1875f, 0.58203125f, + 2.109375f, 0.194335938f, 0.53125f, -0.365234375f, 0.76171875f, -5.0625f, + -2.984375f, -1.625f, 0.08203125f, -2.984375f, 2.671875f, -1.734375f, + 1.109375f, -0.482421875f, -3.96875f, 2.03125f, 1.8515625f, 0.294921875f, + -1.3359375f, -2.28125f, -0.77734375f, -0.33203125f, 5.4375f, -2.296875f, + -0.1796875f, 0.640625f, -2.109375f, 2.046875f, -1.4921875f, -0.00817871094f, + 3.390625f, 3.59375f, -0.0942382812f, 0.859375f, 1.578125f, 2.171875f, + -0.96484375f, -2.578125f, -3.046875f, -1.0703125f, 0.8046875f, -0.109863281f, + 4.15625f, -1.3828125f, 0.140625f, -0.369140625f, -1.8984375f, 3.640625f, + 2.8125f, 0.00817871094f, -1.2734375f, 3.234375f, -1.2890625f, 6.15625f, + 4.75f, -2.03125f, -3.484375f, -1.8984375f, 5.84375f, -1.1796875f, + -2.078125f, -4.625f, 0.99609375f, -3.140625f, 1.265625f, -2.53125f, + 1.828125f, 0.98828125f, 1.59375f, -1.1640625f, -4.25f, 3.28125f, + -1.828125f, -2.015625f, -4.0625f, -4.09375f, 4.5625f, -0.287109375f, + 1.359375f, 3.828125f, 0.78515625f, 2.203125f, 2.0625f, 0.64453125f, + 0.0981445312f, -2.140625f, 2.25f, 4.25f, 4.1875f, 0.90625f, + -0.45703125f, 0.08984375f, -2.328125f, -4.15625f, -7.28125f, -0.138671875f, + -1.0078125f, -3.015625f, -0.08203125f, 0.671875f, -1.125f, -1.6484375f, + -1.359375f, 6.375f, 0.95703125f, -2.21875f, -1.59375f, -1.3671875f, + 4.4375f, 0.0279541016f, 1.4921875f, -1.421875f, 0.00408935547f, 1.0078125f, + 0.77734375f, 4.8125f, 0.36328125f, 1.078125f, +}; + +inline constexpr float kLtxTowerPaddedStateBf16_4[] = { + 0.90625f, 2.421875f, 3.203125f, 1.375f, -1.625f, -0.5f, + 0.97265625f, -1.65625f, -1.390625f, -1.1875f, -0.0539550781f, -3.953125f, + 0.25390625f, 1.28125f, -2.46875f, -0.51171875f, 0.51171875f, -2.234375f, + 1.46875f, 0.201171875f, -0.28125f, 0.0290527344f, 3.203125f, -0.140625f, + 0.6328125f, -2.25f, -1.484375f, 0.44921875f, -2.03125f, -0.6328125f, + 0.44921875f, -3.53125f, 0.90625f, 2.421875f, 3.203125f, 1.375f, + -1.625f, -0.5f, 0.97265625f, -1.65625f, -1.390625f, -1.1875f, + -0.0539550781f, -3.953125f, 0.25390625f, 1.28125f, -2.46875f, -0.51171875f, + 0.51171875f, -2.234375f, 1.46875f, 0.201171875f, -0.28125f, 0.0290527344f, + 3.203125f, -0.140625f, 0.6328125f, -2.25f, -1.484375f, 0.44921875f, + -2.03125f, -0.6328125f, 0.44921875f, -3.53125f, 0.90625f, 2.421875f, + 3.203125f, 1.375f, -1.625f, -0.5f, 0.97265625f, -1.65625f, + -1.390625f, -1.1875f, -0.0539550781f, -3.953125f, 0.25390625f, 1.28125f, + -2.46875f, -0.51171875f, 0.51171875f, -2.234375f, 1.46875f, 0.201171875f, + -0.28125f, 0.0290527344f, 3.203125f, -0.140625f, 0.6328125f, -2.25f, + -1.484375f, 0.44921875f, -2.03125f, -0.6328125f, 0.44921875f, -3.53125f, + 0.90625f, 2.421875f, 3.203125f, 1.375f, -1.625f, -0.5f, + 0.97265625f, -1.65625f, -1.390625f, -1.1875f, -0.0539550781f, -3.953125f, + 0.25390625f, 1.28125f, -2.46875f, -0.51171875f, 0.51171875f, -2.234375f, + 1.46875f, 0.201171875f, -0.28125f, 0.0290527344f, 3.203125f, -0.140625f, + 0.6328125f, -2.25f, -1.484375f, 0.44921875f, -2.03125f, -0.6328125f, + 0.44921875f, -3.53125f, 0.90625f, 2.421875f, 3.203125f, 1.375f, + -1.625f, -0.5f, 0.97265625f, -1.65625f, -1.390625f, -1.1875f, + -0.0539550781f, -3.953125f, 0.25390625f, 1.28125f, -2.46875f, -0.51171875f, + 0.51171875f, -2.234375f, 1.46875f, 0.201171875f, -0.28125f, 0.0290527344f, + 3.203125f, -0.140625f, 0.6328125f, -2.25f, -1.484375f, 0.44921875f, + -2.03125f, -0.6328125f, 0.44921875f, -3.53125f, 0.90625f, 2.421875f, + 3.203125f, 1.375f, -1.625f, -0.5f, 0.97265625f, -1.65625f, + -1.390625f, -1.1875f, -0.0539550781f, -3.953125f, 0.25390625f, 1.28125f, + -2.46875f, -0.51171875f, 0.51171875f, -2.234375f, 1.46875f, 0.201171875f, + -0.28125f, 0.0290527344f, 3.203125f, -0.140625f, 0.6328125f, -2.25f, + -1.484375f, 0.44921875f, -2.03125f, -0.6328125f, 0.44921875f, -3.53125f, + 0.90625f, 2.421875f, 3.203125f, 1.375f, -1.625f, -0.5f, + 0.97265625f, -1.65625f, -1.390625f, -1.1875f, -0.0539550781f, -3.953125f, + 0.25390625f, 1.28125f, -2.46875f, -0.51171875f, 0.51171875f, -2.234375f, + 1.46875f, 0.201171875f, -0.28125f, 0.0290527344f, 3.203125f, -0.140625f, + 0.6328125f, -2.25f, -1.484375f, 0.44921875f, -2.03125f, -0.6328125f, + 0.44921875f, -3.53125f, 0.90625f, 2.421875f, 3.203125f, 1.375f, + -1.625f, -0.5f, 0.97265625f, -1.65625f, -1.390625f, -1.1875f, + -0.0539550781f, -3.953125f, 0.25390625f, 1.28125f, -2.46875f, -0.51171875f, + 0.51171875f, -2.234375f, 1.46875f, 0.201171875f, -0.28125f, 0.0290527344f, + 3.203125f, -0.140625f, 0.6328125f, -2.25f, -1.484375f, 0.44921875f, + -2.03125f, -0.6328125f, 0.44921875f, -3.53125f, 0.90625f, 2.421875f, + 3.203125f, 1.375f, -1.625f, -0.5f, 0.97265625f, -1.65625f, + -1.390625f, -1.1875f, -0.0539550781f, -3.953125f, 0.25390625f, 1.28125f, + -2.46875f, -0.51171875f, 0.51171875f, -2.234375f, 1.46875f, 0.201171875f, + -0.28125f, 0.0290527344f, 3.203125f, -0.140625f, 0.6328125f, -2.25f, + -1.484375f, 0.44921875f, -2.03125f, -0.6328125f, 0.44921875f, -3.53125f, + 0.90625f, 2.421875f, 3.203125f, 1.375f, -1.625f, -0.5f, + 0.97265625f, -1.65625f, -1.390625f, -1.1875f, -0.0539550781f, -3.953125f, + 0.25390625f, 1.28125f, -2.46875f, -0.51171875f, 0.51171875f, -2.234375f, + 1.46875f, 0.201171875f, -0.28125f, 0.0290527344f, 3.203125f, -0.140625f, + 0.6328125f, -2.25f, -1.484375f, 0.44921875f, -2.03125f, -0.6328125f, + 0.44921875f, -3.53125f, 0.90625f, 2.421875f, 3.203125f, 1.375f, + -1.625f, -0.5f, 0.97265625f, -1.65625f, -1.390625f, -1.1875f, + -0.0539550781f, -3.953125f, 0.25390625f, 1.28125f, -2.46875f, -0.51171875f, + 0.51171875f, -2.234375f, 1.46875f, 0.201171875f, -0.28125f, 0.0290527344f, + 3.203125f, -0.140625f, 0.6328125f, -2.25f, -1.484375f, 0.44921875f, + -2.03125f, -0.6328125f, 0.44921875f, -3.53125f, 0.90625f, 2.421875f, + 3.203125f, 1.375f, -1.625f, -0.5f, 0.97265625f, -1.65625f, + -1.390625f, -1.1875f, -0.0539550781f, -3.953125f, 0.25390625f, 1.28125f, + -2.46875f, -0.51171875f, 0.51171875f, -2.234375f, 1.46875f, 0.201171875f, + -0.28125f, 0.0290527344f, 3.203125f, -0.140625f, 0.6328125f, -2.25f, + -1.484375f, 0.44921875f, -2.03125f, -0.6328125f, 0.44921875f, -3.53125f, + -7.125f, 1.1171875f, 0.231445312f, 3.9375f, 2.015625f, 4.75f, + 1.7109375f, 0.46484375f, 0.171875f, 2.25f, -4.84375f, 2.96875f, + -5.78125f, -6.21875f, 1.3125f, 2.09375f, 4.09375f, 3.125f, + 3.140625f, -0.6640625f, -3.59375f, 5.15625f, 3.21875f, -4.90625f, + 0.5625f, -2.109375f, -1.6796875f, 2.765625f, 5.84375f, -0.9609375f, + -0.765625f, 0.91796875f, -5.5f, -0.83984375f, 5.75f, 2.890625f, + -0.73046875f, 3.96875f, 2.59375f, 2.828125f, 1.796875f, 0.51171875f, + -4.9375f, 1.4921875f, -4.09375f, -1.84375f, -0.29296875f, 0.423828125f, + 1.7265625f, 0.224609375f, -0.1640625f, -2.75f, 2.625f, 7.8125f, + 6.25f, -3.8125f, -0.32421875f, -2.640625f, 1.59375f, 4.15625f, + 4.875f, 1.5078125f, -2.546875f, -1.640625f, -2.8125f, -8.0625f, + 4.125f, 2.671875f, 0.099609375f, 5.65625f, -3.65625f, -0.114257812f, + 2.5625f, -1.703125f, -4.1875f, 1.015625f, -3.671875f, -7.5f, + -0.76953125f, -1.5703125f, 0.515625f, -1.7421875f, 1.265625f, -2.375f, + 2.78125f, 4.03125f, 7.25f, -5.28125f, 0.2734375f, -0.298828125f, + 0.423828125f, 5.0625f, 3.390625f, -0.40625f, 2.890625f, 2.078125f, + -0.5234375f, 3.0625f, 7.78125f, -0.578125f, 3.71875f, -0.40625f, + 1.6015625f, -3.546875f, -3.71875f, -0.8359375f, -5.0f, -2.65625f, + -3.0625f, 3.65625f, -3.1875f, 0.796875f, 0.16796875f, 1.6484375f, + 1.078125f, -2.015625f, 1.875f, 3.59375f, -0.0290527344f, -4.28125f, + 0.234375f, -1.5546875f, 0.0776367188f, 2.390625f, 1.46875f, 3.765625f, + 1.5078125f, 0.35546875f, -2.34375f, -2.921875f, -0.0388183594f, 2.921875f, + -2.859375f, 4.125f, 0.55859375f, 7.0f, 3.359375f, 0.435546875f, + 0.91796875f, -0.00830078125f, -1.6796875f, 0.306640625f, 2.25f, -4.78125f, + -1.7578125f, -3.515625f, -1.4921875f, -1.9765625f, 3.1875f, 1.96875f, + 1.734375f, -0.029296875f, -3.28125f, 0.0456542969f, 1.953125f, -0.20703125f, + -1.65625f, -1.4609375f, -1.4375f, -0.0290527344f, 3.65625f, -2.046875f, + -1.3515625f, -1.859375f, -0.828125f, 4.75f, -2.453125f, -0.099609375f, + 4.1875f, 3.453125f, -0.87890625f, 2.53125f, 2.5625f, 2.015625f, + 0.86328125f, -1.0390625f, -2.328125f, -4.5f, -0.16015625f, -2.25f, + 4.5625f, 2.5625f, -0.8125f, -0.62109375f, -0.83984375f, 1.4921875f, + 3.6875f, 2.625f, -1.203125f, 3.78125f, -4.03125f, 6.375f, + 4.59375f, -2.3125f, -4.40625f, -1.328125f, 8.5f, 0.9140625f, + -2.609375f, -4.21875f, -0.84765625f, -2.5625f, 0.671875f, -3.625f, + 4.28125f, -0.58984375f, -0.122070312f, 1.4765625f, -1.921875f, 4.1875f, + -3.984375f, -1.9453125f, -7.40625f, -4.03125f, 3.15625f, -0.78515625f, + 3.0625f, 2.109375f, 1.328125f, 4.28125f, 3.0625f, 0.92578125f, + 0.84765625f, -2.84375f, 1.40625f, 6.75f, 6.0f, 3.21875f, + 0.5625f, 1.265625f, -1.859375f, -3.625f, -8.4375f, -0.53125f, + -2.4375f, -1.0390625f, -0.306640625f, 0.9375f, -1.078125f, -2.421875f, + 0.88671875f, 5.28125f, 1.828125f, -2.03125f, -2.625f, 1.28125f, + 3.890625f, -2.140625f, 2.125f, -3.078125f, -0.231445312f, 1.9453125f, + 0.921875f, 5.25f, 0.9609375f, 0.3125f, +}; + +inline constexpr float kLtxTowerPaddedStateBf16_5[] = { + 1.0859375f, 1.7265625f, 2.296875f, 0.91796875f, -1.828125f, -0.609375f, + 0.7109375f, -2.765625f, -1.234375f, -2.0625f, 0.8984375f, -4.46875f, + -0.0437011719f, -0.326171875f, -2.234375f, 1.078125f, 1.234375f, -2.75f, + 1.09375f, -0.5625f, 0.2734375f, -1.1796875f, 2.890625f, -1.578125f, + 0.0476074219f, -2.3125f, -3.265625f, 1.1953125f, 0.126953125f, -0.204101562f, + 2.390625f, -2.984375f, 1.0859375f, 1.7265625f, 2.296875f, 0.91796875f, + -1.828125f, -0.609375f, 0.7109375f, -2.765625f, -1.234375f, -2.0625f, + 0.8984375f, -4.46875f, -0.0437011719f, -0.326171875f, -2.234375f, 1.078125f, + 1.234375f, -2.75f, 1.09375f, -0.5625f, 0.2734375f, -1.1796875f, + 2.890625f, -1.578125f, 0.0476074219f, -2.3125f, -3.265625f, 1.1953125f, + 0.126953125f, -0.204101562f, 2.390625f, -2.984375f, 1.0859375f, 1.7265625f, + 2.296875f, 0.91796875f, -1.828125f, -0.609375f, 0.7109375f, -2.765625f, + -1.234375f, -2.0625f, 0.8984375f, -4.46875f, -0.0437011719f, -0.326171875f, + -2.234375f, 1.078125f, 1.234375f, -2.75f, 1.09375f, -0.5625f, + 0.2734375f, -1.1796875f, 2.890625f, -1.578125f, 0.0476074219f, -2.3125f, + -3.265625f, 1.1953125f, 0.126953125f, -0.204101562f, 2.390625f, -2.984375f, + 1.0859375f, 1.7265625f, 2.296875f, 0.91796875f, -1.828125f, -0.609375f, + 0.7109375f, -2.765625f, -1.234375f, -2.0625f, 0.8984375f, -4.46875f, + -0.0437011719f, -0.326171875f, -2.234375f, 1.078125f, 1.234375f, -2.75f, + 1.09375f, -0.5625f, 0.2734375f, -1.1796875f, 2.890625f, -1.578125f, + 0.0476074219f, -2.3125f, -3.265625f, 1.1953125f, 0.126953125f, -0.204101562f, + 2.390625f, -2.984375f, 1.0859375f, 1.7265625f, 2.296875f, 0.91796875f, + -1.828125f, -0.609375f, 0.7109375f, -2.765625f, -1.234375f, -2.0625f, + 0.8984375f, -4.46875f, -0.0437011719f, -0.326171875f, -2.234375f, 1.078125f, + 1.234375f, -2.75f, 1.09375f, -0.5625f, 0.2734375f, -1.1796875f, + 2.890625f, -1.578125f, 0.0476074219f, -2.3125f, -3.265625f, 1.1953125f, + 0.126953125f, -0.204101562f, 2.390625f, -2.984375f, 1.0859375f, 1.7265625f, + 2.296875f, 0.91796875f, -1.828125f, -0.609375f, 0.7109375f, -2.765625f, + -1.234375f, -2.0625f, 0.8984375f, -4.46875f, -0.0437011719f, -0.326171875f, + -2.234375f, 1.078125f, 1.234375f, -2.75f, 1.09375f, -0.5625f, + 0.2734375f, -1.1796875f, 2.890625f, -1.578125f, 0.0476074219f, -2.3125f, + -3.265625f, 1.1953125f, 0.126953125f, -0.204101562f, 2.390625f, -2.984375f, + 1.0859375f, 1.7265625f, 2.296875f, 0.91796875f, -1.828125f, -0.609375f, + 0.7109375f, -2.765625f, -1.234375f, -2.0625f, 0.8984375f, -4.46875f, + -0.0437011719f, -0.326171875f, -2.234375f, 1.078125f, 1.234375f, -2.75f, + 1.09375f, -0.5625f, 0.2734375f, -1.1796875f, 2.890625f, -1.578125f, + 0.0476074219f, -2.3125f, -3.265625f, 1.1953125f, 0.126953125f, -0.204101562f, + 2.390625f, -2.984375f, 1.0859375f, 1.7265625f, 2.296875f, 0.91796875f, + -1.828125f, -0.609375f, 0.7109375f, -2.765625f, -1.234375f, -2.0625f, + 0.8984375f, -4.46875f, -0.0437011719f, -0.326171875f, -2.234375f, 1.078125f, + 1.234375f, -2.75f, 1.09375f, -0.5625f, 0.2734375f, -1.1796875f, + 2.890625f, -1.578125f, 0.0476074219f, -2.3125f, -3.265625f, 1.1953125f, + 0.126953125f, -0.204101562f, 2.390625f, -2.984375f, 1.0859375f, 1.7265625f, + 2.296875f, 0.91796875f, -1.828125f, -0.609375f, 0.7109375f, -2.765625f, + -1.234375f, -2.0625f, 0.8984375f, -4.46875f, -0.0437011719f, -0.326171875f, + -2.234375f, 1.078125f, 1.234375f, -2.75f, 1.09375f, -0.5625f, + 0.2734375f, -1.1796875f, 2.890625f, -1.578125f, 0.0476074219f, -2.3125f, + -3.265625f, 1.1953125f, 0.126953125f, -0.204101562f, 2.390625f, -2.984375f, + 1.0859375f, 1.7265625f, 2.296875f, 0.91796875f, -1.828125f, -0.609375f, + 0.7109375f, -2.765625f, -1.234375f, -2.0625f, 0.8984375f, -4.46875f, + -0.0437011719f, -0.326171875f, -2.234375f, 1.078125f, 1.234375f, -2.75f, + 1.09375f, -0.5625f, 0.2734375f, -1.1796875f, 2.890625f, -1.578125f, + 0.0476074219f, -2.3125f, -3.265625f, 1.1953125f, 0.126953125f, -0.204101562f, + 2.390625f, -2.984375f, 1.0859375f, 1.7265625f, 2.296875f, 0.91796875f, + -1.828125f, -0.609375f, 0.7109375f, -2.765625f, -1.234375f, -2.0625f, + 0.8984375f, -4.46875f, -0.0437011719f, -0.326171875f, -2.234375f, 1.078125f, + 1.234375f, -2.75f, 1.09375f, -0.5625f, 0.2734375f, -1.1796875f, + 2.890625f, -1.578125f, 0.0476074219f, -2.3125f, -3.265625f, 1.1953125f, + 0.126953125f, -0.204101562f, 2.390625f, -2.984375f, 1.0859375f, 1.7265625f, + 2.296875f, 0.91796875f, -1.828125f, -0.609375f, 0.7109375f, -2.765625f, + -1.234375f, -2.0625f, 0.8984375f, -4.46875f, -0.0437011719f, -0.326171875f, + -2.234375f, 1.078125f, 1.234375f, -2.75f, 1.09375f, -0.5625f, + 0.2734375f, -1.1796875f, 2.890625f, -1.578125f, 0.0476074219f, -2.3125f, + -3.265625f, 1.1953125f, 0.126953125f, -0.204101562f, 2.390625f, -2.984375f, + -6.625f, 0.27734375f, 2.6875f, 1.796875f, -0.6328125f, 5.0f, + 2.9375f, -3.078125f, -0.72265625f, 1.0390625f, -3.65625f, 1.3203125f, + -7.3125f, -4.90625f, 0.37890625f, 1.1875f, 4.75f, 3.359375f, + 3.0625f, -2.953125f, -5.15625f, 6.625f, 2.5625f, -5.75f, + -0.202148438f, -1.8671875f, 0.219726562f, 3.09375f, 6.71875f, -1.25f, + -1.203125f, 2.890625f, -4.34375f, -1.1015625f, 7.75f, 1.4296875f, + -2.109375f, 5.4375f, 1.546875f, 0.96484375f, 0.326171875f, 1.40625f, + -3.9375f, 0.6640625f, -2.828125f, -2.5f, -1.09375f, 1.15625f, + 4.40625f, 0.0437011719f, -2.03125f, -2.890625f, 1.703125f, 9.0f, + 5.5f, -5.34375f, -0.302734375f, -2.03125f, 5.25f, 3.421875f, + 6.78125f, 0.29296875f, -2.921875f, -0.369140625f, -1.296875f, -9.3125f, + 3.359375f, 1.21875f, -2.15625f, 6.28125f, -1.421875f, -2.359375f, + 2.5f, -1.984375f, -2.609375f, -0.194335938f, -5.0625f, -8.375f, + -0.5546875f, -1.75f, 2.296875f, -1.078125f, 0.9609375f, -3.828125f, + 0.578125f, 4.03125f, 6.90625f, -6.78125f, 2.484375f, 0.6015625f, + 3.609375f, 6.125f, 3.65625f, -0.71484375f, 1.7421875f, 3.46875f, + 0.50390625f, 1.9296875f, 7.25f, -0.515625f, 4.8125f, -0.3515625f, + 0.82421875f, -4.3125f, -5.125f, -3.421875f, -3.234375f, -4.03125f, + -3.5f, 2.859375f, -1.890625f, 1.984375f, 2.765625f, 1.78125f, + 0.392578125f, -2.453125f, 0.103027344f, 4.625f, -0.890625f, -7.03125f, + 2.828125f, 0.28515625f, 0.73046875f, 3.953125f, 1.953125f, 4.46875f, + -0.5390625f, 3.71875f, -2.859375f, -4.1875f, 0.26171875f, 4.6875f, + -2.265625f, 5.75f, 0.2265625f, 3.328125f, 4.125f, -0.546875f, + 1.984375f, -1.625f, -3.0625f, -0.149414062f, 1.046875f, -5.8125f, + 1.6953125f, -5.0625f, -3.171875f, -1.3203125f, 3.796875f, 3.71875f, + 1.203125f, -2.953125f, -2.84375f, -1.1015625f, 6.0625f, -1.15625f, + -2.53125f, -0.96484375f, -1.859375f, 2.109375f, 3.234375f, -1.7890625f, + 1.359375f, 0.0991210938f, -1.7578125f, 6.5f, -2.015625f, -0.7109375f, + 5.0f, 6.84375f, 1.859375f, 3.453125f, 2.640625f, 1.046875f, + -2.046875f, -0.73046875f, -1.4140625f, -4.5625f, -1.5546875f, -1.5703125f, + 4.40625f, 2.78125f, -0.703125f, -1.6015625f, -0.5859375f, 3.59375f, + 6.75f, 2.921875f, -1.0234375f, 1.9375f, -2.84375f, 8.0f, + 5.875f, -4.75f, -3.453125f, -0.255859375f, 9.8125f, 2.703125f, + -3.9375f, -2.65625f, -1.765625f, -1.7109375f, 1.9375f, -2.921875f, + 2.03125f, 0.0834960938f, 0.0556640625f, 1.5078125f, -1.7578125f, 5.0625f, + -6.03125f, -2.703125f, -7.25f, -3.84375f, 4.34375f, -3.140625f, + 4.375f, 4.96875f, 3.203125f, 5.0625f, 0.74609375f, 2.375f, + 0.9921875f, -1.765625f, 0.640625f, 6.1875f, 5.21875f, 4.875f, + -1.203125f, 2.09375f, -2.15625f, -2.609375f, -7.46875f, 1.1015625f, + -1.2265625f, -0.0317382812f, -2.125f, 0.5078125f, -2.46875f, -2.234375f, + 2.234375f, 2.296875f, 2.453125f, -2.359375f, -2.8125f, 0.341796875f, + 4.59375f, -1.5234375f, 4.46875f, -2.640625f, -0.5234375f, 0.0395507812f, + 0.27734375f, 6.8125f, 1.90625f, -0.0991210938f, +}; + +inline constexpr float kLtxTowerPaddedStateBf16_6[] = { + 1.4140625f, 1.859375f, 0.640625f, 2.328125f, -2.390625f, -0.63671875f, + -0.5625f, -3.6875f, 0.2578125f, -1.5625f, -0.99609375f, -4.625f, + 0.100585938f, -0.6796875f, -0.8046875f, -0.166015625f, 0.80859375f, -2.53125f, + 2.546875f, -0.341796875f, 0.34375f, -1.984375f, 3.203125f, -1.65625f, + 2.28125f, -1.890625f, -3.984375f, 2.25f, -0.1953125f, 1.0546875f, + 3.890625f, -1.3359375f, 1.4140625f, 1.859375f, 0.640625f, 2.328125f, + -2.390625f, -0.63671875f, -0.5625f, -3.6875f, 0.2578125f, -1.5625f, + -0.99609375f, -4.625f, 0.100585938f, -0.6796875f, -0.8046875f, -0.166015625f, + 0.80859375f, -2.53125f, 2.546875f, -0.341796875f, 0.34375f, -1.984375f, + 3.203125f, -1.65625f, 2.28125f, -1.890625f, -3.984375f, 2.25f, + -0.1953125f, 1.0546875f, 3.890625f, -1.3359375f, 1.4140625f, 1.859375f, + 0.640625f, 2.328125f, -2.390625f, -0.63671875f, -0.5625f, -3.6875f, + 0.2578125f, -1.5625f, -0.99609375f, -4.625f, 0.100585938f, -0.6796875f, + -0.8046875f, -0.166015625f, 0.80859375f, -2.53125f, 2.546875f, -0.341796875f, + 0.34375f, -1.984375f, 3.203125f, -1.65625f, 2.28125f, -1.890625f, + -3.984375f, 2.25f, -0.1953125f, 1.0546875f, 3.890625f, -1.3359375f, + 1.4140625f, 1.859375f, 0.640625f, 2.328125f, -2.390625f, -0.63671875f, + -0.5625f, -3.6875f, 0.2578125f, -1.5625f, -0.99609375f, -4.625f, + 0.100585938f, -0.6796875f, -0.8046875f, -0.166015625f, 0.80859375f, -2.53125f, + 2.546875f, -0.341796875f, 0.34375f, -1.984375f, 3.203125f, -1.65625f, + 2.28125f, -1.890625f, -3.984375f, 2.25f, -0.1953125f, 1.0546875f, + 3.890625f, -1.3359375f, 1.4140625f, 1.859375f, 0.640625f, 2.328125f, + -2.390625f, -0.63671875f, -0.5625f, -3.6875f, 0.2578125f, -1.5625f, + -0.99609375f, -4.625f, 0.100585938f, -0.6796875f, -0.8046875f, -0.166015625f, + 0.80859375f, -2.53125f, 2.546875f, -0.341796875f, 0.34375f, -1.984375f, + 3.203125f, -1.65625f, 2.28125f, -1.890625f, -3.984375f, 2.25f, + -0.1953125f, 1.0546875f, 3.890625f, -1.3359375f, 1.4140625f, 1.859375f, + 0.640625f, 2.328125f, -2.390625f, -0.63671875f, -0.5625f, -3.6875f, + 0.2578125f, -1.5625f, -0.99609375f, -4.625f, 0.100585938f, -0.6796875f, + -0.8046875f, -0.166015625f, 0.80859375f, -2.53125f, 2.546875f, -0.341796875f, + 0.34375f, -1.984375f, 3.203125f, -1.65625f, 2.28125f, -1.890625f, + -3.984375f, 2.25f, -0.1953125f, 1.0546875f, 3.890625f, -1.3359375f, + 1.4140625f, 1.859375f, 0.640625f, 2.328125f, -2.390625f, -0.63671875f, + -0.5625f, -3.6875f, 0.2578125f, -1.5625f, -0.99609375f, -4.625f, + 0.100585938f, -0.6796875f, -0.8046875f, -0.166015625f, 0.80859375f, -2.53125f, + 2.546875f, -0.341796875f, 0.34375f, -1.984375f, 3.203125f, -1.65625f, + 2.28125f, -1.890625f, -3.984375f, 2.25f, -0.1953125f, 1.0546875f, + 3.890625f, -1.3359375f, 1.4140625f, 1.859375f, 0.640625f, 2.328125f, + -2.390625f, -0.63671875f, -0.5625f, -3.6875f, 0.2578125f, -1.5625f, + -0.99609375f, -4.625f, 0.100585938f, -0.6796875f, -0.8046875f, -0.166015625f, + 0.80859375f, -2.53125f, 2.546875f, -0.341796875f, 0.34375f, -1.984375f, + 3.203125f, -1.65625f, 2.28125f, -1.890625f, -3.984375f, 2.25f, + -0.1953125f, 1.0546875f, 3.890625f, -1.3359375f, 1.4140625f, 1.859375f, + 0.640625f, 2.328125f, -2.390625f, -0.63671875f, -0.5625f, -3.6875f, + 0.2578125f, -1.5625f, -0.99609375f, -4.625f, 0.100585938f, -0.6796875f, + -0.8046875f, -0.166015625f, 0.80859375f, -2.53125f, 2.546875f, -0.341796875f, + 0.34375f, -1.984375f, 3.203125f, -1.65625f, 2.28125f, -1.890625f, + -3.984375f, 2.25f, -0.1953125f, 1.0546875f, 3.890625f, -1.3359375f, + 1.4140625f, 1.859375f, 0.640625f, 2.328125f, -2.390625f, -0.63671875f, + -0.5625f, -3.6875f, 0.2578125f, -1.5625f, -0.99609375f, -4.625f, + 0.100585938f, -0.6796875f, -0.8046875f, -0.166015625f, 0.80859375f, -2.53125f, + 2.546875f, -0.341796875f, 0.34375f, -1.984375f, 3.203125f, -1.65625f, + 2.28125f, -1.890625f, -3.984375f, 2.25f, -0.1953125f, 1.0546875f, + 3.890625f, -1.3359375f, 1.4140625f, 1.859375f, 0.640625f, 2.328125f, + -2.390625f, -0.63671875f, -0.5625f, -3.6875f, 0.2578125f, -1.5625f, + -0.99609375f, -4.625f, 0.100585938f, -0.6796875f, -0.8046875f, -0.166015625f, + 0.80859375f, -2.53125f, 2.546875f, -0.341796875f, 0.34375f, -1.984375f, + 3.203125f, -1.65625f, 2.28125f, -1.890625f, -3.984375f, 2.25f, + -0.1953125f, 1.0546875f, 3.890625f, -1.3359375f, 1.4140625f, 1.859375f, + 0.640625f, 2.328125f, -2.390625f, -0.63671875f, -0.5625f, -3.6875f, + 0.2578125f, -1.5625f, -0.99609375f, -4.625f, 0.100585938f, -0.6796875f, + -0.8046875f, -0.166015625f, 0.80859375f, -2.53125f, 2.546875f, -0.341796875f, + 0.34375f, -1.984375f, 3.203125f, -1.65625f, 2.28125f, -1.890625f, + -3.984375f, 2.25f, -0.1953125f, 1.0546875f, 3.890625f, -1.3359375f, + -7.59375f, -0.9296875f, 2.296875f, 3.234375f, -0.5078125f, 6.375f, + 4.4375f, -5.8125f, 2.109375f, 2.1875f, -2.84375f, 1.359375f, + -9.1875f, -3.796875f, 1.6171875f, -2.203125f, 4.0625f, 2.109375f, + 2.109375f, -4.6875f, -6.3125f, 6.3125f, 3.15625f, -5.75f, + 1.3828125f, -1.078125f, -0.98046875f, 4.5625f, 7.4375f, -0.93359375f, + -0.6640625f, 1.828125f, -4.84375f, -2.453125f, 9.4375f, 1.953125f, + -3.25f, 8.3125f, 0.9140625f, 1.328125f, 1.234375f, 1.359375f, + -3.75f, 1.390625f, -3.109375f, -0.232421875f, 0.3828125f, -0.5f, + 4.875f, -0.431640625f, -2.390625f, -3.3125f, 0.703125f, 7.90625f, + 6.28125f, -3.921875f, 3.375f, 1.8515625f, 5.375f, 3.265625f, + 6.875f, 2.109375f, -3.796875f, -2.0625f, -2.078125f, -12.5625f, + 3.59375f, 1.6875f, -3.0625f, 8.9375f, 0.46484375f, -3.984375f, + 3.359375f, -1.90625f, -2.3125f, 0.201171875f, -4.78125f, -5.25f, + 0.75f, -2.703125f, 2.0f, -0.61328125f, 0.38671875f, -3.6875f, + 0.6640625f, 2.9375f, 6.4375f, -8.5625f, 4.40625f, 2.15625f, + 3.96875f, 6.71875f, 3.25f, -0.224609375f, 1.5390625f, 3.625f, + 2.5625f, 4.03125f, 9.75f, -0.0311279297f, 7.09375f, 0.6796875f, + 0.6328125f, -6.90625f, -5.125f, -5.0f, -3.71875f, -4.0625f, + -2.359375f, 1.21875f, -1.8671875f, 0.7578125f, 2.4375f, 2.078125f, + 0.5390625f, -0.47265625f, -0.188476562f, 2.75f, 0.27734375f, -10.6875f, + 8.1875f, -0.0249023438f, 1.5390625f, 5.3125f, 0.87109375f, 5.09375f, + -0.66015625f, 4.46875f, -3.390625f, -5.0625f, 0.033203125f, 6.34375f, + -0.58203125f, 7.9375f, 1.4921875f, 2.21875f, 7.4375f, -1.2421875f, + 1.390625f, -3.125f, -2.890625f, 1.6875f, 2.75f, -9.1875f, + 1.109375f, -6.8125f, -1.6796875f, -1.765625f, 2.828125f, 3.71875f, + -0.796875f, -3.0625f, -3.125f, 0.9375f, 5.0625f, 0.215820312f, + -1.859375f, -0.5625f, -4.71875f, 3.25f, 4.9375f, -2.609375f, + 2.25f, -0.0498046875f, -1.90625f, 7.5f, -2.78125f, -2.46875f, + 6.40625f, 7.03125f, 2.40625f, 2.421875f, 2.59375f, 1.9921875f, + -1.0234375f, -4.15625f, -3.28125f, -5.4375f, -2.90625f, -2.078125f, + 4.78125f, 0.373046875f, 0.376953125f, 0.2578125f, 1.109375f, 5.375f, + 7.59375f, 3.109375f, -2.71875f, 1.546875f, -4.21875f, 9.1875f, + 10.0f, -4.15625f, -3.625f, -0.921875f, 10.0f, 5.1875f, + -3.359375f, -4.40625f, -3.15625f, -1.0546875f, 3.140625f, -1.4765625f, + 0.78125f, 0.16796875f, -0.34375f, 4.65625f, -2.90625f, 5.3125f, + -7.84375f, -2.390625f, -10.375f, -7.625f, 4.90625f, -2.421875f, + 8.5f, 5.84375f, 2.671875f, 4.71875f, 0.5546875f, 2.40625f, + 0.6484375f, -0.87109375f, 1.4296875f, 6.8125f, 5.84375f, 5.125f, + 0.50390625f, 4.90625f, -2.4375f, -4.875f, -5.0f, 1.0625f, + -2.671875f, 1.0546875f, -0.166015625f, -0.796875f, -1.6171875f, -4.875f, + 2.8125f, 0.8046875f, 0.03515625f, -0.498046875f, -1.90625f, 2.96875f, + 5.6875f, -2.875f, 6.71875f, -2.203125f, 0.131835938f, 1.0703125f, + -0.80859375f, 7.3125f, 1.3828125f, -0.88671875f, +}; + +inline constexpr float kLtxTowerPaddedStateBf16_7[] = { + 0.75390625f, 1.6875f, 0.200195312f, 2.9375f, -2.03125f, -1.6171875f, + -0.94921875f, -4.125f, 1.2578125f, -0.361328125f, -0.77734375f, -4.5625f, + -1.09375f, -1.046875f, -0.703125f, 0.6796875f, 0.66796875f, -1.7265625f, + 0.50390625f, -0.4921875f, 0.671875f, -1.046875f, 1.1640625f, -2.796875f, + 2.53125f, -0.466796875f, -2.46875f, 2.46875f, -0.9765625f, 2.4375f, + 3.6875f, -0.72265625f, 0.75390625f, 1.6875f, 0.200195312f, 2.9375f, + -2.03125f, -1.6171875f, -0.94921875f, -4.125f, 1.2578125f, -0.361328125f, + -0.77734375f, -4.5625f, -1.09375f, -1.046875f, -0.703125f, 0.6796875f, + 0.66796875f, -1.7265625f, 0.50390625f, -0.4921875f, 0.671875f, -1.046875f, + 1.1640625f, -2.796875f, 2.53125f, -0.466796875f, -2.46875f, 2.46875f, + -0.9765625f, 2.4375f, 3.6875f, -0.72265625f, 0.75390625f, 1.6875f, + 0.200195312f, 2.9375f, -2.03125f, -1.6171875f, -0.94921875f, -4.125f, + 1.2578125f, -0.361328125f, -0.77734375f, -4.5625f, -1.09375f, -1.046875f, + -0.703125f, 0.6796875f, 0.66796875f, -1.7265625f, 0.50390625f, -0.4921875f, + 0.671875f, -1.046875f, 1.1640625f, -2.796875f, 2.53125f, -0.466796875f, + -2.46875f, 2.46875f, -0.9765625f, 2.4375f, 3.6875f, -0.72265625f, + 0.75390625f, 1.6875f, 0.200195312f, 2.9375f, -2.03125f, -1.6171875f, + -0.94921875f, -4.125f, 1.2578125f, -0.361328125f, -0.77734375f, -4.5625f, + -1.09375f, -1.046875f, -0.703125f, 0.6796875f, 0.66796875f, -1.7265625f, + 0.50390625f, -0.4921875f, 0.671875f, -1.046875f, 1.1640625f, -2.796875f, + 2.53125f, -0.466796875f, -2.46875f, 2.46875f, -0.9765625f, 2.4375f, + 3.6875f, -0.72265625f, 0.75390625f, 1.6875f, 0.200195312f, 2.9375f, + -2.03125f, -1.6171875f, -0.94921875f, -4.125f, 1.2578125f, -0.361328125f, + -0.77734375f, -4.5625f, -1.09375f, -1.046875f, -0.703125f, 0.6796875f, + 0.66796875f, -1.7265625f, 0.50390625f, -0.4921875f, 0.671875f, -1.046875f, + 1.1640625f, -2.796875f, 2.53125f, -0.466796875f, -2.46875f, 2.46875f, + -0.9765625f, 2.4375f, 3.6875f, -0.72265625f, 0.75390625f, 1.6875f, + 0.200195312f, 2.9375f, -2.03125f, -1.6171875f, -0.94921875f, -4.125f, + 1.2578125f, -0.361328125f, -0.77734375f, -4.5625f, -1.09375f, -1.046875f, + -0.703125f, 0.6796875f, 0.66796875f, -1.7265625f, 0.50390625f, -0.4921875f, + 0.671875f, -1.046875f, 1.1640625f, -2.796875f, 2.53125f, -0.466796875f, + -2.46875f, 2.46875f, -0.9765625f, 2.4375f, 3.6875f, -0.72265625f, + 0.75390625f, 1.6875f, 0.200195312f, 2.9375f, -2.03125f, -1.6171875f, + -0.94921875f, -4.125f, 1.2578125f, -0.361328125f, -0.77734375f, -4.5625f, + -1.09375f, -1.046875f, -0.703125f, 0.6796875f, 0.66796875f, -1.7265625f, + 0.50390625f, -0.4921875f, 0.671875f, -1.046875f, 1.1640625f, -2.796875f, + 2.53125f, -0.466796875f, -2.46875f, 2.46875f, -0.9765625f, 2.4375f, + 3.6875f, -0.72265625f, 0.75390625f, 1.6875f, 0.200195312f, 2.9375f, + -2.03125f, -1.6171875f, -0.94921875f, -4.125f, 1.2578125f, -0.361328125f, + -0.77734375f, -4.5625f, -1.09375f, -1.046875f, -0.703125f, 0.6796875f, + 0.66796875f, -1.7265625f, 0.50390625f, -0.4921875f, 0.671875f, -1.046875f, + 1.1640625f, -2.796875f, 2.53125f, -0.466796875f, -2.46875f, 2.46875f, + -0.9765625f, 2.4375f, 3.6875f, -0.72265625f, 0.75390625f, 1.6875f, + 0.200195312f, 2.9375f, -2.03125f, -1.6171875f, -0.94921875f, -4.125f, + 1.2578125f, -0.361328125f, -0.77734375f, -4.5625f, -1.09375f, -1.046875f, + -0.703125f, 0.6796875f, 0.66796875f, -1.7265625f, 0.50390625f, -0.4921875f, + 0.671875f, -1.046875f, 1.1640625f, -2.796875f, 2.53125f, -0.466796875f, + -2.46875f, 2.46875f, -0.9765625f, 2.4375f, 3.6875f, -0.72265625f, + 0.75390625f, 1.6875f, 0.200195312f, 2.9375f, -2.03125f, -1.6171875f, + -0.94921875f, -4.125f, 1.2578125f, -0.361328125f, -0.77734375f, -4.5625f, + -1.09375f, -1.046875f, -0.703125f, 0.6796875f, 0.66796875f, -1.7265625f, + 0.50390625f, -0.4921875f, 0.671875f, -1.046875f, 1.1640625f, -2.796875f, + 2.53125f, -0.466796875f, -2.46875f, 2.46875f, -0.9765625f, 2.4375f, + 3.6875f, -0.72265625f, 0.75390625f, 1.6875f, 0.200195312f, 2.9375f, + -2.03125f, -1.6171875f, -0.94921875f, -4.125f, 1.2578125f, -0.361328125f, + -0.77734375f, -4.5625f, -1.09375f, -1.046875f, -0.703125f, 0.6796875f, + 0.66796875f, -1.7265625f, 0.50390625f, -0.4921875f, 0.671875f, -1.046875f, + 1.1640625f, -2.796875f, 2.53125f, -0.466796875f, -2.46875f, 2.46875f, + -0.9765625f, 2.4375f, 3.6875f, -0.72265625f, 0.75390625f, 1.6875f, + 0.200195312f, 2.9375f, -2.03125f, -1.6171875f, -0.94921875f, -4.125f, + 1.2578125f, -0.361328125f, -0.77734375f, -4.5625f, -1.09375f, -1.046875f, + -0.703125f, 0.6796875f, 0.66796875f, -1.7265625f, 0.50390625f, -0.4921875f, + 0.671875f, -1.046875f, 1.1640625f, -2.796875f, 2.53125f, -0.466796875f, + -2.46875f, 2.46875f, -0.9765625f, 2.4375f, 3.6875f, -0.72265625f, + -8.4375f, -0.8125f, 1.1953125f, 2.75f, -0.310546875f, 4.1875f, + 1.7109375f, -3.28125f, 1.09375f, 2.71875f, -2.796875f, 0.237304688f, + -8.875f, -4.8125f, 2.0625f, -1.4453125f, 1.5703125f, 2.203125f, + 3.796875f, -5.03125f, -5.875f, 4.59375f, 2.390625f, -5.78125f, + 6.84375f, -0.78125f, -0.470703125f, 4.3125f, 6.8125f, -0.9609375f, + -1.96875f, 1.8984375f, -6.9375f, -1.09375f, 7.59375f, -0.34765625f, + -3.515625f, 6.625f, -0.765625f, 3.25f, 0.09375f, 1.078125f, + -3.390625f, -1.1484375f, -3.65625f, -2.578125f, 0.8359375f, 0.59375f, + 3.0625f, 0.0441894531f, -0.9765625f, -2.609375f, 0.169921875f, 7.40625f, + 6.15625f, -2.84375f, 6.1875f, 0.42578125f, 5.34375f, 2.6875f, + 6.9375f, 2.359375f, -4.125f, -0.95703125f, -3.40625f, -11.4375f, + 1.9140625f, 0.447265625f, -2.09375f, 6.9375f, -1.3046875f, -1.265625f, + 1.8828125f, -0.60546875f, -1.953125f, -2.4375f, -4.3125f, -6.6875f, + 0.94140625f, -1.46875f, 1.203125f, -0.29296875f, 2.34375f, -3.0625f, + 0.8125f, 2.40625f, 4.8125f, -7.21875f, 7.125f, 1.5859375f, + 2.921875f, 7.3125f, 2.078125f, 0.198242188f, 1.1015625f, 3.625f, + 1.8125f, 4.28125f, 6.8125f, -1.265625f, 7.03125f, 1.5390625f, + -0.283203125f, -5.59375f, -6.28125f, -3.96875f, -2.796875f, -5.125f, + -1.4921875f, -1.7265625f, -2.21875f, 2.84375f, 1.0625f, 3.40625f, + 3.1875f, 1.296875f, 0.34765625f, 3.40625f, 1.5078125f, -9.3125f, + 11.25f, -0.6328125f, 0.57421875f, 5.375f, 0.5859375f, 6.34375f, + -2.46875f, 3.875f, -3.9375f, -4.34375f, -1.984375f, 3.96875f, + 0.00354003906f, 6.625f, -0.388671875f, 3.96875f, 4.75f, -0.484375f, + 0.88671875f, -4.375f, -3.96875f, 0.163085938f, 2.1875f, -7.9375f, + 0.4609375f, -5.125f, -0.056640625f, 0.0134887695f, 2.421875f, 2.9375f, + 0.2578125f, -4.375f, -0.0849609375f, 0.5625f, 2.921875f, 1.46875f, + -3.6875f, 0.84375f, -6.625f, 1.6875f, 2.453125f, -0.96875f, + 1.25f, -1.7890625f, -0.5390625f, 7.40625f, -4.6875f, -2.1875f, + 6.90625f, 5.90625f, 2.390625f, 0.890625f, 2.75f, 2.71875f, + -0.67578125f, -4.1875f, -4.375f, -4.375f, -1.53125f, -0.77734375f, + 6.1875f, 0.7578125f, 1.484375f, -1.1484375f, 0.49609375f, 4.1875f, + 5.71875f, 4.96875f, -3.875f, 2.15625f, -5.90625f, 7.59375f, + 8.125f, -3.140625f, -3.21875f, -3.046875f, 9.1875f, 4.90625f, + -3.375f, -3.734375f, -4.0625f, -0.69921875f, 2.265625f, -0.921875f, + 2.34375f, 0.7734375f, 0.73046875f, 6.90625f, -5.71875f, 3.34375f, + -4.5625f, -2.34375f, -9.8125f, -8.8125f, 4.09375f, -2.109375f, + 7.375f, 3.21875f, 4.59375f, 3.53125f, 0.451171875f, 4.0625f, + 0.180664062f, 1.046875f, 1.1328125f, 7.40625f, 4.375f, 4.125f, + 0.48046875f, 6.84375f, -2.515625f, -3.546875f, -4.71875f, 0.11328125f, + -2.21875f, -1.046875f, 0.51953125f, -1.8046875f, -0.8984375f, -1.828125f, + 2.875f, 0.828125f, -0.5859375f, -2.296875f, -2.890625f, 2.296875f, + 3.375f, -1.2734375f, 8.0f, -0.65234375f, -0.180664062f, 2.25f, + -1.578125f, 7.0625f, 1.265625f, 0.5859375f, +}; + +inline constexpr float kLtxTowerPaddedStateBf16_8[] = { + 1.5078125f, 2.5625f, -0.578125f, 2.609375f, -0.0395507812f, -1.4375f, + -0.59375f, -4.6875f, 2.140625f, 0.302734375f, -0.6796875f, -4.78125f, + -0.8203125f, -1.109375f, 0.170898438f, -2.765625f, -0.60546875f, -2.40625f, + 1.5703125f, -1.296875f, 0.200195312f, -0.74609375f, 1.1171875f, -3.96875f, + 3.265625f, -1.078125f, -2.703125f, 3.765625f, -1.4765625f, 2.578125f, + 3.65625f, -1.078125f, 1.5078125f, 2.5625f, -0.578125f, 2.609375f, + -0.0395507812f, -1.4375f, -0.59375f, -4.6875f, 2.140625f, 0.302734375f, + -0.6796875f, -4.78125f, -0.8203125f, -1.109375f, 0.170898438f, -2.765625f, + -0.60546875f, -2.40625f, 1.5703125f, -1.296875f, 0.200195312f, -0.74609375f, + 1.1171875f, -3.96875f, 3.265625f, -1.078125f, -2.703125f, 3.765625f, + -1.4765625f, 2.578125f, 3.65625f, -1.078125f, 1.5078125f, 2.5625f, + -0.578125f, 2.609375f, -0.0395507812f, -1.4375f, -0.59375f, -4.6875f, + 2.140625f, 0.302734375f, -0.6796875f, -4.78125f, -0.8203125f, -1.109375f, + 0.170898438f, -2.765625f, -0.60546875f, -2.40625f, 1.5703125f, -1.296875f, + 0.200195312f, -0.74609375f, 1.1171875f, -3.96875f, 3.265625f, -1.078125f, + -2.703125f, 3.765625f, -1.4765625f, 2.578125f, 3.65625f, -1.078125f, + 1.5078125f, 2.5625f, -0.578125f, 2.609375f, -0.0395507812f, -1.4375f, + -0.59375f, -4.6875f, 2.140625f, 0.302734375f, -0.6796875f, -4.78125f, + -0.8203125f, -1.109375f, 0.170898438f, -2.765625f, -0.60546875f, -2.40625f, + 1.5703125f, -1.296875f, 0.200195312f, -0.74609375f, 1.1171875f, -3.96875f, + 3.265625f, -1.078125f, -2.703125f, 3.765625f, -1.4765625f, 2.578125f, + 3.65625f, -1.078125f, 1.5078125f, 2.5625f, -0.578125f, 2.609375f, + -0.0395507812f, -1.4375f, -0.59375f, -4.6875f, 2.140625f, 0.302734375f, + -0.6796875f, -4.78125f, -0.8203125f, -1.109375f, 0.170898438f, -2.765625f, + -0.60546875f, -2.40625f, 1.5703125f, -1.296875f, 0.200195312f, -0.74609375f, + 1.1171875f, -3.96875f, 3.265625f, -1.078125f, -2.703125f, 3.765625f, + -1.4765625f, 2.578125f, 3.65625f, -1.078125f, 1.5078125f, 2.5625f, + -0.578125f, 2.609375f, -0.0395507812f, -1.4375f, -0.59375f, -4.6875f, + 2.140625f, 0.302734375f, -0.6796875f, -4.78125f, -0.8203125f, -1.109375f, + 0.170898438f, -2.765625f, -0.60546875f, -2.40625f, 1.5703125f, -1.296875f, + 0.200195312f, -0.74609375f, 1.1171875f, -3.96875f, 3.265625f, -1.078125f, + -2.703125f, 3.765625f, -1.4765625f, 2.578125f, 3.65625f, -1.078125f, + 1.5078125f, 2.5625f, -0.578125f, 2.609375f, -0.0395507812f, -1.4375f, + -0.59375f, -4.6875f, 2.140625f, 0.302734375f, -0.6796875f, -4.78125f, + -0.8203125f, -1.109375f, 0.170898438f, -2.765625f, -0.60546875f, -2.40625f, + 1.5703125f, -1.296875f, 0.200195312f, -0.74609375f, 1.1171875f, -3.96875f, + 3.265625f, -1.078125f, -2.703125f, 3.765625f, -1.4765625f, 2.578125f, + 3.65625f, -1.078125f, 1.5078125f, 2.5625f, -0.578125f, 2.609375f, + -0.0395507812f, -1.4375f, -0.59375f, -4.6875f, 2.140625f, 0.302734375f, + -0.6796875f, -4.78125f, -0.8203125f, -1.109375f, 0.170898438f, -2.765625f, + -0.60546875f, -2.40625f, 1.5703125f, -1.296875f, 0.200195312f, -0.74609375f, + 1.1171875f, -3.96875f, 3.265625f, -1.078125f, -2.703125f, 3.765625f, + -1.4765625f, 2.578125f, 3.65625f, -1.078125f, 1.5078125f, 2.5625f, + -0.578125f, 2.609375f, -0.0395507812f, -1.4375f, -0.59375f, -4.6875f, + 2.140625f, 0.302734375f, -0.6796875f, -4.78125f, -0.8203125f, -1.109375f, + 0.170898438f, -2.765625f, -0.60546875f, -2.40625f, 1.5703125f, -1.296875f, + 0.200195312f, -0.74609375f, 1.1171875f, -3.96875f, 3.265625f, -1.078125f, + -2.703125f, 3.765625f, -1.4765625f, 2.578125f, 3.65625f, -1.078125f, + 1.5078125f, 2.5625f, -0.578125f, 2.609375f, -0.0395507812f, -1.4375f, + -0.59375f, -4.6875f, 2.140625f, 0.302734375f, -0.6796875f, -4.78125f, + -0.8203125f, -1.109375f, 0.170898438f, -2.765625f, -0.60546875f, -2.40625f, + 1.5703125f, -1.296875f, 0.200195312f, -0.74609375f, 1.1171875f, -3.96875f, + 3.265625f, -1.078125f, -2.703125f, 3.765625f, -1.4765625f, 2.578125f, + 3.65625f, -1.078125f, 1.5078125f, 2.5625f, -0.578125f, 2.609375f, + -0.0395507812f, -1.4375f, -0.59375f, -4.6875f, 2.140625f, 0.302734375f, + -0.6796875f, -4.78125f, -0.8203125f, -1.109375f, 0.170898438f, -2.765625f, + -0.60546875f, -2.40625f, 1.5703125f, -1.296875f, 0.200195312f, -0.74609375f, + 1.1171875f, -3.96875f, 3.265625f, -1.078125f, -2.703125f, 3.765625f, + -1.4765625f, 2.578125f, 3.65625f, -1.078125f, 1.5078125f, 2.5625f, + -0.578125f, 2.609375f, -0.0395507812f, -1.4375f, -0.59375f, -4.6875f, + 2.140625f, 0.302734375f, -0.6796875f, -4.78125f, -0.8203125f, -1.109375f, + 0.170898438f, -2.765625f, -0.60546875f, -2.40625f, 1.5703125f, -1.296875f, + 0.200195312f, -0.74609375f, 1.1171875f, -3.96875f, 3.265625f, -1.078125f, + -2.703125f, 3.765625f, -1.4765625f, 2.578125f, 3.65625f, -1.078125f, + -8.8125f, 1.5390625f, 0.134765625f, 1.1171875f, -1.0703125f, 1.4453125f, + 1.0078125f, -0.142578125f, 3.046875f, 3.0625f, -0.142578125f, 0.71875f, + -9.1875f, -2.09375f, 1.5703125f, -1.6484375f, 1.828125f, -0.0317382812f, + 1.9453125f, -6.34375f, -8.8125f, 5.0f, 2.28125f, -5.90625f, + 4.09375f, -0.265625f, -0.546875f, 4.0625f, 4.21875f, -2.65625f, + -2.265625f, 2.21875f, -8.9375f, 0.546875f, 5.90625f, -2.25f, + -4.4375f, 4.875f, -0.99609375f, 4.09375f, 0.4765625f, 1.4609375f, + -1.765625f, -0.29296875f, -5.15625f, -0.6171875f, 1.5625f, -0.54296875f, + 1.828125f, -1.125f, -3.6875f, -2.734375f, -1.734375f, 8.25f, + 5.4375f, -3.0625f, 5.90625f, 3.140625f, 3.015625f, 1.875f, + 4.03125f, 0.76953125f, -4.09375f, -0.5546875f, -4.90625f, -10.0625f, + -0.0297851562f, -1.4296875f, -4.25f, 5.15625f, -0.6328125f, -0.190429688f, + 2.5f, -0.765625f, -1.328125f, -2.75f, -5.03125f, -5.0f, + 2.71875f, -1.9296875f, 1.875f, -2.09375f, 0.81640625f, -3.828125f, + -0.62890625f, -0.28515625f, 3.71875f, -8.9375f, 6.875f, 4.40625f, + 2.828125f, 9.0f, 2.25f, -2.953125f, 1.15625f, 3.0625f, + 1.140625f, 7.875f, 3.875f, -2.75f, 6.28125f, 1.4296875f, + 0.796875f, -6.0625f, -4.71875f, -4.8125f, -1.6953125f, -3.84375f, + -1.4921875f, 0.484375f, -0.71484375f, 0.77734375f, 1.6171875f, 1.3671875f, + 1.5625f, 0.94140625f, -1.046875f, 1.78125f, 0.64453125f, -8.9375f, + 10.875f, 0.0317382812f, 2.5625f, 5.96875f, -0.75390625f, 6.875f, + -3.046875f, 5.5625f, -4.84375f, -3.609375f, -1.6796875f, 4.40625f, + -1.3828125f, 5.03125f, -0.4609375f, 5.75f, 7.0625f, -1.765625f, + 2.421875f, -7.0f, -3.5625f, 3.21875f, 4.5625f, -7.125f, + 0.76171875f, -6.03125f, -1.90625f, -2.5f, 0.8828125f, 1.4296875f, + 0.9453125f, -5.0625f, 1.25f, 1.6171875f, 2.6875f, 0.9375f, + -2.375f, -1.0f, -8.6875f, 2.03125f, 2.484375f, 1.0546875f, + 2.359375f, -1.1875f, -0.48828125f, 7.25f, -6.4375f, -0.90625f, + 7.34375f, 4.0625f, 1.6015625f, 1.8359375f, 2.765625f, 3.25f, + -0.30859375f, -3.84375f, -2.3125f, -2.40625f, -3.234375f, -2.0f, + 4.6875f, -0.69921875f, 2.46875f, -3.53125f, 0.365234375f, 5.5625f, + 6.84375f, 3.859375f, -4.90625f, 1.6640625f, -6.71875f, 8.6875f, + 7.375f, 0.73046875f, -2.984375f, -1.78125f, 9.375f, 4.59375f, + -4.21875f, -1.296875f, -3.421875f, -2.21875f, 2.578125f, -0.119140625f, + 1.4375f, 4.125f, 0.28125f, 6.90625f, -5.84375f, 5.0f, + -5.71875f, -1.421875f, -8.5f, -7.875f, 5.78125f, -2.21875f, + 6.09375f, 4.34375f, 4.6875f, 3.078125f, -2.078125f, 2.921875f, + -0.60546875f, 0.44140625f, 2.03125f, 11.0f, 3.0f, 3.5f, + 0.235351562f, 7.03125f, -2.46875f, -5.3125f, -4.8125f, -1.6796875f, + -2.015625f, -0.67578125f, 1.9921875f, 0.23828125f, -1.03125f, -3.15625f, + 4.3125f, 1.5390625f, -1.4609375f, -0.6328125f, -3.375f, 2.5f, + 4.875f, -2.53125f, 8.5625f, -0.369140625f, 1.0859375f, 3.25f, + -2.9375f, 6.46875f, -1.0703125f, 1.0f, +}; + +inline constexpr float kLtxTowerPaddedStateBf16_9[] = { + 1.71875f, 3.125f, -0.44921875f, 1.5234375f, 1.0f, -2.765625f, + -0.228515625f, -6.0f, 0.51953125f, 1.6484375f, 0.326171875f, -4.125f, + -0.546875f, -0.159179688f, 1.2890625f, -1.0f, 0.640625f, -3.34375f, + 2.328125f, -0.59375f, 0.248046875f, -0.2734375f, 1.6875f, -4.0f, + 2.703125f, -2.078125f, -2.796875f, 2.53125f, -0.318359375f, 2.6875f, + 2.78125f, -0.0776367188f, 1.71875f, 3.125f, -0.44921875f, 1.5234375f, + 1.0f, -2.765625f, -0.228515625f, -6.0f, 0.51953125f, 1.6484375f, + 0.326171875f, -4.125f, -0.546875f, -0.159179688f, 1.2890625f, -1.0f, + 0.640625f, -3.34375f, 2.328125f, -0.59375f, 0.248046875f, -0.2734375f, + 1.6875f, -4.0f, 2.703125f, -2.078125f, -2.796875f, 2.53125f, + -0.318359375f, 2.6875f, 2.78125f, -0.0776367188f, 1.71875f, 3.125f, + -0.44921875f, 1.5234375f, 1.0f, -2.765625f, -0.228515625f, -6.0f, + 0.51953125f, 1.6484375f, 0.326171875f, -4.125f, -0.546875f, -0.159179688f, + 1.2890625f, -1.0f, 0.640625f, -3.34375f, 2.328125f, -0.59375f, + 0.248046875f, -0.2734375f, 1.6875f, -4.0f, 2.703125f, -2.078125f, + -2.796875f, 2.53125f, -0.318359375f, 2.6875f, 2.78125f, -0.0776367188f, + 1.71875f, 3.125f, -0.44921875f, 1.5234375f, 1.0f, -2.765625f, + -0.228515625f, -6.0f, 0.51953125f, 1.6484375f, 0.326171875f, -4.125f, + -0.546875f, -0.159179688f, 1.2890625f, -1.0f, 0.640625f, -3.34375f, + 2.328125f, -0.59375f, 0.248046875f, -0.2734375f, 1.6875f, -4.0f, + 2.703125f, -2.078125f, -2.796875f, 2.53125f, -0.318359375f, 2.6875f, + 2.78125f, -0.0776367188f, 1.71875f, 3.125f, -0.44921875f, 1.5234375f, + 1.0f, -2.765625f, -0.228515625f, -6.0f, 0.51953125f, 1.6484375f, + 0.326171875f, -4.125f, -0.546875f, -0.159179688f, 1.2890625f, -1.0f, + 0.640625f, -3.34375f, 2.328125f, -0.59375f, 0.248046875f, -0.2734375f, + 1.6875f, -4.0f, 2.703125f, -2.078125f, -2.796875f, 2.53125f, + -0.318359375f, 2.6875f, 2.78125f, -0.0776367188f, 1.71875f, 3.125f, + -0.44921875f, 1.5234375f, 1.0f, -2.765625f, -0.228515625f, -6.0f, + 0.51953125f, 1.6484375f, 0.326171875f, -4.125f, -0.546875f, -0.159179688f, + 1.2890625f, -1.0f, 0.640625f, -3.34375f, 2.328125f, -0.59375f, + 0.248046875f, -0.2734375f, 1.6875f, -4.0f, 2.703125f, -2.078125f, + -2.796875f, 2.53125f, -0.318359375f, 2.6875f, 2.78125f, -0.0776367188f, + 1.71875f, 3.125f, -0.44921875f, 1.5234375f, 1.0f, -2.765625f, + -0.228515625f, -6.0f, 0.51953125f, 1.6484375f, 0.326171875f, -4.125f, + -0.546875f, -0.159179688f, 1.2890625f, -1.0f, 0.640625f, -3.34375f, + 2.328125f, -0.59375f, 0.248046875f, -0.2734375f, 1.6875f, -4.0f, + 2.703125f, -2.078125f, -2.796875f, 2.53125f, -0.318359375f, 2.6875f, + 2.78125f, -0.0776367188f, 1.71875f, 3.125f, -0.44921875f, 1.5234375f, + 1.0f, -2.765625f, -0.228515625f, -6.0f, 0.51953125f, 1.6484375f, + 0.326171875f, -4.125f, -0.546875f, -0.159179688f, 1.2890625f, -1.0f, + 0.640625f, -3.34375f, 2.328125f, -0.59375f, 0.248046875f, -0.2734375f, + 1.6875f, -4.0f, 2.703125f, -2.078125f, -2.796875f, 2.53125f, + -0.318359375f, 2.6875f, 2.78125f, -0.0776367188f, 1.71875f, 3.125f, + -0.44921875f, 1.5234375f, 1.0f, -2.765625f, -0.228515625f, -6.0f, + 0.51953125f, 1.6484375f, 0.326171875f, -4.125f, -0.546875f, -0.159179688f, + 1.2890625f, -1.0f, 0.640625f, -3.34375f, 2.328125f, -0.59375f, + 0.248046875f, -0.2734375f, 1.6875f, -4.0f, 2.703125f, -2.078125f, + -2.796875f, 2.53125f, -0.318359375f, 2.6875f, 2.78125f, -0.0776367188f, + 1.71875f, 3.125f, -0.44921875f, 1.5234375f, 1.0f, -2.765625f, + -0.228515625f, -6.0f, 0.51953125f, 1.6484375f, 0.326171875f, -4.125f, + -0.546875f, -0.159179688f, 1.2890625f, -1.0f, 0.640625f, -3.34375f, + 2.328125f, -0.59375f, 0.248046875f, -0.2734375f, 1.6875f, -4.0f, + 2.703125f, -2.078125f, -2.796875f, 2.53125f, -0.318359375f, 2.6875f, + 2.78125f, -0.0776367188f, 1.71875f, 3.125f, -0.44921875f, 1.5234375f, + 1.0f, -2.765625f, -0.228515625f, -6.0f, 0.51953125f, 1.6484375f, + 0.326171875f, -4.125f, -0.546875f, -0.159179688f, 1.2890625f, -1.0f, + 0.640625f, -3.34375f, 2.328125f, -0.59375f, 0.248046875f, -0.2734375f, + 1.6875f, -4.0f, 2.703125f, -2.078125f, -2.796875f, 2.53125f, + -0.318359375f, 2.6875f, 2.78125f, -0.0776367188f, 1.71875f, 3.125f, + -0.44921875f, 1.5234375f, 1.0f, -2.765625f, -0.228515625f, -6.0f, + 0.51953125f, 1.6484375f, 0.326171875f, -4.125f, -0.546875f, -0.159179688f, + 1.2890625f, -1.0f, 0.640625f, -3.34375f, 2.328125f, -0.59375f, + 0.248046875f, -0.2734375f, 1.6875f, -4.0f, 2.703125f, -2.078125f, + -2.796875f, 2.53125f, -0.318359375f, 2.6875f, 2.78125f, -0.0776367188f, + -7.875f, 1.1328125f, 1.234375f, -0.07421875f, -4.21875f, 2.875f, + 1.265625f, 0.44921875f, 4.09375f, 4.625f, -1.421875f, 0.2890625f, + -9.4375f, -3.109375f, 2.421875f, -0.15234375f, 2.15625f, 0.3671875f, + 3.15625f, -4.09375f, -9.5f, 5.53125f, 0.7578125f, -5.9375f, + 5.03125f, -0.21484375f, 0.7734375f, 4.96875f, 2.53125f, -2.671875f, + -0.71875f, 0.984375f, -7.65625f, 0.7578125f, 5.75f, -2.9375f, + -8.125f, 6.34375f, -0.27734375f, 2.78125f, 0.6953125f, 3.109375f, + -3.4375f, -0.0795898438f, -5.125f, -1.4765625f, 2.21875f, 0.9921875f, + 1.84375f, -0.8359375f, -2.640625f, -0.95703125f, -1.9609375f, 8.3125f, + 4.0625f, -2.421875f, 6.375f, 3.265625f, 4.96875f, 2.921875f, + 2.09375f, 0.84765625f, -4.0625f, -1.125f, -4.34375f, -6.8125f, + -2.609375f, -1.75f, -6.125f, 3.921875f, 0.194335938f, -0.77734375f, + 2.140625f, -0.122558594f, -1.140625f, -0.73046875f, -5.0625f, -4.9375f, + 3.78125f, -0.322265625f, 1.4609375f, -3.65625f, 0.283203125f, -1.9609375f, + -1.109375f, -0.0263671875f, 4.0625f, -10.625f, 6.5625f, 5.5625f, + 4.8125f, 10.1875f, 3.578125f, -4.625f, 1.234375f, 2.375f, + 1.703125f, 6.65625f, 3.125f, -2.484375f, 5.375f, 1.2109375f, + 0.98046875f, -5.84375f, -7.3125f, -4.96875f, -2.25f, -3.890625f, + -3.59375f, 0.33984375f, -0.248046875f, 2.78125f, 1.6171875f, -1.140625f, + 1.9296875f, 1.4765625f, -0.94921875f, 4.1875f, 0.196289062f, -8.125f, + 11.0f, -2.015625f, 4.4375f, 6.9375f, -0.828125f, 4.96875f, + -4.59375f, 3.796875f, -1.3359375f, -1.8046875f, -3.9375f, 3.921875f, + -1.515625f, 5.15625f, 0.314453125f, 5.21875f, 4.28125f, -0.75f, + 1.578125f, -4.15625f, -2.375f, 3.078125f, 4.21875f, -4.15625f, + 1.6796875f, -6.75f, 0.0668945312f, 0.125976562f, 1.5546875f, 0.921875f, + 0.118164062f, -5.4375f, 0.91015625f, 2.953125f, 5.0625f, 2.15625f, + -4.28125f, -0.75f, -9.25f, 1.859375f, 4.59375f, 1.5859375f, + 1.453125f, -1.8046875f, -3.265625f, 7.03125f, -5.8125f, -0.90625f, + 7.09375f, 4.59375f, 1.359375f, 2.90625f, 2.734375f, 3.296875f, + -1.828125f, -1.1015625f, -2.609375f, -4.34375f, -2.96875f, 0.0593261719f, + 4.625f, -0.87890625f, 2.296875f, -4.875f, 0.5078125f, 5.09375f, + 6.25f, 5.21875f, -3.78125f, -0.4296875f, -3.5f, 8.625f, + 7.65625f, 3.96875f, -1.140625f, -0.209960938f, 10.6875f, 1.9140625f, + -3.578125f, -1.5078125f, -1.9296875f, -1.53125f, 3.671875f, -1.5703125f, + 0.296875f, 6.0f, 0.283203125f, 8.0625f, -5.875f, 6.21875f, + -4.28125f, -0.79296875f, -7.3125f, -5.96875f, 5.3125f, -1.3671875f, + 2.515625f, 3.421875f, 4.15625f, 3.578125f, -2.984375f, 2.9375f, + 0.014831543f, 0.52734375f, 3.46875f, 11.625f, 0.87109375f, 0.79296875f, + 1.5546875f, 6.6875f, -2.3125f, -5.78125f, -4.9375f, -0.111328125f, + -0.466796875f, 1.9140625f, 0.8828125f, 1.6796875f, 0.54296875f, -3.0625f, + 5.28125f, 1.3671875f, -0.35546875f, 0.859375f, -1.828125f, 4.53125f, + 6.9375f, -3.578125f, 8.3125f, -0.62109375f, 2.09375f, 4.46875f, + -2.890625f, 4.875f, -1.265625f, -1.5234375f, +}; + +inline constexpr float kLtxTowerPaddedStateBf16_10[] = { + 3.28125f, 2.359375f, 0.61328125f, 3.25f, 1.4765625f, -3.640625f, + 0.625f, -6.8125f, -0.109375f, 0.6640625f, -1.3984375f, -5.34375f, + -1.203125f, 1.453125f, 2.828125f, -0.29296875f, 0.341796875f, -3.203125f, + 1.703125f, -0.0405273438f, -0.796875f, -0.0244140625f, 1.9453125f, -4.40625f, + 2.796875f, -3.140625f, -2.78125f, 2.875f, 0.48828125f, 2.84375f, + 3.578125f, 1.8828125f, 3.28125f, 2.359375f, 0.61328125f, 3.25f, + 1.4765625f, -3.640625f, 0.625f, -6.8125f, -0.109375f, 0.6640625f, + -1.3984375f, -5.34375f, -1.203125f, 1.453125f, 2.828125f, -0.29296875f, + 0.341796875f, -3.203125f, 1.703125f, -0.0405273438f, -0.796875f, -0.0244140625f, + 1.9453125f, -4.40625f, 2.796875f, -3.140625f, -2.78125f, 2.875f, + 0.48828125f, 2.84375f, 3.578125f, 1.8828125f, 3.28125f, 2.359375f, + 0.61328125f, 3.25f, 1.4765625f, -3.640625f, 0.625f, -6.8125f, + -0.109375f, 0.6640625f, -1.3984375f, -5.34375f, -1.203125f, 1.453125f, + 2.828125f, -0.29296875f, 0.341796875f, -3.203125f, 1.703125f, -0.0405273438f, + -0.796875f, -0.0244140625f, 1.9453125f, -4.40625f, 2.796875f, -3.140625f, + -2.78125f, 2.875f, 0.48828125f, 2.84375f, 3.578125f, 1.8828125f, + 3.28125f, 2.359375f, 0.61328125f, 3.25f, 1.4765625f, -3.640625f, + 0.625f, -6.8125f, -0.109375f, 0.6640625f, -1.3984375f, -5.34375f, + -1.203125f, 1.453125f, 2.828125f, -0.29296875f, 0.341796875f, -3.203125f, + 1.703125f, -0.0405273438f, -0.796875f, -0.0244140625f, 1.9453125f, -4.40625f, + 2.796875f, -3.140625f, -2.78125f, 2.875f, 0.48828125f, 2.84375f, + 3.578125f, 1.8828125f, 3.28125f, 2.359375f, 0.61328125f, 3.25f, + 1.4765625f, -3.640625f, 0.625f, -6.8125f, -0.109375f, 0.6640625f, + -1.3984375f, -5.34375f, -1.203125f, 1.453125f, 2.828125f, -0.29296875f, + 0.341796875f, -3.203125f, 1.703125f, -0.0405273438f, -0.796875f, -0.0244140625f, + 1.9453125f, -4.40625f, 2.796875f, -3.140625f, -2.78125f, 2.875f, + 0.48828125f, 2.84375f, 3.578125f, 1.8828125f, 3.28125f, 2.359375f, + 0.61328125f, 3.25f, 1.4765625f, -3.640625f, 0.625f, -6.8125f, + -0.109375f, 0.6640625f, -1.3984375f, -5.34375f, -1.203125f, 1.453125f, + 2.828125f, -0.29296875f, 0.341796875f, -3.203125f, 1.703125f, -0.0405273438f, + -0.796875f, -0.0244140625f, 1.9453125f, -4.40625f, 2.796875f, -3.140625f, + -2.78125f, 2.875f, 0.48828125f, 2.84375f, 3.578125f, 1.8828125f, + 3.28125f, 2.359375f, 0.61328125f, 3.25f, 1.4765625f, -3.640625f, + 0.625f, -6.8125f, -0.109375f, 0.6640625f, -1.3984375f, -5.34375f, + -1.203125f, 1.453125f, 2.828125f, -0.29296875f, 0.341796875f, -3.203125f, + 1.703125f, -0.0405273438f, -0.796875f, -0.0244140625f, 1.9453125f, -4.40625f, + 2.796875f, -3.140625f, -2.78125f, 2.875f, 0.48828125f, 2.84375f, + 3.578125f, 1.8828125f, 3.28125f, 2.359375f, 0.61328125f, 3.25f, + 1.4765625f, -3.640625f, 0.625f, -6.8125f, -0.109375f, 0.6640625f, + -1.3984375f, -5.34375f, -1.203125f, 1.453125f, 2.828125f, -0.29296875f, + 0.341796875f, -3.203125f, 1.703125f, -0.0405273438f, -0.796875f, -0.0244140625f, + 1.9453125f, -4.40625f, 2.796875f, -3.140625f, -2.78125f, 2.875f, + 0.48828125f, 2.84375f, 3.578125f, 1.8828125f, 3.28125f, 2.359375f, + 0.61328125f, 3.25f, 1.4765625f, -3.640625f, 0.625f, -6.8125f, + -0.109375f, 0.6640625f, -1.3984375f, -5.34375f, -1.203125f, 1.453125f, + 2.828125f, -0.29296875f, 0.341796875f, -3.203125f, 1.703125f, -0.0405273438f, + -0.796875f, -0.0244140625f, 1.9453125f, -4.40625f, 2.796875f, -3.140625f, + -2.78125f, 2.875f, 0.48828125f, 2.84375f, 3.578125f, 1.8828125f, + 3.28125f, 2.359375f, 0.61328125f, 3.25f, 1.4765625f, -3.640625f, + 0.625f, -6.8125f, -0.109375f, 0.6640625f, -1.3984375f, -5.34375f, + -1.203125f, 1.453125f, 2.828125f, -0.29296875f, 0.341796875f, -3.203125f, + 1.703125f, -0.0405273438f, -0.796875f, -0.0244140625f, 1.9453125f, -4.40625f, + 2.796875f, -3.140625f, -2.78125f, 2.875f, 0.48828125f, 2.84375f, + 3.578125f, 1.8828125f, 3.28125f, 2.359375f, 0.61328125f, 3.25f, + 1.4765625f, -3.640625f, 0.625f, -6.8125f, -0.109375f, 0.6640625f, + -1.3984375f, -5.34375f, -1.203125f, 1.453125f, 2.828125f, -0.29296875f, + 0.341796875f, -3.203125f, 1.703125f, -0.0405273438f, -0.796875f, -0.0244140625f, + 1.9453125f, -4.40625f, 2.796875f, -3.140625f, -2.78125f, 2.875f, + 0.48828125f, 2.84375f, 3.578125f, 1.8828125f, 3.28125f, 2.359375f, + 0.61328125f, 3.25f, 1.4765625f, -3.640625f, 0.625f, -6.8125f, + -0.109375f, 0.6640625f, -1.3984375f, -5.34375f, -1.203125f, 1.453125f, + 2.828125f, -0.29296875f, 0.341796875f, -3.203125f, 1.703125f, -0.0405273438f, + -0.796875f, -0.0244140625f, 1.9453125f, -4.40625f, 2.796875f, -3.140625f, + -2.78125f, 2.875f, 0.48828125f, 2.84375f, 3.578125f, 1.8828125f, + -8.375f, 1.1875f, 1.859375f, 2.96875f, -4.4375f, 3.046875f, + 1.828125f, 0.6796875f, 6.40625f, 5.84375f, -0.6640625f, 0.5625f, + -9.875f, -4.375f, 3.21875f, 2.953125f, 1.171875f, -1.78125f, + 6.5625f, -4.0f, -12.9375f, 4.3125f, -0.121582031f, -6.28125f, + 5.5625f, 0.5546875f, 0.62890625f, 4.75f, 3.609375f, -0.96875f, + -0.174804688f, 2.625f, -8.6875f, 1.265625f, 5.75f, 1.4375f, + -9.5f, 8.5625f, -0.953125f, 3.375f, 1.8984375f, 4.46875f, + -2.625f, 0.0991210938f, -4.90625f, -3.1875f, 4.25f, 3.734375f, + 1.71875f, -2.71875f, 0.124023438f, -0.796875f, -4.75f, 7.96875f, + 2.828125f, -2.390625f, 6.34375f, 3.203125f, 5.0f, 2.53125f, + 3.03125f, 2.859375f, -3.078125f, -0.1015625f, -6.4375f, -4.21875f, + -3.375f, -0.137695312f, -7.53125f, 4.6875f, 0.46875f, -2.265625f, + 3.015625f, 0.50390625f, -1.5625f, 0.6484375f, -5.5f, -7.59375f, + 3.734375f, 0.208984375f, 3.015625f, -4.40625f, 1.28125f, -1.5859375f, + -1.734375f, -1.8046875f, 4.3125f, -10.625f, 7.5625f, 7.71875f, + 5.53125f, 10.5f, 3.625f, -2.9375f, 2.34375f, 3.734375f, + 1.46875f, 8.75f, 1.484375f, -0.248046875f, 5.90625f, -0.6171875f, + 2.203125f, -8.375f, -7.59375f, -3.390625f, -3.359375f, -6.3125f, + -3.671875f, -0.49609375f, 0.97265625f, 2.234375f, 1.6328125f, -0.19921875f, + 2.953125f, 2.859375f, -2.921875f, 3.34375f, -1.03125f, -10.375f, + 11.75f, -0.66015625f, 5.1875f, 7.625f, 0.267578125f, 4.9375f, + -3.5625f, 4.15625f, -3.09375f, -0.236328125f, -4.3125f, 8.25f, + -1.1640625f, 7.46875f, 1.6953125f, 5.65625f, 4.625f, -1.9453125f, + 2.421875f, -4.9375f, -1.234375f, 1.015625f, 6.28125f, -3.828125f, + 3.0f, -6.5625f, 1.3984375f, 1.46875f, -0.072265625f, -0.373046875f, + -0.5f, -6.53125f, 1.6328125f, 4.6875f, 5.59375f, 1.546875f, + -4.09375f, 1.3828125f, -8.1875f, 1.0703125f, 5.03125f, 3.34375f, + 2.9375f, 1.453125f, -4.3125f, 7.40625f, -5.53125f, -1.3359375f, + 9.875f, 4.59375f, 0.66015625f, 1.9921875f, 2.375f, 1.328125f, + -0.31640625f, -0.47265625f, -1.046875f, -3.125f, -2.0f, 0.8671875f, + 3.15625f, -2.203125f, 2.5f, -3.6875f, 0.0344238281f, 4.65625f, + 8.0625f, 4.875f, -1.9375f, 3.28125f, -2.828125f, 10.25f, + 8.4375f, 4.3125f, -2.984375f, -0.3125f, 12.25f, -1.609375f, + -5.15625f, -3.0f, 0.239257812f, -2.015625f, 1.1171875f, -4.25f, + -0.267578125f, 4.75f, 1.1484375f, 6.65625f, -7.3125f, 5.28125f, + -2.5f, 1.0f, -6.75f, -4.9375f, 5.25f, -3.078125f, + 2.984375f, 2.828125f, 5.9375f, 5.78125f, -1.90625f, 3.484375f, + 0.23046875f, 0.2109375f, 4.0625f, 13.75f, -0.0649414062f, 1.484375f, + 1.0f, 5.0625f, -2.65625f, -7.34375f, -4.0625f, -0.73046875f, + -2.671875f, 0.8515625f, 2.375f, -0.5859375f, 0.490234375f, -4.65625f, + 3.96875f, 1.8828125f, 0.466796875f, 0.0693359375f, -0.91015625f, 5.46875f, + 6.96875f, -4.46875f, 7.59375f, -1.8671875f, 2.5625f, 7.21875f, + -2.734375f, 4.34375f, -1.9296875f, -2.390625f, +}; + +inline constexpr float kLtxTowerPaddedStateBf16_11[] = { + 3.28125f, 2.875f, 1.78125f, 2.78125f, 3.59375f, -3.71875f, + 0.61328125f, -6.5f, -0.2890625f, -0.85546875f, -0.9453125f, -4.75f, + -0.46484375f, 0.94140625f, 3.515625f, -1.5546875f, 0.396484375f, -1.3359375f, + 2.75f, 0.35546875f, -1.9453125f, -1.59375f, 1.25f, -3.828125f, + 3.59375f, -2.734375f, -1.9921875f, 3.515625f, 0.57421875f, 4.5625f, + 3.34375f, 0.66796875f, 3.28125f, 2.875f, 1.78125f, 2.78125f, + 3.59375f, -3.71875f, 0.61328125f, -6.5f, -0.2890625f, -0.85546875f, + -0.9453125f, -4.75f, -0.46484375f, 0.94140625f, 3.515625f, -1.5546875f, + 0.396484375f, -1.3359375f, 2.75f, 0.35546875f, -1.9453125f, -1.59375f, + 1.25f, -3.828125f, 3.59375f, -2.734375f, -1.9921875f, 3.515625f, + 0.57421875f, 4.5625f, 3.34375f, 0.66796875f, 3.28125f, 2.875f, + 1.78125f, 2.78125f, 3.59375f, -3.71875f, 0.61328125f, -6.5f, + -0.2890625f, -0.85546875f, -0.9453125f, -4.75f, -0.46484375f, 0.94140625f, + 3.515625f, -1.5546875f, 0.396484375f, -1.3359375f, 2.75f, 0.35546875f, + -1.9453125f, -1.59375f, 1.25f, -3.828125f, 3.59375f, -2.734375f, + -1.9921875f, 3.515625f, 0.57421875f, 4.5625f, 3.34375f, 0.66796875f, + 3.28125f, 2.875f, 1.78125f, 2.78125f, 3.59375f, -3.71875f, + 0.61328125f, -6.5f, -0.2890625f, -0.85546875f, -0.9453125f, -4.75f, + -0.46484375f, 0.94140625f, 3.515625f, -1.5546875f, 0.396484375f, -1.3359375f, + 2.75f, 0.35546875f, -1.9453125f, -1.59375f, 1.25f, -3.828125f, + 3.59375f, -2.734375f, -1.9921875f, 3.515625f, 0.57421875f, 4.5625f, + 3.34375f, 0.66796875f, 3.28125f, 2.875f, 1.78125f, 2.78125f, + 3.59375f, -3.71875f, 0.61328125f, -6.5f, -0.2890625f, -0.85546875f, + -0.9453125f, -4.75f, -0.46484375f, 0.94140625f, 3.515625f, -1.5546875f, + 0.396484375f, -1.3359375f, 2.75f, 0.35546875f, -1.9453125f, -1.59375f, + 1.25f, -3.828125f, 3.59375f, -2.734375f, -1.9921875f, 3.515625f, + 0.57421875f, 4.5625f, 3.34375f, 0.66796875f, 3.28125f, 2.875f, + 1.78125f, 2.78125f, 3.59375f, -3.71875f, 0.61328125f, -6.5f, + -0.2890625f, -0.85546875f, -0.9453125f, -4.75f, -0.46484375f, 0.94140625f, + 3.515625f, -1.5546875f, 0.396484375f, -1.3359375f, 2.75f, 0.35546875f, + -1.9453125f, -1.59375f, 1.25f, -3.828125f, 3.59375f, -2.734375f, + -1.9921875f, 3.515625f, 0.57421875f, 4.5625f, 3.34375f, 0.66796875f, + 3.28125f, 2.875f, 1.78125f, 2.78125f, 3.59375f, -3.71875f, + 0.61328125f, -6.5f, -0.2890625f, -0.85546875f, -0.9453125f, -4.75f, + -0.46484375f, 0.94140625f, 3.515625f, -1.5546875f, 0.396484375f, -1.3359375f, + 2.75f, 0.35546875f, -1.9453125f, -1.59375f, 1.25f, -3.828125f, + 3.59375f, -2.734375f, -1.9921875f, 3.515625f, 0.57421875f, 4.5625f, + 3.34375f, 0.66796875f, 3.28125f, 2.875f, 1.78125f, 2.78125f, + 3.59375f, -3.71875f, 0.61328125f, -6.5f, -0.2890625f, -0.85546875f, + -0.9453125f, -4.75f, -0.46484375f, 0.94140625f, 3.515625f, -1.5546875f, + 0.396484375f, -1.3359375f, 2.75f, 0.35546875f, -1.9453125f, -1.59375f, + 1.25f, -3.828125f, 3.59375f, -2.734375f, -1.9921875f, 3.515625f, + 0.57421875f, 4.5625f, 3.34375f, 0.66796875f, 3.28125f, 2.875f, + 1.78125f, 2.78125f, 3.59375f, -3.71875f, 0.61328125f, -6.5f, + -0.2890625f, -0.85546875f, -0.9453125f, -4.75f, -0.46484375f, 0.94140625f, + 3.515625f, -1.5546875f, 0.396484375f, -1.3359375f, 2.75f, 0.35546875f, + -1.9453125f, -1.59375f, 1.25f, -3.828125f, 3.59375f, -2.734375f, + -1.9921875f, 3.515625f, 0.57421875f, 4.5625f, 3.34375f, 0.66796875f, + 3.28125f, 2.875f, 1.78125f, 2.78125f, 3.59375f, -3.71875f, + 0.61328125f, -6.5f, -0.2890625f, -0.85546875f, -0.9453125f, -4.75f, + -0.46484375f, 0.94140625f, 3.515625f, -1.5546875f, 0.396484375f, -1.3359375f, + 2.75f, 0.35546875f, -1.9453125f, -1.59375f, 1.25f, -3.828125f, + 3.59375f, -2.734375f, -1.9921875f, 3.515625f, 0.57421875f, 4.5625f, + 3.34375f, 0.66796875f, 3.28125f, 2.875f, 1.78125f, 2.78125f, + 3.59375f, -3.71875f, 0.61328125f, -6.5f, -0.2890625f, -0.85546875f, + -0.9453125f, -4.75f, -0.46484375f, 0.94140625f, 3.515625f, -1.5546875f, + 0.396484375f, -1.3359375f, 2.75f, 0.35546875f, -1.9453125f, -1.59375f, + 1.25f, -3.828125f, 3.59375f, -2.734375f, -1.9921875f, 3.515625f, + 0.57421875f, 4.5625f, 3.34375f, 0.66796875f, 3.28125f, 2.875f, + 1.78125f, 2.78125f, 3.59375f, -3.71875f, 0.61328125f, -6.5f, + -0.2890625f, -0.85546875f, -0.9453125f, -4.75f, -0.46484375f, 0.94140625f, + 3.515625f, -1.5546875f, 0.396484375f, -1.3359375f, 2.75f, 0.35546875f, + -1.9453125f, -1.59375f, 1.25f, -3.828125f, 3.59375f, -2.734375f, + -1.9921875f, 3.515625f, 0.57421875f, 4.5625f, 3.34375f, 0.66796875f, + -10.375f, 0.484375f, 2.328125f, 4.0625f, -5.75f, 1.9140625f, + 1.0703125f, 0.9609375f, 4.75f, 8.75f, -1.3046875f, 1.3046875f, + -9.125f, -5.0f, 2.921875f, 1.3515625f, 1.078125f, -1.4296875f, + 4.0625f, -5.1875f, -14.4375f, 3.234375f, -0.470703125f, -5.90625f, + 6.78125f, 2.15625f, -0.37109375f, 7.65625f, 1.4609375f, 0.953125f, + -2.109375f, 0.67578125f, -10.4375f, -1.28125f, 6.5f, 1.015625f, + -10.375f, 7.625f, -1.71875f, 4.46875f, 0.4921875f, 6.84375f, + -3.75f, 0.00988769531f, -5.34375f, -3.453125f, 5.34375f, 2.171875f, + 1.796875f, -3.015625f, -1.984375f, -0.94921875f, -4.46875f, 8.625f, + 4.21875f, -2.65625f, 7.125f, 3.34375f, 5.15625f, 6.28125f, + 0.0952148438f, 4.03125f, -5.75f, -1.4609375f, -8.5625f, -7.0f, + -5.15625f, -2.28125f, -8.0f, 3.84375f, 0.47265625f, -2.59375f, + 4.5625f, 0.9375f, 0.0417480469f, 0.9453125f, -5.71875f, -7.9375f, + 3.09375f, -0.206054688f, 4.53125f, -3.75f, -1.0078125f, -2.796875f, + -2.21875f, -2.0625f, 3.734375f, -11.5625f, 6.28125f, 8.3125f, + 6.25f, 12.1875f, 2.859375f, -3.375f, 1.265625f, 4.53125f, + 0.78515625f, 8.125f, 1.3515625f, -0.6875f, 3.875f, -0.96875f, + 4.21875f, -8.875f, -5.0625f, -4.28125f, -2.3125f, -5.5f, + -2.296875f, -4.40625f, -1.4765625f, -0.9375f, -1.53125f, 1.203125f, + 4.0625f, 2.578125f, -3.109375f, 4.40625f, -0.95703125f, -11.5625f, + 10.9375f, 1.828125f, 6.78125f, 9.0625f, -0.83203125f, 4.46875f, + -7.03125f, 4.125f, -3.140625f, 0.380859375f, -3.296875f, 7.125f, + -2.671875f, 6.59375f, 2.265625f, 3.453125f, 6.6875f, -0.81640625f, + 3.203125f, -4.8125f, -1.3828125f, 0.5078125f, 4.875f, -5.21875f, + 3.046875f, -6.0f, -1.2890625f, 0.6328125f, -1.9375f, 2.09375f, + -0.11328125f, -7.3125f, 2.1875f, 4.125f, 6.40625f, 3.109375f, + -4.28125f, 2.046875f, -7.875f, 0.69921875f, 4.875f, 1.828125f, + 2.53125f, 1.390625f, -5.78125f, 6.25f, -6.40625f, -1.1484375f, + 11.0f, 6.46875f, 1.6015625f, 2.828125f, 2.203125f, 1.8828125f, + -2.171875f, -1.1328125f, 0.178710938f, -4.65625f, -2.875f, 0.6015625f, + 2.046875f, -1.7578125f, 3.234375f, -5.96875f, -0.6796875f, 3.53125f, + 6.96875f, 6.65625f, -2.484375f, 2.890625f, -4.0625f, 10.0625f, + 10.875f, 4.25f, -5.34375f, -1.140625f, 10.8125f, -0.734375f, + -3.453125f, -4.40625f, 4.09375f, -2.78125f, 2.6875f, -3.84375f, + 0.59765625f, 2.703125f, -0.178710938f, 4.59375f, -8.5625f, 5.84375f, + -0.734375f, 1.3046875f, -5.625f, -3.703125f, 6.59375f, -2.53125f, + 3.203125f, 2.171875f, 7.25f, 5.59375f, -3.171875f, 2.375f, + -1.203125f, 0.54296875f, 5.6875f, 12.375f, -1.4140625f, 2.359375f, + 0.23046875f, 4.875f, 0.65234375f, -5.9375f, -0.119140625f, -1.6328125f, + -0.73046875f, 2.5f, 3.625f, -2.484375f, -0.65234375f, -4.4375f, + 5.71875f, 2.90625f, 3.0f, -0.90625f, -1.4296875f, 5.6875f, + 7.5f, -6.15625f, 7.46875f, -0.396484375f, 2.0625f, 4.9375f, + -2.671875f, 2.53125f, -0.51953125f, -2.96875f, +}; + +inline constexpr float kLtxTowerPaddedStateBf16_12[] = { + 0.78515625f, 0.9453125f, 0.453125f, 0.62109375f, 1.109375f, -0.71484375f, + 0.165039062f, -2.59375f, -0.198242188f, -0.361328125f, -0.44140625f, -2.109375f, + -0.330078125f, -0.283203125f, 0.6796875f, -1.09375f, 0.359375f, -0.341796875f, + 0.90234375f, 0.251953125f, -0.8515625f, -0.6015625f, 1.5390625f, -1.5390625f, + 1.53125f, -1.0859375f, -0.609375f, 1.1640625f, -0.00805664062f, 1.4375f, + 1.1328125f, -0.12109375f, 0.78515625f, 0.9453125f, 0.453125f, 0.62109375f, + 1.109375f, -0.71484375f, 0.165039062f, -2.59375f, -0.198242188f, -0.361328125f, + -0.44140625f, -2.109375f, -0.330078125f, -0.283203125f, 0.6796875f, -1.09375f, + 0.359375f, -0.341796875f, 0.90234375f, 0.251953125f, -0.8515625f, -0.6015625f, + 1.5390625f, -1.5390625f, 1.53125f, -1.0859375f, -0.609375f, 1.1640625f, + -0.00805664062f, 1.4375f, 1.1328125f, -0.12109375f, 0.78515625f, 0.9453125f, + 0.453125f, 0.62109375f, 1.109375f, -0.71484375f, 0.165039062f, -2.59375f, + -0.198242188f, -0.361328125f, -0.44140625f, -2.109375f, -0.330078125f, -0.283203125f, + 0.6796875f, -1.09375f, 0.359375f, -0.341796875f, 0.90234375f, 0.251953125f, + -0.8515625f, -0.6015625f, 1.5390625f, -1.5390625f, 1.53125f, -1.0859375f, + -0.609375f, 1.1640625f, -0.00805664062f, 1.4375f, 1.1328125f, -0.12109375f, + 0.78515625f, 0.9453125f, 0.453125f, 0.62109375f, 1.109375f, -0.71484375f, + 0.165039062f, -2.59375f, -0.198242188f, -0.361328125f, -0.44140625f, -2.109375f, + -0.330078125f, -0.283203125f, 0.6796875f, -1.09375f, 0.359375f, -0.341796875f, + 0.90234375f, 0.251953125f, -0.8515625f, -0.6015625f, 1.5390625f, -1.5390625f, + 1.53125f, -1.0859375f, -0.609375f, 1.1640625f, -0.00805664062f, 1.4375f, + 1.1328125f, -0.12109375f, 0.78515625f, 0.9453125f, 0.453125f, 0.62109375f, + 1.109375f, -0.71484375f, 0.165039062f, -2.59375f, -0.198242188f, -0.361328125f, + -0.44140625f, -2.109375f, -0.330078125f, -0.283203125f, 0.6796875f, -1.09375f, + 0.359375f, -0.341796875f, 0.90234375f, 0.251953125f, -0.8515625f, -0.6015625f, + 1.5390625f, -1.5390625f, 1.53125f, -1.0859375f, -0.609375f, 1.1640625f, + -0.00805664062f, 1.4375f, 1.1328125f, -0.12109375f, 0.78515625f, 0.9453125f, + 0.453125f, 0.62109375f, 1.109375f, -0.71484375f, 0.165039062f, -2.59375f, + -0.198242188f, -0.361328125f, -0.44140625f, -2.109375f, -0.330078125f, -0.283203125f, + 0.6796875f, -1.09375f, 0.359375f, -0.341796875f, 0.90234375f, 0.251953125f, + -0.8515625f, -0.6015625f, 1.5390625f, -1.5390625f, 1.53125f, -1.0859375f, + -0.609375f, 1.1640625f, -0.00805664062f, 1.4375f, 1.1328125f, -0.12109375f, + 0.78515625f, 0.9453125f, 0.453125f, 0.62109375f, 1.109375f, -0.71484375f, + 0.165039062f, -2.59375f, -0.198242188f, -0.361328125f, -0.44140625f, -2.109375f, + -0.330078125f, -0.283203125f, 0.6796875f, -1.09375f, 0.359375f, -0.341796875f, + 0.90234375f, 0.251953125f, -0.8515625f, -0.6015625f, 1.5390625f, -1.5390625f, + 1.53125f, -1.0859375f, -0.609375f, 1.1640625f, -0.00805664062f, 1.4375f, + 1.1328125f, -0.12109375f, 0.78515625f, 0.9453125f, 0.453125f, 0.62109375f, + 1.109375f, -0.71484375f, 0.165039062f, -2.59375f, -0.198242188f, -0.361328125f, + -0.44140625f, -2.109375f, -0.330078125f, -0.283203125f, 0.6796875f, -1.09375f, + 0.359375f, -0.341796875f, 0.90234375f, 0.251953125f, -0.8515625f, -0.6015625f, + 1.5390625f, -1.5390625f, 1.53125f, -1.0859375f, -0.609375f, 1.1640625f, + -0.00805664062f, 1.4375f, 1.1328125f, -0.12109375f, 0.78515625f, 0.9453125f, + 0.453125f, 0.62109375f, 1.109375f, -0.71484375f, 0.165039062f, -2.59375f, + -0.198242188f, -0.361328125f, -0.44140625f, -2.109375f, -0.330078125f, -0.283203125f, + 0.6796875f, -1.09375f, 0.359375f, -0.341796875f, 0.90234375f, 0.251953125f, + -0.8515625f, -0.6015625f, 1.5390625f, -1.5390625f, 1.53125f, -1.0859375f, + -0.609375f, 1.1640625f, -0.00805664062f, 1.4375f, 1.1328125f, -0.12109375f, + 0.78515625f, 0.9453125f, 0.453125f, 0.62109375f, 1.109375f, -0.71484375f, + 0.165039062f, -2.59375f, -0.198242188f, -0.361328125f, -0.44140625f, -2.109375f, + -0.330078125f, -0.283203125f, 0.6796875f, -1.09375f, 0.359375f, -0.341796875f, + 0.90234375f, 0.251953125f, -0.8515625f, -0.6015625f, 1.5390625f, -1.5390625f, + 1.53125f, -1.0859375f, -0.609375f, 1.1640625f, -0.00805664062f, 1.4375f, + 1.1328125f, -0.12109375f, 0.78515625f, 0.9453125f, 0.453125f, 0.62109375f, + 1.109375f, -0.71484375f, 0.165039062f, -2.59375f, -0.198242188f, -0.361328125f, + -0.44140625f, -2.109375f, -0.330078125f, -0.283203125f, 0.6796875f, -1.09375f, + 0.359375f, -0.341796875f, 0.90234375f, 0.251953125f, -0.8515625f, -0.6015625f, + 1.5390625f, -1.5390625f, 1.53125f, -1.0859375f, -0.609375f, 1.1640625f, + -0.00805664062f, 1.4375f, 1.1328125f, -0.12109375f, 0.78515625f, 0.9453125f, + 0.453125f, 0.62109375f, 1.109375f, -0.71484375f, 0.165039062f, -2.59375f, + -0.198242188f, -0.361328125f, -0.44140625f, -2.109375f, -0.330078125f, -0.283203125f, + 0.6796875f, -1.09375f, 0.359375f, -0.341796875f, 0.90234375f, 0.251953125f, + -0.8515625f, -0.6015625f, 1.5390625f, -1.5390625f, 1.53125f, -1.0859375f, + -0.609375f, 1.1640625f, -0.00805664062f, 1.4375f, 1.1328125f, -0.12109375f, + -1.9453125f, -0.110351562f, 0.54296875f, 0.96875f, -1.40625f, 0.3984375f, + -0.0971679688f, 0.21484375f, 1.25f, 1.8515625f, -0.159179688f, 0.62109375f, + -1.4453125f, -0.6953125f, 0.66796875f, -0.200195312f, 0.458984375f, -0.3515625f, + 0.81640625f, -0.7421875f, -2.734375f, 0.453125f, -0.137695312f, -1.3828125f, + 0.9765625f, 0.140625f, 0.306640625f, 1.375f, 0.478515625f, 0.80859375f, + -0.17578125f, 0.170898438f, -1.7578125f, -0.287109375f, 1.421875f, 0.177734375f, + -2.203125f, 1.6015625f, -0.84375f, 1.125f, 0.333984375f, 1.515625f, + -0.51953125f, 0.0168457031f, -0.83984375f, -0.225585938f, 1.0625f, 0.265625f, + 0.3828125f, -0.734375f, 0.106933594f, -0.221679688f, -0.9375f, 1.3984375f, + 0.58203125f, -1.0234375f, 1.5703125f, 0.3515625f, 1.140625f, 1.046875f, + -0.00254821777f, 1.2734375f, -0.92578125f, -0.170898438f, -1.34375f, -1.1484375f, + -1.0078125f, -0.314453125f, -2.03125f, 0.77734375f, 0.00540161133f, -0.248046875f, + 1.0f, 0.25f, 0.0152587891f, -0.133789062f, -0.71484375f, -1.2734375f, + 0.703125f, -0.115722656f, 0.87109375f, -0.337890625f, 0.215820312f, -0.28515625f, + -0.78125f, -0.765625f, 0.828125f, -2.171875f, 1.296875f, 1.2734375f, + 1.4453125f, 2.0625f, 0.59765625f, -0.0888671875f, 0.197265625f, 0.9609375f, + 0.190429688f, 1.2578125f, 0.255859375f, -0.168945312f, 0.41796875f, -0.1328125f, + 0.5859375f, -1.5234375f, -0.96484375f, -0.83984375f, -0.279296875f, -1.140625f, + -0.40234375f, -0.93359375f, -0.80078125f, -0.0229492188f, -0.2890625f, 0.0712890625f, + 1.09375f, 0.8515625f, -0.5625f, 0.71484375f, -0.15625f, -2.484375f, + 1.8515625f, 0.208007812f, 1.609375f, 1.234375f, -0.137695312f, 1.265625f, + -1.484375f, 1.2578125f, -0.71484375f, 0.0177001953f, -0.153320312f, 1.25f, + -1.046875f, 1.7109375f, 0.578125f, 1.2890625f, 1.21875f, 0.427734375f, + 0.208007812f, -1.390625f, -0.498046875f, 0.0145263672f, 0.953125f, -1.46875f, + 0.55078125f, -1.4375f, 0.190429688f, 0.247070312f, -0.33203125f, -0.174804688f, + 0.1484375f, -2.28125f, 0.453125f, 0.75f, 2.0f, 0.66796875f, + -0.6796875f, 1.1015625f, -1.5625f, 0.3984375f, 0.94921875f, 0.30859375f, + 0.5390625f, 0.333984375f, -1.5078125f, 1.046875f, -1.7109375f, -0.0334472656f, + 2.609375f, 1.234375f, 0.400390625f, 0.7578125f, 0.0378417969f, 0.76171875f, + -0.36328125f, -0.30078125f, -0.180664062f, -1.1640625f, -0.296875f, 0.275390625f, + 0.515625f, -0.6171875f, 0.5546875f, -1.3125f, -0.359375f, 0.62109375f, + 1.75f, 1.0078125f, -0.141601562f, 0.65234375f, -0.65625f, 2.21875f, + 2.140625f, 1.34375f, -1.421875f, 0.443359375f, 1.890625f, -0.189453125f, + -0.0756835938f, -0.96875f, 0.91015625f, -0.359375f, 0.0172119141f, -0.78515625f, + 0.0698242188f, 0.1640625f, 0.0888671875f, 0.71875f, -2.046875f, 0.94921875f, + -0.5390625f, 0.890625f, -1.3046875f, -1.2265625f, 1.34375f, -0.0649414062f, + 0.58984375f, 0.77734375f, 1.40625f, 1.2421875f, -0.92578125f, 0.7734375f, + -0.265625f, 0.2890625f, 1.1484375f, 2.375f, 0.0581054688f, 0.78515625f, + -0.5078125f, 1.5859375f, 0.306640625f, -1.3046875f, 0.384765625f, -0.6953125f, + -0.204101562f, 1.125f, 0.78125f, -0.6640625f, -0.453125f, -1.015625f, + 1.015625f, 0.056640625f, 1.1171875f, -0.0849609375f, 0.0217285156f, 1.2578125f, + 2.03125f, -1.328125f, 1.625f, -0.12890625f, 0.5234375f, 0.89453125f, + -0.23046875f, 0.9375f, -0.48828125f, -0.104003906f, }; // --- section 5: the equivalence, measured INSIDE the oracle --- // Per state, max|short-run-at-absolute-positions - padded-run's valid rows|, -// both f32, so this number carries NO dtype noise. It is upstream's own -// answer to 'is dropping the pads free?'. Our port inherits it; the C++ -// gate checks the two claims separately so a failure says which one broke. +// both f32 and both on independently deep-copied modules, so this number +// carries NO dtype noise. It is upstream's own answer to 'is dropping the +// pads free?'. Our port inherits it; the C++ gate checks the two claims +// separately so a failure says which one broke. inline constexpr float kLtxTowerPadEquivalence[] = { - 0.0f, 1.1920929e-06f, 5.7220459e-06f, 5.48362732e-06f, 7.86781311e-06f, 1.23977661e-05f, - 1.87158585e-05f, 2.12192535e-05f, 1.90734863e-05f, 1.8954277e-05f, 2.25305557e-05f, 3.21865082e-05f, - 7.33137131e-06f, + 0.0f, 1.78813934e-06f, 4.23192978e-06f, 6.67572021e-06f, 9.53674316e-06f, 1.85966492e-05f, + 1.82986259e-05f, 1.95503235e-05f, 2.00271606e-05f, 1.57356262e-05f, 4.56571579e-05f, 5.25712967e-05f, + 1.24871731e-05f, +}; + +// --- section 6: the ORACLE's FULL-attention rope cos|sin table, f32 --- +// [position][global_head_dim]: first half cos, second half sin, over the +// global_head_dim/2 DISTINCT angle pairs (upstream stores each twice). +// `rope_type: proportional` at theta 1e6 and partial_rotary_factor 0.25, +// so the trailing pairs are cos=1, sin=0. Emitted because the partial +// factor is NOT resolvable from the hidden states -- see the note above -- +// and because a table that silently rotated every pair would still produce +// 13 finite, plausibly-scaled states. +inline constexpr int64_t kLtxTowerRopePositions = 20; + +inline constexpr float kLtxTowerRopeFullCosSin[] = { + 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, + 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 0.0f, 0.540302336f, 0.98423022f, + 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, + 0.841470957f, 0.176892191f, 0.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 0.0f, -0.416146845f, 0.937418342f, 1.0f, 1.0f, + 1.0f, 1.0f, 1.0f, 1.0f, 0.909297407f, 0.348205268f, + 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, + -0.989992499f, 0.861040652f, 1.0f, 1.0f, 1.0f, 1.0f, + 1.0f, 1.0f, 0.141120002f, 0.5085361f, 0.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 0.0f, -0.653643608f, 0.757506192f, + 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, + -0.756802499f, 0.652827978f, 0.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 0.2836622f, 0.630080283f, 1.0f, 1.0f, + 1.0f, 1.0f, 1.0f, 1.0f, -0.958924294f, 0.776529968f, + 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, + 0.960170269f, 0.482782036f, 1.0f, 1.0f, 1.0f, 1.0f, + 1.0f, 1.0f, -0.279415488f, 0.875740528f, 0.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 0.0f, 0.753902256f, 0.320257008f, + 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, + 0.656986594f, 0.947330713f, 0.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 0.0f, -0.145500034f, 0.147631213f, 1.0f, 1.0f, + 1.0f, 1.0f, 1.0f, 1.0f, 0.989358246f, 0.989042461f, + 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, + -0.91113025f, -0.0296507962f, 1.0f, 1.0f, 1.0f, 1.0f, + 1.0f, 1.0f, 0.412118495f, 0.999560297f, 0.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 0.0f, -0.839071512f, -0.205997631f, + 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, + -0.54402113f, 0.97855252f, 0.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 0.00442569796f, -0.375847399f, 1.0f, 1.0f, + 1.0f, 1.0f, 1.0f, 1.0f, -0.999990225f, 0.926681578f, + 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, + 0.843853951f, -0.53384304f, 1.0f, 1.0f, 1.0f, 1.0f, + 1.0f, 1.0f, -0.536572933f, 0.845583618f, 0.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 0.0f, 0.907446802f, -0.675001681f, + 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, + 0.420167029f, 0.737816215f, 0.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 0.136737213f, -0.794870913f, 1.0f, 1.0f, + 1.0f, 1.0f, 1.0f, 1.0f, 0.990607381f, 0.606778562f, + 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, + -0.759687901f, -0.889670432f, 1.0f, 1.0f, 1.0f, 1.0f, + 1.0f, 1.0f, 0.650287867f, 0.456603259f, 0.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 0.0f, -0.957659483f, -0.95641005f, + 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, + -0.287903309f, 0.292027086f, 0.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 0.0f, -0.275163352f, -0.992984951f, 1.0f, 1.0f, + 1.0f, 1.0f, 1.0f, 1.0f, -0.961397469f, 0.11824052f, + 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, + 0.660316706f, -0.998241663f, 1.0f, 1.0f, 1.0f, 1.0f, + 1.0f, 1.0f, -0.750987232f, -0.0592755191f, 0.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 0.0f, 0.988704622f, -0.972014248f, + 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, + 0.149877205f, -0.234921798f, 0.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 0.0f, }; } // namespace vllm_test diff --git a/tests/vllm/models/test_ltx2_text_encoder.cpp b/tests/vllm/models/test_ltx2_text_encoder.cpp index 0b746c502..f70ee2608 100644 --- a/tests/vllm/models/test_ltx2_text_encoder.cpp +++ b/tests/vllm/models/test_ltx2_text_encoder.cpp @@ -30,6 +30,7 @@ #include #include #include +#include #include #include #include @@ -249,24 +250,30 @@ void AppendU64(std::string& out, uint64_t value) { for (int i = 0; i < 8; ++i) out.push_back(static_cast((value >> (8 * i)) & 0xFF)); } -// Writes a minimal .safetensors carrying only U8 asset tensors, in the shape -// gemma_assets.py:335-386 packs them. `metadata` is written verbatim as the +// One tensor in a synthetic pack, at its real dtype and shape. +struct PackTensor { + std::string name; + std::string dtype; + std::vector shape; + std::string bytes; +}; + +// Writes a minimal .safetensors. `metadata` is written verbatim as the // `__metadata__` object when non-empty. -std::string WritePack(const fs::path& path, - const std::vector>& tensors, - const std::string& metadata_json) { +std::string WriteTypedPack(const fs::path& path, const std::vector& tensors, + const std::string& metadata_json) { nlohmann::json header = nlohmann::json::object(); if (!metadata_json.empty()) header["__metadata__"] = nlohmann::json::parse(metadata_json); uint64_t offset = 0; std::string payload; - for (const auto& [name, bytes] : tensors) { - header[name] = nlohmann::json{ - {"dtype", "U8"}, - {"shape", nlohmann::json::array({static_cast(bytes.size())})}, + for (const PackTensor& t : tensors) { + header[t.name] = nlohmann::json{ + {"dtype", t.dtype}, + {"shape", t.shape}, {"data_offsets", - nlohmann::json::array({offset, offset + static_cast(bytes.size())})}}; - offset += bytes.size(); - payload += bytes; + nlohmann::json::array({offset, offset + static_cast(t.bytes.size())})}}; + offset += t.bytes.size(); + payload += t.bytes; } const std::string head = header.dump(); std::string out; @@ -279,6 +286,25 @@ std::string WritePack(const fs::path& path, return path.string(); } +// The U8-asset form, in the shape gemma_assets.py:335-386 packs them. +std::string WritePack(const fs::path& path, + const std::vector>& tensors, + const std::string& metadata_json) { + std::vector typed; + typed.reserve(tensors.size()); + for (const auto& [name, bytes] : tensors) + typed.push_back( + PackTensor{name, "U8", {static_cast(bytes.size())}, bytes}); + return WriteTypedPack(path, typed, metadata_json); +} + +std::string Bf16Bytes(const std::vector& values) { + std::string out(values.size() * sizeof(uint16_t), '\0'); + auto* p = reinterpret_cast(out.data()); + for (size_t i = 0; i < values.size(); ++i) p[i] = vt::F32ToBF16(values[i]); + return out; +} + std::string BytesToString(const std::vector& bytes) { return std::string(bytes.begin(), bytes.end()); } @@ -579,6 +605,178 @@ const float* TowerGoldenPadded(int64_t state) { return kStates[static_cast(state)]; } +const float* TowerGoldenPaddedBf16(int64_t state) { + static const float* const kStates[] = { + vllm_test::kLtxTowerPaddedStateBf16_0, vllm_test::kLtxTowerPaddedStateBf16_1, + vllm_test::kLtxTowerPaddedStateBf16_2, vllm_test::kLtxTowerPaddedStateBf16_3, + vllm_test::kLtxTowerPaddedStateBf16_4, vllm_test::kLtxTowerPaddedStateBf16_5, + vllm_test::kLtxTowerPaddedStateBf16_6, vllm_test::kLtxTowerPaddedStateBf16_7, + vllm_test::kLtxTowerPaddedStateBf16_8, vllm_test::kLtxTowerPaddedStateBf16_9, + vllm_test::kLtxTowerPaddedStateBf16_10, vllm_test::kLtxTowerPaddedStateBf16_11, + vllm_test::kLtxTowerPaddedStateBf16_12, + }; + return kStates[static_cast(state)]; +} + +// ─────────── the reduced tower as a FILE, so the LOADER is CI-reachable ─────── +// +// `Ltx2LoadGemmaTowerFromSafetensors` and every refusal it documents were +// reachable from exactly one place — the opt-in real-checkpoint case — so none of +// them had CI coverage. The tower fixture above already carries the weight stream +// the ORACLE ran, keyed by HuggingFace parameter NAME; writing that same stream +// into a safetensors file under the CHECKPOINT's tensor names (`model.*`, which +// is what the loader reads) makes the loader answerable to it. The two must agree +// byte for byte, which is a real gate on the parts that have no shape to check +// them: the q|k|v concat ORDER, the `k_eq_v` aliasing of V onto K on the full +// layers, and the per-layer 8-vs-16 head_dim / 2-vs-1 kv-head split. +std::vector TowerPackTensors(const vllm::HfConfig& c) { + const int64_t H = c.hidden_size, I = c.intermediate_size, V = c.vocab_size; + const int64_t Hq = vllm_test::kLtxTowerNumHeads; + std::vector ts; + // `file` is the CHECKPOINT name the loader reads; `stream` is the HuggingFace + // parameter name the deterministic weight stream is keyed by. They differ + // (`model.` vs `language_model.`) and conflating them would make the fixture + // agree with the loader about bytes nobody generated from the same seed. + auto add = [&ts](const std::string& file, const std::string& stream, + std::vector shape) { + int64_t n = 1; + for (int64_t d : shape) n *= d; + ts.push_back(PackTensor{file, "BF16", std::move(shape), Bf16Bytes(TowerRand(stream, n))}); + }; + add("model.embed_tokens.weight", "language_model.embed_tokens.weight", {V, H}); + add("model.norm.weight", "language_model.norm.weight", {H}); + for (int64_t l = 0; l < c.num_hidden_layers; ++l) { + const bool full = vllm_test::kLtxTowerLayerIsFull[static_cast(l)] != 0; + const int64_t Dh = + full ? vllm_test::kLtxTowerGlobalHeadDim : vllm_test::kLtxTowerHeadDim; + const int64_t Hkv = full ? vllm_test::kLtxTowerNumGlobalKvHeads + : vllm_test::kLtxTowerNumKvHeads; + const std::string b = "model.layers." + std::to_string(l) + "."; + auto layer = [&](const char* suffix, std::vector shape) { + add(b + suffix, TowerParam(l, suffix), std::move(shape)); + }; + layer("self_attn.q_proj.weight", {Hq * Dh, H}); + layer("self_attn.k_proj.weight", {Hkv * Dh, H}); + // The full layers ship NO v_proj at all: `attention_k_eq_v` aliases V onto K. + if (!full) layer("self_attn.v_proj.weight", {Hkv * Dh, H}); + layer("self_attn.o_proj.weight", {H, Hq * Dh}); + layer("self_attn.q_norm.weight", {Dh}); + layer("self_attn.k_norm.weight", {Dh}); + layer("mlp.gate_proj.weight", {I, H}); + layer("mlp.up_proj.weight", {I, H}); + layer("mlp.down_proj.weight", {H, I}); + layer("input_layernorm.weight", {H}); + layer("post_attention_layernorm.weight", {H}); + layer("pre_feedforward_layernorm.weight", {H}); + layer("post_feedforward_layernorm.weight", {H}); + layer("layer_scalar", {1}); + } + return ts; +} + +bool SameTensor(const vllm::OwnedTensor& a, const vllm::OwnedTensor& b) { + if (a.dtype != b.dtype || a.rank != b.rank || a.nk != b.nk) return false; + for (int i = 0; i < a.rank; ++i) + if (a.shape[i] != b.shape[i]) return false; + return a.bytes == b.bytes; +} + +// A tokenizer over the reduced tower's 64-id vocabulary whose ADDED tokens spell +// one id each, so a prompt can be written that tokenizes to EXACTLY the token +// sequence the oracle ran. Without that the conditioning path has no committed +// oracle to be held to and only its shapes can be checked. +std::string TowerTokenizerJson() { + nlohmann::json added = nlohmann::json::array(); + nlohmann::json vocab = nlohmann::json::object(); + const char* kSpecial[] = {"", "", ""}; + for (int64_t i = 0; i < 3; ++i) { + vocab[kSpecial[i]] = i; + added.push_back({{"id", i}, {"content", kSpecial[i]}, {"special", true}}); + } + for (int64_t i = 3; i < vllm_test::kLtxTowerVocab; ++i) { + const std::string t = ""; + vocab[t] = i; + added.push_back({{"id", i}, {"content", t}, {"special", false}}); + } + // Normalizer / pre-tokenizer / decoder are the SHIPPED tokenizer's own forms, + // carried over from the wrapper fixture above. They are inert on a prompt made + // only of added tokens (it has no spaces), which is the point: the prompt's + // token ids come from the added-token table and not from BPE luck. + nlohmann::json j; + j["version"] = "1.0"; + j["added_tokens"] = added; + j["normalizer"] = {{"type", "Replace"}, + {"pattern", {{"String", " "}}}, + {"content", "▁"}}; + j["pre_tokenizer"] = {{"type", "Split"}, + {"pattern", {{"String", " "}}}, + {"behavior", "MergedWithPrevious"}, + {"invert", false}}; + j["post_processor"] = { + {"type", "TemplateProcessing"}, + {"single", nlohmann::json::array({{{"Sequence", {{"id", "A"}, {"type_id", 0}}}}})}, + {"special_tokens", nlohmann::json::object()}}; + j["decoder"] = {{"type", "Sequence"}, + {"decoders", nlohmann::json::array( + {{{"type", "Replace"}, + {"pattern", {{"String", "▁"}}}, + {"content", " "}}, + {{"type", "Fuse"}}})}}; + j["model"] = {{"type", "BPE"}, + {"byte_fallback", false}, + {"vocab", vocab}, + {"merges", nlohmann::json::array()}}; + return j.dump(); +} + +// The caption projections for the reduced tower's 32-wide, 13-state stack. Widths +// are the fixture's own; what matters is that BOTH streams are non-degenerate so +// a conditioning defect cannot hide in an unused one. +vllm::Ltx2TextFeatureConfig TowerFeatureConfig() { + vllm::Ltx2TextFeatureConfig cfg; + cfg.variant = vllm::Ltx2TextNormVariant::kPerTokenRmsV2; + cfg.embedding_dim = vllm_test::kLtxTowerHidden; + cfg.num_layers = vllm_test::kLtxTowerNumStates; + cfg.video_out_features = 24; + cfg.audio_out_features = 12; + cfg.aggregate_bias = true; + cfg.is_av = false; + return cfg; +} + +vllm::Ltx2TextEncoderWeights TowerProjections() { + const int64_t flat = vllm_test::kLtxTowerHidden * vllm_test::kLtxTowerNumStates; + vllm::Ltx2TextEncoderWeights w; + w.video.out_features = 24; + w.video.in_features = flat; + w.video.weight = Ltx2Param("tower.video_aggregate_embed.weight", {24, flat}); + w.video.bias = Ltx2Param("tower.video_aggregate_embed.bias", {24}); + w.audio.out_features = 12; + w.audio.in_features = flat; + w.audio.weight = Ltx2Param("tower.audio_aggregate_embed.weight", {12, flat}); + w.audio.bias = Ltx2Param("tower.audio_aggregate_embed.bias", {12}); + return w; +} + +// The ORACLE's left-padded states, laid out exactly as the conditioning path lays +// out its own: full padded width, pad rows ZERO. +std::vector> OraclePaddedStates(const float* (*golden)(int64_t)) { + const int64_t H = vllm_test::kLtxTowerHidden; + const int64_t PT = vllm_test::kLtxTowerPaddedSeq; + const int64_t P = vllm_test::kLtxTowerNumPad; + std::vector> out( + static_cast(vllm_test::kLtxTowerNumStates)); + for (int64_t s = 0; s < vllm_test::kLtxTowerNumStates; ++s) { + std::vector& dst = out[static_cast(s)]; + dst.assign(static_cast(PT * H), 0.0f); + const float* src = golden(s); + for (int64_t t = P; t < PT; ++t) + for (int64_t h = 0; h < H; ++h) + dst[static_cast(t * H + h)] = src[static_cast(t * H + h)]; + } + return out; +} + struct Gemma4CachePool { std::vector> buf; std::vector attn_kv; @@ -1649,8 +1847,19 @@ TEST_CASE("gemma4 tower: LEFT PADDING is equivalent to running the valid tokens" // Positions are the ORIGINAL absolute ones — P..P+T-1, not 0..T-1. That is // what transformers does: with no explicit position_ids it uses the cache // position, which counts pad rows (modeling_gemma4_unified.py, the - // `cache_position` default), so a port that renumbers from zero after dropping - // the pads rotates every query by the wrong angle. + // `cache_position` default). + // + // This comment used to end "so a port that renumbers from zero after dropping + // the pads rotates every query by the wrong angle", and that was an OVERCLAIM. + // MEASURED in the oracle: the same 8 tokens told 12..19 and told 0..7 differ by + // 5.11e-05 in f32 on values of magnitude 14.35 — 3.6e-06 relative, f32 + // round-off — because rotary position embedding is RELATIVE and the pads are + // masked out of attention, so a uniform shift of every position cancels. At + // bf16 the two differ by 1.09, which is 0.65-1.70x the per-state dtype floor, + // i.e. the rounding of different absolute angles rather than a different + // answer. So renumbering is a MIRRORING divergence, not a rotation error, and + // no numeric gate in this suite separates the two cleanly. It is mirrored + // because upstream does it; the reason is fidelity, not arithmetic. std::vector tokens(static_cast(T)); std::vector positions(static_cast(T)); for (int64_t t = 0; t < T; ++t) { @@ -1722,6 +1931,334 @@ TEST_CASE("gemma4 tower: LEFT PADDING is equivalent to running the valid tokens" << worst_ratio << "x its bound"); } +TEST_CASE("gemma4 tower: partial_rotary_factor, on the ROPE TABLE the states cannot see") { + // WHY THIS IS NOT GATED THROUGH THE HIDDEN STATES, stated as a measurement. + // + // `partial_rotary_factor` decides how many of a full-attention layer's angle + // pairs are rotated and how many are zero-padded to identity. It is + // config-carried and shape-invisible, and the case above — which does hold + // every state to the oracle — CANNOT resolve it. Forcing the factor to 1.0 in + // `MakeLayout` (gemma4.cpp) displaces the worst state by 1.09e-01 against that + // state's measured bf16 noise floor of 9.99e-02: a ratio of 1.09, i.e. inside + // the tolerance, and the whole suite stays green at 23 cases / 3583 + // assertions. Enlarging the fixture does not rescue it — MEASURED against this + // oracle, worst signal-to-floor falls from 1.09 at the committed dims to 0.65 + // at (head_dim 16/32, seq 32) and 0.26 at (16/32, seq 8), because bf16 + // accumulation noise grows at least as fast as the rope contribution does. + // + // So the instrument is the TABLE, in f32, with no accumulation in it, against + // the oracle's own `Gemma4UnifiedTextRotaryEmbedding` routed through + // `_compute_proportional_rope_parameters` — the code that actually decides the + // zero padding (modeling_rope_utils.py:187-245). + const vllm::HfConfig cfg = TowerConfig(); + const int64_t Dh = vllm_test::kLtxTowerGlobalHeadDim; + const int64_t P = vllm_test::kLtxTowerRopePositions; + const int64_t pairs = Dh / 2; + + const std::vector got = vllm::Gemma4ProportionalRopeCosSin(cfg, Dh, P - 1); + REQUIRE(static_cast(got.size()) == P * Dh); + + double worst = 0.0; + for (int64_t i = 0; i < P * Dh; ++i) + worst = std::max(worst, std::abs(static_cast(got[static_cast(i)]) - + static_cast( + vllm_test::kLtxTowerRopeFullCosSin[ + static_cast(i)]))); + MESSAGE("gemma4 tower rope: max|ours - oracle| over " + << static_cast(P) << " x " << static_cast(Dh) << " = " << worst); + // Both sides evaluate cos/sin once and store f32. Nothing accumulates, so the + // only difference admissible here is the last-bit disagreement between two + // libm implementations of cos/sin — NOT a tolerance that a rotated pair could + // hide inside. A pair that should be identity and is not moves this by up to + // 1.0, five orders of magnitude above the bound. + CHECK(worst <= 1e-6); + + // The STRUCTURE, exactly, because it is the thing the factor controls and an + // exact check cannot be absorbed by any noise argument. `rope_angles` is + // upstream's `int(partial * head_dim // 2)` (modeling_rope_utils.py:233). + const int64_t rotated = static_cast(0.25 * static_cast(Dh)) / 2; + REQUIRE(rotated == 2); + REQUIRE(rotated < pairs); + for (int64_t t = 0; t < P; ++t) { + for (int64_t j = rotated; j < pairs; ++j) { + CHECK(got[static_cast(t * Dh + j)] == 1.0f); // cos + CHECK(got[static_cast(t * Dh + pairs + j)] == 0.0f); // sin + } + } + // ...and the pairs BELOW the cut really do rotate, so "every pair is identity" + // — a factor read as 0 — is not what just passed. + double moved = 0.0; + for (int64_t t = 0; t < P; ++t) + for (int64_t j = 0; j < rotated; ++j) + moved = std::max(moved, + std::abs(static_cast(got[static_cast(t * Dh + pairs + j)]))); + CHECK(moved > 0.5); +} + +// ─────────────── the LOADER, and the whole prompt path, in CI ──────────────── + +TEST_CASE("ltx2 tower loader: the reduced tower READ BACK OFF A FILE") { + const vllm::HfConfig cfg = TowerConfig(); + const nlohmann::json gemma_config = + nlohmann::json::parse(vllm_test::kLtxTowerTextConfigJson); + const fs::path dir = fs::temp_directory_path() / "vllm_ltx2_tower_loader"; + fs::create_directories(dir); + const std::string path = + WriteTypedPack(dir / "tower.safetensors", TowerPackTensors(cfg), ""); + + SUBCASE("every layer matches the fixture the ORACLE ran, byte for byte") { + const vllm::SafetensorsFile file = vllm::SafetensorsFile::Open(path); + const vllm::Ltx2GemmaTower tower = + vllm::Ltx2LoadGemmaTowerFromSafetensors(file, gemma_config); + const vllm::Gemma4Weights want = TowerWeights(cfg); + + CHECK(tower.config.hidden_size == vllm_test::kLtxTowerHidden); + CHECK(tower.config.num_hidden_layers == vllm_test::kLtxTowerNumLayers); + // Everything here is bf16 already, so nothing was dequantized. The NVFP4 arm + // is the shipped checkpoint's and stays on the opt-in case. + CHECK(tower.dequantized_modules.empty()); + REQUIRE(tower.weights.layers.size() == want.layers.size()); + CHECK(SameTensor(tower.weights.embed_tokens, want.embed_tokens)); + CHECK(SameTensor(tower.weights.final_norm, want.final_norm)); + for (size_t l = 0; l < want.layers.size(); ++l) { + const vllm::Gemma4LayerWeights& g = tower.weights.layers[l]; + const vllm::Gemma4LayerWeights& w = want.layers[l]; + CHECK(g.is_full_attention == w.is_full_attention); + CHECK(g.head_dim == w.head_dim); + CHECK(g.num_kv_heads == w.num_kv_heads); + // The full layers ship no `v_proj`; V aliases K. That is a 1-vs-2 kv-head, + // 16-vs-8 head_dim difference that every shape check downstream passes. + CHECK(g.k_eq_v == w.k_eq_v); + CHECK(SameTensor(g.attn.qkv_proj, w.attn.qkv_proj)); + CHECK(SameTensor(g.attn.o_proj, w.attn.o_proj)); + CHECK(SameTensor(g.attn.q_norm, w.attn.q_norm)); + CHECK(SameTensor(g.attn.k_norm, w.attn.k_norm)); + CHECK(SameTensor(g.mlp.gate_up_proj, w.mlp.gate_up_proj)); + CHECK(SameTensor(g.mlp.down_proj, w.mlp.down_proj)); + CHECK(SameTensor(g.input_layernorm, w.input_layernorm)); + CHECK(SameTensor(g.post_attention_layernorm, w.post_attention_layernorm)); + CHECK(SameTensor(g.pre_feedforward_layernorm, w.pre_feedforward_layernorm)); + CHECK(SameTensor(g.post_feedforward_layernorm, w.post_feedforward_layernorm)); + CHECK(SameTensor(g.layer_scalar, w.layer_scalar)); + } + } + + SUBCASE("a PLE tower is REFUSED, not loaded without its PLE tensors") { + nlohmann::json bad = gemma_config; + bad["hidden_size_per_layer_input"] = 8; + const vllm::SafetensorsFile file = vllm::SafetensorsFile::Open(path); + CHECK_THROWS_AS(vllm::Ltx2LoadGemmaTowerFromSafetensors(file, bad), + std::runtime_error); + } + + SUBCASE("num_kv_shared_layers != 0 is REFUSED, not silently unshared") { + nlohmann::json bad = gemma_config; + bad["num_kv_shared_layers"] = 2; + const vllm::SafetensorsFile file = vllm::SafetensorsFile::Open(path); + CHECK_THROWS_AS(vllm::Ltx2LoadGemmaTowerFromSafetensors(file, bad), + std::runtime_error); + } + + SUBCASE("a missing v_proj without attention_k_eq_v is REFUSED, not aliased") { + // The pack's full layers carry no `v_proj` — that is the real checkpoint's + // shape. Withdrawing the DECLARATION must not turn a missing tensor into a + // deliberate K-aliased layer. + nlohmann::json bad = gemma_config; + bad["attention_k_eq_v"] = false; + const vllm::SafetensorsFile file = vllm::SafetensorsFile::Open(path); + CHECK_THROWS_AS(vllm::Ltx2LoadGemmaTowerFromSafetensors(file, bad), + std::runtime_error); + } + + SUBCASE("layer_types that does not cover every layer is REFUSED") { + nlohmann::json bad = gemma_config; + bad["layer_types"] = nlohmann::json::array({"full_attention", "sliding_attention"}); + const vllm::SafetensorsFile file = vllm::SafetensorsFile::Open(path); + CHECK_THROWS_AS(vllm::Ltx2LoadGemmaTowerFromSafetensors(file, bad), + std::runtime_error); + } + + SUBCASE("a module in NEITHER the bf16 nor the torchao-NVFP4 form is REFUSED") { + // F16 parses as a tensor and has the right element count, so a loader that + // read whichever of the two forms happened to fit would build a tower out of + // reinterpreted bytes. The refusal names the module. + std::vector ts = TowerPackTensors(cfg); + int hits = 0; + for (PackTensor& t : ts) { + if (t.name == "model.layers.0.self_attn.q_proj.weight") { + t.dtype = "F16"; + ++hits; + } + } + REQUIRE(hits == 1); + const std::string bad_path = + WriteTypedPack(dir / "tower_f16.safetensors", ts, ""); + const vllm::SafetensorsFile file = vllm::SafetensorsFile::Open(bad_path); + CHECK_THROWS_AS(vllm::Ltx2LoadGemmaTowerFromSafetensors(file, gemma_config), + std::runtime_error); + } + + SUBCASE("a NON-bf16 norm vector is REFUSED rather than reinterpreted") { + // F16 is the same WIDTH as bf16, so the file parses and the element count is + // right; only the exponent layout differs. Nothing downstream of a norm + // weight read that way would look wrong — it would just scale every + // activation by a different number. + std::vector ts = TowerPackTensors(cfg); + int hits = 0; + for (PackTensor& t : ts) { + if (t.name == "model.norm.weight") { + t.dtype = "F16"; + ++hits; + } + } + REQUIRE(hits == 1); + const std::string bad_path = + WriteTypedPack(dir / "tower_f16norm.safetensors", ts, ""); + const vllm::SafetensorsFile file = vllm::SafetensorsFile::Open(bad_path); + CHECK_THROWS_AS(vllm::Ltx2LoadGemmaTowerFromSafetensors(file, gemma_config), + std::runtime_error); + } +} + +TEST_CASE("ltx2 prompt -> conditioning: the VALUES, against the left-padded oracle") { + // THE HEADLINE PATH, AND UNTIL NOW ITS ONLY GATE WAS OPT-IN. + // + // `Ltx2EncodePromptToConditioning` is what the row exists to ship, and the + // only case that called it needed a 24 GB checkpoint. Everything it does that + // nothing else does — tokenize, drop the pads, run the tower at the surviving + // tokens' own positions, scatter the rows back to the full padded width, and + // hand the stack to the extractor — was therefore gated on nothing but shapes, + // isfinite, max|v| > 1e-3, sort_index and "two prompts differ". + // + // What makes a VALUE gate possible in CI is that the committed left-padded + // oracle run is a run of this exact situation: 12 pad rows then 8 valid tokens + // at absolute positions 12..19. Give the path a tokenizer that produces those + // 8 tokens and the oracle's own rows are the answer it owes. + // + // ONE THING THIS DOES NOT SHARPLY GATE, said plainly rather than implied. + // Renumbering the positions from zero (`positions[i] = i`) does red this case, + // but only at 1.10x the audio floor — and that is a property of the DEFECT, not + // a weakness here: rotary embedding is relative and the pads are masked, so + // upstream's own f32 answers for 12..19 and 0..7 agree to 3.6e-06 relative. + // The numbering is mirrored for fidelity to transformers, and the note at the + // left-pad case above carries the measurement. + const vllm::HfConfig cfg = TowerConfig(); + const nlohmann::json gemma_config = + nlohmann::json::parse(vllm_test::kLtxTowerTextConfigJson); + const fs::path dir = fs::temp_directory_path() / "vllm_ltx2_tower_prompt"; + fs::create_directories(dir); + const std::string path = + WriteTypedPack(dir / "tower.safetensors", TowerPackTensors(cfg), ""); + const vllm::SafetensorsFile file = vllm::SafetensorsFile::Open(path); + const vllm::Ltx2GemmaTower tower = + vllm::Ltx2LoadGemmaTowerFromSafetensors(file, gemma_config); + + const int64_t T = vllm_test::kLtxTowerSeq; + const int64_t PT = vllm_test::kLtxTowerPaddedSeq; + const int64_t P = vllm_test::kLtxTowerNumPad; + const int64_t S = vllm_test::kLtxTowerNumStates; + + const vllm::tok::Tokenizer tokenizer = + vllm::tok::Tokenizer::FromHfJsonBytes(TowerTokenizerJson(), ""); + vllm::Ltx2GemmaSpecialIds ids; + ids.bos_id = vllm_test::kLtxTowerTokens[0]; + ids.pad_id = static_cast(vllm_test::kLtxTowerPadId); + + // The prompt spells tokens 1..T-1; the BOS at index 0 is what the wrapper + // prepends. Built from the golden rather than typed out, so it cannot drift. + std::string prompt; + for (int64_t i = 1; i < T; ++i) + prompt += "(i)]) + + ">"; + + const vllm::Ltx2TextFeatureConfig fcfg = TowerFeatureConfig(); + const vllm::Ltx2TextEncoderWeights proj = TowerProjections(); + vt::Queue q = Qcpu(); + const vllm::Ltx2PromptConditioning out = vllm::Ltx2EncodePromptToConditioning( + tower, tokenizer, ids, proj, fcfg, prompt, q, PT); + + // The tokenizer really did reproduce the oracle's batch: same ids, same pad + // run, same mask. If this ever stops holding, the value comparison below is + // comparing two different prompts and has to fail loudly here first. + REQUIRE(out.seq == PT); + REQUIRE(out.tokens.num_valid == T); + REQUIRE(out.tokens.first_valid == P); + for (int64_t i = 0; i < PT; ++i) { + CHECK(out.tokens.input_ids[static_cast(i)] == + vllm_test::kLtxTowerPaddedTokens[static_cast(i)]); + CHECK(out.mask[static_cast(i)] == + vllm_test::kLtxTowerPaddedMask[static_cast(i)]); + } + + // The reference: the ORACLE's left-padded states through the SAME projection, + // at both of the oracle's own arithmetic widths. The projection is shared with + // the path under test — deliberately, because it is separately gated against + // its own goldens above; what is NOT shared is the hidden states, which is + // exactly the part `first_valid + i` decides. + const std::vector> f32_states = + OraclePaddedStates(&TowerGoldenPadded); + const std::vector> bf16_states = + OraclePaddedStates(&TowerGoldenPaddedBf16); + auto as_states = [&](const std::vector>& bufs) { + vllm::Ltx2TextHiddenStates st; + for (const std::vector& b : bufs) st.layers.push_back(b.data()); + st.batch = 1; + st.seq = PT; + st.hidden = vllm_test::kLtxTowerHidden; + return st; + }; + REQUIRE(static_cast(f32_states.size()) == S); + const vllm::Ltx2TextConditioning want_f32 = vllm::Ltx2TextEncoderConditioning( + as_states(f32_states), out.mask.data(), proj, fcfg); + const vllm::Ltx2TextConditioning want_bf16 = vllm::Ltx2TextEncoderConditioning( + as_states(bf16_states), out.mask.data(), proj, fcfg); + + // The floor, propagated rather than borrowed: it is the oracle's OWN + // f32-vs-bf16 spread carried through the identical projection, so it is the + // smallest difference this comparison can resolve. It cannot be widened to + // rescue a failure without regenerating the oracle. + auto max_diff = [](const std::vector& a, const std::vector& b) { + if (a.size() != b.size()) return std::numeric_limits::infinity(); + double d = 0.0; + for (size_t i = 0; i < a.size(); ++i) + d = std::max(d, std::abs(static_cast(a[i]) - static_cast(b[i]))); + return d; + }; + const double video_floor = max_diff(want_f32.video, want_bf16.video); + const double audio_floor = max_diff(want_f32.audio, want_bf16.audio); + REQUIRE(video_floor > 0.0); + REQUIRE(audio_floor > 0.0); + + const double video_bf16 = max_diff(out.conditioning.video, want_bf16.video); + const double video_f32 = max_diff(out.conditioning.video, want_f32.video); + const double audio_bf16 = max_diff(out.conditioning.audio, want_bf16.audio); + const double audio_f32 = max_diff(out.conditioning.audio, want_f32.audio); + MESSAGE("ltx2 prompt->conditioning: video max|diff| vs bf16 oracle = " + << video_bf16 << " (" << (video_bf16 / video_floor) + << "x the propagated floor " << video_floor << "), vs f32 oracle = " + << video_f32 << "; audio " << audio_bf16 << " (" + << (audio_bf16 / audio_floor) << "x " << audio_floor << ") / " << audio_f32); + CHECK(video_bf16 <= video_floor); + CHECK(video_f32 <= 2.0 * video_floor); + CHECK(audio_bf16 <= audio_floor); + CHECK(audio_f32 <= 2.0 * audio_floor); + + // The reorder and the mask are position-free, so they are held EXACTLY. + REQUIRE(out.conditioning.sort_index.size() == want_f32.sort_index.size()); + for (size_t i = 0; i < want_f32.sort_index.size(); ++i) + CHECK(out.conditioning.sort_index[i] == want_f32.sort_index[i]); + REQUIRE(out.conditioning.additive_mask.size() == want_f32.additive_mask.size()); + for (size_t i = 0; i < want_f32.additive_mask.size(); ++i) + CHECK(out.conditioning.additive_mask[i] == want_f32.additive_mask[i]); + + // And the conditioning is not a wall of zeros that every bound above would + // also accept. + double vmax = 0.0; + for (float x : out.conditioning.video) + vmax = std::max(vmax, std::abs(static_cast(x))); + CHECK(vmax > 1e-3); +} + // ──────────────────── a real prompt becomes real tokens ────────────────────── namespace { @@ -1978,12 +2515,19 @@ TEST_CASE("ltx2 e2e: a PROMPT drives the real Gemma-4 12B tower to conditioning" CHECK(tower.config.num_hidden_layers == 48); CHECK(tower.config.vocab_size == 262144); CHECK(static_cast(tower.weights.layers.size()) == 48); - // Every one of the 337 quantized modules on the text path arrived NVFP4 and + // Every one of the 329 quantized modules on the text path arrived NVFP4 and // was dequantized — a tower that silently found bf16 tensors instead would be - // a different checkpoint. + // a different checkpoint. The count is arithmetic, not a memory: the 40 + // sliding layers carry q, k, v, o, gate, up, down; the 8 full ones carry the + // same minus `v_proj`, which they do not ship; and `embed_tokens` is the one + // module outside the layers. 40*7 + 8*6 + 1 = 329. + // + // PINNED exactly rather than `> 300`. A lower bound is satisfied by a loader + // that quietly took, say, 40 of the 48 layers' modules from a bf16 fallback, + // which is the failure the line is here to catch. MESSAGE("ltx2 e2e: dequantized " << tower.dequantized_modules.size() << " torchao-NVFP4 modules"); - CHECK(tower.dequantized_modules.size() > 300); + CHECK(tower.dequantized_modules.size() == 40 * 7 + 8 * 6 + 1); // The mixed geometry, READ BACK off what was actually built rather than off // the config that asked for it. From ddfcb516a0c06704d143d8455a7747cb70ca29fb Mon Sep 17 00:00:00 2001 From: Ettore Di Giacinto Date: Thu, 13 Aug 2026 11:23:02 +0000 Subject: [PATCH 3/4] fix(ltx-2.5): F7 was still inverted in the file that carries the call (#435) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The last round corrected the post_processor rationale in the HEADER and left the SOURCE saying the opposite thing, twelve lines above the `Encode` call it annotates. The two made contradictory predictions from the same premise: the header said a future post_processor makes us WRONG, the source said it keeps us RIGHT. F7's whole content was "the rationale was inverted", so half of it was still open. VERIFIED AGAINST UPSTREAM, not taken on trust. The reviewer could not reach the anchor; this was read at /home/mudler/_git/LTX-2 pin fd4ded7f: packages/ltx-core/src/ltx_core/text_encoders/gemma/tokenizer.py:37-43 encoded = self.tokenizer( text, padding=False, truncation=True, max_length=self.max_length, return_tensors="pt", ) That is `__call__` with its DEFAULT `add_special_tokens=True`, so upstream DOES run the post_processor. The HEADER had the direction right; the SOURCE was the wrong one, and it is the source that is corrected here. A THIRD claim in the same comment was also false. "Doing both would double the BOS" is not true: upstream's own guard at :45 (`not input_ids or input_ids[0] != bos_id`), mirrored at ltx2_text_encoder.cpp:712, absorbs a leading BOS from either call. The real exposure is a post_processor that adds anything ELSE, and the comment now says that instead. SIBLING SWEEP, built from the SUBJECT (post_processor, BOS, add_special_tokens, Encode) rather than from the sentences being fixed, since a grep built from the new text only confirms itself. Two more hits, both corrected: * gen-ltx2-prompt-tokens-goldens.py:86 annotated its `add_special_tokens=False` as transcribing ":38-43" -- the same conflation, in the generator that produces the committed goldens. Anchor corrected to :37-43 and the deliberate flag flip is now stated. * ltx2_text_encoder.h:421 called the BOS prepend "unconditional", which contradicts test_ltx2_text_encoder.cpp:2398 ("i.e. conditional") and :45 itself. It is conditional, and the guard is why. ──────────────────────────────────────────────────────────────────────────────── TWO COMMENT OVERCLAIMS, PROVED BY THE REVIEWER'S MUTATION Replacing `Ltx2ComputeRightPadOrder`'s stable partition with the identity permutation reds two OTHER cases (22 assertions) and leaves the new conditioning case entirely green. `out.conditioning` and `want_f32` both reach `sort_index` and `additive_mask` through the SAME function over the SAME `out.mask`, so a defect there cancels and those ~40 assertions cannot fire. "Held EXACTLY" was an assertion true by construction wearing a gate's label. This is NOT a coverage hole and no test changes. Both are genuinely gated by "ltx2 text: additive mask, right-pad ordering and the binary mask" and "ltx2 text: the encoder -> conditioning hand-off", which compare against committed upstream goldens rather than against a second call of the code under test. The comment now says what its assertions do establish (the mask is threaded through unaltered, and the mask itself is held to the golden) and names the two cases that actually gate the ordering. ──────────────────────────────────────────────────────────────────────────────── TWO COVERAGE LIMITS RECORDED, NOT FIXED * The loader case's "the q|k|v concat ORDER" claim holds for the LTX path ONLY. `Ltx2LoadGemmaTowerFromSafetensors` uses its own `TowerConcat` (ltx2_text_encoder.cpp:943-945); `gemma4_weights.cpp:281-295` is a SEPARATE implementation this suite never loads, and mutating it leaves every case here green. That path owes its own gate. * The rope-table instrument covers the FULL-ATTENTION arm only. The sliding layers' `default` rope at theta 1e4 has no equivalent f32 instrument and is reached only through the hidden states, where the same bf16 noise-floor argument works against resolving a config-carried angle defect. ──────────────────────────────────────────────────────────────────────────────── DOCS Comment-only in src/include/tests, so AGENTS.md owes nothing here -- but check-doc-checkpoint is path-derived and demands FEATURES.md (from src/vllm/model_executor/models/) and USAGE.md (from include/vllm/). The prior repair at 9fbc68256 paid it the same way. Both edits are GENUINE rather than gate-appeasement: they record the tokenization divergence this commit just verified, which is a real user-facing caveat -- our prompt tokenization mirrors upstream only while the checkpoint's post_processor stays empty. USAGE.md:454 and :473 are left alone; they are inherited from the base branch and belong to PR #600's lane. The FEATURES.md note is folded into an existing paragraph rather than added as a new one, because check-public-doc-tables budgets prose paragraphs (21) as well as table cells (220 chars) and rows (600), and the LTX row's cell is already at 217. CODE IS BYTE-IDENTICAL. The only non-comment line in the diff is a trailing comment on an unchanged statement. GATE, CPU, Release, VLLM_CPP_CUDA=OFF: BUILD_EXIT=0, no "No space left" / "BFD assertion", df 86% used test_ltx2_text_encoder: 26 cases / 4115 assertions, Status SUCCESS, exit 0 (matches the declared baseline exactly) ctest -N: 414 (the brief said 409; this configure enumerates 414 at the unmodified head, and a comment-only diff cannot register a test) ctest: 414/414 passed, 0 failed, exit 0, first pass under -j 8, no flaky re-runs needed binary md5 unchanged across the post-docs rebuild (8b48f39b...) check-doc-checkpoint "range" still reports b0aa475a3, d67f8125e and aa6aa0ecd. All three are ancestors of 9fbc68256, inherited, and not repairable from here without editing #600's lane. Issue: #435, #604 FOLLOWING_AGENTS_PROTOCOL Following-Agents-Protocol: true AI-Assisted: true Assisted-by: AGENT:claude-opus-5 [Claude Code] --- docs/FEATURES.md | 8 +++++- docs/USAGE.md | 9 +++++- .../model_executor/models/ltx2_text_encoder.h | 5 ++-- scripts/gen-ltx2-prompt-tokens-goldens.py | 8 +++++- .../models/ltx2_text_encoder.cpp | 20 +++++++++---- tests/vllm/models/test_ltx2_text_encoder.cpp | 28 ++++++++++++++++++- 6 files changed, 66 insertions(+), 12 deletions(-) diff --git a/docs/FEATURES.md b/docs/FEATURES.md index c02775371..5b1592379 100644 --- a/docs/FEATURES.md +++ b/docs/FEATURES.md @@ -146,7 +146,13 @@ speed-pending, which [BENCHMARKS.md](BENCHMARKS.md) tracks. ### Standalone and non-registered lanes These run through dedicated forwards, not the `REGISTER_VLLM_MODEL` registry, so -they sit outside the gated list above. +they sit outside the gated list above. One caveat the LTX-2.5 row is too narrow +to carry: its text tower's prompt tokenization mirrors upstream only while the +checkpoint's tokenizer `post_processor` adds nothing. The shipped one is MEASURED +empty, so this port's plain encode plus an explicit BOS prepend matches +upstream's `add_special_tokens=True` today; a checkpoint with a non-empty +`post_processor` would tokenize differently here, and `ltx2_text_encoder.cpp` +names the line that would have to change. | Lane | Tested checkpoint(s) | Correctness gate | Speed vs reference | |---|---|---|---| diff --git a/docs/USAGE.md b/docs/USAGE.md index 69508491c..d524d44c0 100644 --- a/docs/USAGE.md +++ b/docs/USAGE.md @@ -374,7 +374,14 @@ kaiser resampler this project does not carry. And a VAE configured with the checkpoint ships as a tensor, the tower is materialized and forwarded, and both caption projections emit their conditioning streams — all of it gated in CI against a running upstream tower rather than against invariants derived from its -own output. What still blocks a prompt is the hop from there into +own output. One tokenization detail is a KNOWN DIVERGENCE rather than a mirror, +and it is checkpoint-conditional: upstream tokenizes through the HuggingFace +`__call__` with its default `add_special_tokens=True`, so it runs the tokenizer's +post_processor, while this port calls the plain encode and prepends BOS by hand. +On the shipped checkpoint the two are identical — its post_processor declares an +EMPTY special-token map, measured on the shipped file rather than assumed — so +nothing is lost today. A checkpoint whose post_processor DID add tokens would +tokenize differently here. What still blocks a prompt is the hop from there into cross-attention, which "A second behaviour changed" below states precisely. Conditioning therefore still comes from `--prompt-embeds` plus `--audio-prompt-embeds`: rows of diff --git a/include/vllm/model_executor/models/ltx2_text_encoder.h b/include/vllm/model_executor/models/ltx2_text_encoder.h index 883d4cf23..243a8dee2 100644 --- a/include/vllm/model_executor/models/ltx2_text_encoder.h +++ b/include/vllm/model_executor/models/ltx2_text_encoder.h @@ -418,8 +418,9 @@ struct Ltx2GemmaPromptTokens { // tokenizer.py:31-59, mirrored including the parts that look like details: // // * `text.strip()` first (:33). diffusers strips too (pipeline_ltx2.py:333). -// * encode, then PREPEND BOS unconditionally if it is not already first -// (:44-46). +// * encode, then PREPEND BOS if it is not already first — CONDITIONAL, on +// upstream's own `if not input_ids or input_ids[0] != bos_id` guard +// (:44-46). A port that prepends unconditionally doubles the BOS. // // Two things about that, and the first one is a KNOWN DIVERGENCE rather than // a mirrored default. Upstream calls `self.tokenizer(text, ...)` — `__call__` diff --git a/scripts/gen-ltx2-prompt-tokens-goldens.py b/scripts/gen-ltx2-prompt-tokens-goldens.py index 7bc5e0154..661942467 100644 --- a/scripts/gen-ltx2-prompt-tokens-goldens.py +++ b/scripts/gen-ltx2-prompt-tokens-goldens.py @@ -83,7 +83,13 @@ def tokenize_with_weights(tok, text: str, bos_id: int, pad_id: int): only thing borrowed is the algorithm, and every step cites its line. """ text = text.strip() # :33 - ids = list(tok.encode(text, add_special_tokens=False).ids) # :38-43 + # :37-43 is `self.tokenizer(text, ...)` — `__call__` with its DEFAULT + # `add_special_tokens=True`, so upstream runs the post_processor. This passes + # False deliberately, to transcribe what the C++ `Encode` does; the two agree + # only because the measured post_processor here has an EMPTY `special_tokens` + # map (asserted into the emitted header below). On a checkpoint where it added + # something, THIS line and the C++ call would both have to change. + ids = list(tok.encode(text, add_special_tokens=False).ids) # :37-43 if len(ids) > MAX_LENGTH: # truncation=True ids = ids[:MAX_LENGTH] if not ids or ids[0] != bos_id: # :44-46 diff --git a/src/vllm/model_executor/models/ltx2_text_encoder.cpp b/src/vllm/model_executor/models/ltx2_text_encoder.cpp index 2b9b79549..dee68d973 100644 --- a/src/vllm/model_executor/models/ltx2_text_encoder.cpp +++ b/src/vllm/model_executor/models/ltx2_text_encoder.cpp @@ -686,12 +686,20 @@ Ltx2GemmaPromptTokens Ltx2TokenizeGemmaPrompt(const tok::Tokenizer& tokenizer, ? std::string() : prompt.substr(begin, prompt.find_last_not_of(kSpace) - begin + 1); - // NOT EncodeWithSpecialTokens. The shipped tokenizer's post_processor is a - // TemplateProcessing with an EMPTY `special_tokens` map, so it adds nothing and - // the two are identical HERE — but upstream calls the plain encode and then - // prepends BOS itself, and mirroring which call is made keeps that true if a - // future checkpoint ships a post_processor that does add something. Doing both - // would double the BOS. + // NOT EncodeWithSpecialTokens — and that is a KNOWN DIVERGENCE, not a mirror. + // Upstream calls `self.tokenizer(text, ...)` (tokenizer.py:37-43) — `__call__` + // with its default `add_special_tokens=True` — so upstream DOES run the + // post_processor, and plain `Encode` does not. The two are identical HERE only + // because the shipped tokenizer's post_processor is a TemplateProcessing whose + // `special_tokens` map is EMPTY, so it has nothing to add: MEASURED on the + // shipped file, not assumed. If a future checkpoint ships a post_processor that + // DOES add something, upstream would emit it and we would not — so this is the + // line to change, not a property to rely on. + // + // The one thing that would NOT go wrong is a doubled BOS: the guard below + // (`ids.front() != bos_id`) is upstream's own guard at :45, so a post_processor + // that emitted a leading BOS would be absorbed by either call. The exposure is + // a post_processor that adds anything ELSE. Full note at the declaration. std::vector ids = tokenizer.Encode(stripped); Ltx2GemmaPromptTokens out; diff --git a/tests/vllm/models/test_ltx2_text_encoder.cpp b/tests/vllm/models/test_ltx2_text_encoder.cpp index f70ee2608..7a6195167 100644 --- a/tests/vllm/models/test_ltx2_text_encoder.cpp +++ b/tests/vllm/models/test_ltx2_text_encoder.cpp @@ -629,6 +629,13 @@ const float* TowerGoldenPaddedBf16(int64_t state) { // byte for byte, which is a real gate on the parts that have no shape to check // them: the q|k|v concat ORDER, the `k_eq_v` aliasing of V onto K on the full // layers, and the per-layer 8-vs-16 head_dim / 2-vs-1 kv-head split. +// +// SCOPE, because "the concat order is gated" is broader than what this reaches. +// The only concat under this case is the LTX tower loader's own `TowerConcat` +// (ltx2_text_encoder.cpp:943-945). `gemma4_weights.cpp` assembles its qkv through +// a SEPARATE implementation (gemma4_weights.cpp:281-295) that nothing in this +// suite loads — MEASURED: mutating it leaves every case in this file green. That +// path owes its own gate; this one does not stand in for it. std::vector TowerPackTensors(const vllm::HfConfig& c) { const int64_t H = c.hidden_size, I = c.intermediate_size, V = c.vocab_size; const int64_t Hq = vllm_test::kLtxTowerNumHeads; @@ -1950,6 +1957,13 @@ TEST_CASE("gemma4 tower: partial_rotary_factor, on the ROPE TABLE the states can // the oracle's own `Gemma4UnifiedTextRotaryEmbedding` routed through // `_compute_proportional_rope_parameters` — the code that actually decides the // zero padding (modeling_rope_utils.py:187-245). + // + // SCOPE, so the instrument is not read as covering more than it does: this is + // the FULL-ATTENTION table only (`kLtxTowerGlobalHeadDim`, the `proportional` + // arm at theta 1e6 — the one `partial_rotary_factor` applies to). The SLIDING + // layers' `default` rope at theta 1e4 has NO equivalent f32 instrument; it is + // reached only through the hidden states, where the same bf16 noise-floor + // argument above works against resolving a config-carried angle defect. const vllm::HfConfig cfg = TowerConfig(); const int64_t Dh = vllm_test::kLtxTowerGlobalHeadDim; const int64_t P = vllm_test::kLtxTowerRopePositions; @@ -2243,7 +2257,19 @@ TEST_CASE("ltx2 prompt -> conditioning: the VALUES, against the left-padded orac CHECK(audio_bf16 <= audio_floor); CHECK(audio_f32 <= 2.0 * audio_floor); - // The reorder and the mask are position-free, so they are held EXACTLY. + // The reorder and the mask, compared EXACTLY — but read what that does and does + // NOT prove, because the label oversells it. `out.conditioning` and `want_f32` + // reach `sort_index` / `additive_mask` through the SAME + // `Ltx2ComputeRightPadOrder`, over the SAME `out.mask`, so a defect INSIDE that + // function cancels and these assertions cannot fire. MEASURED: replacing its + // stable partition with the identity permutation leaves this case entirely + // green. What they DO establish is that the end-to-end path hands the mask + // through unaltered — `out.mask` itself is held to the golden above — so the + // conditioning is ordered consistently with the tokens this case just checked. + // The ORDERING ITSELF is gated by the two cases that red on that same mutation, + // both against committed upstream goldens rather than against a second call of + // the code under test: "ltx2 text: additive mask, right-pad ordering and the + // binary mask" and "ltx2 text: the encoder -> conditioning hand-off". REQUIRE(out.conditioning.sort_index.size() == want_f32.sort_index.size()); for (size_t i = 0; i < want_f32.sort_index.size(); ++i) CHECK(out.conditioning.sort_index[i] == want_f32.sort_index[i]); From 131328e868cf67605e60a72fbb2869537416b5ae Mon Sep 17 00:00:00 2001 From: Ettore Di Giacinto Date: Thu, 13 Aug 2026 11:59:36 +0000 Subject: [PATCH 4/4] fix(ltx-2.5): F10 was one of EIGHT wrong anchors this branch added (#435, #604) The re-review found `test_ltx2_text_encoder.cpp:635` citing `ltx2_text_encoder.cpp:943-945` for "the LTX tower loader's own `TowerConcat`". Lines 943-945 are the `q_proj` `TowerModule` load. The concat calls are :951 and :953; the helper is defined at :835. The substantive claim was measured and is true, and only the number was wrong -- which is the worst shape for this defect, because a reader who follows the anchor concludes a TRUE claim is unsupported. Fixing one number and stopping is what let the class survive three review rounds, so every `file:line` this branch ADDS over `row/MODEL-DIFFUSION-LTX25` was resolved against the tree it points into. Extracted mechanically by SHAPE off the added lines of `git diff origin/row/MODEL-DIFFUSION-LTX25...HEAD` (`name.ext:NN`, `name.ext:NN-MM`, bare `:NN` / `:NN-MM`, "line(s) NN", "SS N"), not by grepping the sentences already known to be wrong -- a grep built from text you just fixed only confirms itself. 19 citations added, in 6 files. 19 resolved. 8 wrong, at 6 comment sites. site cited is ------------------------------------------------------------------------ test_ltx2_text_encoder.cpp:635 ltx2_te.cpp:943-945 q_proj load test_ltx2_text_encoder.cpp:1959 rope_utils.py:187-245 ends at 254 test_ltx2_text_encoder.cpp:1992 rope_utils.py:233 blank line gemma4.h:260 gemma4_unified.py:257-274 prev fn tail gemma4.h:260 rope_utils.py:187-245 ends at 254 gen-ltx2-gemma-tower-goldens.py:378 gemma4_unified.py:214-218 call, no lookup gen-ltx2-gemma-tower-goldens.py:378 rope_utils.py:187-245 ends at 254 ltx2_text_encoder.cpp:1055 gemma4.cpp:300-312 cuts the cast The three `modeling_rope_utils.py:187-245` sites are one anchor repeated. The function is `_compute_proportional_rope_parameters`, :187-254, and all three sentences name its ZERO PADDING -- which is `torch.zeros(nope_angles, ...)` at :246, ONE LINE past the cited end. Following the anchor is following it to the `torch.cat(` that opens two lines earlier and stopping before the argument that matters. Corrected to :187-254, with :246 named where the padding is the claim. `modeling_rope_utils.py:233` is a blank line. `rope_angles = int(rope_proportion * head_dim // 2)`, which the comment quotes, is :234. `modeling_gemma4_unified.py:257-274` opens on the PREVIOUS function's `return` (:257) and stops before `forward`'s own (:275). The `emb = torch.cat((freqs, freqs), dim=-1)` the sentence mirrors is :271, so the anchor does contain it, but both ends land in the wrong construct. Corrected to the whole method, :259-275, with :271 named. `modeling_gemma4_unified.py:214-218` is the CALL, `rope_init_fn(self.config, **rope_init_fn_kwargs)`. The sentence claims the class "routes `rope_type: proportional` to `_compute_proportional_rope_parameters`", and the routing is `ROPE_INIT_FUNCTIONS[rope_type]` at :207, outside the range -- a reader at :214-218 cannot see what `rope_init_fn` resolves to, so the claim reads unsupported. Widened to :206-218. `gemma4.cpp:300-312` opens on the weight-less V `RmsNorm` at :300 and closes on the `} else {` at :312, which EXCLUDES the `vt::CastF32` pair at :313-314 that the sentence is about ("run a CastF32 on every K and V it wrote"). The `kv.dtype != adt` arm is :306-315. Corrected, with the two `DBuf`s and the casts named separately, because those are the two costs the sentence charges. The eleven that resolve as written, checked one by one, not assumed: LTX-2 `tokenizer.py:37-43` (three sites, the `self.tokenizer(...)` call), `:44-46`, `:45`, `:12-15`, `gemma_assets.py:335-386` (`build_text_encoder_tensors_from_gemma_root`, :335 to its `return` at :386), `base_encoder.py:41`; diffusers `pipeline_ltx2.py:339` (literally `add_special_tokens=True`); ours `gemma4_weights.cpp:281-295`, which does span all three qkv arms as the previous round reported. Two non-line anchors added by the F7 commit -- the two test-case NAMES it cites as the ones that gate the ordering -- exist verbatim at :1115 and :1166. PINS. LTX-2 at `fd4ded7f`, tree clean. diffusers at `3a2f35d4`. transformers 5.12.1 at `/home/mudler/recon-cpu/venv`, the interpreter the tower generator actually ran under; both files are md5-IDENTICAL to `/home/mudler/_git/ transformers` @ `7d06b1a5`, so the numbering above is not an artifact of which install was read. F10's anchor. `:951-953` and not `:835`, because the sentence is the LTX half of a contrast whose other half is `gemma4_weights.cpp:281-295` -- assembly SITES, not a helper definition -- and because the qkv concat ORDER is what the case gates and what the previous round's mutation (`q,k,v` -> `q,v,k`, 14 assertions RED) perturbed at :951. `:835` is named alongside it so the helper is still one hop away. DOCS. The code is byte-identical; this is comments and two documents. `check-doc-checkpoint` is path-derived and demands `FEATURES.md` (from `src/vllm/model_executor/models/`) and `USAGE.md` (from `include/vllm/`), which is the same bill `9fbc68256` and `ddfcb516a` paid. Both edits are genuine. `USAGE.md` still opened its LTX-2.5 gate section with "**There is no LTX-2.5 render path yet** ... no text encoder, no VAE, no pipeline and no `/v1/videos` route for it -- asking the video engine for LTX-2.5 will not work." Every clause is false, and the SAME DOCUMENT contradicts all of them: `ltx2-gen` renders end to end at :412, `--video-family ltx-2.5` pins the family on the server at :435, and the text tower is this row. Rewritten to say what the section is for. The refusal list that follows is left byte-for-byte alone: it is inherited text, it is not part of this finding, and `ltx2.h:38` and `:47-49` do support the two clauses of it I checked. `FEATURES.md` pointed at "`ltx2_text_encoder.cpp` names the line that would have to change" -- an unresolvable pointer, in a commit about unresolvable pointers. It now names `Ltx2TokenizeGemmaPrompt`. A symbol, deliberately, because a line number in a public document has nothing that can keep it true. Folded into the existing paragraph: the 700-char prose cap and the 220-char cell cap make an addition an EVICTION of someone else's content, and the LTX row's two cells are already at 217 and 215. `docs/USAGE.md:454` and `:473` untouched -- #600's lane. GATE -- CPU, Release, `VLLM_CPP_CUDA=OFF`, `build-f10`, deleted after. cmake --build build-f10 -j 16 BUILD_EXIT=0; 0 hits for 'No space left|BFD assertion'; df 85% ctest -N 414 ctest -j 8 --output-on-failure 414/414 passed, 0 failed, exit 0 ./build-f10/tests/test_ltx2_text_encoder 26 cases | 4115 assertions | 0 failed Status: SUCCESS, exit 0 (baseline 26 / 4115 matched exactly) First pass under `-j 8`; no suite needed a serial re-run. `doc-checkpoint --staged` and `now-current --staged` both ok. `doc-checkpoint range` still reports `b0aa475a3`, `d67f8125e` and `aa6aa0ecd` -- the identical three failures this worktree recorded BEFORE any edit, all ancestors of `9fbc68256`, inherited and not repairable from here. FOLLOWING_AGENTS_PROTOCOL Following-Agents-Protocol: true AI-Assisted: true Assisted-by: AGENT:claude-opus-5 [Claude Code] --- docs/FEATURES.md | 4 ++-- docs/USAGE.md | 9 ++++++--- include/vllm/model_executor/models/gemma4.h | 4 +++- scripts/gen-ltx2-gemma-tower-goldens.py | 5 +++-- .../model_executor/models/ltx2_text_encoder.cpp | 5 +++-- tests/vllm/models/test_ltx2_text_encoder.cpp | 13 +++++++------ 6 files changed, 24 insertions(+), 16 deletions(-) diff --git a/docs/FEATURES.md b/docs/FEATURES.md index 5b1592379..beec3a261 100644 --- a/docs/FEATURES.md +++ b/docs/FEATURES.md @@ -151,8 +151,8 @@ to carry: its text tower's prompt tokenization mirrors upstream only while the checkpoint's tokenizer `post_processor` adds nothing. The shipped one is MEASURED empty, so this port's plain encode plus an explicit BOS prepend matches upstream's `add_special_tokens=True` today; a checkpoint with a non-empty -`post_processor` would tokenize differently here, and `ltx2_text_encoder.cpp` -names the line that would have to change. +`post_processor` would tokenize differently here, and `Ltx2TokenizeGemmaPrompt` +in `ltx2_text_encoder.cpp` is the call that would have to change. | Lane | Tested checkpoint(s) | Correctness gate | Speed vs reference | |---|---|---|---| diff --git a/docs/USAGE.md b/docs/USAGE.md index d524d44c0..6302fdf9e 100644 --- a/docs/USAGE.md +++ b/docs/USAGE.md @@ -1755,9 +1755,12 @@ routes stay unregistered. ## LTX-2.5: reproducing the DiT parity gate -**There is no LTX-2.5 render path yet.** What ships today is the DiT's layout and -forward, and there is no text encoder, no VAE, no pipeline and no `/v1/videos` -route for it — asking the video engine for LTX-2.5 will not work. The C++ surface +**This section is the DiT layer's own parity gate, not the render path.** It used +to open by saying there was no render path, no text encoder, no VAE, no pipeline +and no `/v1/videos` route for LTX-2.5; every one of those has since landed, and +what the video engine can actually be asked for is under "LTX-2.5: what runs, and +what it cannot do" above. What follows reproduces the DiT layer's gate from +source. The C++ surface is `include/vllm/model_executor/models/ltx2.h`, and it refuses by name every arm it does not carry (a non-f32 stream dtype, the 19B caption-projection checkpoint form, keyframe absolute-position embeddings, the video-only / audio-only model types). diff --git a/include/vllm/model_executor/models/gemma4.h b/include/vllm/model_executor/models/gemma4.h index 7d386b9fe..6aad0723d 100644 --- a/include/vllm/model_executor/models/gemma4.h +++ b/include/vllm/model_executor/models/gemma4.h @@ -257,7 +257,9 @@ std::vector Gemma4GenerateGreedyViaRegistry( // [max_pos + 1, head_dim]: the first head_dim/2 columns are cos and the second // half sin, over the head_dim/2 DISTINCT angle pairs, mirroring upstream's // `emb = cat((freqs, freqs))` with each angle stored once -// (modeling_gemma4_unified.py:257-274, modeling_rope_utils.py:187-245). +// (`Gemma4UnifiedTextRotaryEmbedding.forward`, modeling_gemma4_unified.py:259-275 +// — the `cat` itself is :271; the inv_freq it consumes comes from +// modeling_rope_utils.py:187-254). // // This is a GATE SURFACE, and it exists because of a measurement rather than a // preference. `partial_rotary_factor` decides how many angle pairs are rotated diff --git a/scripts/gen-ltx2-gemma-tower-goldens.py b/scripts/gen-ltx2-gemma-tower-goldens.py index 08cb5ead7..507860af4 100644 --- a/scripts/gen-ltx2-gemma-tower-goldens.py +++ b/scripts/gen-ltx2-gemma-tower-goldens.py @@ -375,8 +375,9 @@ def rope_cos_sin(config, layer_type: str, head_dim: int, positions) -> np.ndarra Built by the real `Gemma4UnifiedTextRotaryEmbedding`, which is what routes `rope_type: "proportional"` to `_compute_proportional_rope_parameters` - (modeling_gemma4_unified.py:214-218, modeling_rope_utils.py:187-245) and so - is the only thing that decides how many angle pairs are zero-padded. + (modeling_gemma4_unified.py:206-218 -- the ROPE_INIT_FUNCTIONS lookup at :207 + and the call at :218; modeling_rope_utils.py:187-254) and so is the only + thing that decides how many angle pairs are zero-padded. Returns [len(positions), head_dim]: the first head_dim/2 columns are cos over the distinct angle pairs and the second half is sin, which is the diff --git a/src/vllm/model_executor/models/ltx2_text_encoder.cpp b/src/vllm/model_executor/models/ltx2_text_encoder.cpp index dee68d973..a695e1614 100644 --- a/src/vllm/model_executor/models/ltx2_text_encoder.cpp +++ b/src/vllm/model_executor/models/ltx2_text_encoder.cpp @@ -1052,8 +1052,9 @@ Ltx2PromptConditioning Ltx2EncodePromptToConditioning( // is strictly WIDER, so every token gate and every golden still passed — it // simply held twice the bytes and made `Gemma4AttnBlock` allocate two extra // per-layer cast buffers and run a CastF32 on every K and V it wrote - // (gemma4.cpp:300-312, the `kv.dtype != adt` arm). That is exactly the defect - // class AGENTS.md names: a token gate cannot see a dtype that is too wide. + // (gemma4.cpp:306-315, the `kv.dtype != adt` arm — the two DBufs at :307-308 + // and the CastF32 pair at :313-314). That is exactly the defect class + // AGENTS.md names: a token gate cannot see a dtype that is too wide. // At the shipped 48 layers x 1024 positions this is ~2x on a cache that peaks // near 200 MB for one prompt. const int64_t block = 16; diff --git a/tests/vllm/models/test_ltx2_text_encoder.cpp b/tests/vllm/models/test_ltx2_text_encoder.cpp index 7a6195167..b36f0b0f4 100644 --- a/tests/vllm/models/test_ltx2_text_encoder.cpp +++ b/tests/vllm/models/test_ltx2_text_encoder.cpp @@ -632,10 +632,11 @@ const float* TowerGoldenPaddedBf16(int64_t state) { // // SCOPE, because "the concat order is gated" is broader than what this reaches. // The only concat under this case is the LTX tower loader's own `TowerConcat` -// (ltx2_text_encoder.cpp:943-945). `gemma4_weights.cpp` assembles its qkv through -// a SEPARATE implementation (gemma4_weights.cpp:281-295) that nothing in this -// suite loads — MEASURED: mutating it leaves every case in this file green. That -// path owes its own gate; this one does not stand in for it. +// (ltx2_text_encoder.cpp:951-953, both qkv arms; the helper is at :835). +// `gemma4_weights.cpp` assembles its qkv through a SEPARATE implementation +// (gemma4_weights.cpp:281-295) that nothing in this suite loads — MEASURED: +// mutating it leaves every case in this file green. That path owes its own +// gate; this one does not stand in for it. std::vector TowerPackTensors(const vllm::HfConfig& c) { const int64_t H = c.hidden_size, I = c.intermediate_size, V = c.vocab_size; const int64_t Hq = vllm_test::kLtxTowerNumHeads; @@ -1956,7 +1957,7 @@ TEST_CASE("gemma4 tower: partial_rotary_factor, on the ROPE TABLE the states can // So the instrument is the TABLE, in f32, with no accumulation in it, against // the oracle's own `Gemma4UnifiedTextRotaryEmbedding` routed through // `_compute_proportional_rope_parameters` — the code that actually decides the - // zero padding (modeling_rope_utils.py:187-245). + // zero padding (modeling_rope_utils.py:187-254; the `torch.zeros` pad is :246). // // SCOPE, so the instrument is not read as covering more than it does: this is // the FULL-ATTENTION table only (`kLtxTowerGlobalHeadDim`, the `proportional` @@ -1989,7 +1990,7 @@ TEST_CASE("gemma4 tower: partial_rotary_factor, on the ROPE TABLE the states can // The STRUCTURE, exactly, because it is the thing the factor controls and an // exact check cannot be absorbed by any noise argument. `rope_angles` is - // upstream's `int(partial * head_dim // 2)` (modeling_rope_utils.py:233). + // upstream's `int(partial * head_dim // 2)` (modeling_rope_utils.py:234). const int64_t rotated = static_cast(0.25 * static_cast(Dh)) / 2; REQUIRE(rotated == 2); REQUIRE(rotated < pairs);