Skip to content

Qwen3.8-Flash-Next on any consumer hardware: one-click install for Windows / Linux. Strata inference engine, OpenAI/Anthropic API on localhost, optional image input.

C++

APR port, stage 4: trellis decode and Hadamard rotation on the GPU paths

Laurent Zuijdwijkfbf045eb6ad5
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8295506ad..4b9532bbf 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1733,6 +1733,16 @@ if(STRATA_NATIVE_EXPERTS)
set_tests_properties(native_expert_parity_${_name} PROPERTIES TIMEOUT 120)
endforeach()
add_test(NAME native_expert_parity_q5_1_min COMMAND native_expert_parity --q5_1-min)
+ # APR: the trellis expert types and the Hadamard activation rotation, when ggml comes from the agention fork
+ # (the only tree with these types; marked by its ggml-cuda/tq.cuh)
+ if(STRATA_GGML_DIR AND EXISTS "${STRATA_GGML_DIR}/ggml/src/ggml-cuda/tq.cuh")
+ foreach(_pair tqk6/tqk7 tq2_t/tq2_t)
+ string(REPLACE "/" "_" _name "${_pair}")
+ add_test(NAME native_expert_parity_${_name} COMMAND native_expert_parity --synthetic ${_pair})
+ add_test(NAME native_expert_parity_hadamard_${_name} COMMAND native_expert_parity --synthetic-hadamard ${_pair})
+ set_tests_properties(native_expert_parity_${_name} native_expert_parity_hadamard_${_name} PROPERTIES TIMEOUT 300)
+ endforeach()
+ endif()
# #290: the BF16 token embedding (--embd-gguf) gathered and dequantized bit for bit
add_test(NAME native_expert_parity_bf16_embd COMMAND native_expert_parity --bf16-embd)
endif()
diff --git a/include/strata/core/peer_experts.hpp b/include/strata/core/peer_experts.hpp
index a6e3766a9..cd9d53bd3 100644
--- a/include/strata/core/peer_experts.hpp
+++ b/include/strata/core/peer_experts.hpp
@@ -98,6 +98,8 @@ private:
void* h_meta_ = nullptr; void* d_meta_ = nullptr; // groups: ptr | start | dst | tok | count
uint8_t* d_q8_ = nullptr;
void* d_scratch_ = nullptr;
+ const float* d_sx_ = nullptr; // APR: device sign vectors (x: H, h: FF); nullptr = identity
+ const float* d_sh_ = nullptr;
std::vector<int32_t> row_of_; ///< compact row -> original entry
int64_t launched_rows_ = 0;
bool launched_direct_ = false;
diff --git a/include/strata/core/remote_experts.hpp b/include/strata/core/remote_experts.hpp
index d499c0315..4e3be387e 100644
--- a/include/strata/core/remote_experts.hpp
+++ b/include/strata/core/remote_experts.hpp
@@ -87,6 +87,9 @@ private:
float* d_out_ = nullptr;
uint8_t* d_q8_ = nullptr;
float* d_scales_ = nullptr;
+ float* d_xr_ = nullptr; // APR: the Hadamard-rotated expert input (CAP x H)
+ const float* d_sx_ = nullptr; // APR: device sign vectors (x: H, h: FF); nullptr = identity
+ const float* d_sh_ = nullptr;
void* d_scratch_ = nullptr;
void* d_meta_ = nullptr; ///< one contiguous upload of grouped indices, instead of five small copies
int32_t* d_start_ = nullptr;
diff --git a/include/strata/core/verify.hpp b/include/strata/core/verify.hpp
index e3d261558..fd6a61c70 100644
--- a/include/strata/core/verify.hpp
+++ b/include/strata/core/verify.hpp
@@ -528,6 +528,9 @@ private:
static constexpr int64_t kPcieGroupRows = 4; // the PCIe call's groups side by side (of <= 16)
uint8_t* hit_xq_ = nullptr;
uint8_t* nat_xq_ = nullptr; // plan v0.3 P6: q8_1 activations for a native pack's grouped experts
+ float* nat_xr_ = nullptr; // APR: the Hadamard-rotated expert input (the shared expert and the CPU keep xm)
+ const float* had_sx_ = nullptr; // APR: device sign vectors for x (n_embd) and h (n_ff); nullptr = identity
+ const float* had_sh_ = nullptr;
float* hit_xs_ = nullptr;
void* hit_scratch_ = nullptr;
float *head_mixed_ = nullptr, *head_inj_ = nullptr, *head_logits_ = nullptr;
diff --git a/include/strata/kernels/iq_kernels.hpp b/include/strata/kernels/iq_kernels.hpp
index 0a39f6460..bc5c5a04b 100644
--- a/include/strata/kernels/iq_kernels.hpp
+++ b/include/strata/kernels/iq_kernels.hpp
@@ -48,6 +48,10 @@ struct NativeExpertLayout {
size_t up_off = 0, down_off = 0; // byte offsets inside the blob
size_t bytes = 0; // the whole blob
size_t tail_off = 0; // NVFP4: {s_gate, s_up, s_down, 0} at the blob's end; 0 = none
+ // APR (prism.hadamard): the down weights are Hadamard-folded, so native_expert_grouped rotates h before
+ // quantizing it (hadamard_rows). had_block 0 = none; d_signs is a DEVICE vector of n_ff signs or nullptr.
+ int had_block = 0;
+ const float* d_signs = nullptr;
};
NativeExpertLayout native_expert_layout(int gu_type, int d_type, int64_t n_embd, int64_t n_ff);
/// Whether `native_expert_grouped` has kernels for this gate/up and down type pair at these dimensions, and the
@@ -83,6 +87,16 @@ void native_grouped_set_v1(bool v1);
/// The bench only: the AMD kernel layout (STRATA_EXP_MODE values; -1 = the environment's) and the phase
/// (0 all, 1 gate/up + SwiGLU + quantize, 2 down).
void native_expert_set_mode(int mode, int phase);
+
+/// APR (prism.hadamard): y = H_block (signs * x) per block of `block` values of each of `rows` rows of `width`
+/// (x == y allowed). `signs`: a device vector of `width` signs, or nullptr (identity). The same floats as the CPU's
+/// hadamard_rotate. The f16 form rotates in place, computing in float.
+void hadamard_rows(const float* x, float* y, int64_t rows, int64_t width, int block, const float* signs, void* stream);
+void hadamard_rows_f16(uint16_t* x, int64_t rows, int64_t width, int block, const float* signs, void* stream);
+/// A device copy (on the current device) of the host sign vector `host` of `width` signs, made on first use and
+/// kept for the process. Call it at setup, not inside a CUDA graph capture. nullptr for a nullptr `host`.
+const float* hadamard_device_signs(const float* host, int width);
+
/// `iq_mmvq` and `native_expert_grouped` decode each weight part once and apply it to every column / entry;
/// true selects the older kernels that decode it again per column (STRATA_OLD_IQ_MMVQ=1 at startup). Both give
/// bitwise the same results. Set before graph capture; captured graphs keep the kernels they captured.
diff --git a/src/core/peer_experts.cpp b/src/core/peer_experts.cpp
index 6c8f567e6..5a2164ca1 100644
--- a/src/core/peer_experts.cpp
+++ b/src/core/peer_experts.cpp
@@ -2,6 +2,7 @@
#include "strata/core/peer_experts.hpp"
#include "strata/kernels/cpu/expert_layout.hpp"
+#include "strata/kernels/cpu/hadamard.hpp"
#include "strata/kernels/elementwise.hpp"
#include "strata/kernels/iq_kernels.hpp"
#include "strata/kernels/quantize_act.hpp"
@@ -73,6 +74,7 @@ void PeerExperts::close() {
d_x_ = d_out_ = h_x_ = h_out_ = nullptr;
d_meta_ = h_meta_ = d_scratch_ = nullptr;
d_q8_ = nullptr;
+ d_sx_ = d_sh_ = nullptr;
stream_ = refill_ = nullptr;
refill_ev_ = nullptr;
device_ = -1;
@@ -131,6 +133,10 @@ bool PeerExperts::open(int device, const std::vector<std::pair<int32_t, int32_t>
ck(cudaMalloc((void**) &d_q8_, (size_t) CAP * (H / 32) * 36), "activations", err) &&
ck(cudaMalloc(&d_scratch_, scratch), "scratch", err);
if (!alloc_ok) { close(); return false; }
+ if (strata::kernels::cpu::hadamard_spec().any()) { // APR: this device's copies of the sign vectors
+ d_sx_ = strata::kernels::hadamard_device_signs(strata::kernels::cpu::hadamard_signs((int) H), (int) H);
+ d_sh_ = strata::kernels::hadamard_device_signs(strata::kernels::cpu::hadamard_signs((int) ff), (int) ff);
+ }
// the pairs the primary does not hold, in rank order, as many as fit
size_t free_b = 0, total_b = 0;
@@ -234,9 +240,12 @@ bool PeerExperts::launch(int64_t layer, const float* x, const int32_t* ids, int6
Meta* dm = (Meta*) d_meta_;
const auto& lay = strata::kernels::cpu::expert_layout();
if (lay.native) {
- strata::kernels::quantize_q8_1_rows(d_x_, n_tok, H, d_q8_, s);
const auto& f = lay.fmt[(size_t) layer];
- const auto L = strata::kernels::native_expert_layout(f.gu_type, f.d_type, f.n_embd, f.n_ff);
+ // APR: Hadamard-folded gate/up take H (s * x); d_x_ is this device's private copy, rotated in place
+ if (f.had_gu) strata::kernels::hadamard_rows(d_x_, d_x_, n_tok, H, f.had_block, d_sx_, s);
+ strata::kernels::quantize_q8_1_rows(d_x_, n_tok, H, d_q8_, s);
+ auto L = strata::kernels::native_expert_layout(f.gu_type, f.d_type, f.n_embd, f.n_ff);
+ if (f.had_d) { L.had_block = f.had_block; L.d_signs = d_sh_; }
strata::kernels::native_expert_grouped(L, dm->ptr, dm->start, dm->count, dm->dst, dm->tok, groups, rows, d_q8_,
d_scratch_, d_out_, s);
} else {
diff --git a/src/core/remote_experts.cpp b/src/core/remote_experts.cpp
index f01bf6fe3..4148fcec2 100644
--- a/src/core/remote_experts.cpp
+++ b/src/core/remote_experts.cpp
@@ -2,6 +2,7 @@
#include "strata/core/remote_expert_opt.hpp"
#include "strata/kernels/cpu/expert_layout.hpp"
+#include "strata/kernels/cpu/hadamard.hpp"
#include "strata/kernels/iq_kernels.hpp"
#include "strata/kernels/quantize_act.hpp"
#include "strata/kernels/s2_expert_grouped.hpp"
@@ -100,6 +101,7 @@ void RemoteExperts::close() {
if (d_out_) cudaFree(d_out_);
if (d_q8_) cudaFree(d_q8_);
if (d_scales_) cudaFree(d_scales_);
+ if (d_xr_) cudaFree(d_xr_);
if (d_scratch_) cudaFree(d_scratch_);
if (d_meta_) cudaFree(d_meta_);
if (h_x_) cudaFreeHost(h_x_);
@@ -115,6 +117,8 @@ void RemoteExperts::close() {
h_meta_ = d_meta_ = nullptr;
d_q8_ = nullptr;
d_scales_ = nullptr;
+ d_xr_ = nullptr;
+ d_sx_ = d_sh_ = nullptr;
d_scratch_ = nullptr;
d_start_ = d_dst_ = d_tok_ = d_count_ = nullptr;
d_ptr_ = nullptr;
@@ -206,12 +210,18 @@ bool RemoteExperts::open(int device, int slots, int64_t layers, int64_t experts,
check(cudaMalloc((void**) &d_q8_, (size_t) CAP * (H / 32) * 36), "activation", err, device) &&
check(cudaMalloc((void**) &d_scales_, (size_t) CAP * (H / 32) * sizeof(float)), "activation scales", err, device) &&
check(cudaMalloc(&d_scratch_, scratch), "scratch", err, device) &&
- check(cudaMalloc(&d_meta_, meta_bytes), "group metadata", err, device);
+ check(cudaMalloc(&d_meta_, meta_bytes), "group metadata", err, device) &&
+ (!strata::kernels::cpu::hadamard_spec().any() ||
+ check(cudaMalloc((void**) &d_xr_, (size_t) CAP * H * sizeof(float)), "rotated input", err, device));
if (!allocated) { close(); return false; }
if (!check(cudaStreamCreateWithFlags(&read_stream_, cudaStreamNonBlocking), "cache read stream", err, device)) {
close();
return false;
}
+ if (strata::kernels::cpu::hadamard_spec().any()) { // APR: this device's copies of the sign vectors
+ d_sx_ = strata::kernels::hadamard_device_signs(strata::kernels::cpu::hadamard_signs((int) H), (int) H);
+ d_sh_ = strata::kernels::hadamard_device_signs(strata::kernels::cpu::hadamard_signs((int) FF), (int) FF);
+ }
// Zero-copy: the helper reads its input from, and writes its compact rows into, the pinned host buffers
// directly - two copies fewer per layer, each of which is a PCIe round trip. STRATA_REMOTE_ZEROCOPY=0 copies.
const char* zc = std::getenv("STRATA_REMOTE_ZEROCOPY");
@@ -312,9 +322,15 @@ bool RemoteExperts::begin(int64_t layer, const float* x, const int32_t* ids, int
if (!staged) return false;
const auto& lay = strata::kernels::cpu::expert_layout();
if (lay.native) {
- strata::kernels::quantize_q8_1_rows(zero_copy_ ? z_x_ : d_x_, n_tok, H, d_q8_, s);
const auto& fmt = lay.fmt[(size_t) layer];
+ const float* xe = zero_copy_ ? z_x_ : d_x_;
+ if (fmt.had_gu) { // APR: Hadamard-folded gate/up take H (s * x)
+ strata::kernels::hadamard_rows(xe, d_xr_, n_tok, H, fmt.had_block, d_sx_, s);
+ xe = d_xr_;
+ }
+ strata::kernels::quantize_q8_1_rows(xe, n_tok, H, d_q8_, s);
auto L = strata::kernels::native_expert_layout(fmt.gu_type, fmt.d_type, fmt.n_embd, fmt.n_ff);
+ if (fmt.had_d) { L.had_block = fmt.had_block; L.d_signs = d_sh_; }
strata::kernels::native_expert_grouped(L, d_ptr_, d_start_, d_count_, d_dst_, d_tok_,
groups_, (int64_t) dst_.size(), d_q8_, d_scratch_, zero_copy_ && !reduce ? z_out_ : d_out_, s);
} else {
diff --git a/src/core/verify.cpp b/src/core/verify.cpp
index 9a9830fe7..aff952b74 100644
--- a/src/core/verify.cpp
+++ b/src/core/verify.cpp
@@ -21,6 +21,7 @@
#include "strata/core/peer_experts.hpp"
#include "strata/kernels/iq_kernels.hpp"
#include "strata/kernels/cpu/expert_layout.hpp"
+#include "strata/kernels/cpu/hadamard.hpp"
#include "strata/kernels/bf16_gemv.hpp"
#include "strata/kernels/native_router.hpp"
#include "strata/kernels/native_moe.hpp"
@@ -714,6 +715,7 @@ bool Verifier::init(const WeightTable& wt, const ModelGeometry& g, SessionState&
staging_ = b.take<uint8_t>((uint64_t) kStagingBlobs * strata::kernels::cpu::expert_layout().max_blob);
hit_xq_ = b.take<uint8_t>(T * (N / 32) * 34); hit_xs_ = b.take<float>(T * (N / 32));
nat_xq_ = b.take<uint8_t>(T * (N / 32) * 36);
+ nat_xr_ = b.take<float>(T * N);
hit_scratch_ = b.take<uint8_t>(std::max<uint64_t>(
strata::kernels::moe_hit_grouped_scratch_bytes((int64_t) (T * K), g.n_embd, g.n_ff),
strata::kernels::native_expert_scratch_bytes((int64_t) (T * K), g.n_ff)));
@@ -766,6 +768,10 @@ bool Verifier::init(const WeightTable& wt, const ModelGeometry& g, SessionState&
return false;
}
}
+ { // APR (prism.hadamard, hadamard.txt): the sign vectors on this device, before any graph capture
+ had_sx_ = strata::kernels::hadamard_device_signs(strata::kernels::cpu::hadamard_signs((int) g.n_embd), (int) g.n_embd);
+ had_sh_ = strata::kernels::hadamard_device_signs(strata::kernels::cpu::hadamard_signs((int) g.n_ff), (int) g.n_ff);
+ }
sink_.staging = (unsigned long long) staging_;
sink_.staging_cap = kStagingBlobs;
(void) TS;
@@ -1639,8 +1645,17 @@ bool Verifier::record_window(int T, cudaStream_t cs, std::string& err) {
if (sh_fork) cudaEventRecord(ev_join_, sh_cs_);
}
if (strata::kernels::cpu::expert_layout().native) {
- if (!qdedup)
- if (!q8_ffn) quantize_q8_1_rows(xm, n, N, nat_xq_ + (size_t) tb * (N / 32) * 36, cs);
+ // APR: Hadamard-folded gate/up take H (s * x); xm itself stays as it is (the shared expert above and the
+ // doorbell copy for the CPU pool, which rotates its own in native_quant_act). The q8_1 image of xm that
+ // STRATA_QFUSE / STRATA_VERIFY_QDEDUP may already have written is of the unrotated input, so a folded layer
+ // always rewrites it from the rotated rows (same stream, after the shared expert has read it).
+ const auto& f = strata::kernels::cpu::expert_layout().fmt[(size_t) l];
+ if (f.had_gu) {
+ hadamard_rows(xm, nat_xr_ + (size_t) tb * N, n, N, f.had_block, had_sx_, cs);
+ quantize_q8_1_rows(nat_xr_ + (size_t) tb * N, n, N, nat_xq_ + (size_t) tb * (N / 32) * 36, cs);
+ } else if (!qdedup && !q8_ffn) {
+ quantize_q8_1_rows(xm, n, N, nat_xq_ + (size_t) tb * (N / 32) * 36, cs);
+ }
} else
quantize_q8_0_scaled(xm, hit_xq_ + (size_t) tb * (N / 32) * 34, hit_xs_ + (size_t) tb * (N / 32), (int64_t) n * N, cs);
stamp(l, 18, grp);
@@ -1676,7 +1691,8 @@ bool Verifier::record_window(int T, cudaStream_t cs, std::string& err) {
if (lay.native) {
// the layer's GGUF formats (i-quant gate/up, Q2_0 / IQ4_NL down)
const auto& f = lay.fmt[(size_t) l];
- const NativeExpertLayout L = native_expert_layout(f.gu_type, f.d_type, f.n_embd, f.n_ff);
+ NativeExpertLayout L = native_expert_layout(f.gu_type, f.d_type, f.n_embd, f.n_ff);
+ if (f.had_d) { L.had_block = f.had_block; L.d_signs = had_sh_; } // APR: h is rotated in there
native_expert_grouped(L, gp, gs, gn, p_dst, p_tok, cap, cap,
nat_xq_ + (size_t) tb * (N / 32) * 36, hit_scratch_, dst_buf, cs, gy);
} else {
diff --git a/src/kernels/cuda/iq_kernels.cu b/src/kernels/cuda/iq_kernels.cu
index 47e0e76e5..7d4fcae73 100644
--- a/src/kernels/cuda/iq_kernels.cu
+++ b/src/kernels/cuda/iq_kernels.cu
@@ -16,10 +16,15 @@
#define GGML_COMMON_DECL_CUDA
#define GGML_COMMON_IMPL_CUDA
#include "ggml-common.h"
+#include "ggml-common-tq.h" // APR trellis types (agention llama.cpp fork)
+#include <cmath>
#include <cstdio>
#include <utility>
#include <cstdlib>
+#include <map>
+#include <mutex>
+#include <tuple>
#include <type_traits>
namespace strata::kernels {
@@ -600,6 +605,70 @@ __device__ __forceinline__ float vec_dot_nvfp4_q8_1(const void* __restrict__ vbq
return sum;
}
+// ---------------------------------------------------------------- APR trellis types (ggml 144 TQ2_T, 145 TQK6, 146 TQK7)
+// Transcribed from the agention llama.cpp fork's ggml-cuda/tq.cuh (6d3f2b1b8; format in ggml-common-tq.h). A
+// 128-value block is 8 lanes of 4 trellis steps (16 values); the dot of lane l reads q8_1 block l/2, ints 4(l&1)..
+template<int TY> struct TqInfo;
+template<> struct TqInfo<144> { using block_t = block_tq2_t; }; // byte-aligned, no K
+template<> struct TqInfo<145> { using block_t = block_tqk6; static constexpr int K = 6; };
+template<> struct TqInfo<146> { using block_t = block_tqk7; static constexpr int K = 7; };
+__device__ __forceinline__ float tq_h2f(uint32_t bits) { return __half2float(__ushort_as_half((unsigned short) bits)); }
+// the four unscaled weights of the step with state s: (a.x, a.y, b.x, b.y)
+__device__ __forceinline__ void tq_step(uint32_t s, float2& a, float2& b) {
+ const uint32_t* lut = (const uint32_t*) tq_lut_f16;
+ const uint32_t x = (s & TQ_STATE_MASK) * 0x9e3779b1u;
+ const uint32_t pa = lut[x >> 21], pb = lut[(x >> 10) & 2047u];
+ a = make_float2(tq_h2f(pa & 0xFFFFu), tq_h2f(pa >> 16));
+ b = make_float2(tq_h2f(pb & 0xFFFFu), tq_h2f(pb >> 16));
+}
+// the states of steps 4l..4l+3 of one block (qs is 2-byte aligned: every trellis block has an even size)
+template<int TY>
+__device__ __forceinline__ void tq_states4(const uint8_t* qs, int l, uint32_t s[4]) {
+ const uint16_t* qs16 = (const uint16_t*) qs;
+ if constexpr (TY == 144) { // s_t = qs[(t + 31) % 32] << 8 | qs[t]
+ const uint32_t w01 = qs16[2 * l + 0], w23 = qs16[2 * l + 1];
+ const uint32_t prev = qs[(4 * l + 31) & 31];
+ const uint32_t b0 = w01 & 0xFF, b1 = w01 >> 8, b2 = w23 & 0xFF, b3 = w23 >> 8;
+ s[0] = (prev << 8) | b0;
+ s[1] = (b0 << 8) | b1;
+ s[2] = (b1 << 8) | b2;
+ s[3] = (b2 << 8) | b3;
+ } else {
+ // step t's state: the 16 stream bits from bit (31 - t)*K, circular over 2K u16 words; steps 4l..4l+3 all
+ // lie in the four words from (28 - 4l)*K >> 4
+ constexpr int K = TqInfo<TY>::K, nwords = 2 * K;
+ const int off3 = (28 - 4 * l) * K, wb = off3 >> 4, r = off3 & 15;
+ const int wi1 = wb + 1 >= nwords ? wb + 1 - nwords : wb + 1;
+ const int wi2 = wb + 2 >= nwords ? wb + 2 - nwords : wb + 2;
+ const int wi3 = wb + 3 >= nwords ? wb + 3 - nwords : wb + 3;
+ const uint64_t v = (uint64_t) qs16[wb] | ((uint64_t) qs16[wi1] << 16) | ((uint64_t) qs16[wi2] << 32) |
+ ((uint64_t) qs16[wi3] << 48);
+#pragma unroll
+ for (int i = 0; i < 4; ++i) s[i] = (uint32_t) (v >> (r + (3 - i) * K)) & 0xFFFFu;
+ }
+}
+// lane iqs/4 of block kbx against the q8_1 blocks aligned with the block's start (4 per trellis block)
+template<int TY>
+__device__ __forceinline__ float vec_dot_tq_q8_1(const void* __restrict__ vbq, const block_q8_1* __restrict__ bq8_1,
+ const int& kbx, const int& iqs) {
+ const auto* b = (const typename TqInfo<TY>::block_t*) vbq + kbx;
+ const int l = iqs / 4;
+ uint32_t s[4];
+ tq_states4<TY>(b->qs, l, s);
+ const block_q8_1* b8 = bq8_1 + l / 2;
+ const int* q8 = (const int*) b8->qs + 4 * (l & 1);
+ float sum = 0.0f;
+#pragma unroll
+ for (int i = 0; i < 4; ++i) {
+ float2 p0, p1;
+ tq_step(s[i], p0, p1);
+ const int v = q8[i];
+ sum += p0.x * (float) (int8_t) (v) + p0.y * (float) (int8_t) (v >> 8) + p1.x * (float) (int8_t) (v >> 16) +
+ p1.y * (float) (int8_t) (v >> 24);
+ }
+ return tq_h2f(b->d) * __low2float(b8->ds) * sum;
+}
+
// ---------------------------------------------------------------- the formats
// qk = values per block, ipb = dot calls per block (qi / vdr), step = the iqs stride between calls.
template<int TY> struct Fmt;
@@ -637,21 +706,28 @@ template<> struct Fmt<6> { static constexpr int qk = 32, ipb = QI5_0 / VDR_Q5_0,
__device__ static float dot(const void* v, const block_q8_1* y, int kbx, int iqs) { return vec_dot_q5_0_q8_1(v, y, kbx, iqs); } };
template<> struct Fmt<8> { static constexpr int qk = 32, ipb = QI8_0 / VDR_Q8_0, step = VDR_Q8_0;
__device__ static float dot(const void* v, const block_q8_1* y, int kbx, int iqs) { return vec_dot_q8_0_q8_1(v, y, kbx, iqs); } };
+// APR trellis types: 8 lanes of 4 steps per 128-value block, iqs = 4 * lane
+template<> struct Fmt<144> { static constexpr int qk = 128, ipb = 8, step = 4;
+ __device__ static float dot(const void* v, const block_q8_1* y, int kbx, int iqs) { return vec_dot_tq_q8_1<144>(v, y, kbx, iqs); } };
+template<> struct Fmt<145> { static constexpr int qk = 128, ipb = 8, step = 4;
+ __device__ static float dot(const void* v, const block_q8_1* y, int kbx, int iqs) { return vec_dot_tq_q8_1<145>(v, y, kbx, iqs); } };
+template<> struct Fmt<146> { static constexpr int qk = 128, ipb = 8, step = 4;
+ __device__ static float dot(const void* v, const block_q8_1* y, int kbx, int iqs) { return vec_dot_tq_q8_1<146>(v, y, kbx, iqs); } };
// The formats of each role, one list each so a type cannot be in one switch and missing from another. Every
// entry is a kernel template for each CUDA architecture of the build, hence two lists rather than one.
#ifdef STRATA_Q6K_EXPERTS // opt-in build (-DSTRATA_Q6K_EXPERTS=ON): one more instance per kernel, loaded at start
-#define STRATA_GU_FMTS(X) X(16) X(17) X(18) X(21) X(22) X(23) X(29) X(42) X(12) X(13) X(14) X(6) X(2) X(3) X(8) X(40)
+#define STRATA_GU_FMTS(X) X(16) X(17) X(18) X(21) X(22) X(23) X(29) X(42) X(12) X(13) X(14) X(6) X(2) X(3) X(8) X(40) X(144) X(145)
#else
-#define STRATA_GU_FMTS(X) X(16) X(17) X(18) X(21) X(22) X(23) X(29) X(42) X(12) X(13) X(6) X(2) X(3) X(8) X(40)
+#define STRATA_GU_FMTS(X) X(16) X(17) X(18) X(21) X(22) X(23) X(29) X(42) X(12) X(13) X(6) X(2) X(3) X(8) X(40) X(144) X(145)
#endif
// Q5_K / Q6_K downs: Qwen3.6-35B-A3B (FF 512, whole 256-blocks per row); Flash-Next's FF 640 never selects them
#ifdef STRATA_Q6K_EXPERTS
-#define STRATA_D_FMTS(X) X(20) X(23) X(42) X(7) X(6) X(2) X(3) X(8) X(13) X(14) X(40)
+#define STRATA_D_FMTS(X) X(20) X(23) X(42) X(7) X(6) X(2) X(3) X(8) X(13) X(14) X(40) X(144) X(146)
#else
-#define STRATA_D_FMTS(X) X(20) X(23) X(42) X(7) X(6) X(2) X(3) X(8) X(13) X(40)
+#define STRATA_D_FMTS(X) X(20) X(23) X(42) X(7) X(6) X(2) X(3) X(8) X(13) X(40) X(144) X(146)
#endif
-#define STRATA_MMVQ_FMTS(X) X(16) X(17) X(18) X(20) X(21) X(22) X(23) X(29) X(42) X(12) X(13) X(7) X(6) X(2) X(3) X(8) X(40)
+#define STRATA_MMVQ_FMTS(X) X(16) X(17) X(18) X(20) X(21) X(22) X(23) X(29) X(42) X(12) X(13) X(7) X(6) X(2) X(3) X(8) X(40) X(144) X(145) X(146)
template<> struct Fmt<40> { static constexpr int qk = 64, ipb = 2, step = 4; // NVFP4: 2 calls of 32 values
__device__ static float dot(const void* v, const block_q8_1* y, int kbx, int iqs) { return vec_dot_nvfp4_q8_1(v, y, kbx, iqs); } };
@@ -1458,6 +1534,34 @@ __global__ void __launch_bounds__(256) native_gu_multi_kernel(const unsigned lon
}
}
+// APR (prism.hadamard): y = H_block (signs * x) per block of each row, block = blockDim.x (a power of two <= 1024),
+// one thread block per (row block, row). The butterflies are the CPU's (hadamard.cpp) in the same order, so the
+// rotated values are the same floats.
+template<typename T> __device__ __forceinline__ float ld_f(const T* p) { return (float) *p; }
+template<> __device__ __forceinline__ float ld_f<__half>(const __half* p) { return __half2float(*p); }
+template<typename T> __device__ __forceinline__ void st_f(T* p, float v) { *p = v; }
+template<> __device__ __forceinline__ void st_f<__half>(__half* p, float v) { *p = __float2half(v); }
+template<typename T>
+__global__ void hadamard_rows_kernel(const T* __restrict__ x, T* __restrict__ y, int64_t width,
+ const float* __restrict__ signs, float scale) {
+ extern __shared__ float hbuf[];
+ const int n = blockDim.x, i = threadIdx.x;
+ const int64_t col = (int64_t) blockIdx.x * n + i, at = (int64_t) blockIdx.y * width + col;
+ float v = ld_f<T>(x + at);
+ if (signs) v *= signs[col];
+ hbuf[i] = v;
+ for (int len = 1; len < n; len <<= 1) {
+ __syncthreads();
+ if ((i & len) == 0) {
+ const float a = hbuf[i], c = hbuf[i + len];
+ hbuf[i] = a + c;
+ hbuf[i + len] = a - c;
+ }
+ }
+ __syncthreads();
+ st_f<T>(y + at, hbuf[i] * scale);
+}
+
__global__ void swiglu_entries_kernel(const float* __restrict__ gate, const float* __restrict__ up, float* __restrict__ h,
long long n) {
const long long i = (long long) blockIdx.x * blockDim.x + threadIdx.x;
@@ -2026,6 +2130,27 @@ __device__ void dq_nvfp4(const void* vx, int64_t ibs, dst_t* yy, int tid) {
}
}
+// APR trellis types: one 256-value call = two 128-blocks; thread tid decodes block tid/16, lane (tid/2)%8, steps
+// 2(tid%2)..2(tid%2)+1 (8 values)
+template<int TY, typename dst_t>
+__device__ void dq_tq(const void* vx, int64_t ibs, dst_t* yy, int tid) {
+ const int blk = tid >> 4, l = (tid >> 1) & 7, half = tid & 1;
+ const auto* b = (const typename TqInfo<TY>::block_t*) vx + 2 * ibs + blk;
+ const float d = tq_h2f(b->d);
+ uint32_t s[4];
+ tq_states4<TY>(b->qs, l, s);
+ dst_t* y = yy + blk * 128 + 16 * l + 8 * half;
+#pragma unroll
+ for (int i = 0; i < 2; ++i) {
+ float2 a, c;
+ tq_step(s[2 * half + i], a, c);
+ y[4 * i + 0] = cvt<dst_t>(d * a.x);
+ y[4 * i + 1] = cvt<dst_t>(d * a.y);
+ y[4 * i + 2] = cvt<dst_t>(d * c.x);
+ y[4 * i + 3] = cvt<dst_t>(d * c.y);
+ }
+}
+
// Every type below must also be in is_iq() (BF16: embed_type_supported): the host entry points refuse the others,
// so the default is unreachable.
template<typename dst_t>
@@ -2053,6 +2178,9 @@ __device__ __forceinline__ void dq_dispatch(int ty, const void* vx, int64_t ibs,
case 40: dq_nvfp4(vx, ibs, y, tid); break;
case 8: dq_q8_0(vx, ibs, y, tid); break;
case 30: dq_bf16(vx, ibs, y, tid); break;
+ case 144: dq_tq<144>(vx, ibs, y, tid); break;
+ case 145: dq_tq<145>(vx, ibs, y, tid); break;
+ case 146: dq_tq<146>(vx, ibs, y, tid); break;
default: break;
}
}
@@ -2094,9 +2222,9 @@ __global__ void dequant_gu_kernel(int ty, const void* __restrict__ gate, const v
bool is_iq(int t) {
return t == 16 || t == 17 || t == 18 || t == 20 || t == 21 || t == 22 || t == 23 || t == 29 || t == 42 || t == 11 ||
#ifdef STRATA_Q6K_EXPERTS
- t == 12 || t == 13 || t == 14 || t == 7 || t == 6 || t == 2 || t == 3 || t == 8 || t == 40;
+ t == 12 || t == 13 || t == 14 || t == 7 || t == 6 || t == 2 || t == 3 || t == 8 || t == 40 || t == 144 || t == 145 || t == 146;
#else
- t == 12 || t == 13 || t == 7 || t == 6 || t == 2 || t == 3 || t == 8 || t == 40;
+ t == 12 || t == 13 || t == 7 || t == 6 || t == 2 || t == 3 || t == 8 || t == 40 || t == 144 || t == 145 || t == 146;
#endif
}
// values per block of the types the grouped expert kernels take (0 = none)
@@ -2966,6 +3094,47 @@ void iq_dequant_gu_f16(int t, const void* gate, const void* up, int64_t n_ff, in
check("iq_dequant_gu_f16");
}
+void hadamard_rows(const float* x, float* y, int64_t rows, int64_t width, int block, const float* signs, void* stream) {
+ if (rows <= 0) return;
+ if (block < 2 || block > 1024 || (block & (block - 1)) || width % block) {
+ std::fprintf(stderr, "hadamard_rows: block %d, width %lld\n", block, (long long) width);
+ std::exit(1);
+ }
+ hadamard_rows_kernel<float><<<dim3((unsigned) (width / block), (unsigned) rows), block, block * sizeof(float),
+ (cudaStream_t) stream>>>(x, y, width, signs, 1.0f / std::sqrt((float) block));
+ check("hadamard_rows");
+}
+
+void hadamard_rows_f16(uint16_t* x, int64_t rows, int64_t width, int block, const float* signs, void* stream) {
+ if (rows <= 0) return;
+ if (block < 2 || block > 1024 || (block & (block - 1)) || width % block) {
+ std::fprintf(stderr, "hadamard_rows_f16: block %d, width %lld\n", block, (long long) width);
+ std::exit(1);
+ }
+ hadamard_rows_kernel<__half><<<dim3((unsigned) (width / block), (unsigned) rows), block, block * sizeof(float),
+ (cudaStream_t) stream>>>((const __half*) x, (__half*) x, width, signs,
+ 1.0f / std::sqrt((float) block));
+ check("hadamard_rows_f16");
+}
+
+const float* hadamard_device_signs(const float* host, int width) {
+ if (host == nullptr || width <= 0) return nullptr;
+ static std::mutex mu;
+ static std::map<std::tuple<int, const float*, int>, float*> table; // (device, host vector, width)
+ int dev = 0;
+ cudaGetDevice(&dev);
+ std::lock_guard<std::mutex> lock(mu);
+ float*& d = table[std::make_tuple(dev, host, width)];
+ if (d == nullptr) {
+ if (cudaMalloc((void**) &d, (size_t) width * sizeof(float)) != cudaSuccess ||
+ cudaMemcpy(d, host, (size_t) width * sizeof(float), cudaMemcpyHostToDevice) != cudaSuccess) {
+ std::fprintf(stderr, "hadamard_device_signs: %s\n", cudaGetErrorString(cudaGetLastError()));
+ std::exit(1);
+ }
+ }
+ return d;
+}
+
bool native_expert_supported(int gu_type, int d_type, int64_t n_embd, int64_t n_ff) noexcept {
const int qg = gu_qk(gu_type), qd = d_qk(d_type);
return qg > 0 && qd > 0 && is_iq(gu_type) && is_iq(d_type) && n_embd % qg == 0 && n_ff % qd == 0 &&
@@ -3788,8 +3957,11 @@ void native_expert_grouped(const NativeExpertLayout& L, const unsigned long long
#else
const bool sw_v1 = v1;
#endif
- if (sw_v1) {
+ // APR: Hadamard-folded down weights take the rotated h, so h exists as floats first (the separate passes)
+ if (sw_v1 || L.had_block > 0) {
swiglu_entries_kernel<<<(unsigned) ((nh + 255) / 256), 256, 0, s>>>(gate, up, h, nh);
+ if (L.had_block > 0) // APR: the down weights are Hadamard-folded, so is their input (in place, every entry row)
+ hadamard_rows(h, h, cap_entries, L.n_ff, L.had_block, L.d_signs, s);
quantize_q8_1_kernel<<<(unsigned) ((nh + 255) / 256), 256, 0, s>>>(h, hq, nh);
} else {
swiglu_q8_1_entries_kernel<<<(unsigned) ((nh + 255) / 256), 256, 0, s>>>(gate, up, grp_start, n_groups,
diff --git a/src/kernels/native_expert_parity.cpp b/src/kernels/native_expert_parity.cpp
index 3c979ebb9..9cba3c04a 100644
--- a/src/kernels/native_expert_parity.cpp
+++ b/src/kernels/native_expert_parity.cpp
@@ -17,6 +17,7 @@
#include "strata/kernels/cpu/iq_avx2.hpp"
#include "strata/kernels/cpu/kq_avx2.hpp"
#include "strata/kernels/cpu/expert_layout.hpp"
+#include "strata/kernels/cpu/hadamard.hpp"
#include "ggml-cpu.h"
#include "strata/kernels/iq_kernels.hpp"
@@ -73,13 +74,17 @@ int check_blob(const cpu::NativeFmt& f, const std::vector<uint8_t>& blob, int se
std::vector<float> x((size_t) NT * H);
for (auto& v : x) v = nd(rng);
std::vector<float> ref((size_t) NT * H), got_c((size_t) NT * H), got_g((size_t) NT * H);
+ // APR (--hadamard): the folded expert's reference takes H (s * x) and H (s * h), as llama.cpp's graph does
+ std::vector<float> xr(x);
+ if (f.had_gu) for (int k = 0; k < NT; ++k) cpu::hadamard_rotate(xr.data() + k * H, (int) H, f.had_block, f.gu_signs);
for (int k = 0; k < NT; ++k) {
std::vector<float> h(FF);
for (int64_t r = 0; r < FF; ++r) {
double g = 0, u = 0;
- for (int64_t i = 0; i < H; ++i) { g += (double) G[r * H + i] * x[k * H + i]; u += (double) U[r * H + i] * x[k * H + i]; }
+ for (int64_t i = 0; i < H; ++i) { g += (double) G[r * H + i] * xr[k * H + i]; u += (double) U[r * H + i] * xr[k * H + i]; }
h[r] = (float) (g / (1.0 + std::exp(-g)) * u);
}
+ if (f.had_d) cpu::hadamard_rotate(h.data(), (int) FF, f.had_block, f.d_signs);
for (int64_t r = 0; r < H; ++r) {
double o = 0;
for (int64_t i = 0; i < FF; ++i) o += (double) D[r * FF + i] * h[i];
@@ -285,7 +290,8 @@ int check_blob(const cpu::NativeFmt& f, const std::vector<uint8_t>& blob, int se
}
// (c) the GPU: one group holding the NT entries
{
- const auto L = strata::kernels::native_expert_layout(f.gu_type, f.d_type, H, FF);
+ auto L = strata::kernels::native_expert_layout(f.gu_type, f.d_type, H, FF);
+ if (f.had_d) { L.had_block = f.had_block; L.d_signs = strata::kernels::hadamard_device_signs(f.d_signs, (int) FF); }
void *dblob, *dx, *dxq, *dscr;
float* dout;
unsigned long long* dptr;
@@ -309,6 +315,32 @@ int check_blob(const cpu::NativeFmt& f, const std::vector<uint8_t>& blob, int se
cudaMemcpy(dn, &one, 4, cudaMemcpyHostToDevice);
cudaMemcpy(ddst, idx, NT * 4, cudaMemcpyHostToDevice);
cudaMemcpy(dtok, idx, NT * 4, cudaMemcpyHostToDevice);
+ if (f.had_gu) { // APR: the GPU rotation of x (in place here), then its floats against the CPU's
+ strata::kernels::hadamard_rows((const float*) dx, (float*) dx, NT, H, f.had_block,
+ strata::kernels::hadamard_device_signs(f.gu_signs, (int) H), s);
+ std::vector<float> gx(x.size());
+ cudaStreamSynchronize(s);
+ cudaMemcpy(gx.data(), dx, gx.size() * 4, cudaMemcpyDeviceToHost);
+ const bool same = std::memcmp(gx.data(), xr.data(), gx.size() * 4) == 0;
+ std::printf(" gpu hadamard_rows vs cpu hadamard_rotate: %s (rel %.2e)\n",
+ same ? "bitwise equal" : "differ", rel(gx, xr));
+ if (!(rel(gx, xr) < 1e-6)) ++failures;
+ // the f16 form (prompt path) on the unrotated x: within fp16 rounding of the float rotation
+ std::vector<uint16_t> xh(x.size()), xh_out(x.size());
+ for (size_t i = 0; i < x.size(); ++i) xh[i] = ggml_fp32_to_fp16(x[i]);
+ uint16_t* dxh = nullptr;
+ cudaMalloc((void**) &dxh, xh.size() * 2);
+ cudaMemcpy(dxh, xh.data(), xh.size() * 2, cudaMemcpyHostToDevice);
+ strata::kernels::hadamard_rows_f16(dxh, NT, H, f.had_block,
+ strata::kernels::hadamard_device_signs(f.gu_signs, (int) H), s);
+ cudaStreamSynchronize(s);
+ cudaMemcpy(xh_out.data(), dxh, xh.size() * 2, cudaMemcpyDeviceToHost);
+ cudaFree(dxh);
+ std::vector<float> xf(x.size());
+ for (size_t i = 0; i < xf.size(); ++i) xf[i] = ggml_fp16_to_fp32(xh_out[i]);
+ std::printf(" gpu hadamard_rows_f16 vs cpu float rotation: rel %.2e\n", rel(xf, xr));
+ if (!(rel(xf, xr) < 2e-3)) ++failures;
+ }
strata::kernels::quantize_q8_1_rows((const float*) dx, NT, H, dxq, s);
strata::kernels::native_expert_grouped(L, dptr, dstart, dn, ddst, dtok, 1, NT, dxq, dscr, dout, s);
cudaStreamSynchronize(s);
@@ -542,6 +574,7 @@ int main(int argc, char** argv) {
if (argc < 2) {
std::fprintf(stderr, "usage: native_expert_parity <shard.gguf> [layer ...]\n"
" native_expert_parity --synthetic GU/DOWN ... (ggml type names, e.g. q4_K/q5_1)\n"
+ " native_expert_parity --synthetic-hadamard GU/DOWN ... (the same, Hadamard-folded: APR)\n"
" native_expert_parity --q5_1-min\n"
" native_expert_parity --bf16-embd\n");
return 2;
@@ -562,7 +595,13 @@ int main(int argc, char** argv) {
failures += check_q5_1_min(s);
} else if (mode == "--bf16-embd") {
failures += check_bf16_embd(s);
- } else if (mode == "--synthetic") {
+ } else if (mode == "--synthetic" || mode == "--synthetic-hadamard") {
+ // --synthetic-hadamard: the same with the layer Hadamard-folded (APR, prism.hadamard): random signs, block 128
+ const bool had = mode == "--synthetic-hadamard";
+ static std::vector<float> sx((size_t) H), sh((size_t) FF);
+ std::mt19937 srng(5);
+ for (auto& v : sx) v = (srng() & 1) ? 1.f : -1.f;
+ for (auto& v : sh) v = (srng() & 1) ? 1.f : -1.f;
for (int i = 2; i < argc; ++i) {
const std::string arg = argv[i];
const size_t slash = arg.find('/');
@@ -576,7 +615,13 @@ int main(int argc, char** argv) {
++failures;
continue;
}
- failures += check_blob(f, synthetic_blob(f, i), i, "synthetic", s);
+ if (had) {
+ f.had_block = 128;
+ f.had_gu = f.had_d = true;
+ f.gu_signs = sx.data();
+ f.d_signs = sh.data();
+ }
+ failures += check_blob(f, synthetic_blob(f, i), i, had ? "hadamard" : "synthetic", s);
}
} else {
const strata::GgufModel model(strata::gguf_split_paths(argv[1]));
diff --git a/src/prefill/prefill.cpp b/src/prefill/prefill.cpp
index 3d6d0ec14..c8c7fa72f 100644
--- a/src/prefill/prefill.cpp
+++ b/src/prefill/prefill.cpp
@@ -1123,6 +1123,8 @@ const MmqPlan& mmq_plan() {
if (on && lay.native && fused::native_supported(gt, dt)) { p.fo[(size_t) l] = 1; p.any = true; }
continue;
}
+ // APR (prism.hadamard): folded layers rotate their activations on the FP16 path only
+ if (lay.native && (lay.fmt[(size_t) l].had_gu || lay.fmt[(size_t) l].had_d)) { p.fallback = true; continue; }
p.layer[(size_t) l] = 1;
p.any = true;
p.gu_max = std::max(p.gu_max, mmq::matrix_bytes(gt, 1280, N));
@@ -3192,7 +3194,14 @@ bool Prefill::run_impl(const int64_t* tokens, int64_t n, int64_t pos0, std::stri
// keep MMQ; without the variable nothing here runs. A native pack's layer takes the native kernels
// (moe_fused_iq.hpp) where they cover its two formats, else MMQ (or the FP16 path: IQ1_M).
const strata::kernels::cpu::ExpertLayout& lay = strata::kernels::cpu::expert_layout();
- const bool use_mmq = mmq_plan().any && mmq_plan().layer[(size_t) l];
+ // APR (prism.hadamard): the rotation is applied on the FP16 path only, so a folded layer never
+ // takes MMQ (nor the fused kernels or the peer, which need MMQ)
+ const bool had_gu = lay.native && lay.fmt[(size_t) l].had_gu;
+ const bool had_d = lay.native && lay.fmt[(size_t) l].had_d;
+ const bool use_mmq = mmq_plan().any && mmq_plan().layer[(size_t) l]; // never for a folded layer
+ const int had_block = lay.native ? lay.fmt[(size_t) l].had_block : 0;
+ const float* had_sx = had_gu ? strata::kernels::hadamard_device_signs(lay.fmt[(size_t) l].gu_signs, N) : nullptr;
+ const float* had_sh = had_d ? strata::kernels::hadamard_device_signs(lay.fmt[(size_t) l].d_signs, 640) : nullptr;
const int mmq_gt = lay.native ? lay.fmt[(size_t) l].gu_type : 42;
const int mmq_dt = lay.native ? lay.fmt[(size_t) l].d_type : 42;
// --peer-device: MMQ only, whether or not the peer took the prompt path (set_peer can decline), as
@@ -3648,6 +3657,8 @@ bool Prefill::run_impl(const int64_t* tokens, int64_t n, int64_t pos0, std::stri
}
} else {
gather_rows16(m.mixed_h, m.src_dev, m.Xs, T * K, N, m.cs);
+ // APR: Hadamard-folded gate/up take H (s * x); Xs is this layer's private gathered copy
+ if (had_gu) strata::kernels::hadamard_rows_f16(m.Xs, T * K, N, had_block, had_sx, m.cs);
}
// multi-GPU: the peer's share, enqueued before the primary's own experts so both cards work at once
peer_now = use_mmq && !order_peer.empty();
@@ -4173,6 +4184,7 @@ bool Prefill::run_impl(const int64_t* tokens, int64_t n, int64_t pos0, std::stri
pt.mark(kPfGemmGU, cs);
m.gemm.f16(m.Xs + o0 * N, m.dq_gu[q], m.GU + o0 * 1280, ne, 1280, N);
swiglu_interleaved(m.GU + o0 * 1280, m.Hh + o0 * 640, ne, m.cs);
+ if (had_d) strata::kernels::hadamard_rows_f16(m.Hh + o0 * 640, ne, 640, had_block, had_sh, m.cs);
pt.mark(kPfGemmD, cs);
m.gemm.f16(m.Hh + o0 * 640, m.dq_d[q], m.Dm + o0 * N, ne, N, 640);
return true;
diff --git a/src/program/generate.cpp b/src/program/generate.cpp
index 0ebbe9ab3..fb72da92e 100644
--- a/src/program/generate.cpp
+++ b/src/program/generate.cpp
@@ -3016,13 +3016,19 @@ int main(int argc, char** argv) {
(void) strata::prefill::mmq::supported(f.d_type);
#endif
}
- // APR (prism.hadamard) packs: the CPU pool rotates the expert activations (native_quant_act / _h), the GPU
- // expert kernels, the remote GPUs and the prompt path do not yet. Refused here
- // rather than run with unrotated activations, which would produce plausible-looking garbage.
+ // APR (prism.hadamard) packs: every expert path rotates its activations (CPU pool: native_quant_act / _h;
+ // GPU verify, remote GPUs, prompt FP16 path: hadamard_rows), but the GPU side has been checked
+ // by native_expert_parity only, not end to end on a GPU: opt-in until it has (STRATA_APR=1).
if (strata::kernels::cpu::hadamard_spec().any()) {
- std::fprintf(stderr, "strata generate: this pack's experts are Hadamard-folded (hadamard.txt, an APR "
- "model); the GPU expert paths cannot apply the activation rotation yet\n");
- return 1;
+ const char* apr = std::getenv("STRATA_APR");
+ if (apr == nullptr || apr[0] != '1') {
+ std::fprintf(stderr, "strata generate: this pack's experts are Hadamard-folded (hadamard.txt, an APR "
+ "model), whose GPU path is not validated end to end yet; set STRATA_APR=1 to "
+ "run it anyway\n");
+ return 1;
+ }
+ std::fprintf(stderr, "strata generate: APR pack: Hadamard-folded experts (block %d), experimental\n",
+ strata::kernels::cpu::hadamard_spec().block);
}
}
const bool native_pack = strata::kernels::cpu::expert_layout().native;
diff --git a/third_party/ggml/ggml-common-tq.h b/third_party/ggml/ggml-common-tq.h
new file mode 100644
index 000000000..a1cf9d853
--- /dev/null
+++ b/third_party/ggml/ggml-common-tq.h
@@ -0,0 +1,295 @@
+// third_party/ggml/ggml-common-tq.h - the trellis (APR) expert formats of Agention's llama.cpp fork
+// (agentionai/llama.cpp 073bc9e68, ggml/src/ggml-common.h; MIT, the same license as the rest of third_party/ggml).
+// The block structs and the 2048-point "Hyb" codebook, unchanged, for Strata's device kernels. ggml-cpu takes
+// them from the fork itself (-DSTRATA_GGML_DIR).
+//
+// TQ2_T / TQK6 / TQK7: 128 weights per block, {fp16 d; qs}. qs is 32 trellis steps of K bits (K = 8 / 6 / 7;
+// TQ2_T byte-aligned, TQK bit-packed LSB-first, circular, step t's 16-bit window at bit (31 - t)*K; TQ2_T's state
+// s_t = qs[(t + 31) % 32] << 8 | qs[t]). Step t gives weights 4t..4t+3: x = (s & 0x7fff) * 0x9e3779b1, points
+// lut[x >> 21] and lut[(x >> 10) & 2047] (fp16 pairs), times d.
+#pragma once
+
+#include <stdint.h>
+
+#define QK_TQ2_T 128
+#define QK_TQK 128
+#define TQ_STATE_BITS 15
+#define TQ_STATE_MASK ((1u << TQ_STATE_BITS) - 1u)
+
+typedef struct {
+ uint16_t d; // fp16 scale
+ uint8_t qs[QK_TQ2_T/4]; // one trellis byte per 4 weights
+} block_tq2_t;
+static_assert(sizeof(block_tq2_t) == 34, "wrong tq2_t block size/padding");
+typedef struct {
+ uint16_t d;
+ uint8_t qs[4*6]; // 32 steps x 6 bits
+} block_tqk6;
+static_assert(sizeof(block_tqk6) == 26, "wrong tqk6 block size/padding");
+typedef struct {
+ uint16_t d;
+ uint8_t qs[4*7]; // 32 steps x 7 bits
+} block_tqk7;
+static_assert(sizeof(block_tqk7) == 30, "wrong tqk7 block size/padding");
+
+#if defined(__CUDACC__) || defined(__HIPCC__)
+// point i = (tq_lut_f16[2i], tq_lut_f16[2i+1]) as fp16 bit patterns; 16-byte aligned so a point reads as one u32
+alignas(16) static const __device__ uint16_t tq_lut_f16[4096] = {
+ 0xbd4d, 0xb8f7, 0xb6ce, 0x3cd5, 0xbd9e, 0x4368, 0x3dce, 0xb8a6, 0x395e, 0xb430, 0x3bc1, 0x3dbc, 0xb92b, 0x3c9c, 0xbca2, 0x3aaa,
+ 0x3cdb, 0xb8e1, 0xbb33, 0x3dfb, 0x3a8d, 0xbb18, 0xbd64, 0x3da0, 0xbf1a, 0x3b83, 0xb389, 0x3659, 0xb40f, 0xabd7, 0x40ee, 0x35a2,
+ 0xc057, 0x3972, 0xbe17, 0x3996, 0xb926, 0xb9b5, 0x393b, 0x3c75, 0x4151, 0xbdef, 0xb5a3, 0xbd09, 0xb408, 0x4012, 0x3b7f, 0x3ece,
+ 0xb688, 0x4011, 0x3b17, 0xbe30, 0x3d9b, 0xb4bf, 0xb870, 0xb8c8, 0xb537, 0x38b2, 0x31be, 0x34b0, 0x3389, 0x3871, 0xba33, 0x38b8,
+ 0xbce0, 0x3b3d, 0x3367, 0x3d3d, 0x3f50, 0x3cbe, 0x30b0, 0xb991, 0x3733, 0x3986, 0xb70e, 0xb6d9, 0xbe8c, 0xbd98, 0xbcca, 0xbe04,
+ 0x36a9, 0x403c, 0xb527, 0x3eae, 0x3c6a, 0x3982, 0xb655, 0xbd5b, 0x3ebb, 0x3596, 0x417e, 0xbbbd, 0x2fe0, 0xb1d3, 0xb858, 0x31c0,
+ 0xb54e, 0xbc10, 0x3cf0, 0xaf8b, 0x38e6, 0x3f5f, 0x3b87, 0xb2f6, 0xb114, 0xb675, 0x29bf, 0x3298, 0xbb7b, 0xb955, 0x34e9, 0xa984,
+ 0xc04a, 0x378f, 0x31a0, 0x3c8c, 0x2dea, 0x3c68, 0x2fe1, 0x2d29, 0x2c33, 0xbd72, 0x379d, 0x3e3e, 0xb918, 0x3cf2, 0xbcbe, 0x38bf,
+ 0x3284, 0xbdd5, 0x3707, 0xbd01, 0xbec1, 0x38c1, 0xb960, 0x3838, 0x3413, 0x3010, 0x376d, 0x3672, 0x302f, 0x3f42, 0x3a61, 0xbe9a,
+ 0x3c06, 0xbc71, 0xbb57, 0xbcf2, 0xa9dc, 0x3c85, 0x3873, 0xb8b2, 0x2d1e, 0x340d, 0x3661, 0xb73f, 0xbb91, 0xb8b7, 0xb956, 0x3943,
+ 0x3958, 0x3985, 0x3b26, 0xb556, 0xae17, 0xc2b9, 0x34e9, 0xb9ea, 0x33d5, 0xb6f4, 0x3826, 0xb1af, 0xb8a4, 0xaf98, 0x3a2d, 0xbc69,
+ 0x3a25, 0x358e, 0x406d, 0x32fd, 0x38a4, 0xb11a, 0xb170, 0xb02e, 0xaa0a, 0xb5cb, 0x3c04, 0x3d45, 0xb258, 0xb55b, 0xb412, 0xbbf5,
+ 0x3d33, 0x3f4b, 0xbc6e, 0x38a9, 0xb8c0, 0xb715, 0x2ec6, 0xbdd9, 0xbeb3, 0x2980, 0x3c54, 0xbb3c, 0x3ba0, 0x2d68, 0x42f9, 0xb209,
+ 0xb557, 0x3337, 0x3870, 0xbda7, 0x2d57, 0x35bd, 0xb8cd, 0x385e, 0x39fe, 0xb68e, 0x3eda, 0xbd74, 0x3643, 0xbd54, 0x3a32, 0x37d4,
+ 0x38f8, 0x2f7f, 0x37f3, 0x380f, 0x1b1e, 0xbc23, 0x25c7, 0x35c8, 0x2e3e, 0xb82a, 0xb85f, 0x3897, 0x3c0c, 0x3cb3, 0xc13e, 0x377b,
+ 0xb3a4, 0x3f09, 0xc006, 0x3c73, 0xbda5, 0x3ad1, 0xb0c6, 0xa3cf, 0xb9d5, 0xb680, 0x384b, 0xb493, 0x3a3c, 0xa985, 0xbcb5, 0xba24,
+ 0xbd0c, 0x3c21, 0x2f68, 0x34dc, 0xbc5d, 0xbdb7, 0xbbbf, 0xbddb, 0xb4c4, 0xb95a, 0xb59b, 0xbdaa, 0x34cf, 0xbdce, 0x3bad, 0x3f9d,
+ 0x3a05, 0x3bd5, 0xb69c, 0x2c64, 0x4003, 0x3adb, 0x3d4c, 0x35e8, 0x308d, 0xb5cc, 0xbd2d, 0xbb86, 0xb124, 0x3cd3, 0x3a0a, 0xb2ab,
+ 0xb507, 0x3d4b, 0xb190, 0x284c, 0x384c, 0xbe83, 0xbc94, 0xb806, 0x31e4, 0xb146, 0xbbe0, 0x3178, 0xbc9d, 0x3819, 0x3824, 0x2e8f,
+ 0xc246, 0x4150, 0xbcf3, 0x3a43, 0x3da9, 0xbdd5, 0xb229, 0x3c47, 0x400e, 0xc001, 0x3bb2, 0xb0c3, 0xbd46, 0x3822, 0xb92d, 0xa4a9,
+ 0x3c72, 0x3cfa, 0x3550, 0x4284, 0xb9e5, 0xbc97, 0xb996, 0x357a, 0xba03, 0xaf70, 0x35e7, 0xbc07, 0xb663, 0x397b, 0x3c59, 0x2942,
+ 0xadf7, 0xb689, 0xb875, 0x3db8, 0x35ea, 0xb63c, 0x3674, 0x3349, 0x3926, 0x3ae0, 0xbb20, 0xb56e, 0x3f05, 0xa9ae, 0x3ce5, 0x3c38,
+ 0x40b8, 0xb1ef, 0xba73, 0xba2b, 0xbdd7, 0x3d3f, 0x3822, 0x3c09, 0xbd87, 0xbce4, 0xba38, 0x36be, 0xb808, 0xbe23, 0xba33, 0xbd77,
+ 0x3b90, 0x3466, 0xc1c5, 0xb805, 0x34c0, 0x375b, 0xb4be, 0xa2db, 0xb96c, 0x3495, 0xb38a, 0xb99a, 0x390a, 0x31d5, 0xa910, 0x3e16,
+ 0x2878, 0x3dd6, 0x3964, 0xbdc0, 0xb783, 0xb3ef, 0xba12, 0xb571, 0xb8ce, 0xc0f2, 0xbd8f, 0x3771, 0x3656, 0x3eba, 0xbe0e, 0x3c39,
+ 0x3ac5, 0x371b, 0x3469, 0x4071, 0xbd99, 0x2e19, 0x3ab2, 0x3cb8, 0x36d9, 0xa92c, 0xbcb4, 0xbc9b, 0xa0fa, 0xb4e2, 0x34ed, 0x31fd,
+ 0x4033, 0xb0a0, 0xbac8, 0x342e, 0x3df5, 0xbccd, 0xbc5a, 0xbc5f, 0x3f32, 0x3ada, 0x3878, 0x39ec, 0x3db1, 0x3ce5, 0xb891, 0xbe93,
+ 0x3c11, 0xb75e, 0xb82c, 0xbb27, 0x36d6, 0xba67, 0xb602, 0x352c, 0x3507, 0xbf3a, 0xb8e9, 0xbcf5, 0xb55e, 0x3773, 0xb832, 0xbd0a,
+ 0xbf01, 0x3989, 0x3edf, 0x3d73, 0xbb3d, 0x3bc8, 0xbf82, 0xb7e0, 0x4053, 0x393f, 0xb07d, 0x2f91, 0xbc8b, 0xb6af, 0x3538, 0x2a46,
+ 0x3c2f, 0xbbfd, 0xbfc9, 0x324e, 0x3a8f, 0xb702, 0xb939, 0xbda9, 0x3ac3, 0x3c3f, 0x3875, 0x3798, 0x3dc4, 0x3e1b, 0xb820, 0x255e,
+ 0xa7e2, 0xbe92, 0xb63f, 0xb7c7, 0x38bd, 0xbcb4, 0x3a2f, 0xb958, 0xbdf2, 0x34fc, 0x3ba1, 0xb5a8, 0x3975, 0x3047, 0xaecc, 0x21da,
+ 0xb7f7, 0x3bc4, 0x39f8, 0x2eb6, 0xbb3f, 0xbb3a, 0xbd9b, 0xb13d, 0x37fa, 0xbab2, 0x3794, 0x3074, 0xbd7e, 0xbad3, 0x3d65, 0x346b,
+ 0x3cfd, 0xba61, 0xadd5, 0xb8fe, 0xbe09, 0xb6ec, 0xc05b, 0xb544, 0x360c, 0x2fdb, 0xb8ba, 0x39e5, 0xb8a8, 0x3e96, 0x40cf, 0x38cf,
+ 0xba8b, 0xac5a, 0xb691, 0xb284, 0xc0b9, 0xb5d5, 0x3864, 0x3d00, 0x3220, 0xa382, 0x3422, 0xbb8f, 0xba85, 0xb85e, 0x3854, 0x3eb3,
+ 0xc110, 0xb885, 0xbdf8, 0x2e60, 0x1cb3, 0xb8ba, 0xb4d3, 0x3636, 0x382a, 0xaf93, 0xbc81, 0x346a, 0x3d66, 0x3148, 0xc0b3, 0x36fe,
+ 0xaf70, 0x4001, 0x3caf, 0x3eac, 0xbd48, 0xb614, 0x3d04, 0x3de8, 0x3f2b, 0x31d0, 0xb955, 0x30ce, 0xb81b, 0x2d33, 0xb328, 0xb657,
+ 0xb7c2, 0x3527, 0xb9f6, 0xc255, 0xbc1a, 0x3c90, 0xbe9c, 0x35f3, 0xc11d, 0x409a, 0x30db, 0xbf2f, 0xbe02, 0x3285, 0xb607, 0x2f14,
+ 0x3c56, 0x35c2, 0x3288, 0x30ac, 0x3c1c, 0xc25c, 0x3ca4, 0xbbd6, 0x3465, 0x29c8, 0x37a3, 0x4129, 0x3151, 0x3225, 0x2ef2, 0xad41,
+ 0xbbcb, 0xbfc1, 0xb0c0, 0xbe71, 0xb17d, 0xbb59, 0x3cfe, 0xbefb, 0xbdb8, 0x39f0, 0x4014, 0x28a7, 0xb771, 0x396a, 0xbbdc, 0xc063,
+ 0xbabe, 0x2898, 0xb683, 0x3de9, 0xbd1f, 0xaa78, 0x4187, 0x3ded, 0x3e18, 0x3d7b, 0xaf3c, 0xab0c, 0x38a7, 0xb524, 0xb964, 0xc38f,
+ 0xbeda, 0x3d02, 0xaa74, 0xb25d, 0x2d90, 0xbe9a, 0xbe23, 0xbbb0, 0xbf6a, 0x3a8c, 0xbbfa, 0x3d87, 0xb53c, 0x3571, 0x385c, 0xc027,
+ 0xb903, 0xb801, 0x3368, 0x3b7b, 0xb70c, 0x3ab8, 0x38b5, 0xb625, 0xb436, 0x3cb1, 0x8d2a, 0x3f2c, 0xb88e, 0x2c53, 0xb2c8, 0x393b,
+ 0xbdbf, 0x3f40, 0xbc1b, 0x39d9, 0xbc3a, 0x306d, 0xb3ba, 0xb8fc, 0xc07b, 0x3c75, 0xb655, 0xb421, 0x3d34, 0xb720, 0x37f1, 0xb6a0,
+ 0xb338, 0xbec7, 0xba58, 0x334e, 0x3aab, 0xb810, 0xb3d7, 0xbe3d, 0xb984, 0x40a2, 0xb5cd, 0xba54, 0x3afa, 0xb63e, 0xbd80, 0x394d,
+ 0xba54, 0x2dda, 0xbaec, 0xb8e4, 0x2b2a, 0xad38, 0xbd82, 0x3886, 0xac6b, 0xc015, 0x368b, 0x3c72, 0x2fb3, 0xbaa7, 0x38fb, 0xb2cb,
+ 0x335d, 0xbfb5, 0xaba9, 0xa535, 0xafb8, 0x38b7, 0x3d00, 0x3524, 0x3b42, 0xaeac, 0x4144, 0xb1a6, 0xb352, 0xba3a, 0x2c72, 0x39f3,
+ 0x4079, 0xb82c, 0xb9e5, 0xb45f, 0x9d20, 0xb9f5, 0xb2ee, 0xbd36, 0xbad5, 0x2f11, 0x3450, 0x3e80, 0x213f, 0xb684, 0x3200, 0xbd07,
+ 0xb839, 0xbc5e, 0xc217, 0x3f5d, 0x3d9a, 0xbe94, 0x3947, 0x3381, 0x9081, 0xb943, 0x3eac, 0x3795, 0xad61, 0x3915, 0xb810, 0x3d5d,
+ 0x39cb, 0x33f2, 0xbfe8, 0x41ed, 0x3ee7, 0xb4a2, 0xb9e5, 0xb88a, 0x36b3, 0xc0da, 0xb57f, 0x406c, 0xba70, 0x3c5c, 0xb936, 0x3ae4,
+ 0x3e2c, 0xb7ff, 0x35b6, 0xb08e, 0xb8d1, 0x3c3a, 0x227e, 0xafed, 0x3a3d, 0x310a, 0x2d00, 0xb926, 0xbbe1, 0x3f76, 0xb8aa, 0x3e15,
+ 0xb31c, 0xc074, 0x40ee, 0xbcb6, 0x3449, 0x3b03, 0x38f5, 0xbd01, 0xbc2d, 0x386a, 0x3f94, 0xbcfc, 0x33a2, 0xb049, 0x3c77, 0xb86e,
+ 0x366c, 0xb91c, 0xb832, 0x35c6, 0x36ab, 0xbc4c, 0xb6b9, 0x3a04, 0xb2c9, 0x3c84, 0x3006, 0xb762, 0x330e, 0x3580, 0x3d32, 0x3926,
+ 0x38f9, 0xbfb2, 0xc00a, 0x3de6, 0x3a35, 0xafad, 0xbe69, 0x3d88, 0xc30f, 0xbe12, 0xb13d, 0x3d26, 0x382a, 0xb7a5, 0x40fa, 0x3ac3,
+ 0xb8a9, 0xc028, 0xb979, 0x3e19, 0xbac1, 0xbdd7, 0xbd42, 0xb802, 0xb631, 0xbe1a, 0xb8fb, 0xac7a, 0x3ff8, 0x3819, 0x3d3f, 0x42e8,
+ 0xb312, 0xb1dc, 0xc036, 0xaa42, 0xbd28, 0xc078, 0xb6f5, 0x36dd, 0xbad4, 0x31fd, 0x3933, 0xb7e9, 0x39b4, 0x31d4, 0xbd13, 0xb4ae,
+ 0x37d3, 0x3c5d, 0x3925, 0xbafd, 0x3b52, 0x3875, 0x2a38, 0xa581, 0x3b51, 0xb450, 0xc248, 0x3ccc, 0xb1aa, 0x3ad2, 0x36eb, 0xbe90,
+ 0x423c, 0x34e3, 0x3ac2, 0x3bc1, 0x3be5, 0x3749, 0xbcd1, 0x3cee, 0x3ac7, 0x4017, 0x3a67, 0xbfc4, 0xb7eb, 0xb9a8, 0xbf94, 0xbf08,
+ 0xb711, 0xa983, 0x3c0f, 0xb609, 0x3ebd, 0xb7f7, 0x34f4, 0xbca7, 0xbac3, 0x38b1, 0xb5d0, 0xb93f, 0x3e04, 0x3f1d, 0xb7fd, 0x305c,
+ 0xaae3, 0xbcaa, 0xbb0f, 0x3d8c, 0xbca4, 0xbd3f, 0xbb3b, 0xbc08, 0x3a90, 0xb9de, 0x377f, 0xad25, 0xb988, 0xbefe, 0xbdf7, 0xbc6c,
+ 0xba23, 0x35c3, 0xbb14, 0x370a, 0x3c45, 0xb3a9, 0xb889, 0x3c72, 0x3a36, 0x3e71, 0x3a90, 0xb8e0, 0x34cb, 0x34a6, 0x40be, 0x3c6c,
+ 0xbe95, 0xbc3f, 0xba4d, 0x2284, 0xb96e, 0xb73e, 0x384d, 0xbc04, 0xb452, 0x3a03, 0x41a8, 0xc100, 0x3c75, 0x2ed2, 0xbc47, 0x3ab6,
+ 0x3746, 0x3a63, 0xb62f, 0x3735, 0xb9dd, 0x3c2f, 0xbba8, 0xb08f, 0xb270, 0x3289, 0x3972, 0x3c1e, 0x3844, 0xb5ae, 0x3cee, 0x3d30,
+ 0xb98f, 0x3fa2, 0x3e16, 0xb150, 0x3c9c, 0x382c, 0x3483, 0xae2e, 0x3b71, 0x3a84, 0xbb53, 0x32f4, 0x3540, 0x3ab2, 0xb6e0, 0xba06,
+ 0xbcc9, 0x3701, 0xb89a, 0x361a, 0xbe12, 0x3a74, 0x3b56, 0x37ae, 0xb6ec, 0x38ee, 0xb47a, 0xb60a, 0x3247, 0x374a, 0x394d, 0x3883,
+ 0xb76f, 0x2c41, 0xbc07, 0xb862, 0x395e, 0xbba5, 0xb71f, 0x3865, 0x3897, 0x2cbc, 0xac7a, 0x35c9, 0xb9df, 0x3ac5, 0xb63b, 0xb8b9,
+ 0xc064, 0x3ff6, 0x3ba3, 0xb829, 0xb904, 0x3b7e, 0xafdb, 0xb78e, 0xbaec, 0x3c22, 0xb53d, 0x39a5, 0xbab6, 0xc0d4, 0xb47e, 0xbddb,
+ 0xba66, 0xc01c, 0x37ec, 0xbcb0, 0xb409, 0x3ac3, 0x2b2b, 0x3e47, 0x3b8a, 0xb8e0, 0x38cd, 0x3a77, 0x3cb0, 0xb724, 0xbaef, 0x381f,
+ 0xba7a, 0xb0f9, 0x3940, 0xb138, 0x3855, 0xb840, 0x39af, 0x35f4, 0x3b0f, 0x2c19, 0x3760, 0x3b83, 0xa813, 0x3801, 0xb801, 0x41d6,
+ 0x3026, 0x3ab3, 0xbca3, 0xa9f5, 0xbf1e, 0x370e, 0xb82b, 0x3467, 0xb4c3, 0xbd57, 0xad4c, 0xb4e9, 0xb8c4, 0xbad6, 0xa8f7, 0xbd66,
+ 0x3e70, 0x3cd2, 0x236c, 0x3421, 0xaa8a, 0x3c22, 0xb9c2, 0x9661, 0x3988, 0xb622, 0xb797, 0xb8aa, 0x254c, 0x305c, 0xbd53, 0x271b,
+ 0x3c11, 0xbaa9, 0xb75b, 0x3601, 0x36d1, 0xb4e9, 0xb856, 0xb15d, 0xbe96, 0xc0b2, 0xb7c5, 0x3e32, 0xb069, 0x3e22, 0xbc18, 0x3b41,
+ 0xc16e, 0x31ca, 0x365a, 0x35f9, 0xb491, 0xb700, 0x3a6a, 0xb41b, 0x2f26, 0x406a, 0xb8a6, 0xbd54, 0x3b9b, 0x39e3, 0xbeae, 0xad0f,
+ 0x3b1b, 0xb166, 0xafd4, 0x3655, 0xbde7, 0xbaa7, 0x37c1, 0xbd6c, 0xbc6d, 0x3cbf, 0x3584, 0x2dbd, 0x3d69, 0xb9f9, 0xb992, 0xac53,
+ 0xbf6b, 0xb2a2, 0x35b5, 0xc157, 0x331a, 0x328e, 0xba14, 0xb7b3, 0x3c44, 0x3809, 0x3c08, 0x3361, 0x3b93, 0xbc1c, 0x3b53, 0xbd21,
+ 0xb9d1, 0x39b2, 0x326b, 0xbad9, 0xb1c8, 0x35e6, 0x38ff, 0xaeff, 0xb831, 0xb734, 0xba96, 0xbbe1, 0x33f8, 0x36fb, 0xb049, 0xc15a,
+ 0x3b22, 0xb7a3, 0xb462, 0xbc3d, 0xbf97, 0xb57c, 0x3c86, 0xbcaa, 0xbcb9, 0x3c6e, 0x39ca, 0xb0f5, 0x379f, 0xb5bf, 0xb629, 0xbcb6,
+ 0x3aab, 0x3f0f, 0xc01a, 0x34fc, 0x3869, 0xb6be, 0xb953, 0x32f4, 0xb85f, 0xbdb7, 0x39f4, 0x411a, 0xbce8, 0x203c, 0x3824, 0x2a59,
+ 0xb26f, 0xa60c, 0xb47f, 0x3d96, 0xb8d0, 0xb53f, 0x3706, 0xb69f, 0xb1c9, 0x36cf, 0xad03, 0x37c1, 0x3d80, 0xbc90, 0xba26, 0xb98e,
+ 0x3c5b, 0x334b, 0xc196, 0xb051, 0xbd24, 0xbd79, 0x3b38, 0x3e2f, 0xba82, 0xb64d, 0x2a56, 0x34ed, 0xb36f, 0x2a01, 0x40e9, 0xbfbc,
+ 0xb7ce, 0xb600, 0x3cce, 0x3a9c, 0x33c6, 0xb23c, 0x3c33, 0x36c8, 0xa776, 0x409e, 0xb822, 0x3c35, 0x3e43, 0x30ef, 0xb9b2, 0xb9f7,
+ 0x3c79, 0xba81, 0x3973, 0xaedb, 0xbfe1, 0xba33, 0x348e, 0x3d8a, 0xb5ac, 0xbfa1, 0xb8d9, 0x31b7, 0x3aee, 0x3481, 0x3d3b, 0xb56e,
+ 0x3d98, 0x2c65, 0x39e0, 0x3d74, 0xb51a, 0x3ae2, 0xae6c, 0x3bb9, 0xbdc8, 0x1d86, 0xb9d9, 0x3840, 0xbc60, 0xc0f1, 0x3e26, 0x396d,
+ 0x3dc5, 0xa478, 0xbf35, 0xc01b, 0xb938, 0x39c8, 0x35d1, 0x3fd0, 0xb3bc, 0x3d41, 0xbca8, 0x3bf9, 0xbd36, 0x32f5, 0x3f59, 0x34c8,
+ 0x3e38, 0x3854, 0x338e, 0xb82e, 0x37b2, 0xa3ce, 0xb683, 0x37fd, 0xc104, 0x3f02, 0xb92f, 0x38b3, 0xb454, 0x3bcd, 0x31f4, 0xba42,
+ 0xbf4d, 0x3878, 0xbf7f, 0x3559, 0xb8e0, 0xbc53, 0xbd77, 0x407e, 0xb69e, 0xb0c6, 0xacce, 0xbabd, 0x3c1b, 0xb92f, 0xb8fa, 0x3a5f,
+ 0xb628, 0x3f13, 0x3893, 0xbacd, 0xc047, 0x3ec8, 0xb70b, 0xba7f, 0xb997, 0xb140, 0x2c0c, 0xb466, 0xba3f, 0x3dde, 0xbe75, 0x3ae1,
+ 0xb466, 0x3879, 0x3d68, 0x3c55, 0xb4d9, 0x3c6e, 0xbe71, 0xb803, 0x3e15, 0x2a52, 0x3e1b, 0xbc37, 0x3585, 0xb747, 0xbf22, 0x3db4,
+ 0xbcdb, 0x31a6, 0xb415, 0x2e23, 0xab25, 0xb884, 0x329e, 0xb5ef, 0x3525, 0xb59c, 0xba76, 0x39c2, 0xb6f5, 0xbf1e, 0xbcdf, 0x2dad,
+ 0x3e8c, 0x4019, 0xb92c, 0xbb4a, 0x3494, 0x2ddb, 0x406e, 0x3afd, 0x3b91, 0xb97a, 0x3c1f, 0xbce1, 0x3eae, 0x3c34, 0xbddd, 0x38ec,
+ 0x390f, 0x3e4f, 0xbc20, 0x3e04, 0x378c, 0xba0b, 0x330d, 0xb8aa, 0x3e34, 0x348e, 0xbaa5, 0x352f, 0xbac3, 0x3d2b, 0xb982, 0xbe71,
+ 0x305c, 0xc1e1, 0xbe05, 0xbe12, 0xb70b, 0x2fc1, 0x3c8b, 0xbe71, 0x35ad, 0x3dcc, 0xb581, 0xb612, 0xb42c, 0xb50c, 0xb1c9, 0xb36c,
+ 0xb443, 0x3977, 0xbd4c, 0x3d11, 0x39b8, 0x3b17, 0x269a, 0xbd27, 0xbce0, 0x3d6c, 0xb86d, 0xb611, 0x35e7, 0xb50c, 0xb453, 0x359c,
+ 0x38c6, 0x38bf, 0xb82a, 0x39a6, 0xa8c2, 0x3bb1, 0xb020, 0x3c8b, 0x2c82, 0x2dfa, 0xbb37, 0xb43e, 0x2b23, 0xbbbd, 0x3c97, 0xbd25,
+ 0x3d21, 0xbb81, 0xb8e5, 0xbe12, 0x3845, 0x3d6a, 0xb571, 0xc0ec, 0x3c69, 0x34ba, 0xb96f, 0x2818, 0xbdde, 0x382d, 0x3f0c, 0x3f33,
+ 0xb44b, 0x3c30, 0xaebd, 0xbef5, 0x3a3b, 0x2683, 0xaaf0, 0xb7f8, 0x405e, 0xb4f5, 0x3c5b, 0xb197, 0x359f, 0xbada, 0x3227, 0xbb77,
+ 0x3877, 0x3dec, 0x34a2, 0xb7c6, 0x3bde, 0xba0e, 0xb758, 0x20cc, 0x3760, 0xb8e8, 0xbdaf, 0x3cb8, 0x3cf3, 0x385d, 0x306f, 0x3078,
+ 0xac7a, 0x34d1, 0xb9b8, 0x402f, 0x2d2e, 0xbc80, 0xb55d, 0xbeef, 0x348e, 0x356a, 0x3511, 0x3b68, 0x35a4, 0x32ea, 0x3e99, 0x3a13,
+ 0x4002, 0xb8c9, 0x3dc1, 0x355a, 0x3556, 0xbb78, 0x3560, 0x37ee, 0xba6e, 0xbc4a, 0xb14d, 0x33eb, 0x22a9, 0x3c4a, 0xbd5b, 0x3a27,
+ 0xc0ca, 0xba1d, 0x4053, 0xbd31, 0x3c1a, 0xb87b, 0x38de, 0x36e3, 0x2663, 0x2b95, 0x3b4f, 0x3685, 0x353c, 0xc020, 0xbe97, 0x4050,
+ 0xbc48, 0xa53a, 0x3e4e, 0xbeea, 0xac24, 0xbb52, 0xb743, 0x40d2, 0xb389, 0x3762, 0xb493, 0xbb02, 0x3cb4, 0x342f, 0xba83, 0x3ace,
+ 0xbc28, 0x3923, 0xc004, 0xc0af, 0xb898, 0xb842, 0x38d0, 0x2760, 0xb83e, 0x405e, 0xaffb, 0x4254, 0x3b69, 0x3c6f, 0xba70, 0x3bed,
+ 0xb0de, 0xba70, 0x3d9c, 0xb635, 0xbde3, 0x3de8, 0x3321, 0x38e5, 0x369f, 0x40ae, 0x36e3, 0xbaf2, 0xaf7b, 0xbb9b, 0xb484, 0xc1f3,
+ 0x3f5a, 0x4097, 0x3da5, 0xaead, 0x3934, 0x1e3a, 0xbc67, 0x409f, 0xb2ed, 0x3a55, 0x3009, 0x385a, 0x3166, 0xb6ac, 0x3832, 0xc3f8,
+ 0xb800, 0xa95f, 0xbc8a, 0x2f61, 0x353c, 0xbeba, 0x3284, 0x3ce3, 0x3fad, 0xade8, 0x3da0, 0xb7c1, 0xb56e, 0x382d, 0x385f, 0x3855,
+ 0xbd34, 0x2ff5, 0xba07, 0xb290, 0xbda4, 0xb6f4, 0xb89b, 0x3ad2, 0x3613, 0xbe27, 0x3838, 0x35fc, 0x28e1, 0x3c96, 0x3c1e, 0xbd62,
+ 0x315a, 0x356b, 0x3b05, 0x3b16, 0xbaf3, 0x3ed5, 0xbf42, 0x3c65, 0x3d3f, 0x378a, 0xbf4e, 0xbd43, 0x3c0d, 0x3964, 0x34c3, 0x3c00,
+ 0x345a, 0xbafe, 0xbf4f, 0xba8b, 0x4240, 0xb95b, 0x3b21, 0xc0a2, 0xb6ed, 0x331d, 0xb57a, 0x3111, 0x3594, 0xb8ca, 0xc16a, 0x3d96,
+ 0xb7a9, 0x3c86, 0xb949, 0xb498, 0x2d89, 0x3c1e, 0xad06, 0x2eeb, 0xbc5b, 0xba8a, 0xbe54, 0xb0b9, 0xbc9a, 0x3e71, 0x3ca7, 0x3ff4,
+ 0xbf8b, 0xbbbc, 0xb894, 0x3fef, 0x3bda, 0x40c9, 0x3bc7, 0xbb66, 0xb87e, 0x3cbb, 0xbb1e, 0xb1f7, 0x3a3d, 0x38f6, 0xad22, 0x3cd9,
+ 0xbdb4, 0xbd81, 0xb005, 0xbd96, 0x3d6e, 0xb91c, 0x38f2, 0xbd5e, 0xb513, 0x2e27, 0x3e5b, 0xbe1c, 0x34b3, 0x366e, 0xbb24, 0xb6cd,
+ 0x36f7, 0xbfb4, 0xb00c, 0x34a3, 0xb1bf, 0x37df, 0xb9d6, 0x33d3, 0x396f, 0x3edf, 0xb5d1, 0xb6f7, 0x2aa1, 0x38b2, 0x36b1, 0x223d,
+ 0xbc6a, 0x3d3e, 0xb777, 0xb7b5, 0xb8ed, 0xb91c, 0x3be6, 0x35f5, 0xc077, 0xbd74, 0xbcdc, 0x3966, 0xbc12, 0x3d0b, 0x3312, 0x28cb,
+ 0xbd0d, 0x4128, 0xbef1, 0xb80e, 0xb758, 0x3eb4, 0xb6d3, 0x352f, 0x343d, 0x3ca3, 0xb733, 0xbaef, 0xbce4, 0xbc1d, 0x3eac, 0x38fa,
+ 0xb9d1, 0x3bce, 0x3953, 0x36ec, 0xbbb4, 0x3985, 0x4005, 0x3fe2, 0x3f4e, 0xb991, 0x39d5, 0xbe2c, 0xb44e, 0xb37f, 0x3acf, 0x30aa,
+ 0xb358, 0x40c3, 0x3c1f, 0x3b9b, 0x39ec, 0x39a7, 0x3d01, 0x4111, 0x367d, 0xbb76, 0x3c75, 0x3a48, 0xb547, 0x3c01, 0x3d2f, 0x3ae0,
+ 0xc3b1, 0xb837, 0x2e1d, 0x36c1, 0xb2d3, 0xbd8e, 0xb23a, 0x3d80, 0xbd29, 0x3c9b, 0x37a8, 0x348c, 0x3c9e, 0xb5aa, 0x3311, 0x40d3,
+ 0x256d, 0x4028, 0x2e47, 0xa66e, 0x390a, 0xb8de, 0x3306, 0x3c03, 0xbc58, 0xbb3f, 0xbc05, 0xbc21, 0x376c, 0x28e2, 0xb536, 0x3dda,
+ 0x2427, 0x3ebb, 0xb70a, 0xbdbf, 0x3cc4, 0xbb10, 0x3d33, 0x2d29, 0xc044, 0xbfd0, 0xbfd3, 0x3726, 0x32d9, 0xad34, 0xc040, 0x3d32,
+ 0x3f66, 0x2b12, 0x377a, 0x3ae9, 0x3088, 0xc02d, 0x384f, 0x38e2, 0x3c2b, 0xacfb, 0xbbda, 0xb9de, 0x2d0a, 0x3945, 0x38f1, 0x40ba,
+ 0x3858, 0x1b91, 0x2f58, 0xba15, 0x3642, 0x3a7f, 0x39d4, 0x387a, 0xb9af, 0x3efc, 0xc007, 0xbcc6, 0xba9b, 0x3938, 0xb635, 0xaa27,
+ 0xa2e3, 0x3509, 0xb38b, 0xbb66, 0xbbc3, 0xb775, 0xbbc7, 0x33f5, 0xc014, 0xb6ba, 0xa91a, 0x340b, 0xc0ad, 0x3dad, 0xa94d, 0xb70e,
+ 0xb9b4, 0xbcf0, 0x2f73, 0xb38a, 0x34f1, 0x304e, 0x3cdf, 0xbfe6, 0xc329, 0x34c3, 0x3c80, 0xbdc0, 0x37bd, 0x39ed, 0x393d, 0xaaa3,
+ 0x3a94, 0xbd49, 0xc288, 0xb4d2, 0x2c3e, 0xbfb6, 0xbca0, 0xb93d, 0xb9d6, 0x3200, 0xac36, 0x3875, 0x3072, 0x33f7, 0x3e47, 0xb8f7,
+ 0xba54, 0x3116, 0x3a12, 0xc037, 0x3ad7, 0xb48c, 0x323b, 0xb798, 0xc11c, 0xbf50, 0xaf13, 0xaf0b, 0x3c1c, 0x2efc, 0x3b04, 0xbc68,
+ 0xb611, 0x38fa, 0xb74f, 0x3f8c, 0x3b22, 0xbf1a, 0xc394, 0x3cef, 0x3ca6, 0x2614, 0x37c3, 0xbe03, 0x3cd0, 0xc072, 0x3f2e, 0xc15f,
+ 0x3c11, 0x34da, 0xb4e7, 0x3cf5, 0xc030, 0x3030, 0xb32a, 0x3837, 0xc1c0, 0xbca2, 0x33dd, 0x3ef1, 0x982a, 0xac37, 0x3c5e, 0xb7b3,
+ 0xb5b6, 0xb9cd, 0xb9e9, 0x2c0c, 0x3832, 0xab2a, 0xacea, 0x419a, 0x3458, 0x3922, 0xc18e, 0x3c1f, 0x2ae8, 0xb762, 0x393d, 0xbe8c,
+ 0xb009, 0xbd47, 0x3d9b, 0x3abd, 0xb95a, 0x3c56, 0x3cfe, 0x3107, 0x37d9, 0xbc56, 0x312d, 0xb846, 0x3752, 0x3d2e, 0x41d2, 0x4030,
+ 0xb2d1, 0x3bf0, 0x30c5, 0xbc39, 0xb1ee, 0xb8aa, 0x405a, 0x3d48, 0x3c11, 0x2a02, 0xb800, 0xc184, 0x3dd2, 0x308d, 0xb975, 0xbd48,
+ 0x32b5, 0xb942, 0x38c6, 0xbe0e, 0x3688, 0xc06f, 0x33b3, 0xbc61, 0x3910, 0xc094, 0x3cb1, 0x38f8, 0xbe18, 0xc2b8, 0x37d6, 0xb3de,
+ 0xab85, 0x3b2e, 0xb8f6, 0x299c, 0x3676, 0xbdb1, 0xb87d, 0x3f26, 0x3068, 0xc117, 0xb7ae, 0x3a16, 0x30ea, 0x3b44, 0xb347, 0x30a9,
+ 0x31a2, 0x39c3, 0x36bf, 0x3021, 0x38f6, 0xbc13, 0xb882, 0x338d, 0xb892, 0x3bf4, 0x385d, 0xba38, 0x3b4e, 0x305d, 0x43aa, 0x387b,
+ 0x36a4, 0xb0c4, 0xb800, 0xb925, 0xb9d7, 0xbdef, 0xbba6, 0x4244, 0x36da, 0x3452, 0x3b75, 0xc191, 0x381f, 0x318b, 0x38a3, 0x405a,
+ 0xba2a, 0x3d74, 0xb9b5, 0x3666, 0x3990, 0x3802, 0xb8ed, 0x37cc, 0x3697, 0x36e9, 0x3d43, 0xb3ef, 0xbaa8, 0x3cbf, 0xbdf3, 0xadc4,
+ 0x2c73, 0xb0b6, 0xbbd5, 0x386a, 0xbaaf, 0xbece, 0x35f2, 0x3d58, 0x358e, 0x3ca3, 0xb987, 0x3d37, 0x3770, 0x3cba, 0x3d8a, 0x400f,
+ 0x37a5, 0x3910, 0x3bce, 0x3148, 0xb10b, 0xb1f2, 0x343f, 0x3a6d, 0x399b, 0xb733, 0x38b6, 0x3550, 0xbe87, 0xb90a, 0xc1ea, 0xbe4b,
+ 0xbe96, 0xbe8f, 0x3999, 0xb92a, 0x3a77, 0xb1c8, 0x366c, 0x3508, 0xb7aa, 0xbcc4, 0xb03d, 0xb591, 0xbecf, 0xb9fc, 0xbb2f, 0x40f5,
+ 0x4073, 0xc0db, 0x421c, 0xbf44, 0x339f, 0x34cd, 0x37bd, 0xb4dc, 0xb531, 0xb44c, 0x3e9d, 0x3b38, 0xba12, 0xa9ff, 0x3655, 0xb9ce,
+ 0xb32e, 0x3441, 0x3f6f, 0x3c08, 0x3a43, 0xb860, 0xbcf7, 0x3dfe, 0xc07a, 0xbc86, 0x3745, 0xbbf6, 0x2987, 0x36a6, 0x35e0, 0x267f,
+ 0xb4b8, 0xb9f1, 0xb865, 0x3a39, 0x2f53, 0xbd26, 0x37b5, 0x388c, 0x3b0e, 0xb889, 0x3c18, 0xa422, 0xb894, 0x1666, 0xb37f, 0xaf72,
+ 0x3772, 0xb081, 0xc090, 0xb0ea, 0x33ad, 0x41d0, 0xb75b, 0x345f, 0x3de3, 0xba82, 0xafd1, 0xb979, 0x3f52, 0x36ec, 0xb928, 0x42c7,
+ 0xbc71, 0xb54e, 0x3b45, 0x356d, 0xb63d, 0x3d77, 0xa722, 0x2873, 0x3ab5, 0xac22, 0xbe38, 0x3ccb, 0xb82f, 0xba9d, 0xb88a, 0x34f9,
+ 0x3dde, 0xb997, 0xc1b1, 0x399d, 0x3d55, 0xc19a, 0xb380, 0x3e72, 0xb701, 0xbd0a, 0xc16c, 0xba7f, 0x39a8, 0x3df0, 0xbf04, 0xb595,
+ 0xba46, 0xb904, 0x3ab7, 0x35c9, 0xb181, 0xb9da, 0xba29, 0x3a40, 0xbee1, 0xb257, 0xc262, 0xbabb, 0x3d35, 0x39fa, 0x2661, 0x3922,
+ 0xb5da, 0x3c35, 0xac1e, 0xbc02, 0xb9c2, 0x375b, 0x343c, 0xb5e8, 0xbc03, 0xbd4a, 0x2c70, 0x3840, 0xb98c, 0x3a48, 0xbd06, 0xb987,
+ 0xc008, 0x3a3f, 0x3676, 0xadf0, 0x391e, 0x437f, 0x4179, 0x38df, 0x3a92, 0x3dd2, 0xb42f, 0xb870, 0x3e99, 0xb0b3, 0x3136, 0x3c3b,
+ 0xb98b, 0x3b57, 0xaf33, 0x3d80, 0xb578, 0x3475, 0x3f58, 0xb620, 0x3a60, 0x386c, 0xaf9c, 0xbc68, 0x3826, 0xb99a, 0xb8c8, 0xb414,
+ 0xb952, 0x374b, 0x40e7, 0xba0c, 0x3a49, 0x4072, 0xb76d, 0xbc2a, 0xbc67, 0xaebb, 0x3a0b, 0xba0d, 0x3f56, 0x3e43, 0x3d02, 0xbc43,
+ 0xb9a2, 0x3e82, 0x3a1f, 0xb796, 0x355d, 0xbc5c, 0x3a70, 0xba8a, 0x333c, 0xbd61, 0x3caf, 0xb9c7, 0xbd93, 0x31f0, 0xbd05, 0xbce5,
+ 0xb4b9, 0xba81, 0xbc7d, 0xbbf2, 0x3740, 0xb976, 0xb53f, 0xbe7b, 0xbced, 0xb266, 0x30be, 0x3bda, 0x3f03, 0xbab0, 0x3bdf, 0xbfc7,
+ 0xadc6, 0xbf88, 0xb00b, 0x2c42, 0x3e4d, 0xc2c9, 0xbe94, 0x4114, 0x3b5a, 0xbcba, 0x3d7c, 0xbd31, 0x3726, 0x37ac, 0x397e, 0x3a3a,
+ 0x2f06, 0xbcd0, 0x3d0c, 0x3cb9, 0x35a6, 0x3f37, 0x41f6, 0xb161, 0xba84, 0x3e57, 0xb423, 0x3e1e, 0x3eb8, 0x2e08, 0xb1c0, 0xbc7f,
+ 0x3bef, 0xc03a, 0xbcc4, 0xbb16, 0x38a5, 0x3c4a, 0x3b7f, 0x3bf8, 0x39c9, 0x2964, 0xbddc, 0xb944, 0x406a, 0x3717, 0xb80f, 0xaef2,
+ 0x38c2, 0xbf14, 0x3633, 0x37eb, 0x2c27, 0x3d19, 0xba23, 0x37d2, 0x31dd, 0x3823, 0xbb12, 0x39a3, 0xb985, 0xb57c, 0xb7fa, 0x36a5,
+ 0xb882, 0x3b5b, 0x3856, 0x34c0, 0x3a69, 0xb60d, 0xc03c, 0x3b6e, 0x3b95, 0x219c, 0xac3a, 0xbdd6, 0x4008, 0x356f, 0xae4c, 0x33cb,
+ 0xbd84, 0x3c41, 0x3ba0, 0x3b3c, 0xbb56, 0x387e, 0x3b22, 0xba14, 0x33cb, 0x3f8d, 0x3508, 0x18e0, 0x3b2d, 0xa89e, 0x3c83, 0x3c7f,
+ 0x3cd9, 0xb82a, 0x39b5, 0x3912, 0x39d4, 0xbb1c, 0xb8ed, 0xb1de, 0x3b0b, 0xbb92, 0x3be0, 0x4178, 0x3716, 0x31e8, 0xb3ff, 0xbc80,
+ 0xba07, 0x393e, 0x39a9, 0xba87, 0xbb2d, 0x4185, 0xb616, 0x32fd, 0xb9d6, 0xbbe7, 0x3645, 0x3cee, 0xb4c6, 0xbcba, 0x3e24, 0xac74,
+ 0x2b37, 0xb9ba, 0x3c42, 0x3142, 0x3505, 0x33e9, 0xbe07, 0xb53e, 0xb609, 0x3b1d, 0xbd2b, 0x36e4, 0x3c8a, 0x36fb, 0x39e9, 0xb8c3,
+ 0x3fba, 0x4295, 0x3766, 0xbf1a, 0x39e3, 0x3ca3, 0x3fc7, 0xb434, 0xb899, 0xbb95, 0x398e, 0xb2e3, 0xbcd6, 0xb5c8, 0x38c5, 0xb442,
+ 0x3cf2, 0x407d, 0xb6e2, 0xb847, 0x3a6a, 0xbdcd, 0x34b0, 0xb342, 0x3a83, 0x2d94, 0x3e96, 0xb644, 0xbead, 0x3e5d, 0xb0bb, 0x39cd,
+ 0xa92f, 0xba58, 0x3c0b, 0xbdf9, 0x39ad, 0xa459, 0x3e21, 0xbd5c, 0x3d83, 0x41c8, 0x3299, 0xbeb7, 0xb260, 0xbc3a, 0xb6c7, 0xb98c,
+ 0x321a, 0x3d96, 0x3834, 0x3a6f, 0x3920, 0x3d35, 0x28a0, 0xbe28, 0xbe36, 0xb9db, 0xb7d3, 0xbbba, 0xbbd1, 0x357f, 0xbd91, 0xc114,
+ 0xb5fd, 0xae9b, 0xc078, 0xb85b, 0xc123, 0xb4c3, 0x38b3, 0xb796, 0xbb1b, 0x3ab8, 0x33b3, 0x37e5, 0x1a62, 0x3a31, 0xb4f1, 0x3a67,
+ 0xbbce, 0x3e7b, 0xb73c, 0xbc7c, 0x408e, 0x4098, 0xbe64, 0x342b, 0x3da6, 0x39c7, 0x4077, 0x1dea, 0xaf4e, 0x3c46, 0x3ebd, 0xbbe8,
+ 0x3936, 0x3cd8, 0x402f, 0x3e99, 0x3c05, 0xb2d2, 0xbc89, 0xb1eb, 0x2dfa, 0x3d84, 0xbed9, 0xbb80, 0x38a5, 0xbb72, 0xbc2c, 0xb173,
+ 0xb84d, 0xb35d, 0xb0ff, 0x3e9f, 0xbc79, 0x3b57, 0xbb5b, 0x307d, 0xb498, 0x3703, 0xbe4a, 0x38be, 0xb878, 0xab2e, 0x3b46, 0xbacc,
+ 0x3ab4, 0x32d8, 0xc20b, 0x365b, 0x35ac, 0x36ed, 0x40e5, 0x2d1b, 0xb594, 0xb0f7, 0xba7a, 0xbe4c, 0xa99c, 0xb070, 0xb21f, 0x2dca,
+ 0xbf8a, 0x3fd8, 0xb83e, 0x391b, 0xbc35, 0x330f, 0x34e7, 0xb698, 0xb482, 0x34c1, 0x36cd, 0xb818, 0x3e69, 0xb449, 0x3646, 0x31ab,
+ 0x38c2, 0x341e, 0x3925, 0xb987, 0x38e5, 0x41b9, 0xb79d, 0xb1ac, 0x36c6, 0x38f9, 0xc103, 0xa977, 0xbead, 0xbce0, 0xbc63, 0xb897,
+ 0x3f5d, 0xb842, 0x3d63, 0x3875, 0xab3a, 0xad0b, 0x25c0, 0xbcd6, 0x38d6, 0xb851, 0xb9a9, 0xc077, 0x3be3, 0xb4a1, 0xc293, 0x39c4,
+ 0x32dc, 0x414b, 0x3ada, 0x38cc, 0xbad6, 0x3b60, 0x3a85, 0xb52e, 0x3d6c, 0x3d6d, 0xb5a4, 0xb855, 0x2ccf, 0x27f6, 0x35b1, 0xbcf6,
+ 0x34df, 0xb4a0, 0xbe85, 0xb62a, 0x39d4, 0xad0d, 0xb542, 0xab88, 0x35dd, 0x345a, 0x353b, 0x3951, 0xb8f8, 0x2f10, 0xbaae, 0x363f,
+ 0x3878, 0x3ca2, 0x35df, 0x38da, 0xb443, 0xbcfd, 0xb87e, 0x2fdb, 0xbc75, 0x36ab, 0x389a, 0x3243, 0x29dc, 0xba70, 0x2ee6, 0x3250,
+ 0xb748, 0x3d29, 0x40a9, 0xbe21, 0xbba6, 0xb60d, 0xbbbc, 0x3c40, 0xb5dd, 0xbb7b, 0x2631, 0x3bf3, 0xbfbb, 0x2ad5, 0x35b7, 0xb417,
+ 0xafde, 0x3831, 0xb651, 0x3145, 0x3cfa, 0xb23f, 0x39ff, 0xb56f, 0xbd12, 0x3f03, 0x33d8, 0x3623, 0x3401, 0x3e04, 0xbe9f, 0x3f6b,
+ 0x30db, 0xa9d7, 0x31d9, 0xb34d, 0x9f5e, 0x3252, 0xc0f6, 0x3c75, 0x348d, 0xb8ec, 0x38d0, 0x3841, 0x3abf, 0x20a8, 0xc090, 0x2b97,
+ 0xbf35, 0xac01, 0xb854, 0x3722, 0xc074, 0x344d, 0x3a91, 0x3972, 0xbe82, 0x39b9, 0xb62c, 0xc02a, 0xbb3a, 0xba61, 0x2fcb, 0x3a29,
+ 0xba51, 0xbb4e, 0xb604, 0x3d17, 0x363e, 0x3b16, 0x3c14, 0x3ab9, 0xb80d, 0x3a9c, 0xb0df, 0x3936, 0xb50c, 0xb8ca, 0xbd85, 0x35f3,
+ 0x2ffc, 0xb02b, 0xc0b9, 0x38fe, 0x390d, 0xba48, 0x408f, 0xbc03, 0xb937, 0x3646, 0xc22b, 0xc0c1, 0xbab4, 0xbad0, 0xb3f6, 0x99a8,
+ 0xbc8c, 0xbf40, 0x2074, 0xbc80, 0xb927, 0xb89b, 0x33be, 0xa9e5, 0x417f, 0x3229, 0xb346, 0x353c, 0x395d, 0xb883, 0x3d69, 0xbadd,
+ 0x3c6c, 0xa743, 0xbd97, 0x3466, 0xbf85, 0x3977, 0x3618, 0x3976, 0x3e77, 0xb9f8, 0xbe06, 0xc024, 0xbc84, 0x325a, 0xbb6c, 0x3d18,
+ 0xb930, 0xbca2, 0xb806, 0xbfb2, 0x3578, 0xb253, 0xb48c, 0x33f1, 0xb9ac, 0xbb21, 0xb012, 0x374a, 0xb0cc, 0x3c0b, 0xaca9, 0x3dc8,
+ 0xb4d9, 0x322c, 0xab2c, 0xb993, 0x3aa6, 0x3a91, 0x42a1, 0x3da6, 0x3151, 0x3e59, 0x3751, 0x2d8e, 0x3365, 0x2d9a, 0xbaaa, 0xb77f,
+ 0xb7f0, 0x32ee, 0x3dd2, 0xbb78, 0x3d0e, 0xbe1c, 0xbe19, 0xbd05, 0xbcfe, 0xbebd, 0xbba1, 0x36b0, 0x3962, 0x4006, 0x380e, 0x370d,
+ 0x3e08, 0x3b9c, 0x2bfe, 0xb2a8, 0x3dd4, 0xc038, 0xc00f, 0xb32c, 0x33b5, 0x39f3, 0x3691, 0xb893, 0xbb79, 0xac1f, 0x3d09, 0xbd82,
+ 0xafcd, 0xb867, 0xc01c, 0xbbb5, 0xbbca, 0xb323, 0xb8d8, 0x3d5d, 0xbbda, 0x2db4, 0xb8ca, 0x38f9, 0xb615, 0x3a87, 0x321c, 0xc099,
+ 0x3a26, 0x3f8c, 0x30a7, 0x36f1, 0x386f, 0xc2a5, 0xb485, 0xb157, 0xb4d2, 0x3f94, 0x2056, 0xb1bb, 0xbb33, 0x35db, 0x35b5, 0xba51,
+ 0xbe3f, 0x845e, 0xb7cd, 0xbd67, 0x2dae, 0xb670, 0x399d, 0xc11f, 0x2c99, 0x378e, 0xb735, 0xbe92, 0x4021, 0x3c61, 0xba18, 0x34c2,
+ 0xb993, 0xb927, 0xb98a, 0xb82a, 0xba9d, 0xbf68, 0xb507, 0xb7f9, 0x40e7, 0xb718, 0x1e42, 0x3cd3, 0x2b48, 0x3a82, 0x3ef1, 0xbf98,
+ 0xb0ad, 0x3a56, 0x34a6, 0xbc12, 0x3fe4, 0x31d6, 0x3d63, 0xa315, 0x22f5, 0xb81a, 0x3b45, 0x32d7, 0x3e26, 0x3689, 0x3d81, 0xbc0c,
+ 0x3d04, 0xbcd3, 0x36b2, 0xb5c8, 0x37bb, 0xb86b, 0xb658, 0x3c81, 0xb81b, 0xba20, 0x356a, 0xadad, 0xbe5d, 0x3048, 0xb9d4, 0x301d,
+ 0xadb0, 0x3d2d, 0xaa8b, 0xb415, 0xb4b2, 0x413f, 0x3c3c, 0xb516, 0xaff4, 0x3572, 0xb682, 0xbbf6, 0xbbce, 0x3bd3, 0x3a19, 0x3d0a,
+ 0x3729, 0x3592, 0xbc5f, 0x3a21, 0x3c5b, 0xb667, 0x3c4b, 0x38c7, 0x3180, 0xaecd, 0xbd82, 0xb9d9, 0xac5a, 0x36d1, 0xc22c, 0x2c34,
+ 0xbcae, 0xb450, 0x3f37, 0x388f, 0xb698, 0xb5fd, 0x23d2, 0x3b4a, 0xb721, 0xae67, 0x3cbc, 0xab02, 0x39d8, 0xbd73, 0x98eb, 0xbaf1,
+ 0x3ad1, 0x381e, 0xb864, 0xbc12, 0xc0e9, 0xc084, 0x3831, 0x3971, 0x3ca9, 0xb2fa, 0xa167, 0x3708, 0x405f, 0xb9ca, 0x3ca1, 0x31ad,
+ 0x383f, 0x339d, 0x389a, 0x364f, 0xb77d, 0x3db4, 0xb56a, 0xb2bc, 0xba8f, 0xb4dd, 0xbf46, 0x32b6, 0x381e, 0xb90a, 0x3db5, 0xbf8a,
+ 0xbc4e, 0x37b4, 0xbc0e, 0xad30, 0x3c84, 0x3d83, 0x3a52, 0x3a04, 0xbc64, 0x4027, 0x3c18, 0x3e6d, 0xbcce, 0xaf48, 0xb052, 0x325c,
+ 0xb876, 0xbf1d, 0xbafa, 0xaf28, 0x3a5b, 0x3498, 0xaab7, 0xbc54, 0x3fdb, 0x3d7e, 0x39e0, 0xbf20, 0xbfc8, 0xaddc, 0xb815, 0xb83b,
+ 0xb793, 0x3798, 0x3915, 0xb6c5, 0xbc75, 0x395b, 0x358f, 0xb960, 0xbc4a, 0xbced, 0xbb4c, 0x34c2, 0x3cfd, 0x2022, 0x2cce, 0x30cf,
+ 0xb632, 0xbc4d, 0x3a35, 0x3308, 0x2f07, 0x38d2, 0xbc58, 0x3c45, 0xbae1, 0xb9ad, 0xbb37, 0x3910, 0xbf4b, 0xb91e, 0x374d, 0xb27e,
+ 0xb59a, 0x367b, 0x3af6, 0x39fb, 0xbb7c, 0x3a2a, 0xbf2d, 0x2d37, 0xb489, 0x3803, 0x3fc6, 0xbdc6, 0x381d, 0x3fe4, 0x33f7, 0xb508,
+ 0x4023, 0xbeb9, 0x3d4c, 0xb0c6, 0xb9aa, 0x38c5, 0xb65d, 0x360a, 0xbd31, 0x3ad7, 0x3f3e, 0x39bf, 0xbc24, 0xb920, 0x3774, 0xb7a3,
+ 0xafd2, 0xbcb9, 0xb627, 0x387a, 0xb7cc, 0x38cb, 0xaf26, 0xb37e, 0xb2c5, 0xbad1, 0xb881, 0xb982, 0xbe79, 0xbf5f, 0xb58c, 0x3cb6,
+ 0xb76a, 0xc084, 0x3888, 0x305f, 0x4386, 0xbb1c, 0x318f, 0x2990, 0xbc45, 0xb415, 0xbd45, 0x3b9a, 0x400b, 0xb6c7, 0x40d8, 0x3f49,
+ 0x3b3e, 0x3953, 0x4121, 0x41a5, 0x3e15, 0x3a86, 0xb745, 0xb50c, 0x394d, 0xbc62, 0x3ce8, 0x36fd, 0xb3fe, 0xb7d3, 0x320d, 0x3663,
+ 0x38fd, 0x39e8, 0xb2dd, 0x38c0, 0x3992, 0xb516, 0xb019, 0xbc1f, 0x35e3, 0xa8c6, 0x3fda, 0x3975, 0x3dba, 0xc0dd, 0x166a, 0x3863,
+ 0xa3cd, 0x3ab2, 0x332f, 0xbcb9, 0xbce3, 0xb88e, 0xbd5e, 0x41f6, 0xba72, 0xbd0a, 0xbac9, 0xc170, 0xbc26, 0xb615, 0xbab0, 0xbca7,
+ 0xc082, 0xbb6c, 0x3f5b, 0x415e, 0x3be8, 0xbe9b, 0x3c55, 0x3f32, 0xa521, 0x410a, 0xbf27, 0xbe1e, 0xbca8, 0x39df, 0xb924, 0xbbf5,
+ 0xb2aa, 0x39c7, 0x3af7, 0x424b, 0xb4c6, 0xaed0, 0x358e, 0x3532, 0x3116, 0x3924, 0xbee5, 0xc199, 0xba6e, 0x3849, 0x3c77, 0xb920,
+ 0x3c82, 0xb481, 0x33de, 0x3c4e, 0xba98, 0x3775, 0xb594, 0x96a7, 0xbd85, 0x4000, 0x2fd0, 0x3fd8, 0x3d71, 0x3bb7, 0x3dc5, 0x3808,
+ 0xbc1c, 0x34a8, 0x3d3d, 0xb86c, 0x3bf1, 0x3841, 0x399c, 0xb9d3, 0xbcee, 0xb752, 0x3ab9, 0xb00a, 0xb744, 0x3198, 0x2fcd, 0x398f,
+ 0x9a32, 0x3d75, 0x360a, 0x3bbc, 0x37e9, 0xbb59, 0xb969, 0xb330, 0xc0a5, 0x3ae6, 0x3e0c, 0x40b0, 0xbcda, 0x343c, 0x34bc, 0xb86c,
+ 0x3cb0, 0x35be, 0xbd82, 0xac1b, 0xbb08, 0xa5a7, 0x34bf, 0xb0f5, 0x3087, 0xb485, 0xa123, 0xbb9c, 0x3df9, 0xb45d, 0x3c17, 0x404c,
+ 0x347a, 0x39a3, 0xb6e8, 0xb913, 0xbd20, 0x38ce, 0xc006, 0x40b0, 0x402a, 0xbb4d, 0x3e7d, 0x3e49, 0x3b8b, 0xb6c8, 0x2d82, 0x3b90,
+ 0x388d, 0xae29, 0x327b, 0x3ad7, 0x3d10, 0xb984, 0x3933, 0x34cc, 0x3002, 0xbbda, 0xbcf3, 0x3819, 0x2c89, 0xbc31, 0x3dbd, 0x38e8,
+ 0xb4e4, 0xbb87, 0xb172, 0x3886, 0x39b9, 0xb829, 0xbd54, 0xb345, 0xb951, 0xba7f, 0x3d9f, 0x36c1, 0xb259, 0x3dd3, 0x3a49, 0x36a4,
+ 0x3b65, 0x3cf2, 0xacae, 0xbe2c, 0xbdae, 0x3ba3, 0x356a, 0x3603, 0x3d0e, 0x3370, 0xb96b, 0x2d88, 0xb8d3, 0x36e3, 0xb804, 0x3b24,
+ 0xc000, 0xbdd0, 0xc006, 0xb8c7, 0x3dc9, 0x3367, 0xb663, 0x344b, 0x3406, 0x341f, 0xac64, 0xc0cf, 0x34c6, 0x3d02, 0x3676, 0x39f8,
+ 0xa4b0, 0x2e04, 0xb4ee, 0x3b5f, 0xbb6d, 0x37d4, 0xb0cc, 0xb491, 0xb1aa, 0xacc8, 0xbea5, 0x3c6c, 0xb99e, 0xbc46, 0xbe17, 0x3b6c,
+ 0xbd5d, 0xbf93, 0xb462, 0x38fa, 0xc0e4, 0x331f, 0x3419, 0x3164, 0xbb25, 0x4066, 0xbd61, 0xbe28, 0x3891, 0xbc66, 0x32be, 0xbc0c,
+ 0x3055, 0x3dee, 0x20f7, 0xb3ab, 0x31ff, 0x3a50, 0xbe6a, 0xbad6, 0xbb8f, 0x3cb5, 0xbe0a, 0x3e97, 0x3110, 0xbc8b, 0x36cb, 0x3c1b,
+ 0xbb83, 0xbe5f, 0xaecd, 0x310b, 0xb4b8, 0x2985, 0x3c4a, 0xb9d9, 0x39c5, 0xbc1d, 0x390b, 0x3d9e, 0x3675, 0xbca4, 0x3ce1, 0xb49c,
+ 0xbb08, 0x3fff, 0x3927, 0x35e3, 0xbd50, 0xbc60, 0x39b6, 0xbd13, 0x4123, 0xc2a2, 0xbeab, 0x37d9, 0xb8ed, 0x3425, 0xbace, 0x3a36,
+ 0xb0c7, 0x4057, 0x3c69, 0x3e0c, 0xb5b0, 0x3a03, 0xba05, 0xbaa0, 0x19c4, 0x9c4c, 0xb72f, 0x3c37, 0x3467, 0xbd02, 0xb522, 0xb537,
+ 0x3673, 0x2c4d, 0xb17b, 0xbdef, 0xb95a, 0x3daa, 0xbbe8, 0xb4e3, 0x3034, 0xbb3a, 0xc116, 0xbd9c, 0x3891, 0xc1d5, 0xbd9f, 0xb874,
+ 0xbc4b, 0x357f, 0xb09a, 0x3f79, 0x3f0c, 0xc07e, 0xbbfe, 0xbca2, 0xbb50, 0x2af5, 0xb02f, 0xbaf7, 0xb629, 0xb509, 0x39c8, 0x36fc,
+ 0xa825, 0x395c, 0xb901, 0x3553, 0xbd9d, 0xbbeb, 0x39f2, 0xb451, 0x37bc, 0x3f3c, 0x35a3, 0x3866, 0x3046, 0x35fb, 0x3999, 0xbcb3,
+ 0xa417, 0x3d1d, 0xbc37, 0x3bec, 0x3c7c, 0x3bfa, 0xbcb8, 0xc1d5, 0x3c1a, 0x3c40, 0xb23c, 0xb73b, 0x3546, 0x3a09, 0xbbf5, 0xbb7f,
+ 0x30e8, 0xbe3f, 0x39fe, 0x3a8b, 0x341a, 0x9b02, 0xbc35, 0x2b91, 0x4256, 0x3a51, 0x3fd1, 0xba43, 0xb55c, 0x393a, 0x3c6f, 0xae6a,
+ 0x3da8, 0xb266, 0xbd17, 0xba78, 0x35cf, 0x3e3a, 0xb5dd, 0x3e4d, 0x345d, 0x32ff, 0xbca2, 0x35a2, 0xb9f1, 0x3c82, 0xbbc5, 0x38f1,
+ 0x3f36, 0xbe7b, 0xbe77, 0xb44a, 0xbd3b, 0x3501, 0x344c, 0xbe42, 0xbc81, 0x3dc3, 0x2613, 0xbf15, 0xbb1c, 0x3c71, 0x345f, 0xba6a,
+ 0xb944, 0x3c03, 0xb5ea, 0xbae1, 0xab67, 0x3e77, 0xc04f, 0xb9db, 0xbe0c, 0xb86e, 0xbc4f, 0xb9cd, 0x3ca8, 0xb07a, 0x36be, 0xb41f,
+ 0xac27, 0x3256, 0x3870, 0xb327, 0xb5f6, 0x3b9d, 0x30ba, 0xb8de, 0x3c1b, 0xb06a, 0x3ae1, 0x3d54, 0xba28, 0x3d08, 0x38a3, 0xb938,
+ 0x3472, 0xb96b, 0x3945, 0x3b80, 0xadbe, 0x3ab1, 0x3ccf, 0x39b5, 0x34a8, 0x3836, 0xb49e, 0x308c, 0x3916, 0xb5ba, 0xbb8a, 0x3b1b,
+ 0xbc56, 0xbe6f, 0xbd9e, 0xb4d5, 0x3e83, 0xa343, 0x3adc, 0xb2fc, 0xba2f, 0x3b55, 0x3cec, 0xb624, 0x261f, 0x37d7, 0xbf76, 0x3eb1,
+ 0x38b1, 0xb9c8, 0xa60d, 0x361c, 0xbca6, 0xc00c, 0xbb55, 0xbc6b, 0x34c5, 0x38ba, 0xb802, 0x383c, 0xbd59, 0x3e68, 0x3a2e, 0xbbad,
+ 0x3c74, 0x3b24, 0x3010, 0x3ebf, 0xb953, 0xbfa8, 0xb16b, 0x3b7c, 0x3952, 0x2c82, 0xb8ef, 0x412c, 0xb7ec, 0x3cdb, 0x3bc9, 0x38e0,
+ 0xbbfb, 0xbaa3, 0x3f28, 0xb1df, 0x3a77, 0xbccf, 0xb1a5, 0xb933, 0x3018, 0x37cb, 0xbec0, 0x31bc, 0xbd2e, 0x3997, 0x3930, 0x3906,
+ 0xb86f, 0x37fd, 0x323d, 0x33e5, 0xa60a, 0x38d7, 0xb30a, 0xb451, 0x3597, 0x3123, 0xc063, 0xbe8a, 0xbe42, 0x37af, 0xaff0, 0x3b21,
+ 0x365f, 0xb277, 0xb5b8, 0x2ad2, 0xc11d, 0x3a45, 0x31fd, 0xb500, 0xbf3f, 0xbc72, 0x3038, 0x24a3, 0x2890, 0xb595, 0xc08f, 0xc1c7,
+ 0xb86e, 0xbcaa, 0x3189, 0x38a6, 0xb408, 0x325d, 0x2ca7, 0x3b05, 0x3c55, 0xbf35, 0x387c, 0x3b7e, 0x3c20, 0x3a0b, 0x3741, 0x3db8,
+ 0x3a12, 0x3c4d, 0xb87c, 0x3d11, 0xbdc9, 0xbed7, 0x2444, 0xbdbb, 0xb9c6, 0x3cc9, 0xae72, 0xba10, 0x38b7, 0x3953, 0xb1e6, 0xbbe2,
+ 0xa918, 0x30b1, 0xbc8f, 0x283d, 0xaeb3, 0xb160, 0x3794, 0x3336, 0x3327, 0x401d, 0xbf99, 0x3d15, 0xad02, 0x3a32, 0x3df6, 0x3c57,
+ 0xbef4, 0x34ed, 0xbc1f, 0x368c, 0x3aed, 0xb95b, 0x38dd, 0x3bf3, 0x4185, 0x3c2f, 0xbbfc, 0x37b5, 0x37f3, 0x355e, 0x3559, 0x3c46,
+ 0xc003, 0x38bc, 0x3b53, 0xbda0, 0xac8d, 0x2acb, 0xb8ac, 0x396c, 0x2be0, 0xbb1f, 0x3ce8, 0x3b90, 0xae9f, 0x3ef8, 0xb33e, 0x3cf4,
+ 0x2c97, 0xb898, 0xbaa5, 0x3f56, 0x3e58, 0xbb16, 0xb33c, 0xc004, 0x400e, 0xbc68, 0x38bd, 0xa939, 0x3a55, 0x3b35, 0x40d6, 0x3db5,
+ 0x4176, 0xb869, 0x30ba, 0xbd7f, 0xba99, 0xb379, 0x3ecf, 0xb915, 0xb19f, 0x30f2, 0x3e11, 0xb632, 0xbe94, 0x3be5, 0x3d28, 0xac5d,
+ 0xb6e7, 0xbb64, 0xb282, 0x4380, 0xbde1, 0x36b5, 0x36c2, 0x3867, 0x3cca, 0x2e1c, 0x31cc, 0x2e2f, 0xb0d4, 0xbcff, 0xbb1c, 0xbd67,
+ 0x309a, 0x3d2c, 0xab7d, 0xbd03, 0xbbe1, 0xbefc, 0xbfbe, 0x3b98, 0xb53c, 0xbc72, 0x2f15, 0x3cca, 0xc106, 0xbc36, 0xb702, 0x3b57,
+ 0x391a, 0xb4da, 0x3861, 0x3afe, 0x3ea8, 0x335b, 0x34e4, 0xbd62, 0x3f1f, 0xbc86, 0xbcf4, 0x35bc, 0xb34a, 0xbf53, 0x3834, 0xbd10,
+ 0x273d, 0x39a1, 0xb839, 0xb4e4, 0x39b8, 0x34da, 0xbed6, 0x3a76, 0x3c50, 0xc0fa, 0xbd35, 0xb061, 0xb1b6, 0x34f0, 0x3ab1, 0xbc18,
+ 0xb91d, 0xb62c, 0xbb36, 0xb829, 0xb940, 0xafab, 0x3d46, 0x3e81, 0xb20b, 0xb822, 0xbe39, 0x35fd, 0x32f1, 0x3966, 0x2e17, 0xb543,
+ 0xbbed, 0x3a89, 0xb2a3, 0xbcc5, 0x3369, 0xb42b, 0xbbd4, 0x1f58, 0xbc48, 0x3ef4, 0x3bbe, 0xac2b, 0xbdf5, 0xb2e4, 0xbcae, 0x3f94,
+ 0xa11a, 0xc068, 0x35bb, 0xb82e, 0x3f77, 0xbbb9, 0xb386, 0x3b46, 0xb675, 0x22f3, 0x3e8b, 0xbcb2, 0xb8ba, 0xba29, 0x4235, 0xbd08,
+ 0x1038, 0x3f9f, 0xade8, 0x399f, 0x3363, 0xb9da, 0x3909, 0x37c8, 0x3c82, 0xbc4c, 0xbc3a, 0xb788, 0xa897, 0x39da, 0xb6d2, 0x3bee,
+};
+#endif