diff --git a/.agents/porting-inventory.md b/.agents/porting-inventory.md index d8e71aa27..820dcd9ed 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 3935cc1c9..beec3a261 100644 --- a/docs/FEATURES.md +++ b/docs/FEATURES.md @@ -146,14 +146,20 @@ 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 `Ltx2TokenizeGemmaPrompt` +in `ltx2_text_encoder.cpp` is the call that would have to change. | Lane | Tested checkpoint(s) | Correctness gate | Speed vs reference | |---|---|---|---| | 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 ef3370d82..6302fdf9e 100644 --- a/docs/USAGE.md +++ b/docs/USAGE.md @@ -369,8 +369,21 @@ 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. 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 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 @@ -456,6 +469,19 @@ because that would hand back a lower quality render as if it were the one you asked for. Keyframe and reference conditioning is refused for the same reason: it runs through the video VAE's encoder, and only the decoder is ported. +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 @@ -1729,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). @@ -1775,6 +1804,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/gemma4.h b/include/vllm/model_executor/models/gemma4.h index c65a09034..6aad0723d 100644 --- a/include/vllm/model_executor/models/gemma4.h +++ b/include/vllm/model_executor/models/gemma4.h @@ -251,6 +251,30 @@ 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 +// (`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 +// 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 c64262197..243a8dee2 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,199 @@ 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, 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__` +// 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 +// 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 99ab43729..a1a55447a 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). // // WHAT PHASE L9c CHANGED, AND WHAT IT DID NOT. The link BELOW the tower is now // real: when the checkpoint carries the two `*_embeddings_connector` families 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..507860af4 --- /dev/null +++ b/scripts/gen-ltx2-gemma-tower-goldens.py @@ -0,0 +1,656 @@ +#!/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 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 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 +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 copy +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): + """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 + # 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, + ) + 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: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 + 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() + + +# --------------------------------------------------------------------------- +# 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 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 + # 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" + "// 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 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( + 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..661942467 --- /dev/null +++ b/scripts/gen-ltx2-prompt-tokens-goldens.py @@ -0,0 +1,197 @@ +#!/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/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 4dbee3ff7..a695e1614 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,530 @@ 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 — 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; + // 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`. 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); + } + + // 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. + // + // 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: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; + 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), + static_cast(0)); + PagedKvCache kv; + kv.data = kv_storage.back().data(); + kv.dtype = vt::DType::kBF16; + 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 07bdde3f8..1b03c1af8 100644 --- a/src/vllm/multimodal/ltx2_video.cpp +++ b/src/vllm/multimodal/ltx2_video.cpp @@ -670,12 +670,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..0cd54c941 --- /dev/null +++ b/tests/vllm/models/ltx2_gemma_tower_goldens.inc @@ -0,0 +1,4288 @@ +// 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. +// 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, + -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.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[] = { + -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.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[] = { + -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.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[] = { + 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.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[] = { + 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.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[] = { + 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.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[] = { + 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.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[] = { + 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.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[] = { + 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.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[] = { + 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.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[] = { + 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.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[] = { + 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.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 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.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/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..b36f0b0f4 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 @@ -38,12 +39,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; @@ -245,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; @@ -275,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()); } @@ -369,6 +399,392 @@ 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)]; +} + +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. +// +// 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: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; + 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; @@ -1259,3 +1675,995 @@ 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). + // + // 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) { + 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"); +} + +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-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` + // 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; + 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:234). + 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, 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]); + 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 { + +// 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 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. 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() == 40 * 7 + 8 * 6 + 1); + + // 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); +}