Add files using upload-large-folder tool

agents/modmind/config.py

@@ -0,0 +1,158 @@
+"""
+config.py -- SpikeWhale: combined config from SpikeTransformer (My Project) + NanoWhale (DeepSeek-V4).
+
+Features carried from My Project (not in NanoWhale):
+  - DERF attention: erf(alpha*score+bias)*gamma replaces softmax
+  - XSA (Exclusive Self-Attention): orthogonality correction removes self-echo from attn output
+  - Engram N-gram module: hash-table N-gram lookup with DERF gate injected into embeddings
+  - Three-tier optimizer: embed/table params trained at lower LR
+
+Features carried from NanoWhale (not in My Project):
+  - MLA (Multi-Head Latent Attention): low-rank Q projection + direct K,V (MQA)
+  - Partial RoPE: rotary embeddings on only qk_rope_head_dim dims of Q and K
+  - Low-rank grouped output projection (o_lora_rank)
+  - Hyper-Connections: hc_mult residual streams with learned routing between layers
+  - Shared expert in MoE (always-active expert alongside routed experts)
+  - sqrtsoftplus expert scoring (vs softmax in My Project)
+  - Hash-based routing for first num_hash_layers layers
+  - norm_topk_prob + routed_scaling_factor
+  - Multi-Token Prediction (MTP): extra heads predict k steps ahead
+  - torch.compile, FineWeb-Edu streaming, Trackio, YAML configs in train.py
+"""
+
+from transformers import PretrainedConfig
+
+
+class SpikeWhaleConfig(PretrainedConfig):
+    model_type = "spike_whale"
+
+    def __init__(
+        self,
+        # Standard
+        vocab_size: int = 129280,
+        hidden_size: int = 2048,
+        num_hidden_layers: int = 11,
+        max_position_embeddings: int = 8192,
+        rms_norm_eps: float = 1e-6,
+        initializer_range: float = 0.02,
+        tie_word_embeddings: bool = False,
+        hidden_dropout: float = 0.0,
+        bos_token_id: int = 0,
+        eos_token_id: int = 1,
+        # MLA Attention (NanoWhale)
+        num_attention_heads: int = 8,
+        num_key_value_heads: int = 1,   # 1 = MQA; >1 = GQA
+        q_lora_rank: int = 160,         # low-rank Q: hidden -> q_lora_rank -> num_heads*head_dim
+        head_dim: int = 96,             # total per-head dim = nope_head_dim + qk_rope_head_dim
+        qk_rope_head_dim: int = 32,     # RoPE applied only to these dims
+        o_lora_rank: int = 80,          # low-rank output: num_heads*head_dim -> o_lora_rank -> hidden
+        attention_dropout: float = 0.0,
+        rope_theta: float = 10000.0,
+        # DERF + XSA (My Project)
+        use_derf: bool = True,
+        use_xsa: bool = True,
+        # MoE (combined)
+        use_moe: bool = True,
+        moe_intermediate_size: int = 640,
+        n_routed_experts: int = 4,
+        n_shared_experts: int = 1,      # NanoWhale: always-active shared expert
+        num_experts_per_tok: int = 2,
+        norm_topk_prob: bool = True,    # NanoWhale: normalize top-k routing weights
+        scoring_func: str = "sqrtsoftplus",  # NanoWhale: sqrt(softplus(x)) vs softmax
+        routed_scaling_factor: float = 1.0,  # NanoWhale: scale routed expert weights
+        num_hash_layers: int = 2,       # NanoWhale: first N layers use hash routing
+        moe_aux_loss_coef: float = 0.01,
+        moe_layers: list = None,
+        # Hyper-Connections (NanoWhale)
+        use_hyper_connections: bool = True,
+        hc_mult: int = 4,               # number of parallel residual streams
+        hc_sinkhorn_iters: int = 20,
+        hc_eps: float = 1e-6,
+        # Multi-Token Prediction (NanoWhale)
+        num_nextn_predict_layers: int = 1,  # extra MTP heads (0 = disabled)
+        # Engram N-gram module (My Project)
+        use_engram: bool = True,
+        engram_compress_dim: int = 64,
+        engram_num_heads: int = 4,
+        engram_table_size: int = 8192,
+        engram_max_ngram: int = 3,
+        engram_gate_init_bias: float = -4.0,
+        use_hrm_refine: bool = False,
+        hrm_refine_steps: int = 3,
+        hrm_refine_dim: int = 256,
+        # --- ModularMind-on-V2 additions (off/unused unless enabled) ---
+        use_latent_io: bool = False,   # add latent output head + injection input path
+        d_latent: int = 256,           # RecursiveLink contract dim (fixed across chain)
+        chain_position: int = 0,       # context-doubling slot: ctx & theta scale by 2^pos
+        base_context: int = 8192,      # ctx at position 0 (>= training --seq-len)
+        base_rope_theta: float = 10000.0,
+        **kwargs,
+    ):
+        super().__init__(
+            bos_token_id=bos_token_id,
+            eos_token_id=eos_token_id,
+            tie_word_embeddings=tie_word_embeddings,
+            **kwargs,
+        )
+        self.vocab_size = vocab_size
+        self.hidden_size = hidden_size
+        self.num_hidden_layers = num_hidden_layers
+        self.max_position_embeddings = max_position_embeddings
+        self.rms_norm_eps = rms_norm_eps
+        self.initializer_range = initializer_range
+        self.hidden_dropout = hidden_dropout
+
+        self.num_attention_heads = num_attention_heads
+        self.num_key_value_heads = num_key_value_heads
+        self.q_lora_rank = q_lora_rank
+        self.head_dim = head_dim
+        self.qk_rope_head_dim = qk_rope_head_dim
+        self.nope_head_dim = head_dim - qk_rope_head_dim
+        self.o_lora_rank = o_lora_rank
+        self.attention_dropout = attention_dropout
+        self.rope_theta = rope_theta
+        self.use_derf = use_derf
+        self.use_xsa = use_xsa
+
+        self.use_moe = use_moe
+        self.moe_intermediate_size = moe_intermediate_size
+        self.n_routed_experts = n_routed_experts
+        self.n_shared_experts = n_shared_experts
+        self.num_experts_per_tok = num_experts_per_tok
+        self.norm_topk_prob = norm_topk_prob
+        self.scoring_func = scoring_func
+        self.routed_scaling_factor = routed_scaling_factor
+        self.num_hash_layers = num_hash_layers
+        self.moe_aux_loss_coef = moe_aux_loss_coef
+        self.moe_layers = moe_layers if moe_layers is not None else list(range(num_hidden_layers))
+
+        self.use_hyper_connections = use_hyper_connections
+        self.hc_mult = hc_mult
+        self.hc_sinkhorn_iters = hc_sinkhorn_iters
+        self.hc_eps = hc_eps
+
+        self.num_nextn_predict_layers = num_nextn_predict_layers
+
+        self.use_engram = use_engram
+        self.engram_compress_dim = engram_compress_dim
+        self.engram_num_heads = engram_num_heads
+        self.engram_table_size = engram_table_size
+        self.engram_max_ngram = engram_max_ngram
+        self.engram_gate_init_bias = engram_gate_init_bias
+        self.use_hrm_refine = use_hrm_refine
+        self.hrm_refine_steps = hrm_refine_steps
+        self.hrm_refine_dim = hrm_refine_dim
+        # --- ModularMind-on-V2 additions ---
+        self.use_latent_io = use_latent_io
+        self.d_latent = d_latent
+        self.chain_position = chain_position
+        self.base_context = base_context
+        self.base_rope_theta = base_rope_theta
+        # Context-doubling: each chain slot doubles ctx and rope theta.
+        # position 0 -> (8192, 10000); position 1 -> (16384, 20000); etc.
+        # Applied only when latent IO is on (i.e. this is a ModularMind specialist),
+        # so plain V2 keeps its own max_position_embeddings/rope_theta untouched.
+        if use_latent_io:
+            scale = 2 ** chain_position
+            self.max_position_embeddings = base_context * scale
+            self.rope_theta = base_rope_theta * scale

agents/modmind/model.py

@@ -0,0 +1,1011 @@
+"""
+model.py -- SpikeWhaleLM: combined architecture from SpikeTransformer (My Project) + NanoWhale.
+
+Architecture flow:
+  Embedding
+    -> Engram delta (N-gram memory, My Project)
+    -> [expand to hc_mult copies if HC enabled]
+    -> N x TransformerBlock:
+         HC pre-op (NanoWhale) -> RMSNorm -> MLA+DERF+XSA Attention (combined)
+                               -> HC post-op
+         HC pre-op             -> RMSNorm -> MoE FFN w/ shared expert (NanoWhale)
+                               -> HC post-op
+    -> [mean-pool hc_mult copies if HC enabled]
+    -> RMSNorm
+    -> LM head  +  MTP heads (NanoWhale)
+
+Component origins:
+  RMSNorm, RotaryEmbedding          -- both (standard)
+  Engram / DERFContextGate          -- My Project
+  MLADerfXSAAttention               -- MLA from NanoWhale + DERF+XSA from My Project
+  SparseMoEFFN w/ shared expert     -- NanoWhale MoE structure + My Project aux loss
+  HyperConnectionLayer              -- NanoWhale
+  SpikeWhaleLM + MTP heads          -- NanoWhale
+"""
+
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from typing import Optional, Tuple, List
+from transformers import PreTrainedModel
+from transformers.modeling_outputs import CausalLMOutputWithPast
+from torch.utils.checkpoint import checkpoint as gradient_checkpoint
+
+from config import SpikeWhaleConfig
+
+
+# ---------------------------------------------------------------------------
+# Primitives
+# ---------------------------------------------------------------------------
+
+class RMSNorm(nn.Module):
+    def __init__(self, dim: int, eps: float = 1e-6):
+        super().__init__()
+        self.eps = eps
+        self.weight = nn.Parameter(torch.ones(dim))
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps) * self.weight
+
+
+class RotaryEmbedding(nn.Module):
+    """RoPE for the rope partition of Q and K (qk_rope_head_dim dims only)."""
+
+    def __init__(self, dim: int, max_positions: int = 4096, theta: float = 10000.0):
+        super().__init__()
+        inv_freq = 1.0 / (theta ** (torch.arange(0, dim, 2).float() / dim))
+        self.register_buffer("inv_freq", inv_freq)
+        t = torch.arange(max_positions).float()
+        freqs = torch.outer(t, inv_freq)
+        self.register_buffer("cos_cache", freqs.cos())
+        self.register_buffer("sin_cache", freqs.sin())
+
+    def forward(self, x: torch.Tensor, position_ids: torch.Tensor) -> torch.Tensor:
+        """
+        x: [B, H, S, rope_dim]
+        position_ids: [B, S]
+        """
+        cos = self.cos_cache[position_ids].unsqueeze(1)   # [B, 1, S, rope_dim//2]
+        sin = self.sin_cache[position_ids].unsqueeze(1)
+        d = cos.shape[-1]
+        x1, x2 = x[..., :d], x[..., d:]
+        return torch.cat([x1 * cos - x2 * sin, x1 * sin + x2 * cos], dim=-1)
+
+
+# ---------------------------------------------------------------------------
+# Engram: N-gram hash lookup + DERF gate  (My Project, preserved)
+# ---------------------------------------------------------------------------
+
+class TokenCompressor(nn.Module):
+    def __init__(self, embed_dim: int, compress_dim: int):
+        super().__init__()
+        self.proj = nn.Linear(embed_dim, compress_dim, bias=False)
+        nn.init.normal_(self.proj.weight, std=0.02)
+        # BUGFIX: this projection feeds ONLY the integer hash index
+        # (idx = h.abs().long() % table_size) in MultiHeadHashLookup. The .long()
+        # cast is non-differentiable, so no gradient ever reaches this weight --
+        # it can never learn. Worse, _classify_params put it in the weight-decay
+        # group, so AdamW was steadily shrinking it toward zero and degrading the
+        # hash projection over a long run. Freeze it: a fixed random projection is
+        # exactly the right behavior for an LSH-style hash, and freezing drops it
+        # from the optimizer (saves state) and from weight decay. Checkpoint-safe:
+        # the parameter still exists and is still saved/loaded in state_dict.
+        self.proj.weight.requires_grad_(False)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.proj(x)
+
+
+class MultiHeadHashLookup(nn.Module):
+    def __init__(self, num_heads: int, table_size: int,
+                 compress_dim: int, out_dim: int, max_ngram: int = 3):
+        super().__init__()
+        self.num_heads = num_heads
+        self.table_size = table_size
+        self.max_ngram = max_ngram
+        self.out_dim = out_dim
+
+        self.tables = nn.ModuleList([
+            nn.Embedding(table_size, out_dim) for _ in range(num_heads)
+        ])
+        for t in self.tables:
+            nn.init.normal_(t.weight, std=0.01)
+
+        for n in range(1, max_ngram + 1):
+            for k in range(n):
+                proj = torch.randn(num_heads, compress_dim)
+                proj = proj / (proj.norm(dim=1, keepdim=True) + 1e-8)
+                self.register_buffer(f"hash_proj_n{n}_p{k}", proj)
+
+    def forward(self, compressed: torch.Tensor) -> torch.Tensor:
+        """
+        compressed: [B, S, compress_dim]
+        returns:    [B, S, out_dim]
+
+        All positions are processed in parallel. The outer loop runs max_ngram
+        times (≤3), not S times (≤2048). Each iteration is a single matmul +
+        embedding lookup across the whole sequence, making this GPU-friendly
+        and compatible with torch.compile.
+        """
+        B, S, _ = compressed.shape
+        device = compressed.device
+        out = torch.zeros(B, S, self.out_dim, device=device, dtype=compressed.dtype)
+        # Per-position normalization: tracks how many (n-gram × head) contributions
+        # each position receives. Positions near the start get fewer contributions
+        # because shorter n-grams don't exist yet (matches original causal behavior).
+        norm = torch.zeros(S, device=device)
+
+        for n in range(1, self.max_ngram + 1):
+            if S < n:
+                continue
+            valid_len = S - n + 1   # positions [n-1 .. S-1] are valid for order-n
+            start = n - 1
+
+            # Accumulate position-k contribution to the order-n hash.
+            # compressed[:, k : k+valid_len, :] is the k-th token of every n-gram
+            # window simultaneously → [B, valid_len, num_heads] after projection.
+            h = torch.zeros(B, valid_len, self.num_heads, device=device)
+            for k in range(n):
+                proj = getattr(self, f"hash_proj_n{n}_p{k}")   # [num_heads, compress_dim]
+                h = h + torch.matmul(compressed[:, k:k + valid_len, :].float(), proj.t())
+
+            idx = h.abs().long() % self.table_size              # [B, valid_len, num_heads]
+
+            for head_idx, table in enumerate(self.tables):
+                out[:, start:, :] = out[:, start:, :] + table(idx[:, :, head_idx])
+
+            norm[start:] += self.num_heads
+
+        # Cast back to input dtype: the norm division promotes bf16→float32 under autocast.
+        # Keeping the output in the same dtype as the input avoids a silent dtype mismatch
+        # when EngramModule adds this result back onto the (bf16) embedding tensor.
+        return (out / norm.view(1, -1, 1).clamp(min=1)).to(compressed.dtype)
+
+
+class DERFContextGate(nn.Module):
+    """
+    DERF gate: gate = gamma * erf(alpha * proj([retrieved, x]) + bias)
+    Positive probability = (gate + 1) / 2 applied to retrieved embedding.
+    Large negative init_bias keeps gate closed at start of training.
+    """
+    def __init__(self, obs_size: int, init_bias: float = -4.0):
+        super().__init__()
+        self.proj = nn.Linear(obs_size * 2, obs_size)
+        self.alpha = nn.Parameter(torch.ones(obs_size))
+        self.bias = nn.Parameter(torch.full((obs_size,), init_bias))
+        self.gamma = nn.Parameter(torch.ones(obs_size))
+
+    def forward(self, retrieved: torch.Tensor, x: torch.Tensor) -> torch.Tensor:
+        logits = self.proj(torch.cat([retrieved, x], dim=-1))
+        gate = self.gamma * ((torch.erf(self.alpha * logits + self.bias) + 1.0) / 2.0)
+        return retrieved * gate
+
+
+class EngramModule(nn.Module):
+    """
+    N-gram hash lookup with DERF gate (My Project), fully vectorized.
+    All S positions are processed in parallel — the sequential Python loop
+    over sequence positions has been eliminated. The lookup now accepts the
+    full [B, S, compress_dim] compressed tensor and returns [B, S, H] in one pass.
+    """
+    def __init__(self, cfg: SpikeWhaleConfig):
+        super().__init__()
+        self.compressor = TokenCompressor(cfg.hidden_size, cfg.engram_compress_dim)
+        self.lookup = MultiHeadHashLookup(
+            cfg.engram_num_heads, cfg.engram_table_size,
+            cfg.engram_compress_dim, cfg.hidden_size, cfg.engram_max_ngram,
+        )
+        self.gate = DERFContextGate(cfg.hidden_size, cfg.engram_gate_init_bias)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """x: [B, S, H] -> engram_delta: [B, S, H]"""
+        compressed = self.compressor(x.detach())    # [B, S, compress_dim]
+        retrieved = self.lookup(compressed)          # [B, S, H]
+        return self.gate(retrieved, x)              # [B, S, H]
+
+
+# ---------------------------------------------------------------------------
+# Hyper-Connections  (NanoWhale, simplified)
+# ---------------------------------------------------------------------------
+
+class HyperConnectionLayer(nn.Module):
+    """
+    Simplified Hyper-Connections for one sublayer (attention or FFN).
+
+    Maintains hc_mult parallel residual streams.
+    Pre-op: learned weighted average of hc_mult copies -> single hidden state for sublayer.
+    Post-op: sublayer output added to each copy with learned per-stream weights.
+
+    Full HC uses Sinkhorn-normalized 2D routing matrices; this uses softmax-normalized
+    1D weights for pre/post routing -- captures the same multi-stream routing spirit.
+    """
+    def __init__(self, hidden_size: int, hc_mult: int,
+                 sinkhorn_iters: int = 20, eps: float = 1e-6):
+        super().__init__()
+        self.hc_mult = hc_mult
+        # pre_weight: how to mix hc_mult copies into one sublayer input
+        # post_weight: how to distribute the sublayer delta to each copy
+        #
+        # BUGFIX: these must NOT be initialized identically across streams.
+        # The model expands the hidden state into hc_mult *identical* copies.
+        # With uniform pre/post weights, pre_op produces sum_i copy_i * w_i =
+        # copy * sum(softmax)=copy (all copies equal), and post_op adds the same
+        # delta to every copy -- so the streams stay byte-for-byte identical at
+        # every layer. When all streams are equal, the softmax Jacobian applied
+        # to the (equal) per-stream gradients is exactly zero, so pre_weight and
+        # post_weight receive ZERO gradient and never move off 1/hc_mult. The HC
+        # routing then learns nothing and just burns hc_mult x memory/compute.
+        #
+        # Breaking the post_weight symmetry at init makes the streams diverge
+        # after the first sublayer, which restores gradient flow to all HC
+        # weights. We center post_weight so softmax starts near-uniform (keeps
+        # the residual baseline ~unchanged) but with a distinct value per stream.
+        self.pre_weight = nn.Parameter(
+            torch.linspace(0.5, -0.5, hc_mult) / max(hc_mult, 1)
+        )
+        self.post_weight = nn.Parameter(
+            torch.linspace(-0.5, 0.5, hc_mult) / max(hc_mult, 1)
+        )
+
+    def pre_op(self, copies: torch.Tensor) -> torch.Tensor:
+        """copies: [B, hc_mult, S, H] -> [B, S, H]"""
+        w = F.softmax(self.pre_weight, dim=0)           # [hc_mult]
+        return (copies * w.view(1, -1, 1, 1)).sum(dim=1)
+
+    def post_op(self, copies: torch.Tensor, delta: torch.Tensor) -> torch.Tensor:
+        """
+        copies: [B, hc_mult, S, H]
+        delta:  [B, S, H]
+        Returns updated copies: [B, hc_mult, S, H]
+        """
+        w = F.softmax(self.post_weight, dim=0)          # [hc_mult]
+        return copies + delta.unsqueeze(1) * w.view(1, -1, 1, 1)
+
+
+# ---------------------------------------------------------------------------
+# MLA + DERF + XSA Attention  (combined)
+# ---------------------------------------------------------------------------
+
+class MLADerfXSAAttention(nn.Module):
+    """
+    Multi-Head Latent Attention (NanoWhale) with DERF scores + XSA correction (My Project).
+
+    MLA (from NanoWhale):
+      Q: hidden -> q_lora_rank (RMSNorm) -> num_heads * head_dim  (low-rank projection)
+      K, V: hidden -> num_kv_heads * head_dim  (direct, MQA by default with num_kv_heads=1)
+      Output: num_heads * head_dim -> o_lora_rank -> hidden  (low-rank output)
+      Partial RoPE: applied only to the last qk_rope_head_dim dims of Q and K
+
+    DERF (from My Project):
+      Replaces softmax: erf(alpha * scores + bias) * gamma, shifted to [0,1] then normalized.
+      Per-head learnable alpha, bias, gamma.
+
+    XSA (from My Project):
+      After computing the weighted value sum y, subtract the component of y that
+      projects onto each position's own value vector. Forces the output to carry
+      only cross-position information, not echo the current token back.
+    """
+
+    def __init__(self, cfg: SpikeWhaleConfig):
+        super().__init__()
+        self.num_heads = cfg.num_attention_heads
+        self.num_kv_heads = cfg.num_key_value_heads
+        self.head_dim = cfg.head_dim
+        self.qk_rope_head_dim = cfg.qk_rope_head_dim
+        self.nope_head_dim = cfg.nope_head_dim
+        self.hidden_size = cfg.hidden_size
+        self.use_derf = cfg.use_derf
+        self.use_xsa = cfg.use_xsa
+        self.dropout_p = cfg.attention_dropout
+        self.kv_groups = self.num_heads // self.num_kv_heads
+
+        # Low-rank Q projection (MLA)
+        self.q_a_proj = nn.Linear(cfg.hidden_size, cfg.q_lora_rank, bias=False)
+        self.q_a_norm = RMSNorm(cfg.q_lora_rank, cfg.rms_norm_eps)
+        self.q_b_proj = nn.Linear(cfg.q_lora_rank, self.num_heads * self.head_dim, bias=False)
+
+        # Direct K, V projections (MQA/GQA)
+        self.k_proj = nn.Linear(cfg.hidden_size, self.num_kv_heads * self.head_dim, bias=False)
+        self.v_proj = nn.Linear(cfg.hidden_size, self.num_kv_heads * self.head_dim, bias=False)
+
+        # Low-rank output projection (MLA)
+        self.o_a_proj = nn.Linear(self.num_heads * self.head_dim, cfg.o_lora_rank, bias=False)
+        self.o_b_proj = nn.Linear(cfg.o_lora_rank, cfg.hidden_size, bias=False)
+
+        # Partial RoPE: applied to qk_rope_head_dim dims only
+        self.rope = RotaryEmbedding(
+            self.qk_rope_head_dim,
+            max_positions=cfg.max_position_embeddings,
+            theta=cfg.rope_theta,
+        )
+
+        # DERF parameters: one per query head (My Project)
+        if self.use_derf:
+            self.derf_alpha = nn.Parameter(torch.ones(self.num_heads))
+            self.derf_bias = nn.Parameter(torch.zeros(self.num_heads))
+            self.derf_gamma = nn.Parameter(torch.ones(self.num_heads))
+
+        nn.init.normal_(self.q_a_proj.weight, std=cfg.initializer_range)
+        nn.init.normal_(self.q_b_proj.weight, std=cfg.initializer_range)
+        nn.init.normal_(self.k_proj.weight, std=cfg.initializer_range)
+        nn.init.normal_(self.v_proj.weight, std=cfg.initializer_range)
+        nn.init.normal_(self.o_a_proj.weight, std=cfg.initializer_range)
+        nn.init.normal_(self.o_b_proj.weight, std=cfg.initializer_range)
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        position_ids: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        past_key_value: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
+        use_cache: bool = False,
+    ) -> Tuple[torch.Tensor, Optional[Tuple[torch.Tensor, torch.Tensor]]]:
+        B, S, _ = x.shape
+
+        # Q via low-rank projection with intermediate norm (MLA)
+        q = self.q_a_norm(self.q_a_proj(x))
+        q = self.q_b_proj(q).view(B, S, self.num_heads, self.head_dim).transpose(1, 2)
+        # [B, num_heads, S, head_dim]
+
+        # K, V direct projections
+        k = self.k_proj(x).view(B, S, self.num_kv_heads, self.head_dim).transpose(1, 2)
+        v = self.v_proj(x).view(B, S, self.num_kv_heads, self.head_dim).transpose(1, 2)
+
+        # Partial RoPE: split into nope and rope partitions, rotate only the rope part
+        q_nope = q[..., :self.nope_head_dim]
+        q_rope = q[..., self.nope_head_dim:]     # qk_rope_head_dim dims
+        k_nope = k[..., :self.nope_head_dim]
+        k_rope = k[..., self.nope_head_dim:]
+
+        q_rope = self.rope(q_rope, position_ids)
+        k_rope = self.rope(k_rope, position_ids)
+
+        q = torch.cat([q_nope, q_rope], dim=-1)
+        k = torch.cat([k_nope, k_rope], dim=-1)
+
+        # KV cache for inference
+        if past_key_value is not None:
+            k = torch.cat([past_key_value[0], k], dim=2)
+            v = torch.cat([past_key_value[1], v], dim=2)
+        present = (k, v) if use_cache else None
+        N = k.shape[2]  # total key positions (past + current)
+
+        # Expand KV heads for MQA/GQA
+        if self.kv_groups > 1:
+            k = k.unsqueeze(2).expand(-1, -1, self.kv_groups, -1, -1).reshape(
+                B, self.num_heads, N, self.head_dim)
+            v = v.unsqueeze(2).expand(-1, -1, self.kv_groups, -1, -1).reshape(
+                B, self.num_heads, N, self.head_dim)
+
+        # Scaled dot-product attention.
+        if self.use_derf:
+            # DERF replaces softmax with a custom erf nonlinearity, so it cannot
+            # use the fused kernel and must materialize scores explicitly.
+            scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(self.head_dim)
+
+            # Build boolean mask for causality (this avoids the -inf math errors)
+            if attention_mask is None and past_key_value is None:
+                is_masked = torch.triu(torch.ones(S, N, dtype=torch.bool, device=scores.device), diagonal=N - S + 1).unsqueeze(0).unsqueeze(0)
+            else:
+                is_masked = (attention_mask < -1.0) if attention_mask is not None else torch.zeros_like(scores, dtype=torch.bool)
+
+            # FIX 2: Do NOT use float('-inf'). If alpha ever hits 0.0, 0.0 * -inf = NaN.
+            # Use a safe negative scalar (-10000.0) for masked positions.
+            safe_scores = scores.masked_fill(is_masked, -10000.0)
+
+            a = self.derf_alpha.view(1, -1, 1, 1)
+            b = self.derf_bias.view(1, -1, 1, 1)
+            g = self.derf_gamma.view(1, -1, 1, 1)
+
+            attn_weights = g * torch.erf(a * safe_scores + b)     # [-gamma, gamma]
+            attn_weights = (attn_weights + g) / 2.0               # shift to [0, gamma]
+            attn_weights = attn_weights.masked_fill(is_masked, 0.0)  # enforce causal mask safely
+            attn_weights = attn_weights / (attn_weights.sum(dim=-1, keepdim=True) + 1e-8)
+
+            if self.dropout_p > 0 and self.training:
+                attn_weights = F.dropout(attn_weights, p=self.dropout_p)
+
+            y = torch.matmul(attn_weights, v)   # [B, num_heads, S, head_dim]
+        else:
+            # OPTIMIZATION: standard (softmax) attention goes through the fused
+            # scaled_dot_product_attention kernel (FlashAttention / mem-efficient
+            # backends). This is the hot path during pretraining (use_derf=False)
+            # and is much faster + lower memory than materializing [B,H,S,N]
+            # scores and a softmax. SDPA already scales by 1/sqrt(head_dim).
+            #
+            # CONTIGUITY FIX: with MQA/GQA, k and v above are built via
+            # .unsqueeze(2).expand(...).reshape(...). Under torch.compile, inductor
+            # can trace the broadcasted (zero-stride) view through to the fused
+            # flash-attention BACKWARD kernel, whose meta-kernel then asserts on the
+            # mismatched stride (e.g. "stride 120==245760 at dim=1") and aborts.
+            # Forcing contiguity guarantees standard strides into the fused kernel.
+            q = q.contiguous()
+            k = k.contiguous()
+            v = v.contiguous()
+            drop = self.dropout_p if self.training else 0.0
+            if past_key_value is None and attention_mask is None:
+                # Prefill / training: pure causal mask, no materialization needed.
+                y = F.scaled_dot_product_attention(q, k, v, is_causal=True, dropout_p=drop)
+            else:
+                # Incremental decode or a provided mask: pass an explicit boolean
+                # keep-mask (True = attend). SDPA fills masked positions with -inf.
+                if attention_mask is not None:
+                    is_masked = (attention_mask < -1.0)
+                else:
+                    is_masked = torch.triu(
+                        torch.ones(S, N, dtype=torch.bool, device=q.device),
+                        diagonal=N - S + 1,
+                    ).unsqueeze(0).unsqueeze(0)
+                y = F.scaled_dot_product_attention(
+                    q, k, v, attn_mask=~is_masked, dropout_p=drop)
+
+        # XSA: remove self-projection from output (My Project)
+        # For each query position s, subtract the component of y[:,:,s,:] that
+        # projects onto the normalized value vector at the same position.
+        if self.use_xsa:
+            past_len = N - S
+            v_self = v[:, :, past_len:past_len + S, :]        # [B, H, S, D]
+            vn = v_self / (v_self.norm(dim=-1, keepdim=True) + 1e-8)
+            projection = (y * vn).sum(dim=-1, keepdim=True) * vn
+            y = y - projection
+
+        # Low-rank output projection (MLA)
+        y = y.transpose(1, 2).contiguous().view(B, S, self.num_heads * self.head_dim)
+        y = self.o_b_proj(self.o_a_proj(y))
+        return y, present
+
+
+# ---------------------------------------------------------------------------
+# MoE FFN: shared expert + sqrtsoftplus + hash routing  (NanoWhale) + aux loss (My Project)
+# ---------------------------------------------------------------------------
+
+class ExpertFFN(nn.Module):
+    """Single SwiGLU expert."""
+    def __init__(self, hidden_size: int, intermediate_size: int):
+        super().__init__()
+        self.gate_proj = nn.Linear(hidden_size, intermediate_size, bias=False)
+        self.up_proj = nn.Linear(hidden_size, intermediate_size, bias=False)
+        self.down_proj = nn.Linear(intermediate_size, hidden_size, bias=False)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.down_proj(F.silu(self.gate_proj(x)) * self.up_proj(x))
+
+
+def sqrtsoftplus(x: torch.Tensor) -> torch.Tensor:
+    """sqrt(softplus(x)) = sqrt(log(1+exp(x))). NanoWhale expert scoring."""
+    # FIX 1: Added 1e-8. If F.softplus(x) evaluates to 0.0, torch.sqrt(0) produces NaN gradients on backward pass.
+    return torch.sqrt(F.softplus(x) + 1e-8)
+
+
+class SparseMoEFFN(nn.Module):
+    """
+    Combines NanoWhale MoE structure with My Project aux loss:
+      - n_shared_experts always-active experts (NanoWhale)
+      - n_routed_experts sparse routed experts, top-k activation
+      - sqrtsoftplus scoring (NanoWhale) vs softmax
+      - hash routing for early layers (NanoWhale)
+      - norm_topk_prob + routed_scaling_factor (NanoWhale)
+      - load-balancing aux loss (My Project)
+    """
+    def __init__(self, cfg: SpikeWhaleConfig, layer_idx: int = 0):
+        super().__init__()
+        self.n_routed_experts = cfg.n_routed_experts
+        self.n_shared_experts = cfg.n_shared_experts
+        self.num_experts_per_tok = cfg.num_experts_per_tok
+        self.norm_topk_prob = cfg.norm_topk_prob
+        self.scoring_func = cfg.scoring_func
+        self.routed_scaling_factor = cfg.routed_scaling_factor
+        self.use_hash_routing = layer_idx < cfg.num_hash_layers
+        self.aux_loss_coef = cfg.moe_aux_loss_coef
+
+        self.router = nn.Linear(cfg.hidden_size, cfg.n_routed_experts, bias=False)
+        self.experts = nn.ModuleList([
+            ExpertFFN(cfg.hidden_size, cfg.moe_intermediate_size)
+            for _ in range(cfg.n_routed_experts)
+        ])
+        self.shared_experts = nn.ModuleList([
+            ExpertFFN(cfg.hidden_size, cfg.moe_intermediate_size)
+            for _ in range(cfg.n_shared_experts)
+        ]) if cfg.n_shared_experts > 0 else None
+
+        self._last_aux_loss: Optional[torch.Tensor] = None
+
+    def forward(self, x: torch.Tensor, position_ids: Optional[torch.Tensor] = None) -> torch.Tensor:
+        B, S, H = x.shape
+        x_flat = x.view(B * S, H)
+        T = B * S
+
+        # Shared experts: always active (NanoWhale)
+        shared_out = torch.zeros_like(x_flat)
+        if self.shared_experts:
+            for expert in self.shared_experts:
+                shared_out = shared_out + expert(x_flat)
+            if len(self.shared_experts) > 1:
+                shared_out = shared_out / len(self.shared_experts)
+
+        # Router
+        if self.use_hash_routing:
+            # Hash routing: deterministic assignment without learned router (NanoWhale).
+            # Assign each of the num_experts_per_tok slots a DISTINCT expert by cycling:
+            # token at absolute position p -> experts [p%n, (p+1)%n, ..., (p+k-1)%n].
+            #
+            # BUGFIX: the assignment must key off the token's ABSOLUTE sequence
+            # position, not torch.arange(T) (its index in the current flattened
+            # batch). With arange(T), incremental KV-cache decoding (S=1) always
+            # sees index 0 and routes every token to expert 0, so generation used
+            # a different expert assignment than training and silently diverged.
+            # Using position_ids makes prefill, full-sequence training, and
+            # step-by-step generation all agree. (For S divisible by n_experts,
+            # this matches the previous training-time behavior exactly, so existing
+            # checkpoints stay valid.)
+            if position_ids is not None:
+                base = (position_ids.reshape(T, 1) % self.n_routed_experts).long()
+            else:
+                base = (torch.arange(T, device=x.device) % self.n_routed_experts).unsqueeze(1)
+            offsets = torch.arange(self.num_experts_per_tok, device=x.device)      # [k]
+            top_k_indices = (base + offsets.unsqueeze(0)) % self.n_routed_experts   # [T, k]
+            top_k_weights = torch.ones(T, self.num_experts_per_tok, device=x.device) / self.num_experts_per_tok
+            self._last_aux_loss = None
+        else:
+            router_logits = self.router(x_flat)
+
+            if self.scoring_func == "sqrtsoftplus":
+                routing_scores = sqrtsoftplus(router_logits)
+            else:
+                routing_scores = F.softmax(router_logits, dim=-1)
+
+            top_k_scores, top_k_indices = torch.topk(routing_scores, self.num_experts_per_tok, dim=-1)
+
+            if self.norm_topk_prob:
+                top_k_weights = top_k_scores / (top_k_scores.sum(dim=-1, keepdim=True) + 1e-8)
+            else:
+                top_k_weights = top_k_scores
+            top_k_weights = top_k_weights * self.routed_scaling_factor
+
+            # Load-balancing aux loss (My Project)
+            softmax_probs = F.softmax(router_logits, dim=-1)
+            expert_mask = torch.zeros_like(softmax_probs)
+            expert_mask.scatter_(1, top_k_indices, 1.0)
+            f_e = expert_mask.mean(0)
+            p_e = softmax_probs.mean(0)
+            self._last_aux_loss = self.n_routed_experts * (f_e * p_e).sum() * self.aux_loss_coef
+
+        # Dispatch tokens to routed experts
+        out = torch.zeros_like(x_flat)
+        for expert_idx, expert in enumerate(self.experts):
+            token_mask = (top_k_indices == expert_idx).any(dim=-1)
+            if not token_mask.any():
+                continue
+            expert_input = x_flat[token_mask]
+            expert_output = expert(expert_input)
+            k_pos = (top_k_indices[token_mask] == expert_idx).nonzero(as_tuple=False)
+            weights = top_k_weights[token_mask][k_pos[:, 0], k_pos[:, 1]].unsqueeze(-1)
+            out[token_mask] = out[token_mask] + expert_output * weights
+
+        out = out + shared_out
+        return out.view(B, S, H)
+
+    def get_aux_loss(self) -> Optional[torch.Tensor]:
+        # Return None when hash routing (no aux loss) or when forward hasn't run yet.
+        # Returning torch.tensor(0.0) here would be a CPU tensor and cause a device
+        # mismatch when added to the CUDA total_aux_loss in SpikeWhaleModel.
+        return self._last_aux_loss
+
+
+class DenseFFN(nn.Module):
+    """Dense SwiGLU FFN for non-MoE layers."""
+    def __init__(self, cfg: SpikeWhaleConfig):
+        super().__init__()
+        self.gate_proj = nn.Linear(cfg.hidden_size, cfg.moe_intermediate_size, bias=False)
+        self.up_proj = nn.Linear(cfg.hidden_size, cfg.moe_intermediate_size, bias=False)
+        self.down_proj = nn.Linear(cfg.moe_intermediate_size, cfg.hidden_size, bias=False)
+
+    def forward(self, x: torch.Tensor, position_ids: Optional[torch.Tensor] = None) -> torch.Tensor:
+        return self.down_proj(F.silu(self.gate_proj(x)) * self.up_proj(x))
+
+    def get_aux_loss(self) -> Optional[torch.Tensor]:
+        return None  # dense layers have no aux loss; None avoids CPU-tensor device mismatch
+
+
+# ---------------------------------------------------------------------------
+# Transformer block with Hyper-Connections
+# ---------------------------------------------------------------------------
+
+class TransformerBlock(nn.Module):
+    """
+    Transformer block combining all features:
+      - Hyper-Connections: pre/post routing through hc_mult streams (NanoWhale)
+      - MLA + DERF + XSA attention (combined)
+      - MoE FFN with shared expert (NanoWhale) + aux loss (My Project)
+    """
+    def __init__(self, cfg: SpikeWhaleConfig, layer_idx: int):
+        super().__init__()
+        self.use_hc = cfg.use_hyper_connections
+        self.hidden_dropout = cfg.hidden_dropout
+
+        self.attn_norm = RMSNorm(cfg.hidden_size, cfg.rms_norm_eps)
+        self.attn = MLADerfXSAAttention(cfg)
+        self.ffn_norm = RMSNorm(cfg.hidden_size, cfg.rms_norm_eps)
+
+        if cfg.use_moe and layer_idx in cfg.moe_layers:
+            self.ffn = SparseMoEFFN(cfg, layer_idx)
+            self.is_moe = True
+        else:
+            self.ffn = DenseFFN(cfg)
+            self.is_moe = False
+
+        if self.use_hc:
+            self.hc_attn = HyperConnectionLayer(cfg.hidden_size, cfg.hc_mult,
+                                                cfg.hc_sinkhorn_iters, cfg.hc_eps)
+            self.hc_ffn = HyperConnectionLayer(cfg.hidden_size, cfg.hc_mult,
+                                               cfg.hc_sinkhorn_iters, cfg.hc_eps)
+
+    def forward(
+        self,
+        x: torch.Tensor,           # [B, hc_mult, S, H] if HC else [B, S, H]
+        position_ids: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        past_key_value: Optional[Tuple] = None,
+        use_cache: bool = False,
+    ) -> Tuple[torch.Tensor, Optional[Tuple], Optional[torch.Tensor]]:
+
+        # --- Attention sub-layer ---
+        if self.use_hc:
+            h = self.hc_attn.pre_op(x)     # [B, S, H]
+        else:
+            h = x
+
+        attn_out, present = self.attn(
+            self.attn_norm(h), position_ids, attention_mask, past_key_value, use_cache
+        )
+        attn_out = F.dropout(attn_out, p=self.hidden_dropout, training=self.training)
+
+        if self.use_hc:
+            x = self.hc_attn.post_op(x, attn_out)
+            h = self.hc_ffn.pre_op(x)      # [B, S, H]
+        else:
+            h = h + attn_out
+
+        # --- FFN sub-layer ---
+        ffn_out = self.ffn(self.ffn_norm(h), position_ids)
+        ffn_out = F.dropout(ffn_out, p=self.hidden_dropout, training=self.training)
+
+        if self.use_hc:
+            x = self.hc_ffn.post_op(x, ffn_out)
+        else:
+            x = h + ffn_out
+
+        return x, present, self.ffn.get_aux_loss()
+
+
+# ---------------------------------------------------------------------------
+# Full model
+# ---------------------------------------------------------------------------
+
+class HRMRefinementBlock(nn.Module):
+    """
+    HRM-INSPIRED iterative refinement (EXPERIMENTAL, off by default). NOT the full
+    Hierarchical Reasoning Model -- only the iterative-refinement mechanism that the
+    independent ARC-Prize ablation found carried most of HRM's benefit, adapted to a
+    causal LM's final hidden state.
+
+    Runs N inner steps; each computes a small gated update conditioned on the current
+    state AND the original ('anchor') input. Per-step gate inits at 0 and up.weight is
+    zero-init -> the block is an EXACT identity at init, so enabling it cannot hurt a
+    fresh model; it only contributes if training opens the gate. Pointwise over
+    positions -> causal-safe (no future-token leakage). In/out [B,S,H].
+    """
+    def __init__(self, hidden_size: int, refine_dim: int, steps: int, eps: float = 1e-6):
+        super().__init__()
+        self.steps = steps
+        self.norm = RMSNorm(hidden_size, eps)
+        self.down = nn.Linear(hidden_size * 2, refine_dim, bias=False)
+        self.up = nn.Linear(refine_dim, hidden_size, bias=False)
+        self.gate = nn.Parameter(torch.zeros(steps))
+        nn.init.normal_(self.down.weight, std=0.02)
+        nn.init.zeros_(self.up.weight)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        anchor = x
+        h = x
+        for t in range(self.steps):
+            inp = torch.cat([self.norm(h), anchor], dim=-1)
+            update = self.up(F.silu(self.down(inp)))
+            h = h + torch.tanh(self.gate[t]) * update
+        return h
+
+
+class LatentProjection(nn.Module):
+    """ModularMind-on-V2: pool final hidden state -> d_latent output vector.
+    Mirrors ModularMind's contract: mean-pool over sequence, ReLU^2 activation
+    (sparse latent codes), Xavier init (NOT zero) so the latent carries signal
+    from step 1 — zero-init would make the chain unable to bootstrap."""
+    def __init__(self, hidden_size: int, d_latent: int, eps: float = 1e-6):
+        super().__init__()
+        self.proj1 = nn.Linear(hidden_size, hidden_size, bias=False)
+        self.proj2 = nn.Linear(hidden_size, d_latent, bias=False)
+        self.norm = RMSNorm(d_latent, eps)
+        nn.init.xavier_uniform_(self.proj1.weight)
+        nn.init.xavier_uniform_(self.proj2.weight)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        pooled = x.mean(dim=1)                # [B, S, H] -> [B, H]
+        h = torch.relu(self.proj1(pooled)) ** 2
+        return self.norm(self.proj2(h))       # [B, d_latent]
+
+
+class LatentInjection(nn.Module):
+    """ModularMind-on-V2: fold an incoming d_latent vector into embeddings.
+    Broadcast across positions, ReGLU-gated add. Gate starts SMALL (not exactly
+    zero): the injection is near-identity at init (stable) while still passing a
+    little gradient, so the upstream RecursiveLink + specialist can bootstrap from
+    step 1. (Exact-zero gate would block all gradient to the link -- the
+    bootstrapping problem ModularMind's LatentProjection docstring warns about.)
+    This is the INPUT side of RecursiveLink (the prev specialist's latent)."""
+    def __init__(self, hidden_size: int, d_latent: int, eps: float = 1e-6,
+                 gate_init: float = 1e-3):
+        super().__init__()
+        self.up = nn.Linear(d_latent, hidden_size, bias=False)
+        self.norm = RMSNorm(hidden_size, eps)
+        self.value_proj = nn.Linear(hidden_size, hidden_size, bias=False)
+        self.gate_proj = nn.Linear(hidden_size, hidden_size, bias=False)
+        self.gate_init = gate_init
+        nn.init.xavier_uniform_(self.up.weight)
+        nn.init.xavier_uniform_(self.value_proj.weight)
+        nn.init.normal_(self.gate_proj.weight, std=gate_init)  # small, not zero
+
+    def forward(self, x: torch.Tensor, latent: torch.Tensor) -> torch.Tensor:
+        # x: [B, S, H], latent: [B, d_latent]
+        inj = self.norm(self.up(latent)).unsqueeze(1)   # [B, 1, H] broadcast over S
+        value = self.value_proj(inj)
+        gate = torch.relu(self.gate_proj(inj))
+        return x + value * gate
+
+
+class RecursiveLink(nn.Module):
+    """ModularMind cross-specialist bridge, V2 build. Converts one specialist's
+    output latent into the next specialist's input latent. ReGLU + residual,
+    single shared module reused for every hop. Fully differentiable."""
+    def __init__(self, d_latent: int = 256, expansion: float = 2.0):
+        super().__init__()
+        d_hidden = int(d_latent * expansion)
+        self.norm = nn.LayerNorm(d_latent)
+        self.value_proj = nn.Linear(d_latent, d_hidden, bias=False)
+        self.gate_proj = nn.Linear(d_latent, d_hidden, bias=False)
+        self.down = nn.Linear(d_hidden, d_latent, bias=False)
+        self.residual_gate = nn.Parameter(torch.ones(1))
+        nn.init.xavier_uniform_(self.value_proj.weight)
+        nn.init.xavier_uniform_(self.gate_proj.weight)
+        nn.init.xavier_uniform_(self.down.weight)
+
+    def forward(self, z: torch.Tensor) -> torch.Tensor:
+        n = self.norm(z)
+        h = self.value_proj(n) * torch.relu(self.gate_proj(n))
+        return z + self.residual_gate * self.down(h)
+
+
+class SpikeWhaleModel(nn.Module):
+    """Decoder stack without LM head."""
+
+    def __init__(self, cfg: SpikeWhaleConfig):
+        super().__init__()
+        self.cfg = cfg
+        self.embed_tokens = nn.Embedding(cfg.vocab_size, cfg.hidden_size)
+        nn.init.normal_(self.embed_tokens.weight, std=cfg.initializer_range)
+
+        self.engram = EngramModule(cfg) if cfg.use_engram else None
+        self.layers = nn.ModuleList([
+            TransformerBlock(cfg, layer_idx=i)
+            for i in range(cfg.num_hidden_layers)
+        ])
+        self.norm = RMSNorm(cfg.hidden_size, cfg.rms_norm_eps)
+        self.hrm_refine = (
+            HRMRefinementBlock(cfg.hidden_size, cfg.hrm_refine_dim,
+                               cfg.hrm_refine_steps, cfg.rms_norm_eps)
+            if getattr(cfg, "use_hrm_refine", False) else None
+        )
+        # ModularMind-on-V2: latent input/output (off unless use_latent_io)
+        if getattr(cfg, "use_latent_io", False):
+            self.latent_inject = LatentInjection(cfg.hidden_size, cfg.d_latent, cfg.rms_norm_eps)
+            self.latent_out = LatentProjection(cfg.hidden_size, cfg.d_latent, cfg.rms_norm_eps)
+        else:
+            self.latent_inject = None
+            self.latent_out = None
+        self.gradient_checkpointing = False
+
+    def reset_latent_gate(self):
+        """Re-init the injection gate SMALL (not zero). Must be called AFTER any HF
+        post_init/_init_weights pass, which otherwise re-randomizes the gate to full
+        scale. Small-but-nonzero keeps injection near-identity at start while letting
+        gradient reach the upstream RecursiveLink (so the chain can bootstrap)."""
+        if self.latent_inject is not None:
+            nn.init.normal_(self.latent_inject.gate_proj.weight,
+                            std=self.latent_inject.gate_init)
+
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.Tensor] = None,
+        past_key_values: Optional[List[Tuple]] = None,
+        use_cache: bool = False,
+        inject_latent: Optional[torch.Tensor] = None,
+    ) -> Tuple[torch.Tensor, Optional[List[Tuple]], torch.Tensor]:
+        B, S = input_ids.shape
+        device = input_ids.device
+
+        if position_ids is None:
+            past_len = past_key_values[0][0].shape[2] if past_key_values else 0
+            position_ids = torch.arange(
+                past_len, past_len + S, device=device
+            ).unsqueeze(0).expand(B, -1)
+
+        # Token embedding
+        x = self.embed_tokens(input_ids)    # [B, S, H]
+
+        # Engram N-gram delta (My Project)
+        if self.engram is not None:
+            x = x + self.engram(x)
+
+        # ModularMind-on-V2: inject the previous specialist's latent (broadcast
+        # across positions, ReGLU-gated). No-op at init (gate zero) and skipped
+        # entirely if no latent is passed.
+        if self.latent_inject is not None and inject_latent is not None:
+            x = self.latent_inject(x, inject_latent)
+
+        # Expand to hc_mult streams for Hyper-Connections (NanoWhale)
+        if self.cfg.use_hyper_connections:
+            x = x.unsqueeze(1).expand(-1, self.cfg.hc_mult, -1, -1).clone()
+            # [B, hc_mult, S, H]
+
+        present_key_values = [] if use_cache else None
+        total_aux_loss = torch.tensor(0.0, device=device)
+
+        for layer_idx, layer in enumerate(self.layers):
+            pkv = past_key_values[layer_idx] if past_key_values else None
+
+            if self.gradient_checkpointing and self.training:
+                # Gradient checkpointing with use_reentrant=False (NanoWhale)
+                x, present, aux_loss = gradient_checkpoint(
+                    layer, x, position_ids, attention_mask, None, False,
+                    use_reentrant=False,
+                )
+            else:
+                x, present, aux_loss = layer(x, position_ids, attention_mask, pkv, use_cache)
+
+            if use_cache:
+                present_key_values.append(present)
+            if aux_loss is not None:
+                total_aux_loss = total_aux_loss + aux_loss
+
+        # Reduce HC streams to single hidden state
+        if self.cfg.use_hyper_connections:
+            x = x.mean(dim=1)              # [B, S, H]
+
+        if self.hrm_refine is not None:
+            x = self.hrm_refine(x)
+
+        x = self.norm(x)
+
+        # ModularMind-on-V2: emit this specialist's output latent (for RecursiveLink).
+        out_latent = self.latent_out(x) if self.latent_out is not None else None
+        return x, present_key_values, total_aux_loss, out_latent
+
+
+class SpikeWhaleLM(PreTrainedModel):
+    """
+    Full causal LM combining all SpikeTransformer + NanoWhale features.
+
+    Training (forward with labels):
+        out = model(input_ids=ids, labels=ids)
+        loss = out.loss   # CE + MTP loss + MoE aux loss
+
+    Generation:
+        out = model(input_ids=ids, use_cache=True)
+        past = out.past_key_values
+        out2 = model(input_ids=next_id, past_key_values=past, use_cache=True)
+    """
+    config_class = SpikeWhaleConfig
+    base_model_prefix = "model"
+    supports_gradient_checkpointing = True
+    _no_split_modules = ["TransformerBlock"]
+
+    def __init__(self, cfg: SpikeWhaleConfig):
+        super().__init__(cfg)
+        self.model = SpikeWhaleModel(cfg)
+        self.lm_head = nn.Linear(cfg.hidden_size, cfg.vocab_size, bias=False)
+        nn.init.normal_(self.lm_head.weight, std=cfg.initializer_range)
+
+        if cfg.tie_word_embeddings:
+            self.lm_head.weight = self.model.embed_tokens.weight
+
+        # Multi-Token Prediction heads (NanoWhale): predict token at position+k
+        self.mtp_heads = nn.ModuleList([
+            nn.Linear(cfg.hidden_size, cfg.vocab_size, bias=False)
+            for _ in range(cfg.num_nextn_predict_layers)
+        ]) if cfg.num_nextn_predict_layers > 0 else None
+
+        self.post_init()
+        # HF post_init re-randomizes Linear weights, clobbering the zero-init
+        # injection gate. Restore it so the latent injection is identity-at-start.
+        self.model.reset_latent_gate()
+
+    def get_input_embeddings(self):
+        return self.model.embed_tokens
+
+    def set_input_embeddings(self, value):
+        self.model.embed_tokens = value
+
+    def get_output_embeddings(self):
+        return self.lm_head
+
+    def set_output_embeddings(self, new_embeddings):
+        self.lm_head = new_embeddings
+
+    def _set_gradient_checkpointing(self, module, value=False):
+        if isinstance(module, SpikeWhaleModel):
+            module.gradient_checkpointing = value
+
+    def forward(
+        self,
+        input_ids: Optional[torch.Tensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.Tensor] = None,
+        past_key_values: Optional[List[Tuple]] = None,
+        labels: Optional[torch.Tensor] = None,
+        use_cache: bool = False,
+        inject_latent: Optional[torch.Tensor] = None,
+        **kwargs,
+    ) -> CausalLMOutputWithPast:
+        hidden, present_kvs, aux_loss, out_latent = self.model(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            position_ids=position_ids,
+            past_key_values=past_key_values,
+            use_cache=use_cache,
+            inject_latent=inject_latent,
+        )
+
+        logits = self.lm_head(hidden)
+        loss = None
+
+        if labels is not None:
+            # Standard next-token CE loss (shifted by 1)
+            shift_logits = logits[..., :-1, :].contiguous()
+            shift_labels = labels[..., 1:].contiguous()
+            loss = F.cross_entropy(
+                shift_logits.view(-1, shift_logits.size(-1)),
+                shift_labels.view(-1),
+                ignore_index=-100,
+            )
+
+            # Multi-Token Prediction loss (NanoWhale)
+            # Each MTP head k predicts token at position + k+1 (beyond the standard +1)
+            if self.mtp_heads is not None:
+                mtp_total = torch.tensor(0.0, device=loss.device)
+                for k, head in enumerate(self.mtp_heads, start=1):
+                    offset = k + 1   # predicts position + offset
+                    if hidden.size(1) > offset:
+                        mtp_logits = head(hidden[..., :-offset, :].contiguous())
+                        mtp_labels = labels[..., offset:].contiguous()
+                        mtp_total = mtp_total + F.cross_entropy(
+                            mtp_logits.view(-1, mtp_logits.size(-1)),
+                            mtp_labels.view(-1),
+                            ignore_index=-100,
+                        )
+                loss = loss + mtp_total / max(len(self.mtp_heads), 1)
+
+            # MoE load-balancing aux loss (My Project)
+            loss = loss + aux_loss
+
+        out = CausalLMOutputWithPast(
+            loss=loss,
+            logits=logits,
+            past_key_values=present_kvs,
+        )
+        out.latent = out_latent   # ModularMind-on-V2: this specialist's output latent
+        return out
+
+    def count_parameters(self) -> int:
+        return sum(p.numel() for p in self.parameters())

agents/modmind/moe_gradio.py

@@ -0,0 +1,388 @@
+"""
+moe_gradio.py -- adapter that drives the agents/ Gradio MoE panel with the ModMind
+SpikeWhale specialists instead of the byte-level ByteGPT experts.
+
+It exposes the SAME public API as agents/orchestrator.py:
+    get_moe(device) -> obj with .available() .reload() .route() .shared_latent()
+                       .generate() .run()
+and .run() returns the SAME dict shape panel.py consumes:
+    {winner, weights, bits_per_byte, steps, generation, shared_latent}
+so agents/panel.py can use it as a drop-in backend (see the MM_MOE_BACKEND switch there).
+
+What this adapter handles (the real differences vs the byte-level experts):
+  * Each specialist has its OWN SpikeTokenizer (different vocab), so per-TOKEN NLL is
+    not comparable across experts. Routing is therefore by BITS-PER-BYTE -- total NLL
+    divided by the query's raw UTF-8 byte count -- which IS comparable across tokenizers.
+  * d_latent=256 (vs 64); the shared RecursiveLink is built at 256, and every ModMind
+    specialist already shares that width, so latent fusion works natively.
+  * Checkpoints are ModMind format ({"model_state": ...}) under
+    <MM_CKPT_ROOT or repo>/<domain>/checkpoints/step_*.pt, loaded exactly like
+    train_link.py does, and hot-reloaded when newer ones appear.
+
+Display mapping (ModMind domain -> the panel's expert slot/emoji):
+    language -> language (the panel shows 📖),  reasoning -> math (➗),  tool_use -> tool (🛠️)
+"""
+from __future__ import annotations
+
+import glob
+import math
+import os
+import random
+import string
+from pathlib import Path
+
+import torch
+import torch.nn.functional as F
+
+from model import RecursiveLink, SpikeWhaleLM
+from specialist_presets import specialist_config
+from spike_tokenizer import SpikeTokenizer
+
+HERE = Path(__file__).parent
+# checkpoints may live on a Modal Volume; tokenizers stay with the code (same rule as train_link.py)
+CKPT_ROOT = Path(os.environ.get("MM_CKPT_ROOT", str(HERE)))
+D_LATENT = 256
+MAX_CTX = 512   # cap prompt/scoring length so CPU routing + generation stay snappy
+
+# (modmind_domain, panel_slot). reasoning trains on FineMath, so it IS the "math" expert.
+SLOTS = [("language", "language"), ("reasoning", "math"), ("tool_use", "tool")]
+DOMAIN2SLOT = {d: s for d, s in SLOTS}
+# trained bridges to surface in the panel as (asker_domain, consultant_domain) "consult" demos
+LINKS = [("language", "reasoning")]
+KEY_CHARS = string.ascii_letters + string.digits   # must match train_link.py
+
+
+def _latest_ckpt(domain: str):
+    cks = sorted(glob.glob(str(CKPT_ROOT / domain / "checkpoints" / "step_*.pt")))
+    return cks[-1] if cks else None
+
+
+class SpikeWhaleMoE:
+    def __init__(self, device: str = "cpu"):
+        self.device = device
+        self.models, self.toks, self.steps, self._mtime = {}, {}, {}, {}
+        self.link = RecursiveLink(d_latent=D_LATENT).to(device).eval()
+        self.trained_link = None     # the TRAINED bridge (train_link.py output), for the consult demo
+        self.bridge_asker = None     # the FULL fine-tuned asker, for reproducible key-recall
+        self.link_meta = None
+        self.reload()
+
+    def reload(self):
+        """Load/refresh any specialist whose checkpoint exists or changed on disk."""
+        for domain, slot in SLOTS:
+            ck = _latest_ckpt(domain)
+            tok_path = HERE / domain / "tokenizer.json"
+            if ck is None or not tok_path.exists():
+                continue
+            mt = os.path.getmtime(ck)
+            if self._mtime.get(slot) == mt:
+                continue
+            cfg = specialist_config(domain)
+            m = SpikeWhaleLM(cfg).to(self.device).eval()
+            st = torch.load(ck, map_location=self.device, weights_only=False)
+            m.load_state_dict(st["model_state"])
+            self.models[slot] = m
+            self.toks[slot] = SpikeTokenizer(vocab_file=str(tok_path))
+            self.steps[slot] = int(st.get("step", 0))
+            self._mtime[slot] = mt
+        self._load_links()
+        return list(self.models)
+
+    def available(self):
+        return list(self.models)
+
+    def _load_links(self):
+        """Load a TRAINED RecursiveLink bridge (train_link.py output) from
+        links/<asker>__from__<consultant>.pt and overlay its bridge-trained injection path
+        onto the asker. The injection only fires when we pass inject_latent (the consult demo),
+        so normal routing/generation is unaffected."""
+        self.trained_link = None
+        self.bridge_asker = None
+        self.link_meta = None
+        for asker_domain, consultant_domain in LINKS:
+            a, c = DOMAIN2SLOT.get(asker_domain), DOMAIN2SLOT.get(consultant_domain)
+            if a not in self.models or c not in self.models:
+                continue
+            lp = CKPT_ROOT / "links" / f"{asker_domain}__from__{consultant_domain}.pt"
+            if not lp.exists():
+                continue
+            st = torch.load(lp, map_location=self.device, weights_only=False)
+            link = RecursiveLink(d_latent=D_LATENT).to(self.device).eval()
+            link.load_state_dict(st["link"])
+            try:
+                self.models[a].model.latent_inject.load_state_dict(st["asker_latent_inject"])
+            except Exception:
+                pass
+            # FULL fine-tuned asker, if this bridge was saved with the updated train_link.py.
+            # Without it we can show latent *influence* (consult) but not reproduce key-recall.
+            if "asker_state" in st:
+                ba = SpikeWhaleLM(specialist_config(asker_domain)).to(self.device).eval()
+                ba.load_state_dict(st["asker_state"])
+                self.bridge_asker = ba
+            self.trained_link = link
+            self.link_meta = {
+                "asker": a, "consultant": c,
+                "key_len": int(st.get("key_len", 6)), "prompt": st.get("prompt", "KEY> "),
+                "with_latent": float(st.get("with_latent", float("nan"))),
+                "without_latent": float(st.get("without_latent", float("nan"))),
+            }
+            return   # one bridge is enough for the panel demo
+
+    def key_recall_available(self):
+        return self.bridge_asker is not None and self.trained_link is not None
+
+    @torch.no_grad()
+    def key_recall(self, n: int = 8, ablate: bool = False):
+        """Reproduce the train_link.py forcing task with the FULL trained asker: a random key
+        is shown ONLY to the consultant; the asker must emit it from the latent alone.
+        Returns {acc, examples:[(key, recovered, ok)]}. ablate=True zeros the latent."""
+        if not self.key_recall_available():
+            return None
+        a, c = self.link_meta["asker"], self.link_meta["consultant"]
+        a_tok, c_tok = self.toks[a], self.toks[c]
+        key_len = self.link_meta.get("key_len", 6)
+        prompt = self.link_meta.get("prompt", "KEY> ")
+        plen = len(a_tok.encode(prompt, add_special_tokens=False))
+        keys = ["".join(random.choice(KEY_CHARS) for _ in range(key_len)) for _ in range(n)]
+        examples, correct = [], 0
+        for k in keys:
+            c_ids = torch.tensor([c_tok.encode(k, add_special_tokens=False)], device=self.device)
+            a_ids = torch.tensor([a_tok.encode(prompt, add_special_tokens=False)
+                                  + a_tok.encode(k, add_special_tokens=False)], device=self.device)
+            latent = self.models[c](input_ids=c_ids).latent
+            inj = torch.zeros_like(self.trained_link(latent)) if ablate else self.trained_link(latent)
+            logits = self.bridge_asker(input_ids=a_ids, inject_latent=inj).logits
+            pred = logits[:, plen - 1:plen - 1 + key_len, :].argmax(-1)[0]
+            out = a_tok.decode(pred.tolist())[:len(k)]
+            ok = (out == k)
+            correct += int(ok)
+            examples.append((k, out, ok))
+        return {"acc": correct / max(1, n), "examples": examples}
+
+    def consult_available(self):
+        return self.trained_link is not None
+
+    def consult_meta(self):
+        return dict(self.link_meta) if self.link_meta else None
+
+    @torch.no_grad()
+    def consult(self, query: str, max_new: int = 120, temperature: float = 0.8,
+                top_k: int = 40, ablate: bool = False):
+        """The asker generates while reading the consultant's latent through the TRAINED
+        RecursiveLink. ablate=True zeros the latent (the truth-test: output should lose the
+        consultant's influence)."""
+        if not self.consult_available():
+            return ""
+        a, c = self.link_meta["asker"], self.link_meta["consultant"]
+        latent = self.models[c](input_ids=self._ids(c, query)).latent      # [1, 256]
+        inj = self.trained_link(latent)
+        if ablate:
+            inj = torch.zeros_like(inj)
+        m, tok = self.models[a], self.toks[a]
+        ids = self._ids(a, query); start = ids.shape[1]
+        ctx_max = int(getattr(m.config, "max_position_embeddings", 2048))
+        for _ in range(max_new):
+            logits = m(input_ids=ids[:, -ctx_max:], inject_latent=inj).logits[:, -1, :] / max(1e-5, temperature)
+            if top_k:
+                v, _ = torch.topk(logits, min(top_k, logits.size(-1)))
+                logits[logits < v[:, [-1]]] = -float("inf")
+            nxt = torch.multinomial(F.softmax(logits, dim=-1), 1)
+            ids = torch.cat([ids, nxt], dim=1)
+            if tok.eos_token_id is not None and int(nxt.item()) == tok.eos_token_id:
+                break
+        return tok.decode(ids[0, start:].tolist())
+
+    def combine_available(self):
+        return "language" in self.models and "math" in self.models
+
+    @torch.no_grad()
+    def combine(self, query: str, max_new: int = 60, blend: float = 0.5,
+                temperature: float = 0.8, top_k: int = 40, consult: bool = False):
+        """Token-level MoE: blend BOTH specialists' next-token distributions every step.
+        Possible because they share the 16k tokenizer (same vocab). blend = weight on Math
+        (0 -> pure Language, 1 -> pure Math, 0.5 -> equal mix). consult=True also injects Math's
+        latent into Language through the trained RecursiveLink during the blend."""
+        if not self.combine_available():
+            return ""
+        lang, math_ = self.models["language"], self.models["math"]
+        tok = self.toks["language"]                 # shared tokenizer (identical for both)
+        ids = self._ids("language", query); start = ids.shape[1]
+        cl = int(getattr(lang.config, "max_position_embeddings", 2048))
+        cm = int(getattr(math_.config, "max_position_embeddings", 2048))
+        inj = None
+        if consult and self.trained_link is not None:
+            latent = math_(input_ids=self._ids("math", query)).latent
+            inj = self.trained_link(latent)
+        t = max(1e-5, temperature)
+        for _ in range(max_new):
+            pl = F.softmax(lang(input_ids=ids[:, -cl:], inject_latent=inj).logits[:, -1, :] / t, dim=-1)
+            pm = F.softmax(math_(input_ids=ids[:, -cm:]).logits[:, -1, :] / t, dim=-1)
+            probs = (1.0 - blend) * pl + blend * pm   # mixture of the two experts' distributions
+            if top_k:
+                v, _ = torch.topk(probs, min(top_k, probs.size(-1)))
+                probs = torch.where(probs < v[:, [-1]], torch.zeros_like(probs), probs)
+                probs = probs / probs.sum(dim=-1, keepdim=True)
+            nxt = torch.multinomial(probs, 1)
+            ids = torch.cat([ids, nxt], dim=1)
+            if tok.eos_token_id is not None and int(nxt.item()) == tok.eos_token_id:
+                break
+        return tok.decode(ids[0, start:].tolist())
+
+    def _ids(self, slot: str, text: str):
+        tok = self.toks[slot]
+        ids = tok.encode(text, add_special_tokens=False)[:MAX_CTX] or [tok.pad_token_id or 0]
+        return torch.tensor([ids], dtype=torch.long, device=self.device)
+
+    @torch.no_grad()
+    def _bits_per_byte(self, slot: str, text: str) -> float:
+        """Total next-token NLL of `text` under this specialist, per RAW UTF-8 byte.
+        Byte-normalisation makes the score comparable across the experts' different
+        tokenizers (a smaller vocab spends more tokens but each is cheaper)."""
+        nbytes = max(1, len(text.encode("utf-8")))
+        ids = self._ids(slot, text)
+        if ids.shape[1] < 2:
+            return float("inf")
+        logits = self.models[slot](input_ids=ids).logits
+        ce = F.cross_entropy(logits[:, :-1, :].reshape(-1, logits.size(-1)),
+                             ids[:, 1:].reshape(-1), reduction="sum")
+        return (ce.item() / math.log(2)) / nbytes
+
+    @torch.no_grad()
+    def route(self, query: str, temp: float = 0.5):
+        """Per-expert bits/byte + softmax routing weights + the winner (lowest bits/byte)."""
+        bits = {slot: self._bits_per_byte(slot, query) for slot in self.models}
+        names = list(bits)
+        logits = torch.tensor([-bits[n] / temp for n in names])
+        w = F.softmax(logits, dim=0).tolist()
+        weights = {n: round(wi, 3) for n, wi in zip(names, w)}
+        winner = min(bits, key=bits.get)
+        return winner, weights, {n: round(b, 3) for n, b in bits.items()}
+
+    @torch.no_grad()
+    def shared_latent(self, query: str):
+        """Each expert's output latent -> sum -> RecursiveLink -> one shared latent (the bus)."""
+        lats = {slot: self.models[slot](input_ids=self._ids(slot, query)).latent
+                for slot in self.models}
+        z = torch.stack([lats[s] for s in lats], 0).sum(0)   # [1, 256]
+        shared = self.link(z)[0]
+        return {s: lats[s][0].tolist() for s in lats}, shared.tolist()
+
+    @torch.no_grad()
+    def generate(self, query: str, expert: str | None = None, max_new: int = 160,
+                 temperature: float = 0.8, top_k: int = 40):
+        if expert is None:
+            expert, _, _ = self.route(query)
+        m, tok = self.models[expert], self.toks[expert]
+        ids = self._ids(expert, query)
+        start = ids.shape[1]
+        ctx_max = int(getattr(m.config, "max_position_embeddings", 2048))
+        for _ in range(max_new):
+            logits = m(input_ids=ids[:, -ctx_max:]).logits[:, -1, :] / max(1e-5, temperature)
+            if top_k:
+                v, _ = torch.topk(logits, min(top_k, logits.size(-1)))
+                logits[logits < v[:, [-1]]] = -float("inf")
+            nxt = torch.multinomial(F.softmax(logits, dim=-1), 1)
+            ids = torch.cat([ids, nxt], dim=1)
+            if tok.eos_token_id is not None and int(nxt.item()) == tok.eos_token_id:
+                break
+        return expert, tok.decode(ids[0, start:].tolist())
+
+    @torch.no_grad()
+    def run(self, query: str, max_new: int = 160, temperature: float = 0.8):
+        """Full pass: route -> fuse latents -> generate from the winner."""
+        if not self.models:
+            return {"error": "no experts trained yet"}
+        winner, weights, bits = self.route(query)
+        _, shared = self.shared_latent(query)
+        _, gen = self.generate(query, winner, max_new, temperature)
+        return {
+            "winner": winner, "weights": weights, "bits_per_byte": bits,
+            "steps": {n: self.steps.get(n, 0) for n in self.models},
+            "generation": gen, "shared_latent": [round(x, 3) for x in shared],
+        }
+
+    # ------------------------------------------------------------------ #
+    # WEIGHT-MERGE section (self-contained; does not touch anything above).
+    # Both specialists are the identical dense architecture, so their weights
+    # can be linearly merged into ONE model:  W = (1-alpha)*Language + alpha*Math.
+    # This is a real merged model (one forward pass), not an output ensemble.
+    # ------------------------------------------------------------------ #
+    def merge_available(self):
+        return "language" in self.models and "math" in self.models
+
+    def _merged_model(self, alpha: float):
+        """Build (and cache the most recent) single weight-merged model at ratio alpha."""
+        alpha = round(float(alpha), 2)
+        cache = getattr(self, "_merge_cache", None)
+        if cache is not None and abs(cache[0] - alpha) < 1e-6:
+            return cache[1]
+        lsd = self.models["language"].state_dict()
+        msd = self.models["math"].state_dict()
+        merged = {}
+        for k in lsd:
+            if lsd[k].is_floating_point():
+                merged[k] = ((1.0 - alpha) * lsd[k].float() + alpha * msd[k].float()).to(lsd[k].dtype)
+            else:
+                merged[k] = lsd[k].clone()      # integer/bool buffers: copy as-is
+        m = SpikeWhaleLM(specialist_config("language")).to(self.device).eval()
+        m.load_state_dict(merged)
+        # make it bridge-ready: re-load the bridge-trained injection weights straight from the
+        # link file (self-contained). The injection only fires when we pass inject_latent.
+        try:
+            lp = CKPT_ROOT / "links" / "language__from__reasoning.pt"
+            if lp.exists():
+                st = torch.load(lp, map_location=self.device, weights_only=False)
+                m.model.latent_inject.load_state_dict(st["asker_latent_inject"])
+        except Exception:
+            pass
+        self._merge_cache = (alpha, m)
+        return m
+
+    @torch.no_grad()
+    def merge_generate(self, query: str, alpha: float = 0.5, max_new: int = 60,
+                       temperature: float = 0.8, top_k: int = 40, consult: bool = False):
+        """Generate from the WEIGHT-MERGED single model. consult=True injects Math's latent
+        into the merged model through the trained RecursiveLink."""
+        if not self.merge_available():
+            return ""
+        m = self._merged_model(alpha)
+        tok = self.toks["language"]              # shared tokenizer
+        ids = self._ids("language", query); start = ids.shape[1]
+        ctx = int(getattr(m.config, "max_position_embeddings", 2048))
+        inj = None
+        if consult and getattr(self, "trained_link", None) is not None:
+            latent = self.models["math"](input_ids=self._ids("math", query)).latent
+            inj = self.trained_link(latent)
+        t = max(1e-5, temperature)
+        for _ in range(max_new):
+            logits = m(input_ids=ids[:, -ctx:], inject_latent=inj).logits[:, -1, :] / t
+            if top_k:
+                v, _ = torch.topk(logits, min(top_k, logits.size(-1)))
+                logits[logits < v[:, [-1]]] = -float("inf")
+            nxt = torch.multinomial(F.softmax(logits, dim=-1), 1)
+            ids = torch.cat([ids, nxt], dim=1)
+            if tok.eos_token_id is not None and int(nxt.item()) == tok.eos_token_id:
+                break
+        return tok.decode(ids[0, start:].tolist())
+
+
+_MOE = None
+
+
+def get_moe(device: str = "cpu"):
+    global _MOE
+    if _MOE is None:
+        _MOE = SpikeWhaleMoE(device=device)
+    else:
+        _MOE.reload()
+    return _MOE
+
+
+if __name__ == "__main__":
+    moe = get_moe()
+    print("experts:", moe.available() or "(none trained yet)")
+    if moe.available():
+        for q in ["The mitochondria is the", "Solve for x: 2x + 3 =", "Book a flight to"]:
+            r = moe.run(q, max_new=60)
+            print(f"\nQ: {q!r}\n  routed-> {r['winner']}  bits/byte {r['bits_per_byte']}  weights {r['weights']}")
+            print(f"  gen: {r['generation']!r}")

agents/modmind/registry.py

@@ -0,0 +1,44 @@
+"""
+registry.py -- the SINGLE SOURCE OF TRUTH for specialists.
+
+To add a new specialist later, add ONE entry here, then:
+    python train_tokenizer.py  --domains <name>
+    python train_specialist.py --domain  <name> --muon --normuon --dean-schedule --compile
+    python train_link.py       --asker language --consultant <name>   # so it can be consulted
+
+Every other script (tokenizer, data prep, model sizing, link trainer) reads from
+here, so nothing else needs editing. `position` is the chain slot (context-doubling
+/ chain ordering in the V2 config); give each new specialist the next index.
+"""
+
+# vocab=16384: the shared length-max tokenizer (covers prose + math; all 256 bytes). Both
+# active specialists use the SAME tokenizer -> identical vocab makes routing directly comparable.
+# PURE specialization (language=100% FineWeb-Edu, reasoning=100% FineMath) -> crisp routing.
+SPECIALISTS = {
+    "language":  dict(dataset="HuggingFaceFW/fineweb-edu", config="sample-100BT",
+                      field="text", vocab=16384, position=0),
+    "reasoning": dict(dataset="HuggingFaceTB/finemath", config="finemath-3plus",
+                      field="text", vocab=16384, position=1),
+    # dormant -- not in ACTIVE; ignore for now (no tool calling this round)
+    "tool_use":  dict(dataset="glaiveai/glaive-function-calling-v2", config=None,
+                      field=("system", "chat"), vocab=16384, position=2),
+}
+
+# which specialists you are actively training right now (the "foundation" set).
+ACTIVE = ["language", "reasoning"]
+
+
+def spec(name):
+    if name not in SPECIALISTS:
+        raise KeyError(f"unknown specialist {name!r}; add it to registry.SPECIALISTS. "
+                       f"known: {list(SPECIALISTS)}")
+    return SPECIALISTS[name]
+
+
+def text_of(name_or_spec, ex):
+    """Extract the training text from a streamed example (handles multi-field specs)."""
+    s = name_or_spec if isinstance(name_or_spec, dict) else spec(name_or_spec)
+    f = s["field"]
+    if isinstance(f, (tuple, list)):
+        return "\n".join(str(ex.get(k, "") or "") for k in f)
+    return ex.get(f, "") or ""

agents/modmind/specialist_presets.py

@@ -0,0 +1,69 @@
+"""
+specialist_presets.py -- ModularMind-on-V2 specialist sizing.
+
+DENSE ~80M specialists (Supra-50M-style, scaled up): a dense Llama-ish transformer with
+NO MoE / Engram / Hyper-Connections / HRM, so the parameters go into language modeling
+instead of machinery -> coherent generation (the lesson from SupraLabs/Supra-50M-Base,
+a dense model that produces coherent multi-paragraph text on FineWeb-Edu).
+
+Shape (shared across domains; only the vocab differs, read from registry.py):
+  hidden 640, 16 layers, 10 heads / 5 KV (GQA), dense FFN 1728, ctx 1024, d_latent 256.
+  -> ~81.5M params at vocab 16384 (the shared length-max tokenizer).
+
+The bridge bus (d_latent=256) and latent IO are kept, so train_link.py / the Gradio
+adapter still work after retraining.
+"""
+from config import SpikeWhaleConfig
+from registry import spec
+
+
+def _dense_80m(vocab_size: int) -> SpikeWhaleConfig:
+    """A dense ~80M specialist for the given vocab."""
+    return SpikeWhaleConfig(
+        vocab_size=vocab_size,
+        hidden_size=640,
+        num_hidden_layers=16,
+        num_attention_heads=10,
+        num_key_value_heads=5,          # GQA
+        head_dim=64,
+        qk_rope_head_dim=16,
+        q_lora_rank=320,
+        o_lora_rank=160,
+        tie_word_embeddings=True,
+        # DENSE: no MoE. moe_intermediate_size still sizes the DenseFFN (model.py).
+        use_moe=False,
+        moe_intermediate_size=1728,
+        # strip the heavy extras -> params go to the LM, not machinery
+        use_engram=False,
+        use_hyper_connections=False,
+        hc_mult=1,
+        use_hrm_refine=False,
+        num_nextn_predict_layers=0,
+        use_derf=False,
+        use_xsa=True,
+        # keep the ModularMind bridge bus so train_link.py / the adapter still work
+        use_latent_io=True,
+        d_latent=256,
+        # uniform 1024 context (Supra used 1024). base_context MUST be >= training --seq-len.
+        chain_position=0,
+        base_context=4096,
+        base_rope_theta=10000.0,
+    )
+
+
+def specialist_config(domain: str = "language", position: int = 0) -> SpikeWhaleConfig:
+    """A dense ~80M specialist; vocab comes from registry.py (single source of truth)."""
+    return _dense_80m(spec(domain)["vocab"])
+
+
+def generic_specialist_config(vocab_size: int, position: int = 0) -> SpikeWhaleConfig:
+    """Same dense ~80M shape for an arbitrary vocab (new domains 'just work')."""
+    return _dense_80m(vocab_size)
+
+
+# Foundation chain ordering (derived from the registry, so it grows automatically)
+try:
+    from registry import SPECIALISTS as _REG
+    FOUNDATION_ORDER = {v["position"]: k for k, v in _REG.items()}
+except Exception:
+    FOUNDATION_ORDER = {0: "language", 1: "reasoning", 2: "tool_use"}

agents/modmind/spike_tokenizer.py

@@ -0,0 +1,82 @@
+"""
+spike_tokenizer.py -- HuggingFace-compatible wrapper for the custom
+byte-level "length-max" (greedy longest-match) tokenizer in tokenizer.json.
+
+The raw tokenizer.json is NOT a HuggingFace `tokenizers` file; it is a plain
+dict {vocab, vocab_size, max_token_len, algorithm:"length-max"}. This wrapper
+makes it loadable by AutoTokenizer.from_pretrained / save_pretrained and
+exposes encode/decode + the bos/eos/pad/unk ids the training scripts expect.
+
+Encoding scheme (verified): byte-level. Text is UTF-8 encoded, each byte mapped
+to its latin-1 character, then greedily matched against the vocab using the
+longest key that matches at each position (max key length = max_token_len).
+"""
+import json, os
+from typing import List, Optional
+from transformers import PreTrainedTokenizer
+
+
+class SpikeTokenizer(PreTrainedTokenizer):
+    vocab_files_names = {"vocab_file": "tokenizer.json"}
+    model_input_names = ["input_ids"]
+
+    def __init__(self, vocab_file=None, **kwargs):
+        with open(vocab_file, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        self._vocab = data["vocab"]                       # str -> id
+        self._ids_to_tokens = {i: t for t, i in self._vocab.items()}
+        self.max_token_len = int(data.get("max_token_len", 24))
+        # length-bucketed keys for fast greedy match (longest length first)
+        self._lengths = sorted({len(k) for k in self._vocab}, reverse=True)
+
+        kwargs.setdefault("bos_token", "<bos>")
+        kwargs.setdefault("eos_token", "<eos>")
+        kwargs.setdefault("unk_token", "<unk>")
+        kwargs.setdefault("pad_token", "<pad>")
+        super().__init__(**kwargs)
+
+    @property
+    def vocab_size(self) -> int:
+        return len(self._vocab)
+
+    def get_vocab(self):
+        return dict(self._vocab)
+
+    # --- core byte-level greedy tokenization ---
+    def _tokenize(self, text: str) -> List[str]:
+        s = text.encode("utf-8").decode("latin-1")  # one char per byte
+        out, i, n = [], 0, len(s)
+        while i < n:
+            matched = None
+            hi = min(self.max_token_len, n - i)
+            for L in range(hi, 0, -1):
+                sub = s[i:i + L]
+                if sub in self._vocab:
+                    matched = sub
+                    break
+            if matched is None:           # single byte always exists in vocab
+                matched = s[i]
+            out.append(matched)
+            i += len(matched)
+        return out
+
+    def _convert_token_to_id(self, token: str) -> int:
+        return self._vocab.get(token, self._vocab["<unk>"])
+
+    def _convert_id_to_token(self, index: int) -> str:
+        return self._ids_to_tokens.get(index, "<unk>")
+
+    def convert_tokens_to_string(self, tokens: List[str]) -> str:
+        specials = {"<pad>", "<unk>", "<bos>", "<eos>"}
+        byte_str = "".join(t for t in tokens if t not in specials)
+        return byte_str.encode("latin-1").decode("utf-8", errors="replace")
+
+    def save_vocabulary(self, save_directory: str, filename_prefix: Optional[str] = None):
+        os.makedirs(save_directory, exist_ok=True)
+        fn = (filename_prefix + "-" if filename_prefix else "") + "tokenizer.json"
+        path = os.path.join(save_directory, fn)
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump({"vocab": self._vocab, "vocab_size": self.vocab_size,
+                       "max_token_len": self.max_token_len,
+                       "algorithm": "length-max"}, f, ensure_ascii=False)
+        return (path,)

agents/panel.py

@@ -0,0 +1,292 @@
+"""
+panel.py -- the Gradio section for the bottom of the boss app: a live demo of the
+Modular-Mind mixture-of-experts.
+
+For the SpikeWhale backend it leads with the *latent bridge* (the real result) and
+organizes the three demos into tabs. Every handler is a generator that yields an
+instant "loading/generating" message first, so the first run never looks frozen while
+the ~80M models lazy-load. Hot-reloads checkpoints.
+"""
+from __future__ import annotations
+
+import os
+import sys
+
+import gradio as gr
+
+EMOJI = {"language": "📖 Language", "math": "➗ Math", "tool": "🛠️ Tool-use"}
+DEVICE = os.environ.get("MM_AGENTS_DEVICE", "cpu")
+# Self-contained SpikeWhale bundle that ships next to this file (agents/modmind/: the 80M
+# specialists + bridge + inference code). If it's present we default to the SpikeWhale backend
+# so the HuggingFace Space "just works" with no env config. Env vars still override.
+_BUNDLED_MODMIND = os.path.join(os.path.dirname(os.path.abspath(__file__)), "modmind")
+_DEFAULT_BACKEND = "spikewhale" if os.path.isdir(_BUNDLED_MODMIND) else "bytegpt"
+_SPIKEWHALE = os.environ.get("MM_MOE_BACKEND", _DEFAULT_BACKEND).lower() in ("spikewhale", "modmind")
+_WARMED = {"done": False}   # so the "loading the models" notice only shows on the first run
+
+_FOOTER = (
+    "Two ~80M dense specialists — 📖 Language (FineWeb-Edu) and ➗ Math (FineMath) — sharing a "
+    "16k length-max tokenizer. A coordinator routes by bits-per-byte, and a trained RecursiveLink "
+    "lets them communicate in latent space (proven in the Bridge tab). Hot-reloads checkpoints."
+    if _SPIKEWHALE else
+    "Three byte-level ~10M specialists, streamed-trained on FineWeb-Edu / FineMath / "
+    "glaive-function-calling. Tiny + early-trained, so generations are rough — the routing "
+    "(which expert is most confident) is the point. It hot-reloads as training continues."
+)
+
+
+def _get_moe():
+    """Pick the MoE backend. Defaults to the bundled SpikeWhale 80M specialists
+    (agents/modmind/) when present, else the byte-level ByteGPT experts. MM_MOE_BACKEND
+    and MODMIND_DIR override."""
+    backend = os.environ.get("MM_MOE_BACKEND", _DEFAULT_BACKEND).lower()
+    if backend in ("spikewhale", "modmind"):
+        mm_dir = os.environ.get("MODMIND_DIR", _BUNDLED_MODMIND)
+        if mm_dir and mm_dir not in sys.path:
+            sys.path.insert(0, mm_dir)   # front: ModMind's model.py wins over agents/model.py
+        from moe_gradio import get_moe
+        return get_moe
+    from orchestrator import get_moe
+    return get_moe
+
+
+def _loading_notice(action="Generating"):
+    """First-run popup + in-place message so nothing ever looks frozen."""
+    if not _WARMED["done"]:
+        gr.Info("First run — loading the models (~20–40s on CPU). After this, it's quick.")
+        return (f"### ⏳ Loading the models + {action.lower()}…\n"
+                "*First run loads the ~80M specialists into memory — this can take ~20–40s on CPU. "
+                "Every run after this is fast.*")
+    return f"### ⏳ {action}…"
+
+
+def _bar(frac, n=18):
+    f = max(0.0, min(1.0, frac))
+    return "█" * round(f * n) + "·" * (n - round(f * n))
+
+
+def moe_run(query, max_new):
+    yield _loading_notice("Routing & generating")
+    moe = _get_moe()(DEVICE)
+    if not moe.available():
+        if _SPIKEWHALE:
+            yield ("### ⏳ No SpikeWhale experts found\nSet `MODMIND_DIR` to your ModMind folder "
+                   "and make sure `<domain>/checkpoints/step_*.pt` exist (the panel hot-reloads them).")
+        else:
+            yield ("### ⏳ No experts trained yet\nRun `python agents/train.py --expert language` "
+                   "(and `math`, `tool`).")
+        return
+    q = (query or "").strip() or "The"
+    r = moe.run(q, max_new=int(max_new))
+    _WARMED["done"] = True
+    w = r["weights"]; bits = r["bits_per_byte"]; steps = r["steps"]
+    rows = "\n".join(
+        f"| {EMOJI.get(n, n)} | {steps.get(n,0):,} | {bits[n]:.2f} | `{_bar(w[n])}` {w[n]*100:4.1f}% |"
+        + ("  ⬅ **routed**" if n == r["winner"] else "")
+        for n in w
+    )
+    lat = r["shared_latent"][:16]
+    spark = "".join("▁▂▃▄▅▆▇█"[min(7, int((abs(v)) / (max(1e-3, max(abs(x) for x in lat))) * 7))] for v in lat)
+    yield f"""### Routed to {EMOJI.get(r['winner'], r['winner'])}
+The expert with the **lowest bits/byte** (most fluent on your text) wins the route.
+
+| expert | train steps | bits/byte | routing weight |
+|---|---|---|---|
+{rows}
+
+**{EMOJI.get(r['winner'], r['winner'])} continues your prompt:**
+> {q}**{r['generation']}**
+
+**Fused latent** (both experts' output latents combined — a glimpse of the shared bus): `{spark}`
+
+<sub>{_FOOTER}</sub>"""
+
+
+def moe_key_recall(n):
+    """THE PROOF: a random key shown only to the consultant; the asker reproduces it from the
+    latent alone (with) vs ablated (without)."""
+    yield _loading_notice("Running the proof")
+    moe = _get_moe()(DEVICE)
+    if not getattr(moe, "key_recall_available", lambda: False)():
+        yield ("### 🔑 Bridge unavailable\nNeeds the **SpikeWhale** backend and a trained "
+               "`links/<asker>__from__<consultant>.pt` saved with the full asker.")
+        return
+    meta = moe.consult_meta()
+    a = EMOJI.get(meta["asker"], meta["asker"]); c = EMOJI.get(meta["consultant"], meta["consultant"])
+    wr = moe.key_recall(n=int(n), ablate=False)
+    ar = moe.key_recall(n=int(n), ablate=True)
+    _WARMED["done"] = True
+    rows = "\n".join(f"| `{k}` | `{rec}` | {'✅' if ok else '❌'} |" for k, rec, ok in wr["examples"])
+    return_ok = wr['acc'] * 100
+    return_no = ar['acc'] * 100
+    yield f"""### 🔑 {a} read {c}'s mind — {return_ok:.0f}% with the latent, {return_no:.0f}% without
+
+A random key is shown **only to {c}**. {a} never sees it — yet by reading {c}'s latent through the
+trained RecursiveLink, it reproduces the key:
+
+| secret key (only {c} saw it) | {a} recovered it | |
+|---|---|---|
+{rows}
+
+## ✅ With the latent: {return_ok:.0f}%  →  ❌ Cut the latent: {return_no:.0f}%
+
+<sub>That collapse to chance when the latent is removed is the whole point: the information is genuinely
+crossing the latent bridge between two models that were trained **separately, on different data**.
+This is the result — routing and generation are the supporting act.</sub>"""
+
+
+def moe_consult(query, max_new):
+    """Latent-influence demo: inject the consultant's latent into the asker (WITH vs WITHOUT).
+    The bridge was trained on key-recall, so the latent *steers* the output rather than answering."""
+    yield _loading_notice("Injecting latent")
+    moe = _get_moe()(DEVICE)
+    if not getattr(moe, "consult_available", lambda: False)():
+        yield ("### 🔗 Latent bridge unavailable\nNeeds the **SpikeWhale** backend and a trained bridge.")
+        return
+    q = (query or "").strip() or "natural selection"
+    meta = moe.consult_meta()
+    a = EMOJI.get(meta["asker"], meta["asker"]); c = EMOJI.get(meta["consultant"], meta["consultant"])
+    with_gen = moe.consult(q, max_new=int(max_new), ablate=False)
+    abl_gen = moe.consult(q, max_new=int(max_new), ablate=True)
+    _WARMED["done"] = True
+    wl, nl = meta["with_latent"], meta["without_latent"]
+    yield f"""### 🔗 Latent influence — {c}'s latent injected into {a}
+
+**WITH {c}'s latent (through the trained RecursiveLink):**
+> {q}**{with_gen}**
+
+**WITHOUT it (latent ablated to zero):**
+> {q}**{abl_gen}**
+
+<sub>This shows the latent's raw *effect* on generation, not a Q&A answer. The bridge was trained on
+key-recall (ablation with={wl:.3f} vs without={nl:.4f}), so the injected latent pushes the asker toward
+that learned behavior — which is why WITH and WITHOUT differ so sharply. The clean proof the latent
+carries real information is the **Bridge** tab.</sub>"""
+
+
+def moe_combine(query, max_new, blend, consult):
+    """Two blends compared at the same mix ratio: a real WEIGHT-MERGE (one merged model) vs an
+    OUTPUT-BLEND (two models run separately, distributions averaged)."""
+    yield _loading_notice("Building merge + blending")
+    moe = _get_moe()(DEVICE)
+    if not getattr(moe, "merge_available", lambda: False)():
+        yield "### 🧬 Needs both specialists loaded."
+        return
+    q = (query or "").strip() or "The water cycle works by"
+    a = float(blend)
+    merged_gen = moe.merge_generate(q, alpha=a, max_new=int(max_new), consult=bool(consult))
+    blend_gen = moe.combine(q, max_new=int(max_new), blend=a, consult=bool(consult))
+    _WARMED["done"] = True
+    mix = f"{int(round((1-a)*100))}% 📖 Language / {int(round(a*100))}% ➗ Math"
+    extra = "  ·  +Reasoning's latent (consult)" if consult else ""
+    yield f"""### 🧬 MoE Modular Minds — two ways to blend  ·  {mix}{extra}
+
+**① Weight merge** — a *single* model whose weights are `(1-α)·Language + α·Math` — one network, one forward pass:
+> {q}**{merged_gen}**
+
+**② Output blend** — both models run separately, their next-token distributions averaged each step:
+> {q}**{blend_gen}**
+
+<sub>Same mix ratio, two different mechanisms. **Weight merge** fuses the actual parameters into one model
+(only possible because they're the identical dense architecture); **output blend** is an inference-time
+ensemble of two separate models (only possible because they share the 16k tokenizer). Tick *consult* to also
+route Reasoning's latent into each through the trained bridge. Exploratory — generations are rough at this scale.</sub>"""
+
+
+HERO = """# 🧩 Modular Mind — two specialists that talk in latent space
+**Two ~80M models trained completely separately** — 📖 **Language** on FineWeb-Edu, ➗ **Math** on
+FineMath — that never saw each other's data. A coordinator **routes** your query to the right one,
+and a trained **RecursiveLink** lets them **communicate through latent space**: Language can read
+information straight out of Math's "mind." The **🔑 Bridge** tab proves it.
+
+> ℹ️ *These specialists were trained only to demonstrate a **verifiable result** — clean routing and a
+> provable latent-bridge ablation — **not** for production-quality output. The generated text is
+> intentionally rough at this scale; the mechanism is the point.*"""
+
+BRIDGE_INTRO = """### The proof: two independent models, one latent channel
+A random secret key is shown **only to ➗ Math**. 📖 Language never sees it — but by reading Math's
+latent through the trained RecursiveLink, it **reproduces the key**. Zero out the latent and it
+collapses to chance. That gap *is* the result: real information crossing between two models that
+were trained on different data and never met. **Hit the button.**"""
+
+INTRO_BYTE = """## 🧩 Experiment — Modular Mind as a Mixture of Experts
+Three tiny ~10M byte-level specialists (language, math, tool-use), each streamed-trained on its own
+dataset. A coordinator **routes** your query to whichever expert is most fluent (perplexity-based MoE)
+and fuses their latents through a **RecursiveLink**. Try a math problem vs. a sentence."""
+
+
+def _routing_block():
+    with gr.Row():
+        q = gr.Textbox(label="Your prompt", value="Solve for x: 2x + 3 = 11",
+                       scale=4, placeholder="a sentence or a math problem…")
+        n = gr.Slider(40, 300, value=80, step=20, label="generate tokens", scale=1)
+    btn = gr.Button("🧭 Route & generate", variant="primary")
+    out = gr.Markdown()
+    btn.click(moe_run, [q, n], out)
+    gr.Examples(examples=[["The theory of evolution explains", 80],
+                          ["Compute the derivative of x^2 + 3x", 80],
+                          ["The history of the Roman Empire began", 80]],
+                inputs=[q, n])
+
+
+def build_moe_panel():
+    """Create the MoE demo components inside the current gr.Blocks context."""
+    if not _SPIKEWHALE:
+        with gr.Accordion("🧩 Experiment: Modular Mind = Mixture of Experts (3 specialists)", open=False):
+            gr.Markdown(INTRO_BYTE)
+            _routing_block()
+        return
+
+    with gr.Accordion("🧩 Modular Mind — independent specialists communicating in latent space", open=True):
+        gr.Markdown(HERO)
+        with gr.Tabs():
+            # The headline result, FIRST.
+            with gr.Tab("🔑 The latent bridge — the proof"):
+                gr.Markdown(BRIDGE_INTRO)
+                with gr.Row():
+                    kn = gr.Slider(4, 16, value=8, step=1, label="keys to test", scale=3)
+                    kbtn = gr.Button("🔑 Run the proof", variant="primary", scale=1)
+                kout = gr.Markdown()
+                kbtn.click(moe_key_recall, [kn], kout)
+
+            # Routing — the supporting act.
+            with gr.Tab("🧭 Routing & generation"):
+                gr.Markdown("Type a math problem vs. a sentence and watch the **route flip** — each "
+                            "expert is most fluent (lowest bits/byte) on its own domain.")
+                _routing_block()
+
+            # Latent influence — honest "with vs without".
+            with gr.Tab("🔗 Latent influence"):
+                gr.Markdown(
+                    "Inject ➗ Math's latent into 📖 Language through the **trained RecursiveLink** and "
+                    "see generation **with vs without** it. The bridge was trained on key-recall, so the "
+                    "latent *steers* the output (it doesn't answer the question) — the point is how "
+                    "strongly it changes generation. The clean proof is the **Bridge** tab.")
+                with gr.Row():
+                    cq = gr.Textbox(label="Text to encode (Math's latent → injected into Language)",
+                                    value="natural selection", scale=4)
+                    cn = gr.Slider(40, 200, value=80, step=20, label="generate tokens", scale=1)
+                cbtn = gr.Button("🔗 Show latent influence (with vs without)", variant="secondary")
+                cout = gr.Markdown()
+                cbtn.click(moe_consult, [cq, cn], cout)
+
+            # MoE Modular Minds — TWO ways to blend the specialists, compared side by side.
+            with gr.Tab("🧬 MoE Modular Minds"):
+                gr.Markdown(
+                    "**Two ways to blend the two specialists**, shown side by side at the same mix ratio:\n"
+                    "- **① Weight merge** — fuse the *parameters* into one model `(1-α)·Language + α·Math` "
+                    "(works because they're the identical dense architecture).\n"
+                    "- **② Output blend** — run both models separately and average their next-token "
+                    "distributions (works because they share the 16k tokenizer).\n\n"
+                    "Slide the mix, and tick *consult* to also route Reasoning's latent into each through the "
+                    "trained bridge.")
+                with gr.Row():
+                    mq = gr.Textbox(label="Prompt", value="The water cycle works by", scale=4)
+                    mn = gr.Slider(40, 160, value=70, step=10, label="generate tokens", scale=1)
+                with gr.Row():
+                    mblend = gr.Slider(0.0, 1.0, value=0.5, step=0.1,
+                                       label="mix α:  0 = 📖 Language   ⟷   1 = ➗ Math", scale=3)
+                    mconsult = gr.Checkbox(value=False, label="consult (inject Reasoning's latent)", scale=1)
+                mbtn = gr.Button("🧬 Blend both ways (weight-merge vs output-blend)", variant="primary")
+                mout = gr.Markdown()
+                mbtn.click(moe_combine, [mq, mn, mblend, mconsult], mout)

app.py

@@ -0,0 +1,535 @@
+"""
+app.py -- Modular Mind: Boss Fight (HuggingFace Space entry point).
+
+A 2D Dark-Souls-style duel. The boss (Demon Slime) is driven by a tiny Modular
+Mind: six specialist networks emit latents that a RecursiveLink merges into one
+shared latent, and a coordinator reads it to pick the boss's next move. The brain
+was trained by self-play reinforcement learning (see train.py / duel_sim.py).
+
+The browser renders the fight at 60fps; at each decision point it calls the Python
+brain through this app's /decide endpoint and shows the Modular Mind deciding live.
+"""
+import json
+import os
+import sys
+from urllib.parse import quote
+
+import gradio as gr
+
+import modular_mind
+import online
+
+# the MoE-experts experiment lives in ./agents (added to the bottom of the page)
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "agents"))
+try:
+    from panel import build_moe_panel
+except Exception as _e:  # agents optional -> game still runs without it
+    build_moe_panel = None
+    print(f"[app] MoE experiment panel unavailable ({_e})")
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+
+# the self-playing piano (a Modular Mind trained on a song) lives in ./piano
+sys.path.insert(0, os.path.join(HERE, "piano"))
+_PIANO = {"player": None, "tried": False}
+
+
+def _get_piano():
+    if not _PIANO["tried"]:
+        _PIANO["tried"] = True
+        try:
+            from poly_mind import PolyPlayer
+            _PIANO["player"] = PolyPlayer()
+        except Exception as e:
+            print(f"[app] piano Modular Mind unavailable ({e})")
+    return _PIANO["player"]
+
+
+try:
+    _pmeta = json.load(open(os.path.join(HERE, "piano", "poly_notes.json")))
+    PIANO_LO, PIANO_HI, PIANO_FPS = _pmeta["midi_lo"], _pmeta["midi_hi"], _pmeta.get("fps", 8)
+except Exception:
+    PIANO_LO, PIANO_HI, PIANO_FPS = 56, 86, 8
+
+_get_piano()   # warm the piano Modular Mind at app startup (so the first play is instant)
+
+
+def _read(path):
+    with open(path, "r", encoding="utf-8") as f:
+        return f.read()
+
+
+CSS = _read(os.path.join(HERE, "web", "game.css"))
+GAME_JS = _read(os.path.join(HERE, "web", "game.js"))
+ASSETS_JS = _read(os.path.join(HERE, "assets_data.js"))
+INDEX_HTML = _read(os.path.join(HERE, "web", "index.html"))
+
+# music/sfx are served as static files by Gradio (allowed_paths below); the game
+# builds audio URLs from this base.
+AUDIO_DIR = os.path.join(HERE, "audio")
+# URL-encode the absolute path (it may contain spaces) but keep "/" and the drive ":"
+AUDIO_BASE_URL = (
+    "/gradio_api/file=" + quote(AUDIO_DIR.replace(os.sep, "/"), safe="/:") + "/"
+)
+
+# real acoustic-grand-piano note samples (served static; the piano plays the nearest
+# sample pitch-shifted to each note, for a real piano sound instead of an oscillator).
+PIANO_SAMPLES_DIR = os.path.join(HERE, "piano", "samples")
+try:
+    PIANO_SAMPLE_MIDIS = sorted(int(f[:-4]) for f in os.listdir(PIANO_SAMPLES_DIR) if f.endswith(".mp3"))
+except Exception:
+    PIANO_SAMPLE_MIDIS = []
+PIANO_SAMPLE_BASE = "/gradio_api/file=" + quote(PIANO_SAMPLES_DIR.replace(os.sep, "/"), safe="/:") + "/"
+
+# warm the default brain
+modular_mind.get_mind("hard")
+
+
+def decide(state_json: str) -> str:
+    """Called by the browser at each boss decision point. In: game-state JSON
+    (includes a "difficulty" tier). Out: chosen action + telemetry, as JSON."""
+    try:
+        state = json.loads(state_json)
+    except Exception:
+        state = {}
+    return json.dumps(modular_mind.decide(state))
+
+
+def learn(traj_json: str) -> str:
+    """Called by the browser at the end of a fight with the full decision trajectory
+    + outcome. Buffers it and periodically finetunes the HARD brain (REINFORCE)."""
+    try:
+        traj = json.loads(traj_json)
+    except Exception:
+        return json.dumps({"error": "bad json"})
+    return json.dumps(online.record_fight(traj))
+
+
+def piano(payload_json: str) -> str:
+    """Called by the browser's self-playing piano: in = {history:[tokens], n}, out =
+    {notes:[midi...], history:[...]}. The Modular Mind autoregressively generates the
+    next `n` notes from the recent history (server-side; history kept client-side)."""
+    try:
+        req = json.loads(payload_json)
+    except Exception:
+        req = {}
+    player = _get_piano()
+    hist = list(req.get("history") or [])
+    n = max(1, min(64, int(req.get("n", 32))))
+    if player is None:
+        return json.dumps({"notes": [], "history": hist, "error": "piano unavailable"})
+    if not hist:
+        hist = [list(f) for f in player.seed]
+    frames, telem = [], []
+    for _ in range(n):
+        toks, midis, tl = player.next_frame(hist)
+        hist.append(toks); frames.append([int(x) for x in midis]); telem.append(tl)
+    return json.dumps({"frames": frames, "telem": telem,
+                       "history": [list(map(int, f)) for f in hist[-player.K:]]})
+
+
+# Bootstrap (runs in the browser): wire window.MM_DECIDE to this app's /decide
+# endpoint via Gradio's REST API (no external CDN), then boot the game once the
+# gr.HTML canvas is in the DOM.
+BOOTSTRAP_JS = """
+(function () {
+  // route each boss decision to the Python Modular Mind through /gradio_api/call
+  window.MM_DECIDE = async (state) => {
+    const post = await fetch('/gradio_api/call/decide', {
+      method: 'POST', headers: {'Content-Type': 'application/json'},
+      body: JSON.stringify({data: [JSON.stringify(state)]}),
+    });
+    const j = await post.json();
+    const res = await fetch('/gradio_api/call/decide/' + j.event_id);
+    const text = await res.text();
+    const line = text.split('\\n').filter(l => l.startsWith('data:')).pop();
+    const arr = JSON.parse(line.slice(5).trim());
+    return JSON.parse(arr[0]);
+  };
+  // send a finished fight's trajectory to the online learner (fire-and-forget)
+  window.MM_LEARN = async (traj) => {
+    try {
+      const post = await fetch('/gradio_api/call/learn', {
+        method: 'POST', headers: {'Content-Type': 'application/json'},
+        body: JSON.stringify({data: [JSON.stringify(traj)]}),
+      });
+      const j = await post.json();
+      await fetch('/gradio_api/call/learn/' + j.event_id);
+    } catch (e) { /* learning is best-effort */ }
+  };
+  const tryBoot = () => {
+    if (document.getElementById('mm-canvas') && window.__mmBoot) window.__mmBoot();
+    else setTimeout(tryBoot, 80);
+  };
+  if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', tryBoot);
+  else tryBoot();
+})();
+"""
+
+# Force Gradio dark mode (matches the dark game) regardless of the visitor's browser
+# setting, by ensuring the ?__theme=dark URL param is present before the app renders.
+FORCE_DARK_JS = """
+(function () {
+  try {
+    var p = new URLSearchParams(window.location.search);
+    if (p.get('__theme') !== 'dark') {
+      p.set('__theme', 'dark');
+      window.location.replace(window.location.pathname + '?' + p.toString() + window.location.hash);
+    }
+  } catch (e) {}
+})();
+"""
+
+# ---- self-playing piano (a Modular Mind trained on the song) -----------------
+PIANO_CSS = """
+#mm-piano-wrap{max-width:920px;margin:6px auto 2px;font-family:system-ui,sans-serif}
+#mm-piano{display:flex;align-items:flex-end;justify-content:center;gap:2px;height:120px;
+  background:#13131a;border:1px solid #2a2a35;border-radius:8px;padding:10px 8px;overflow-x:auto}
+.pk{box-sizing:border-box;border:1px solid #05050a;border-radius:0 0 3px 3px;flex:0 0 auto}
+.pk.white{width:20px;height:100px;background:#e9e9ee}
+.pk.black{width:14px;height:62px;background:#2b2b33}
+.pk.on.white{background:#7ad1ff;box-shadow:0 0 14px #7ad1ff}
+.pk.on.black{background:#3ba0d8;box-shadow:0 0 14px #3ba0d8}
+#mm-piano-ctrl{display:flex;gap:14px;align-items:center;justify-content:center;margin:8px auto 4px}
+#mm-piano-btn{cursor:pointer;background:#2a9d6a;color:#fff;border:none;border-radius:6px;
+  padding:9px 18px;font-weight:700;font-size:14px}
+#mm-piano-btn:hover{background:#33b87c}
+#mm-piano-note{color:#9bd;font-size:13px;min-width:96px;text-align:left}
+#mm-piano-specs{display:flex;gap:8px;justify-content:center;flex-wrap:wrap;margin:8px auto 2px;max-width:800px}
+.psp{width:110px;background:#16161e;border:1px solid #2a2a35;border-radius:6px;padding:6px 9px}
+.psp .nm{font-weight:700;font-size:12px}
+.psp .ow{opacity:.55;font-size:10px;color:#aaa;margin-top:1px}
+.psp .bar{height:7px;background:#2a2a33;border-radius:4px;margin-top:6px;overflow:hidden}
+.psp .fill{height:100%;width:4%;border-radius:4px;transition:width .12s ease}
+#mm-piano-lbl{text-align:center;color:#888;font-size:11px;margin-top:8px}
+#mm-piano-latent{display:flex;gap:3px;justify-content:center;align-items:flex-end;height:22px;margin:5px auto}
+#mm-piano-latent .lc{width:8px;height:3px;border-radius:2px;background:#3a3a48;transition:height .12s ease}
+"""
+PIANO_GLOBALS = (f"window.MM_PIANO_LO={PIANO_LO};window.MM_PIANO_HI={PIANO_HI};"
+                 f"window.MM_PIANO_FPS={PIANO_FPS};"
+                 f"window.MM_PIANO_SAMPLE_BASE={json.dumps(PIANO_SAMPLE_BASE)};"
+                 f"window.MM_PIANO_SAMPLE_MIDIS={json.dumps(PIANO_SAMPLE_MIDIS)};")
+PIANO_JS = r"""
+(function(){
+  var SPC={Bass:'#4da6ff',Tenor:'#2ecc71',Soprano:'#ff6b9d',Sustain:'#1abc9c',Rest:'#95a5a6',Onset:'#e67e22',Phrase:'#9b59b6'};
+  window.__pianoBoot = function(){
+    var wrap=document.getElementById('mm-piano');
+    if(!wrap || wrap.dataset.built) return; wrap.dataset.built='1';
+    var LO=window.MM_PIANO_LO||56, HI=window.MM_PIANO_HI||86, BLACK={1:1,3:1,6:1,8:1,10:1};
+    for(var m=LO;m<=HI;m++){var k=document.createElement('div');
+      k.className='pk '+(BLACK[m%12]?'black':'white'); k.id='pk-'+m; wrap.appendChild(k);}
+    var audio=null, playing=false, queue=[], history=[], fetching=false, timer=null, voices={};
+    var specFills={}, built=false, buffers={}, loaded=false;
+    var PLAY_MS=Math.round(1000/(window.MM_PIANO_FPS||8))+58;     // a touch slower = calmer feel
+    var noteEl=document.getElementById('mm-piano-note'), btn=document.getElementById('mm-piano-btn');
+    var specBox=document.getElementById('mm-piano-specs'), latBox=document.getElementById('mm-piano-latent');
+    var NN=['C','C#','D','D#','E','F','F#','G','G#','A','A#','B'];
+    function name(m){return NN[m%12]+(Math.floor(m/12)-1);}
+    function buildSpecs(telem){
+      if(built || !specBox || !telem) return; built=true;
+      telem.spec.forEach(function(s){
+        var c=SPC[s.name]||'#888', card=document.createElement('div'); card.className='psp';
+        card.innerHTML='<div class="nm" style="color:'+c+'">'+s.name+'</div>'+
+          '<div class="ow">'+(s.owns?('owns '+s.owns):'modulator')+'</div>'+
+          '<div class="bar"><div class="fill" style="background:'+c+'"></div></div>';
+        specBox.appendChild(card); specFills[s.name]=card.querySelector('.fill');
+      });
+      if(latBox){ for(var i=0;i<8;i++){var lc=document.createElement('div'); lc.className='lc'; latBox.appendChild(lc);} }
+    }
+    function updateSpecs(telem){
+      if(!telem) return; buildSpecs(telem);
+      telem.spec.forEach(function(s){
+        var h;
+        if(s.owns!=null && s.drive!=null){ h=Math.abs(s.drive)/4.0*100; }   // owners: by drive
+        else { h=(s.act-16.0)/10.0*100; }                                   // modulators: by latent pulse
+        h=Math.max(4,Math.min(100,h));
+        if(specFills[s.name]) specFills[s.name].style.width=h+'%';
+      });
+      if(latBox && telem.shared){ var lc=latBox.children;
+        for(var i=0;i<lc.length && i<telem.shared.length;i++){
+          lc[i].style.height=Math.max(2,Math.min(20,Math.abs(telem.shared[i])*9))+'px';
+          lc[i].style.background=telem.shared[i]>=0?'#5bbcdf':'#df7a5b';
+        } }
+    }
+    async function fetchPhrase(){
+      if(fetching) return; fetching=true;
+      try{
+        var post=await fetch('/gradio_api/call/piano',{method:'POST',
+          headers:{'Content-Type':'application/json'},
+          body:JSON.stringify({data:[JSON.stringify({history:history,n:32})]})});
+        var j=await post.json();
+        var res=await fetch('/gradio_api/call/piano/'+j.event_id);
+        var text=await res.text();
+        var line=text.split('\n').filter(function(l){return l.indexOf('data:')===0;}).pop();
+        var out=JSON.parse(JSON.parse(line.slice(5).trim())[0]);
+        history=out.history||history;
+        var fr=out.frames||[]; for(var i=0;i<fr.length;i++) queue.push({f:fr[i], t:(out.telem&&out.telem[i])||null});
+      }catch(e){}
+      fetching=false;
+    }
+    function loadSamples(){
+      if(loaded || !audio) return; loaded=true;          // background load; play() upgrades to samples as they arrive
+      var ms=window.MM_PIANO_SAMPLE_MIDIS||[], base=window.MM_PIANO_SAMPLE_BASE||'';
+      ms.forEach(function(sm){
+        var ctl=('AbortController' in window)?new AbortController():null;
+        var to=ctl?setTimeout(function(){ctl.abort();},8000):0;
+        fetch(base+sm+'.mp3', ctl?{signal:ctl.signal}:{}).then(function(r){return r.arrayBuffer();})
+          .then(function(ab){audio.decodeAudioData(ab,function(buf){buffers[sm]=buf;},function(){});})
+          .catch(function(){}).finally(function(){if(to)clearTimeout(to);});
+      });
+    }
+    function nearest(m){ var ks=Object.keys(buffers); if(!ks.length) return null;
+      return ks.map(Number).reduce(function(a,b){return Math.abs(b-m)<Math.abs(a-m)?b:a;}); }
+    function voice(m, vol){          // real sample if it's loaded, else an oscillator -> ALWAYS audible
+      if(!audio) return null;
+      var sm=nearest(m), t=audio.currentTime;
+      if(sm!=null && buffers[sm]){
+        var src=audio.createBufferSource(); src.buffer=buffers[sm];
+        src.playbackRate.value=Math.pow(2,(m-sm)/12);
+        var g=audio.createGain(); g.gain.value=vol;
+        src.connect(g); g.connect(audio.destination); src.start(t);
+        return {src:src, gain:g};
+      }
+      var f=440*Math.pow(2,(m-69)/12);
+      var o1=audio.createOscillator(); o1.type='triangle'; o1.frequency.value=f;
+      var o2=audio.createOscillator(); o2.type='sine'; o2.frequency.value=f*2;
+      var g2=audio.createGain(); g2.gain.value=0.18;
+      var lp=audio.createBiquadFilter(); lp.type='lowpass'; lp.frequency.value=2600;
+      var g=audio.createGain();
+      g.gain.setValueAtTime(0.0001,t); g.gain.exponentialRampToValueAtTime(vol,t+0.014);
+      g.gain.exponentialRampToValueAtTime(Math.max(0.0001,vol*0.3),t+1.6);
+      o1.connect(lp); o2.connect(g2); g2.connect(lp); lp.connect(g); g.connect(audio.destination);
+      o1.start(t); o2.start(t);
+      return {oscs:[o1,o2], gain:g};
+    }
+    function releaseNode(nd){
+      if(!nd || !audio) return; var t=audio.currentTime;
+      try{ nd.gain.gain.cancelScheduledValues(t);
+           nd.gain.gain.setValueAtTime(Math.max(nd.gain.gain.value,0.0001),t);
+           nd.gain.gain.linearRampToValueAtTime(0.0001,t+0.10);
+           if(nd.src) nd.src.stop(t+0.13); if(nd.oscs) nd.oscs.forEach(function(o){o.stop(t+0.13);});
+      }catch(e){}
+    }
+    function releaseAll(){
+      for(var mk in voices){ releaseNode(voices[mk]); var pe=document.getElementById('pk-'+mk); if(pe)pe.classList.remove('on'); }
+      voices={};
+    }
+    function playFrame(midis){     // polyphony: strike new notes, hold sustained ones, release dropped ones
+      var nw={}; (midis||[]).forEach(function(m){ if(m>0) nw[m]=1; });
+      for(var mk in voices){ if(!nw[mk]){ releaseNode(voices[mk]);
+        var pe=document.getElementById('pk-'+mk); if(pe)pe.classList.remove('on'); delete voices[mk]; } }
+      var on=Object.keys(nw), vol=on.length>2?0.5:0.65;
+      on.forEach(function(ms){ var m=+ms; if(!voices[m]){ var v=voice(m,vol); if(v) voices[m]=v;
+        var el=document.getElementById('pk-'+m); if(el)el.classList.add('on'); } });
+      if(noteEl){ noteEl.textContent= on.length ? ('♪ '+on.map(function(ms){return name(+ms);}).join(' ')) : '♪ (rest)'; }
+    }
+    function tick(){ if(!playing) return; if(queue.length<10 && !fetching) fetchPhrase();
+      if(queue.length>0){ var it=queue.shift(); playFrame(it.f); updateSpecs(it.t); } }
+    function start(){
+      if(!audio) audio=new (window.AudioContext||window.webkitAudioContext)();
+      if(audio.state==='suspended'){ try{audio.resume();}catch(e){} }
+      loadSamples();                          // real piano loads in background; oscillator plays until then
+      playing=true; btn.textContent='⏸ Pause';
+      if(queue.length===0) fetchPhrase();
+      if(!timer) timer=setInterval(tick, PLAY_MS);
+    }
+    function stop(){ playing=false; btn.textContent='▶ Let the Modular Mind play'; releaseAll(); }
+    btn.onclick=function(){ playing?stop():start(); };
+  };
+  var t=function(){ if(document.getElementById('mm-piano')) window.__pianoBoot(); else setTimeout(t,120); };
+  if(document.readyState==='loading') document.addEventListener('DOMContentLoaded',t); else t();
+})();
+"""
+PIANO_HTML = """
+<div id="mm-piano-wrap">
+  <div id="mm-piano"></div>
+  <div id="mm-piano-ctrl">
+    <button id="mm-piano-btn">▶ Let the Modular Mind play</button>
+    <span id="mm-piano-note">♪</span>
+  </div>
+  <div id="mm-piano-lbl">specialists firing for each chord — Bass / Tenor / Soprano own a register; Sustain / Onset / Phrase are modulators that only write to the shared latent</div>
+  <div id="mm-piano-specs"></div>
+  <div id="mm-piano-latent" title="RecursiveLink shared latent"></div>
+</div>
+"""
+
+# Injected verbatim into the page <head>: dark-mode forcer, stylesheet, embedded sprite
+# atlases, the game engine, the piano engine, and the bootstrap. (Inline <script> in <head>
+# runs reliably; gr.HTML's innerHTML scripts do not.)
+HEAD = (
+    f"<script>{FORCE_DARK_JS}</script>\n"
+    f"<style>{CSS}</style>\n"
+    f"<style>{PIANO_CSS}</style>\n"
+    f"<script>{ASSETS_JS}</script>\n"
+    f"<script>window.MM_AUDIO_BASE = {json.dumps(AUDIO_BASE_URL)};</script>\n"
+    f"<script>{PIANO_GLOBALS}</script>\n"
+    f"<script>{GAME_JS}</script>\n"
+    f"<script>{PIANO_JS}</script>\n"
+    f"<script>{BOOTSTRAP_JS}</script>\n"
+)
+
+INTRO = """
+# 🍄 Quazim0t0's Thousand Token Wood Entry
+A mini **Dark-Souls-style** duel where the boss is controlled by a **Modular Mind** — six tiny
+specialist networks that communicate through a **shared latent** (RecursiveLink) and a coordinator
+that picks each move. The brain was **trained by self-play reinforcement learning**, not scripted.
+Watch the right-hand panel: every boss decision shows which specialists fired and how the modulators
+steer the fight through the latent. **Click *Enter the Fog* and click the game once to focus, then play.**
+"""
+
+# ---- placeholder repo link (replace REPO_URL with your real GitHub URL) ------
+REPO_URL = "https://github.com/your-username/ModularMind"  # TODO: replace with the real repo
+REPO_MD = f"""
+### 📦 Get the full Modular Mind project
+This Space runs a **tiny, specialist-scale** version of the architecture. The full,
+production-scale **Modular Mind** — transformer specialists (MLA / MoE / Hyper-Connections),
+the `RecursiveLink` latent bridge, context-doubling and the residual latent highway — lives on GitHub:
+
+### 👉 [**Download / view the Modular Mind repo on GitHub**]({REPO_URL})
+*(placeholder link — swap `{REPO_URL}` for your actual repository)*
+"""
+
+TECH_MD = r"""
+## 🧠 How the model works (technical breakdown)
+
+The boss brain is a faithful, **specialist-scale** implementation of the Modular Mind
+architecture — small enough (~**4,500 parameters**, pure-NumPy inference) to decide in
+well under a millisecond on a free CPU, yet structurally identical to the big idea:
+**many small domain specialists that communicate through one shared latent.**
+
+### The pieces
+- **7 specialists** (tiny 2-layer MLPs). Five *own an action* and two *modulators* own none:
+  | Specialist | Owns | Role |
+  |---|---|---|
+  | **Aggressor** | `CLEAVE` | attack when in range |
+  | **Stalker** | `APPROACH` | close the distance |
+  | **Survivor** | `RETREAT` | reset spacing when it can't swing |
+  | **Baiter** | `IDLE` | wait / bait a whiff |
+  | **Defender** | `BLOCK` | guard the player's melee when it can't punish |
+  | **Punisher** | — *(modulator)* | detects "the player is open / recovering" |
+  | **Enrage** | — *(modulator)* | detects "we're low on HP → go berserk" |
+- **`RecursiveLink`** — a ReGLU + residual block that merges the six latents into **one shared latent** (the "bridge").
+- **Coordinator** — a linear read-out of the shared latent that nudges every action's score.
+
+### What every specialist is doing *at one moment* (a single decision tick)
+A souls boss commits to one move at a time, so the brain only fires when the boss is free
+(~2–4 times/second). In that one forward pass, **all six specialists run in parallel**:
+
+1. **Perceive** — the live game state is compressed to a **10-D feature vector** (distance, in-range?, boss HP, player HP, cooldown ready?, is the player attacking / recovering / blocking?).
+2. **Specialise** — each specialist computes `h = tanh(W₁·features)` and emits a **latent vector** `zᵢ` (its "opinion"); the four action-owners also emit a scalar **drive** for their move.
+3. **Communicate** — the six latents are summed and pushed through the **`RecursiveLink`** to form the **shared latent** `s`. This is the only channel the **modulators** have: *Punisher* writes "player is open" and *Enrage* writes "HP is low" into `s` — they cast no direct vote.
+4. **Coordinate** — the **coordinator** reads `s` and produces a **modulation** added to each action's score. So `score(action) = (owner's drive) + (coordinator modulation)`. This is where "the player is open" turns *Aggressor's* CLEAVE up, or "we're low HP" makes the boss commit harder.
+5. **Act** — the boss takes the top-scoring legal action (CLEAVE is masked while on cooldown). A small per-difficulty *mistake rate* adds the easy/normal/hard feel.
+
+That whole loop is the **4-bar specialist panel + shared-latent strip** you see updating in the game — a live X-ray of the model thinking.
+
+### How it learned
+Trained by **self-play REINFORCE** (policy gradient + value baseline) in a headless duel
+simulator: reward = *damage dealt − damage taken*, plus shaping that rewards pressuring in
+range and punishes stalling. Over ~700 batches the win-rate climbed against a near-optimal
+dodging opponent and the tactics — spacing, punishing recovery frames, blocking your punish,
+enraging at low HP — **emerged**; none of it is hand-scripted. The **difficulty tiers are the
+same trained brain at different decision-noise levels** (Easy makes more exploitable mistakes,
+Hard plays sharp ≈0.95 win vs the dodger).
+
+### Why the structure matters
+- **Modular** — you can retrain or swap one specialist without touching the others (e.g. the **Defender/BLOCK** specialist was added later and the rest were untouched).
+- **Explainable** — at any instant you can read *which* specialist drove the decision and how the modulators bent it.
+- **Cheap** — specialists are small and run in parallel; the latent bridge is one tiny matmul.
+
+### It finetunes from *your* fights (online learning)
+Because the model is tiny, a gradient step is microseconds — so the boss can learn
+from real play **on this CPU**. Every HARD-tier fight is logged (state, action, HP per
+decision) and sent to a `/learn` endpoint; we rebuild the per-decision rewards (damage
+dealt − taken, + kill / − death), compute REINFORCE returns, and take **one Adam step**
+that nudges the HARD brain toward what worked against real humans — the backprop is
+hand-written in numpy and verified against PyTorch to ~1e-8. A frozen copy of the
+sim-trained weights is an **anchor** (gentle pull-back) so it can't drift into nonsense,
+and with a `HF_TOKEN` + `MM_DATASET_REPO` secret the adapted weights persist to a
+HuggingFace Dataset across Space restarts. (Only HARD fights train, so the adaptation data
+stays on-policy.)
+"""
+
+USES_MD = r"""
+## 🌍 Three real-world applications of this architecture
+
+The reusable idea isn't "a boss" — it's **small, independently-trainable specialists that
+coordinate through a shared latent instead of through brittle hand-written rules or one giant
+monolithic model.** That pattern transfers well beyond games:
+
+**1. On-device / edge robotics & IoT control.**
+A drone, robot arm, or wearable can't run a huge policy. Give it a handful of tiny specialists
+— *balance*, *obstacle-avoidance*, *navigation*, *battery/thermal management* — each cheap
+enough for a microcontroller, coordinating through one shared latent. You can **add or replace
+a specialist** (e.g., a new sensor) without retraining the whole stack, and the latent bridge
+fuses their context in a single cheap step — exactly what this boss does at 2–4 Hz on a CPU.
+
+**2. Explainable, designer-tunable AI for games & simulations.**
+Studios want NPC/boss/crowd AI that's *steerable and inspectable*, not a black box. With this
+pattern a designer can tune or hot-swap one behavior specialist (more aggressive, more cautious)
+and **see exactly which specialist fired** for any decision — the same live panel shown here.
+That makes balancing, debugging, and difficulty tuning tractable in ways a single end-to-end
+policy isn't.
+
+**3. Modular AI agents / mixture-of-specialists that talk in latent space.**
+The original Modular Mind motivation: instead of an "agent chain" that re-serializes everything
+to **text** at every hop (lossy, slow), let domain specialists — *math*, *code*, *retrieval*,
+*safety/policy* — communicate through a **latent bridge** (`RecursiveLink` + a residual highway
+for deep chains). A small language model can consult a math or tool specialist **without
+flattening to tokens**, each specialist is trained/upgraded independently, and the system stays
+auditable. Useful for cost-sensitive assistants, industrial decisioning (risk + liquidity +
+fraud specialists), or clinical triage (modular diagnostic experts) where you must know *why*.
+"""
+
+
+PIANO_INTRO = """
+### 🎹 Bonus: a self-playing piano — same Modular Mind method, trained on a song
+Under the boss fight, the *same architecture* (tiny specialists → `RecursiveLink` → a coordinator)
+applied to **playing piano in chords**. It was trained by **multi-note next-frame prediction** on a
+*polyphonic* transcription of a song: six specialists (Bass / Tenor / Soprano registers + Sustain /
+Onset / Phrase modulators) emit latents, the bridge merges them, and the coordinator picks the **set
+of notes** to play next. It plays itself with **real recorded acoustic-piano samples**. Press **play**
+and watch the keys + specialists light up.
+<sub>Rough by design — one song, a tiny model, crude polyphonic transcription — the *method carrying over* is the point.</sub>
+"""
+
+with gr.Blocks(theme=gr.themes.Base(), title="Quazim0t0's 🍄 Thousand Token Wood Entry", head=HEAD) as demo:
+    gr.Markdown(INTRO)
+    gr.HTML(INDEX_HTML)
+
+    gr.Markdown(PIANO_INTRO)
+    gr.HTML(PIANO_HTML)
+
+    gr.Markdown(REPO_MD)
+    with gr.Accordion("🧠 How the Modular Mind works (technical breakdown)", open=False):
+        gr.Markdown(TECH_MD)
+    with gr.Accordion("🌍 Three real-world applications", open=False):
+        gr.Markdown(USES_MD)
+
+    # the third application, made real: a live mixture-of-experts at the bottom
+    if build_moe_panel is not None:
+        build_moe_panel()
+
+    # hidden API plumbing: the browser calls /decide via the Gradio REST API
+    inp = gr.Textbox(visible=False)
+    out = gr.Textbox(visible=False)
+    trigger = gr.Button(visible=False)
+    trigger.click(decide, inp, out, api_name="decide")
+
+    linp = gr.Textbox(visible=False)
+    lout = gr.Textbox(visible=False)
+    ltrigger = gr.Button(visible=False)
+    ltrigger.click(learn, linp, lout, api_name="learn")
+
+    pinp = gr.Textbox(visible=False)
+    pout = gr.Textbox(visible=False)
+    ptrigger = gr.Button(visible=False)
+    ptrigger.click(piano, pinp, pout, api_name="piano")
+
+
+if __name__ == "__main__":
+    demo.queue(default_concurrency_limit=8).launch(
+        server_name="0.0.0.0",
+        server_port=int(os.environ.get("PORT", "7860")),
+        allowed_paths=[AUDIO_DIR, PIANO_SAMPLES_DIR],
+    )

features.py

@@ -0,0 +1,53 @@
+"""
+features.py -- the single source of truth for what the Modular Mind sees and the
+action set it chooses from. Imported by the duel simulator (training env), the
+torch model, and the numpy inference brain so all three agree exactly.
+"""
+from __future__ import annotations
+
+import numpy as np
+
+ACTIONS = ["IDLE", "APPROACH", "RETREAT", "CLEAVE", "BLOCK"]
+
+FEATURES = [
+    "abs_dist",          # 0  normalised |player - boss|, 0 close .. 1 far
+    "in_cleave_range",   # 1  player within the boss's cleave reach
+    "in_mid_range",      # 2  player in the "step in and swing" band
+    "boss_hp",           # 3  boss hp fraction
+    "player_hp",         # 4  player hp fraction
+    "boss_ready",        # 5  1 = cleave off cooldown, 0 = recovering
+    "player_pressuring", # 6  player attacking or moving in
+    "player_open",       # 7  player in attack/roll recovery = punishable
+    "player_blocking",   # 8  player is holding block
+    "player_threat",     # 9  player is swinging AT the boss in melee range (block cue)
+    "bias",              # 10
+]
+NF = len(FEATURES)
+
+
+def extract_features(s: dict) -> np.ndarray:
+    arena = float(s.get("arenaW", 900))
+    dist = abs(float(s["playerX"]) - float(s["bossX"]))
+    abs_dist = min(dist / (arena * 0.6), 1.0)
+    cleave_reach = float(s.get("cleaveReach", 160))
+    f = np.zeros(NF, dtype=np.float32)
+    f[0] = abs_dist
+    f[1] = 1.0 if dist <= cleave_reach else 0.0
+    f[2] = 1.0 if cleave_reach < dist <= cleave_reach * 2.2 else 0.0
+    f[3] = float(s.get("bossHP", 1.0))
+    f[4] = float(s.get("playerHP", 1.0))
+    f[5] = 1.0 if float(s.get("bossCooldown", 0.0)) <= 0.0 else 0.0
+    f[6] = 1.0 if (s.get("playerAttacking") or s.get("playerApproaching")) else 0.0
+    f[7] = 1.0 if s.get("playerRecovering") else 0.0
+    f[8] = 1.0 if s.get("playerBlocking") else 0.0
+    f[9] = 1.0 if s.get("playerThreat") else 0.0
+    f[10] = 1.0
+    return f
+
+
+def legal_mask(s: dict) -> np.ndarray:
+    """CLEAVE is illegal while on cooldown; everything else always allowed."""
+    m = np.ones(len(ACTIONS), dtype=np.float32)
+    if float(s.get("bossCooldown", 0.0)) > 0.0:
+        m[ACTIONS.index("CLEAVE")] = 0.0
+    return m

mm_grad.py

@@ -0,0 +1,257 @@
+"""
+mm_grad.py -- pure-numpy forward + backward (REINFORCE gradient) for the Modular
+Mind policy, so the boss can be **finetuned from real player data on a CPU** with
+no torch at runtime.
+
+The math is identical to mm_torch.ModularMindPolicy, hand-differentiated so a
+gradient step is a few thousand FLOPs (microseconds). Verified against torch
+autograd in test_grad() to <1e-6.
+
+Pipeline:
+  player plays a fight -> browser logs (state, action, bossHP, playerHP) per boss
+  decision + who died -> /learn -> we rebuild the per-step rewards (damage dealt
+  - taken, + kill/- death), compute REINFORCE returns, and take one Adam step that
+  nudges the policy toward what worked against real humans. A frozen copy of the
+  sim-trained weights is kept as an anchor (small pull-back) so it can't drift far.
+"""
+from __future__ import annotations
+
+import numpy as np
+
+from features import ACTIONS, NF, extract_features, legal_mask
+from modular_mind import SPEC_DEFS, D_LATENT, H
+
+NA = len(ACTIONS)
+EPS = 1e-5
+
+
+def _ln_fwd(x, w, b):
+    mu = x.mean()
+    var = ((x - mu) ** 2).mean()
+    std = np.sqrt(var + EPS)
+    xhat = (x - mu) / std
+    return xhat * w + b, (xhat, std, w)
+
+
+def _ln_bwd(gy, cache):
+    xhat, std, w = cache
+    n = xhat.shape[0]
+    gw = gy * xhat
+    gb = gy.copy()
+    gxhat = gy * w
+    gx = (gxhat - gxhat.mean() - xhat * (gxhat * xhat).mean()) / std
+    return gx, gw, gb
+
+
+def _relu(x):
+    return np.maximum(x, 0.0)
+
+
+class OnlineLearner:
+    """Holds the live weights + Adam state; updates them from player trajectories."""
+
+    def __init__(self, weights, lr=5e-3, gamma=0.97, anchor_pull=0.02,
+                 w_deal=6.0, w_take=5.0, time_pen=0.01, entropy_coef=0.01):
+        self.W = {k: v.astype(np.float64).copy() for k, v in weights.items()}
+        self.anchor = {k: v.copy() for k, v in self.W.items()}   # sim-trained anchor
+        self.lr, self.gamma, self.anchor_pull = lr, gamma, anchor_pull
+        self.w_deal, self.w_take, self.time_pen = w_deal, w_take, time_pen
+        self.entropy_coef = entropy_coef
+        self.owns = [ACTIONS.index(o) if o else None for _, o, _ in SPEC_DEFS]
+        self.m = {k: np.zeros_like(v) for k, v in self.W.items()}
+        self.v = {k: np.zeros_like(v) for k, v in self.W.items()}
+        self.t = 0
+
+    # ---- forward with cached intermediates -------------------------------
+    def _forward(self, f):
+        W = self.W
+        hs, lats, drives = [], [], np.zeros(NA)
+        for i, owns in enumerate(self.owns):
+            pre = W[f"s{i}_fc1_w"] @ f + W[f"s{i}_fc1_b"]
+            h = np.tanh(pre)
+            hs.append(h)
+            lat = W[f"s{i}_lat_w"] @ h + W[f"s{i}_lat_b"]
+            lats.append(lat)
+            if owns is not None:
+                drives[owns] += W[f"s{i}_drv_w"][0] @ h + W[f"s{i}_drv_b"][0]
+        z = np.sum(lats, axis=0)
+        zn, ln_in_c = _ln_fwd(z, W["link_ni_w"], W["link_ni_b"])
+        pre_g = W["link_g"] @ zn
+        g_act = _relu(pre_g)
+        v_act = W["link_v"] @ zn
+        reglu = g_act * v_act
+        out = W["link_d"] @ reglu
+        shared, ln_out_c = _ln_fwd(out + z, W["link_no_w"], W["link_no_b"])
+        modulation = W["coord_w"] @ shared + W["coord_b"]
+        logits = drives + modulation
+        cache = dict(f=f, hs=hs, lats=lats, z=z, zn=zn, ln_in_c=ln_in_c, pre_g=pre_g,
+                     g_act=g_act, v_act=v_act, reglu=reglu, out=out, shared=shared,
+                     ln_out_c=ln_out_c)
+        return logits, cache
+
+    # ---- backward: accumulate grads of (advantage * -logpi - H) ----------
+    def _backward(self, cache, g_logits, grads):
+        W = self.W
+        # coordinator
+        grads["coord_w"] += np.outer(g_logits, cache["shared"])
+        grads["coord_b"] += g_logits
+        g_shared = W["coord_w"].T @ g_logits
+        # owned-action drives
+        g_drive = {}
+        for i, owns in enumerate(self.owns):
+            if owns is not None:
+                g_drive[i] = g_logits[owns]
+        # out + z layernorm
+        g_outz, gw, gb = _ln_bwd(g_shared, cache["ln_out_c"])
+        grads["link_no_w"] += gw
+        grads["link_no_b"] += gb
+        g_out = g_outz
+        g_z = g_outz.copy()
+        # out = Wd @ reglu
+        grads["link_d"] += np.outer(g_out, cache["reglu"])
+        g_reglu = W["link_d"].T @ g_out
+        # reglu = relu(Wg@zn) * (Wv@zn)
+        g_g_act = g_reglu * cache["v_act"]
+        g_v_act = g_reglu * cache["g_act"]
+        g_pre_g = g_g_act * (cache["pre_g"] > 0)
+        grads["link_g"] += np.outer(g_pre_g, cache["zn"])
+        grads["link_v"] += np.outer(g_v_act, cache["zn"])
+        g_zn = W["link_g"].T @ g_pre_g + W["link_v"].T @ g_v_act
+        # zn = layernorm(z)
+        g_z_ln, gw, gb = _ln_bwd(g_zn, cache["ln_in_c"])
+        grads["link_ni_w"] += gw
+        grads["link_ni_b"] += gb
+        g_z += g_z_ln
+        # z = sum(lat_i) -> each specialist
+        for i, owns in enumerate(self.owns):
+            h = cache["hs"][i]
+            g_lat = g_z
+            grads[f"s{i}_lat_w"] += np.outer(g_lat, h)
+            grads[f"s{i}_lat_b"] += g_lat
+            g_h = W[f"s{i}_lat_w"].T @ g_lat
+            if owns is not None:
+                grads[f"s{i}_drv_w"][0] += g_drive[i] * h
+                grads[f"s{i}_drv_b"][0] += g_drive[i]
+                g_h = g_h + W[f"s{i}_drv_w"][0] * g_drive[i]
+            g_pre = g_h * (1.0 - h * h)
+            grads[f"s{i}_fc1_w"] += np.outer(g_pre, cache["f"])
+            grads[f"s{i}_fc1_b"] += g_pre
+
+    def logpi_grad(self, f, action, advantage, mask):
+        """Grad of advantage * -log pi(action|state) (+ entropy bonus), accumulated."""
+        logits, cache = self._forward(f)
+        masked = np.where(mask > 0.5, logits, -1e9)
+        p = np.exp(masked - masked.max())
+        p = p / p.sum()
+        onehot = np.zeros(NA)
+        onehot[action] = 1.0
+        # d(-adv*logpi)/dlogits = adv*(p - onehot); entropy bonus grad = ent_coef*(p*(logp+H_)...)
+        g_logits = advantage * (p - onehot)
+        # entropy regularizer (encourage exploration): d(-ent_coef*H)/dlogits
+        with np.errstate(divide="ignore"):
+            logp = np.where(p > 1e-12, np.log(p), 0.0)
+        ent_term = self.entropy_coef * p * (logp + (p * (-logp)).sum())
+        g_logits = g_logits + np.where(mask > 0.5, ent_term, 0.0)
+        grads = {k: np.zeros_like(v) for k, v in self.W.items()}
+        self._backward(cache, g_logits, grads)
+        return grads
+
+    def _trajectory_rewards(self, steps, result):
+        """Rebuild per-decision rewards from logged HP (damage dealt - taken)."""
+        n = len(steps)
+        rews = np.zeros(n)
+        for t in range(n):
+            nb = steps[t + 1]["bossHP"] if t + 1 < n else (0.0 if result.get("bossDied") else steps[t]["bossHP"])
+            npl = steps[t + 1]["playerHP"] if t + 1 < n else (0.0 if result.get("playerDied") else steps[t]["playerHP"])
+            dealt = max(0.0, steps[t]["playerHP"] - npl)
+            taken = max(0.0, steps[t]["bossHP"] - nb)
+            rews[t] = dealt * self.w_deal - taken * self.w_take - self.time_pen
+        if result.get("playerDied"):
+            rews[-1] += 8.0
+        elif result.get("bossDied"):
+            rews[-1] -= 5.0
+        return rews
+
+    def update(self, trajectories):
+        """trajectories: list of {steps:[{state,action,bossHP,playerHP}], result:{}}.
+        Returns dict of stats. Mutates self.W in place (one Adam step)."""
+        grads = {k: np.zeros_like(v) for k, v in self.W.items()}
+        all_returns, nsteps = [], 0
+        # first pass: gather returns for a baseline
+        per_traj = []
+        for tr in trajectories:
+            steps = tr.get("steps", [])
+            if len(steps) < 2:
+                continue
+            rews = self._trajectory_rewards(steps, tr.get("result", {}))
+            G = np.zeros(len(rews))
+            acc = 0.0
+            for t in reversed(range(len(rews))):
+                acc = rews[t] + self.gamma * acc
+                G[t] = acc
+            per_traj.append((steps, G))
+            all_returns.extend(G.tolist())
+        if not per_traj:
+            return {"updated": False, "reason": "not enough data"}
+        baseline = float(np.mean(all_returns))
+        adv_std = float(np.std(all_returns)) + 1e-6
+        # second pass: accumulate gradient
+        for steps, G in per_traj:
+            for t, st in enumerate(steps):
+                s = st["state"]
+                f = extract_features(s).astype(np.float64)
+                mask = legal_mask(s)
+                action = ACTIONS.index(st["action"]) if isinstance(st["action"], str) else int(st["action"])
+                adv = (G[t] - baseline) / adv_std
+                g = self.logpi_grad(f, action, adv, mask)
+                for k in grads:
+                    grads[k] += g[k]
+                nsteps += 1
+        # average + anchor pull-back (stay near the sim-trained policy)
+        self.t += 1
+        b1, b2 = 0.9, 0.999
+        for k in self.W:
+            gk = grads[k] / max(1, nsteps) + self.anchor_pull * (self.W[k] - self.anchor[k])
+            self.m[k] = b1 * self.m[k] + (1 - b1) * gk
+            self.v[k] = b2 * self.v[k] + (1 - b2) * (gk * gk)
+            mhat = self.m[k] / (1 - b1 ** self.t)
+            vhat = self.v[k] / (1 - b2 ** self.t)
+            self.W[k] -= self.lr * mhat / (np.sqrt(vhat) + 1e-8)
+        return {"updated": True, "steps": nsteps, "trajectories": len(per_traj),
+                "avg_return": round(baseline, 3)}
+
+
+def test_grad():
+    """Verify the numpy logpi-gradient matches torch autograd."""
+    import torch
+    from mm_torch import ModularMindPolicy
+    m = ModularMindPolicy().double()
+    m.export_npz("_gradchk.npz")
+    W = {k: v for k, v in np.load("_gradchk.npz").items()}
+    learner = OnlineLearner(W, entropy_coef=0.0)
+    rng = np.random.default_rng(0)
+    maxrel = 0.0
+    for _ in range(5):
+        f = rng.normal(size=NF)
+        action = int(rng.integers(NA))
+        mask = np.ones(NA)
+        # numpy grad of -logpi(action) (advantage=1)
+        gnp = learner.logpi_grad(f, action, 1.0, mask)
+        # torch grad
+        m.zero_grad()
+        x = torch.tensor(f, dtype=torch.float64).unsqueeze(0)
+        logits, _ = m(x)
+        logp = torch.log_softmax(logits, dim=-1)[0, action]
+        (-logp).backward()
+        # compare coordinator weight grad as a representative
+        gt = m.coordinator.weight.grad.numpy()
+        rel = np.abs(gnp["coord_w"] - gt).max() / (np.abs(gt).max() + 1e-9)
+        maxrel = max(maxrel, rel)
+    import os
+    os.remove("_gradchk.npz")
+    print(f"max relative grad error (coord_w) vs torch: {maxrel:.2e}")
+    return maxrel
+
+
+if __name__ == "__main__":
+    test_grad()

modular_mind.py

@@ -0,0 +1,185 @@
+"""
+modular_mind.py -- numpy inference for the trained Modular Mind boss brain.
+
+Loads the weights produced by train.py (mm_weights.npz) and runs the exact same
+forward pass as mm_torch.ModularMindPolicy, in pure numpy (no torch needed at game
+runtime -> tiny, fast, instant cold-start on a HuggingFace Space).
+
+decide(state) returns the chosen boss action plus rich telemetry (per-specialist
+drives, the shared latent, the coordinator's modulation) so the game can VISUALISE
+the Modular Mind making each decision -- including the two modulator specialists
+(Punisher, Enrage) whose only influence is the latent they write into the bridge.
+"""
+from __future__ import annotations
+
+import os
+
+import numpy as np
+
+from features import ACTIONS, NF, extract_features, legal_mask
+
+# must match mm_torch.SPEC_DEFS
+SPEC_DEFS = [
+    ("Aggressor", "CLEAVE",   "#ff4d4d"),
+    ("Stalker",   "APPROACH", "#4da6ff"),
+    ("Survivor",  "RETREAT",  "#9b59b6"),
+    ("Baiter",    "IDLE",     "#f1c40f"),
+    ("Defender",  "BLOCK",    "#48b0c4"),
+    ("Punisher",  None,       "#e67e22"),
+    ("Enrage",    None,       "#c0392b"),
+]
+WEIGHTS_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "mm_weights.npz")
+H, D_LATENT = 24, 12
+
+
+def _layernorm(x, w, b, eps=1e-5):
+    mu = x.mean()
+    var = ((x - mu) ** 2).mean()
+    return (x - mu) / np.sqrt(var + eps) * w + b
+
+
+def _relu(x):
+    return np.maximum(x, 0.0)
+
+
+class ModularMind:
+    def __init__(self, weights_path=WEIGHTS_PATH):
+        if os.path.exists(weights_path):
+            self.W = {k: v for k, v in np.load(weights_path).items()}
+            self.trained = True
+        else:  # fallback so the game still runs before training finishes
+            self.W = self._random_weights()
+            self.trained = False
+
+    def _random_weights(self):
+        rng = np.random.default_rng(0)
+        W = {}
+        for i, (_, owns, _) in enumerate(SPEC_DEFS):
+            W[f"s{i}_fc1_w"] = rng.normal(0, .3, (H, NF))
+            W[f"s{i}_fc1_b"] = np.zeros(H)
+            W[f"s{i}_lat_w"] = rng.normal(0, .3, (D_LATENT, H))
+            W[f"s{i}_lat_b"] = np.zeros(D_LATENT)
+            if owns is not None:
+                W[f"s{i}_drv_w"] = rng.normal(0, .3, (1, H))
+                W[f"s{i}_drv_b"] = np.zeros(1)
+        W["link_ni_w"] = np.ones(D_LATENT); W["link_ni_b"] = np.zeros(D_LATENT)
+        W["link_v"] = rng.normal(0, .3, (2 * D_LATENT, D_LATENT))
+        W["link_g"] = rng.normal(0, .3, (2 * D_LATENT, D_LATENT))
+        W["link_d"] = rng.normal(0, .3, (D_LATENT, 2 * D_LATENT))
+        W["link_no_w"] = np.ones(D_LATENT); W["link_no_b"] = np.zeros(D_LATENT)
+        W["coord_w"] = rng.normal(0, .3, (len(ACTIONS), D_LATENT))
+        W["coord_b"] = np.zeros(len(ACTIONS))
+        return W
+
+    def decide(self, state: dict, explore: float = 0.06):
+        W = self.W
+        f = extract_features(state).astype(np.float64)
+
+        drives = np.zeros(len(ACTIONS))
+        latents = []
+        per_spec = []
+        for i, (name, owns, color) in enumerate(SPEC_DEFS):
+            h = np.tanh(W[f"s{i}_fc1_w"] @ f + W[f"s{i}_fc1_b"])
+            lat = W[f"s{i}_lat_w"] @ h + W[f"s{i}_lat_b"]
+            latents.append(lat)
+            drv = None
+            if owns is not None:
+                drv = float((W[f"s{i}_drv_w"] @ h + W[f"s{i}_drv_b"]).item())
+                drives[ACTIONS.index(owns)] += drv
+            per_spec.append({
+                "name": name, "owns": owns, "color": color,
+                "drive": round(drv, 3) if drv is not None else None,
+                "latent_norm": round(float(np.linalg.norm(lat)), 3),
+            })
+
+        # RecursiveLink: shared latent bridge
+        z = np.sum(latents, axis=0)
+        zn = _layernorm(z, W["link_ni_w"], W["link_ni_b"])
+        reglu = _relu(W["link_g"] @ zn) * (W["link_v"] @ zn)
+        out = W["link_d"] @ reglu
+        shared = _layernorm(out + z, W["link_no_w"], W["link_no_b"])
+
+        # Coordinator read-out (modulator influence flows in here)
+        modulation = W["coord_w"] @ shared + W["coord_b"]
+        logits = drives + modulation
+
+        mask = legal_mask(state)
+        masked = np.where(mask > 0.5, logits, -1e9)
+
+        probs = np.exp(masked - masked.max())
+        probs = probs / probs.sum()
+        # `explore` is a true mistake-rate: with prob `explore` take a uniformly
+        # random LEGAL action (the difficulty dial), else the best action. (Sampling
+        # from `probs` barely degrades play -- the policy is too confident -- so we
+        # use uniform mistakes to make easier tiers actually easier.)
+        if explore > 0 and np.random.random() < explore:
+            legal_idx = np.where(mask > 0.5)[0]
+            choice = int(np.random.choice(legal_idx))
+        else:
+            choice = int(np.argmax(masked))
+
+        phase = 2 if state.get("bossHP", 1.0) < 0.5 else 1
+        return {
+            "action": ACTIONS[choice],
+            "phase": phase,
+            "trained": self.trained,
+            "specialists": per_spec,
+            "base_drive": {a: round(float(d), 3) for a, d in zip(ACTIONS, drives)},
+            "modulation": {a: round(float(m), 3) for a, m in zip(ACTIONS, modulation)},
+            "final_drive": {a: round(float(d), 3) for a, d in zip(ACTIONS, logits)},
+            "probs": {a: round(float(p), 3) for a, p in zip(ACTIONS, probs)},
+            "legal": {a: bool(m > 0.5) for a, m in zip(ACTIONS, mask)},
+            "shared_latent": [round(float(x), 3) for x in shared],
+        }
+
+
+# ---- difficulty tiers --------------------------------------------------------
+# Each tier = a different training checkpoint PLUS a decision-noise level. Easy is a
+# partially-trained brain that also "thinks loosely" (more exploration -> more
+# mistakes, more openings for the player); Hard is the fully-trained brain playing
+# sharply. Missing weight files fall back to the hard weights.
+_DIR = os.path.dirname(os.path.abspath(__file__))
+# Difficulty = decision-noise on the trained brain. `explore` is the mistake-rate
+# (prob of a random legal action); higher = the boss makes more exploitable mistakes.
+# (Once the boss learned to BLOCK it dominates the sim even early in training, so a
+# "weaker checkpoint" no longer yields an easy boss -- noise is the controllable dial:
+# vs a near-optimal dodger these give boss win-rates ~0.35 / ~0.65 / ~0.95.)
+DIFFICULTY = {
+    "easy":   {"file": "mm_weights.npz", "explore": 0.50},
+    "normal": {"file": "mm_weights.npz", "explore": 0.22},
+    "hard":   {"file": "mm_weights.npz", "explore": 0.04},
+}
+_MINDS: dict[str, "ModularMind"] = {}
+
+
+def get_mind(difficulty: str = "hard") -> ModularMind:
+    key = difficulty if difficulty in DIFFICULTY else "hard"
+    if key not in _MINDS:
+        path = os.path.join(_DIR, DIFFICULTY[key]["file"])
+        if not os.path.exists(path):                    # tier not trained yet
+            path = os.path.join(_DIR, DIFFICULTY["hard"]["file"])
+        mind = ModularMind(path)
+        # the HARD tier shares the online learner's live (player-adapted) weights,
+        # so finetuning from real fights takes effect immediately. (Lazy import to
+        # avoid an import cycle: online -> mm_grad -> modular_mind.)
+        if key == "hard":
+            try:
+                import online
+                if online.ENABLED:
+                    mind.W = online.live_weights()
+                    mind.trained = True
+            except Exception as e:
+                print(f"[modular_mind] online weights not shared ({e})")
+        _MINDS[key] = mind
+    return _MINDS[key]
+
+
+def decide(state: dict) -> dict:
+    """Route a decision to the brain for the requested difficulty tier (each tier
+    has its own checkpoint and exploration/mistake level)."""
+    key = str(state.get("difficulty", "hard"))
+    if key not in DIFFICULTY:
+        key = "hard"
+    out = get_mind(key).decide(state, explore=DIFFICULTY[key]["explore"])
+    out["difficulty"] = key
+    return out

online.py

@@ -0,0 +1,124 @@
+"""
+online.py -- persistent finetuning of the boss from real player fights.
+
+Flow: the browser logs every boss decision (state, action, HP) during a fight and,
+on fight end, POSTs the trajectory + who-died to /learn. We buffer trajectories and,
+every MM_UPDATE_EVERY fights, run one REINFORCE step (mm_grad.OnlineLearner) that
+nudges the HARD brain toward what actually worked against humans. The adapted
+weights feed straight back into the live boss.
+
+ONLY HARD-tier fights are used, so the data stays on-policy (Easy/Normal are
+deliberately handicapped checkpoints; learning from them would be off-policy).
+
+Persistence (optional, set as Space secrets):
+  HF_TOKEN          - a write token
+  MM_DATASET_REPO   - e.g. "your-name/boss-fight-online"
+If set, adapted weights are pushed to / pulled from that dataset so learning
+survives Space restarts. Without them it still adapts live, just in-memory.
+
+Safety: a frozen copy of the sim-trained weights is kept as an anchor (the learner
+pulls gently back toward it), so a weird run can't brick the boss.
+"""
+from __future__ import annotations
+
+import os
+import threading
+
+import numpy as np
+
+from mm_grad import OnlineLearner
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+BASE_WEIGHTS = os.path.join(HERE, "mm_weights.npz")        # sim-trained HARD brain
+LIVE_WEIGHTS = os.path.join(HERE, "mm_weights_live.npz")   # player-adapted snapshot
+
+ENABLED = os.environ.get("MM_ONLINE", "1") == "1"
+UPDATE_EVERY = int(os.environ.get("MM_UPDATE_EVERY", "3"))  # fights per update
+ADAPT_TIER = "hard"
+DATASET_REPO = os.environ.get("MM_DATASET_REPO")
+HF_TOKEN = os.environ.get("HF_TOKEN")
+WEIGHTS_IN_REPO = "mm_weights_live.npz"
+
+_LOCK = threading.Lock()
+_LEARNER = None
+_BUFFER = []
+_FIGHTS = 0
+
+
+def _pull_from_dataset():
+    """Try to download the latest adapted weights from the HF dataset."""
+    if not (DATASET_REPO and HF_TOKEN):
+        return None
+    try:
+        from huggingface_hub import hf_hub_download
+        p = hf_hub_download(repo_id=DATASET_REPO, filename=WEIGHTS_IN_REPO,
+                            repo_type="dataset", token=HF_TOKEN)
+        return {k: v for k, v in np.load(p).items()}
+    except Exception as e:
+        print(f"[online] no persisted weights pulled ({e}); starting from sim weights")
+        return None
+
+
+def _push_to_dataset():
+    """Upload the current adapted weights to the HF dataset (best-effort)."""
+    if not (DATASET_REPO and HF_TOKEN):
+        return
+    try:
+        from huggingface_hub import upload_file
+        upload_file(path_or_fileobj=LIVE_WEIGHTS, path_in_repo=WEIGHTS_IN_REPO,
+                    repo_id=DATASET_REPO, repo_type="dataset", token=HF_TOKEN)
+    except Exception as e:
+        print(f"[online] dataset push failed ({e})")
+
+
+def get_learner():
+    global _LEARNER
+    if _LEARNER is None:
+        base = _pull_from_dataset()
+        if base is None and os.path.exists(LIVE_WEIGHTS):
+            base = {k: v for k, v in np.load(LIVE_WEIGHTS).items()}
+        if base is None:
+            base = {k: v for k, v in np.load(BASE_WEIGHTS).items()}
+        # anchor is ALWAYS the pristine sim-trained weights
+        _LEARNER = OnlineLearner(base)
+        _LEARNER.anchor = {k: v.astype(np.float64).copy()
+                           for k, v in np.load(BASE_WEIGHTS).items()}
+    return _LEARNER
+
+
+def live_weights():
+    """The HARD brain's current (possibly player-adapted) weights, shared live."""
+    return get_learner().W
+
+
+def _save_live():
+    np.savez(LIVE_WEIGHTS, **{k: v.astype(np.float32) for k, v in get_learner().W.items()})
+    _push_to_dataset()
+
+
+def record_fight(trajectory: dict) -> dict:
+    """Called by /learn. trajectory = {difficulty, steps:[{state,action,bossHP,playerHP}],
+    result:{bossDied,playerDied}}. Buffers it and updates every UPDATE_EVERY fights."""
+    global _FIGHTS
+    if not ENABLED:
+        return {"enabled": False}
+    if trajectory.get("difficulty") != ADAPT_TIER:
+        return {"enabled": True, "skipped": "only HARD-tier fights train the brain"}
+    if len(trajectory.get("steps", [])) < 2:
+        return {"enabled": True, "skipped": "too short"}
+    with _LOCK:
+        _BUFFER.append(trajectory)
+        _FIGHTS += 1
+        if len(_BUFFER) >= UPDATE_EVERY:
+            stats = get_learner().update(list(_BUFFER))
+            _BUFFER.clear()
+            if stats.get("updated"):
+                _save_live()
+            return {"enabled": True, "fights": _FIGHTS, **stats}
+        return {"enabled": True, "fights": _FIGHTS, "buffered": len(_BUFFER),
+                "update_in": UPDATE_EVERY - len(_BUFFER)}
+
+
+def status() -> dict:
+    return {"enabled": ENABLED, "fights_seen": _FIGHTS, "buffered": len(_BUFFER),
+            "persistent": bool(DATASET_REPO and HF_TOKEN), "adapt_tier": ADAPT_TIER}

piano/notes.json

@@ -0,0 +1 @@
+{"seq": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 23, 0, 23, 17, 11, 11, 11, 11, 17, 17, 17, 23, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 13, 13, 13, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 6, 6, 9, 9, 12, 9, 9, 9, 13, 13, 13, 9, 13, 13, 13, 13, 13, 18, 23, 23, 23, 18, 13, 13, 4, 4, 4, 2, 2, 2, 2, 2, 2, 3, 4, 4, 4, 4, 4, 3, 2, 2, 2, 2, 3, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 25, 25, 25, 25, 25, 25, 20, 20, 20, 20, 20, 20, 16, 16, 16, 10, 9, 7, 6, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 8, 8, 8, 8, 8, 8, 8, 8, 13, 13, 13, 13, 13, 13, 13, 11, 11, 11, 11, 11, 20, 20, 20, 20, 20, 20, 20, 20, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 11, 11, 9, 9, 9, 9, 9, 9, 9, 9, 9, 20, 20, 20, 20, 20, 14, 14, 14, 14, 14, 14, 14, 14, 20, 20, 22, 23, 23, 23, 23, 23, 21, 21, 21, 21, 20, 20, 20, 9, 2, 2, 2, 2, 20, 20, 20, 20, 21, 21, 21, 21, 21, 17, 17, 17, 17, 17, 8, 8, 8, 8, 8, 8, 5, 5, 1, 1, 1, 1, 1, 1, 3, 3, 5, 5, 1, 0, 0, 0, 0, 0, 0, 11, 15, 13, 13, 15, 13, 13, 11, 11, 11, 11, 11, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 18, 18, 18, 18, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 8, 8, 6, 6, 6, 6, 6, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 11, 21, 21, 23, 23, 23, 23, 23, 14, 14, 14, 14, 14, 14, 14, 14, 18, 18, 18, 20, 20, 21, 21, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 21, 20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 10, 9, 9, 9, 10, 11, 20, 20, 20, 23, 23, 24, 25, 25, 25, 25, 13, 13, 13, 13, 23, 23, 23, 23, 23, 22, 21, 21, 21, 21, 21, 21, 21, 18, 13, 6, 6, 6, 6, 16, 16, 16, 16, 16, 16, 14, 14, 14, 13, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 24, 24, 24, 24, 13, 1, 1, 1, 1, 1, 1, 1, 3, 0, 5, 5, 11, 12, 13, 13, 13, 13, 15, 25, 0, 0, 0, 13, 0, 0, 15, 18, 18, 18, 18, 18, 18, 18, 18, 16, 16, 16, 16, 16, 17, 17, 17, 17, 16, 16, 16, 16, 16, 16, 16, 13, 13, 13, 13, 12, 12, 8, 8, 8, 8, 9, 9, 9, 10, 20, 20, 20, 20, 21, 21, 21, 21, 18, 18, 18, 18, 20, 20, 20, 20, 20, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 20, 20, 20, 20, 18, 18, 18, 18, 18, 18, 18, 16, 16, 14, 14, 14, 13, 13, 12, 11, 11, 11, 11, 11, 18, 18, 18, 18, 18, 13, 13, 13, 13, 13, 14, 18, 18, 18, 18, 18, 20, 20, 20, 20, 18, 18, 18, 18, 18, 20, 20, 20, 20, 20, 20, 18, 18, 18, 18, 18, 18, 18, 18, 18, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 17, 16, 16, 16, 14, 14, 14, 13, 13, 13, 13, 13, 13, 13, 13, 13, 16, 18, 18, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 19, 19, 18, 18, 18, 18, 18, 19, 20, 20, 20, 19, 18, 18, 18, 10, 9, 9, 9, 10, 21, 21, 21, 21, 9, 9, 9, 9, 21, 21, 21, 21, 21, 21, 23, 25, 25, 25, 25, 23, 23, 12, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 16, 18, 18, 21, 21, 21, 21, 21, 21, 19, 19, 18, 18, 18, 16, 16, 16, 16, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 20, 20, 20, 20, 11, 11, 11, 11, 13, 13, 13, 13, 21, 23, 23, 23, 23, 23, 21, 18, 12, 12, 11, 11, 11, 11, 11, 11, 11, 12, 13, 13, 18, 20, 20, 20, 21, 21, 20, 20, 20, 16, 16, 16, 16, 18, 18, 18, 18, 18, 18, 18, 17, 17, 17, 17, 20, 20, 20, 20, 9, 9, 9, 9, 9, 15, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 19, 20, 20, 20, 20, 23, 23, 23, 23, 21, 21, 21, 21, 21, 14, 14, 14, 14, 14, 14, 18, 25, 25, 25, 25, 25, 25, 25, 25, 24, 24, 24, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 21, 18, 13, 18, 13, 18, 18, 0, 0, 0, 0, 0, 13, 13, 13, 13, 20, 20, 21, 21, 21, 21, 21, 21, 21, 21, 23, 25, 25, 25, 25, 25, 25, 23, 23, 23, 13, 21, 23, 21, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 13, 25, 25, 25, 25, 25, 23, 23, 22, 21, 21, 17, 17, 17, 17, 18, 18, 21, 21, 21, 21, 20, 20, 20, 20, 20, 20, 20, 14, 9, 9, 8, 9, 9, 9, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 13, 13, 9, 9, 9, 14, 25, 25, 25, 25, 25, 25, 25, 25, 20, 19, 14, 14, 14, 14, 14, 14, 14, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 23, 25, 25, 25, 25, 25, 23, 5, 5, 5, 5, 5, 9, 13, 0, 13, 7, 1, 1, 1, 1, 0, 0, 0, 0, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 6, 6, 6, 6, 6, 9, 9, 9, 9, 9, 9, 8, 8, 8, 8, 9, 11, 11, 11, 11, 9, 9, 9, 9, 9, 9, 9, 9, 9, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 8, 0, 13, 0, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 11, 11, 11, 11, 11, 9, 9, 9, 9, 9, 9, 8, 8, 8, 8, 8, 8, 12, 13, 13, 13, 13, 13, 13, 13, 13, 13, 9, 9, 9, 9, 9, 8, 8, 8, 8, 8, 8, 8, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 14, 23, 23, 23, 23, 23, 20, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 21, 21, 18, 18, 17, 17, 17, 17, 17, 18, 18, 18, 18, 7, 7, 6, 6, 6, 6, 7, 9, 9, 9, 9, 9, 11, 11, 11, 11, 11, 11, 11, 9, 9, 9, 9, 9, 9, 8, 8, 8, 8, 9, 11, 11, 11, 11, 11, 10, 9, 9, 9, 9, 9, 9, 9, 8, 8, 8, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 9, 9, 13, 13, 13, 13, 13, 13, 13, 23, 23, 23, 23, 23, 13, 13, 9, 9, 9, 9, 9, 8, 8, 8, 8, 9, 18, 21, 21, 21, 21, 25, 25, 25, 25, 21, 10, 9, 9, 9, 9, 20, 20, 20, 20, 20, 20, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 11, 11, 13, 18, 18, 18, 18, 18, 18, 21, 21, 21, 21, 11, 11, 11, 11, 11, 11, 11, 9, 9, 6, 6, 6, 6, 6, 9, 9, 9, 17, 20, 20, 20, 20, 20, 18, 18, 18, 18, 18, 17, 13, 9, 6, 6, 0, 0, 0, 0, 0, 16, 16, 0, 14, 11, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 11, 13, 13, 13, 9, 6, 6, 6, 6, 6, 7, 9, 9, 9, 9, 11, 11, 11, 11, 11, 13, 13, 16, 20, 20, 20, 20, 18, 18, 18, 17, 17, 18, 18, 18, 18, 13, 15, 15, 13, 13, 13, 7, 10, 20, 20, 20, 20, 20, 20, 20, 20, 20, 16, 13, 13, 13, 13, 13, 13, 14, 15, 14, 13, 13, 13, 13, 13, 13, 13, 11, 9, 9, 9, 9, 16, 22, 22, 22, 21, 21, 20, 16, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 17, 17, 18, 20, 20, 20, 20, 20, 20, 21, 22, 0, 22, 0, 22, 22, 22, 22, 22, 22, 20, 18, 13, 13, 13, 13, 15, 18, 20, 20, 0, 20, 20, 21, 22, 22, 22, 22, 0, 0, 0, 0, 20, 0, 0, 22, 22, 22, 22, 0, 0, 0, 0, 0, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 16, 20, 20, 17, 17, 17, 17, 18, 22, 22, 22, 22, 18, 15, 15, 15, 15, 15, 15, 15, 15, 19, 19, 20, 25, 25, 25, 25, 25, 15, 15, 15, 15, 15, 21, 27, 0, 27, 27, 25, 25, 25, 25, 25, 25, 17, 8, 10, 8, 8, 10, 0, 19, 27, 0, 27, 27, 25, 25, 25, 25, 25, 25, 25, 22, 20, 20, 20, 20, 20, 20, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 16, 16, 16, 16, 13, 13, 13, 13, 13, 13, 13, 10, 10, 10, 10, 10, 15, 15, 15, 15, 15, 15, 15, 13, 11, 10, 8, 8, 8, 8, 10, 19, 20, 20, 20, 20, 20, 20, 20, 20, 19, 19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 20, 19, 19, 11, 1, 1, 1, 1, 1, 8, 8, 9, 20, 20, 22, 22, 22, 20, 20, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 12, 8, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 7, 7, 7, 7, 7, 7, 7, 15, 15, 15, 15, 15, 15, 13, 13, 13, 13, 13, 15, 15, 15, 15, 15, 23, 23, 23, 23, 17, 16, 11, 10, 10, 10, 10, 10, 13, 13, 13, 13, 13, 15, 23, 23, 23, 23, 23, 23, 15, 13, 13, 11, 11, 11, 11, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 22, 22, 22, 22, 21, 21, 21, 21, 22, 22, 23, 23, 23, 23, 25, 25, 25, 25, 23, 23, 23, 23, 23, 23, 22, 22, 20, 20, 20, 18, 15, 15, 15, 15, 15, 15, 15, 15, 13, 13, 13, 13, 13, 13, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 15, 15, 15, 15, 15, 15, 15, 10, 12, 15, 15, 15, 15, 15, 15, 8, 1, 1, 1, 1, 1, 1, 1, 2, 2, 3, 3, 3, 3, 3, 15, 15, 15, 15, 15, 22, 22, 22, 22, 22, 22, 22, 22, 16, 16, 11, 15, 15, 15, 19, 19, 20, 20, 0, 0, 0, 0, 0, 0, 20, 20, 16, 13, 13, 13, 13, 13, 13, 13, 13, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 18, 18, 19, 19, 19, 18, 0, 0, 0, 0, 3, 0, 0, 10, 12, 13, 12, 11, 11, 15, 15, 22, 22, 22, 22, 22, 16, 11, 11, 8, 6, 6, 6, 6, 6, 6, 6, 6, 10, 11, 11, 11, 11, 11, 11, 11, 15, 15, 15, 15, 15, 15, 15, 22, 22, 22, 23, 23, 23, 23, 22, 16, 16, 16, 16, 22, 22, 22, 22, 22, 0, 0, 0, 0, 0, 0, 4, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 20, 20, 20, 20, 20, 20, 13, 13, 13, 13, 13, 14, 14, 14, 16, 16, 15, 15, 15, 15, 16, 16, 23, 23, 23, 23, 23, 16, 16, 16, 15, 11, 10, 10, 10, 10, 11, 18, 22, 23, 23, 23, 22, 20, 13, 8, 8, 8, 8, 8, 8, 8, 10, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 11, 11, 10, 10, 10, 10, 16, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 19, 19, 19, 19, 19, 19, 11, 3, 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, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 6, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3, 5, 9, 9, 9, 9, 9, 9, 9, 14, 20, 20, 20, 20, 6, 6, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 2, 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, 6, 11, 12, 13, 13, 13, 13, 13, 13, 9, 9, 9, 9, 9, 9, 9, 9, 10, 11, 11, 11, 11, 12, 13, 13, 13, 13, 14, 14, 14, 14, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 11, 11, 11, 11, 11, 11, 9, 9, 9, 9, 9, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 2, 2, 2, 11, 11, 11, 11, 11, 14, 17, 21, 21, 21, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 0, 0, 0, 0, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 13, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 18, 25, 25, 25, 25, 25, 25, 25, 23, 23, 20, 11, 11, 11, 11, 11, 11, 11, 11, 13, 18, 22, 25, 25, 25, 25, 25, 25, 25, 25, 25, 13, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 14, 18, 18, 18, 18, 18, 19, 20, 19, 15, 15, 14, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 18, 18, 18, 18, 18, 13, 13, 13, 13, 13, 13, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 13, 13, 13, 13, 13, 13, 18, 18, 18, 21, 21, 21, 21, 21, 21, 21, 21, 9, 9, 9, 1, 4, 4, 4, 4, 11, 11, 11, 11, 9, 9, 9, 9, 9, 9, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 13, 13, 13, 13, 13, 13, 17, 17, 17, 17, 17, 17, 17, 17, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 9, 12, 12, 19, 23, 23, 23, 21, 21, 21, 21, 21, 21, 21, 23, 23, 23, 23, 25, 25, 25, 25, 21, 21, 21, 21, 14, 14, 14, 14, 14, 14, 14, 14, 13, 13, 13, 13, 13, 13, 13, 13, 16, 16, 16, 16, 16, 11, 11, 11, 6, 6, 6, 6, 6, 9, 11, 11, 11, 11, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 17, 13, 13, 13, 13, 13, 13, 13, 13, 1, 1, 1, 1, 1, 2, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 20, 20, 21, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 12, 11, 11, 11, 11, 7, 4, 4, 4, 10, 11, 12, 13, 13, 13, 13, 13, 13, 13, 12, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 11, 11, 11, 11, 11, 11, 11, 11, 14, 19, 20, 21, 21, 20, 21, 21, 20, 20, 20, 20, 20, 18, 8, 8, 8, 8, 8, 8, 8, 8, 8, 16, 25, 25, 25, 25, 25, 25, 25, 25, 25, 22, 10, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 0, 0, 23, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 15, 9, 9, 9, 9, 9, 9, 9, 9, 8, 8, 8, 8, 8, 8, 8, 8, 8, 7, 6, 6, 6, 6, 6, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 6, 6, 6, 6, 5, 5, 5, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 10, 11, 11, 12, 13, 13, 15, 18, 20, 20, 20, 21, 21, 21, 21, 0, 6, 0, 0, 0, 0, 21, 0, 6, 6, 6, 6, 6, 25, 25, 25, 25, 21, 9, 9, 9, 6, 6, 6, 6, 6, 6, 7, 7, 6, 4, 5, 8, 14, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 13, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 23, 25, 25, 25, 25, 25, 25, 25, 25, 12, 11, 11, 11, 11, 11, 11, 11, 11, 17, 23, 23, 24, 24, 23, 23, 14, 14, 14, 14, 14, 14, 11, 11, 11, 11, 11, 11, 0, 0, 0, 0, 12, 12, 12, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 20, 22, 22, 22, 23, 23, 23, 20, 20, 20, 20, 19, 20, 20, 20, 20, 20, 14, 14, 8, 8, 8, 8, 8, 8, 8, 8, 8, 5, 1, 1, 1, 9, 1, 1, 6, 9, 6, 3, 3, 7, 9, 9, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 24, 22, 21, 21, 21, 19, 18, 18, 18, 18, 18, 18, 18, 6, 6, 6, 6, 6, 13, 15, 21, 21, 21, 15, 9, 5, 0, 0, 0, 0, 25, 0, 0, 6, 6, 6, 6, 7, 9, 13, 21, 21, 21, 21, 21, 21, 23, 23, 24, 25, 25, 25, 25, 25, 25, 9, 5, 6, 15, 15, 15, 15, 19, 21, 21, 18, 18, 18, 18, 21, 21, 21, 21, 21, 19, 19, 18, 18, 19, 21, 21, 21, 21, 23, 22, 21, 19, 19, 20, 20, 20, 20, 22, 22, 20, 21, 21, 19, 19, 19, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 11, 11, 11, 11, 19, 23, 25, 26, 25, 25, 25, 25, 23, 23, 23, 24, 23, 23, 23, 23, 23, 23, 20, 20, 23, 23, 25, 25, 25, 25, 25, 25, 25, 25, 18, 18, 18, 18, 18, 18, 18, 18, 21, 21, 21, 20, 20, 20, 13, 13, 13, 13, 13, 13, 13, 13, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 21, 21, 21, 21, 23, 23, 24, 25, 25, 25, 25, 25, 25, 25, 18, 18, 18, 18, 18, 20, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 23, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 21, 21, 18, 18, 18, 18, 16, 16, 16, 16, 16, 16, 17, 19, 20, 20, 20, 20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 21, 21, 21, 21, 20, 20, 20, 20, 20, 20, 20, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 18, 18, 20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 22, 23, 23, 23, 23, 23, 24, 24, 24, 24, 21, 22, 21, 20, 20, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 20, 24, 25, 25, 25, 25, 25, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 24, 25, 25, 18, 13, 14, 14, 13, 13, 13, 13, 12, 11, 11, 11, 11, 11, 11, 8, 6, 6, 6, 14, 23, 25, 25, 25, 25, 25, 25, 25, 23, 23, 23, 23, 23, 23, 23, 23, 23, 6, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 15, 15, 15, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 13, 18, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 22, 22, 21, 21, 21, 21, 21, 21, 21, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 25, 25, 25, 25, 25, 23, 21, 21, 21, 21, 21, 21, 25, 25, 25, 25, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 20, 20, 21, 21, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 23, 23, 23, 23, 23, 23, 23, 23, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 21, 21, 21, 21, 21, 20, 20, 20, 20, 20, 20, 20, 16, 10, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 21, 21, 21, 21, 21, 21, 21, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 18, 18, 18, 18, 18, 18, 18, 18, 18, 13, 10, 10, 10, 10, 11, 11, 11, 20, 20, 20, 20, 20, 20, 20, 15, 9, 9, 9, 9, 9, 9, 9, 9, 9, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 14, 13, 13, 13, 13, 15, 17, 17, 17, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 20, 20, 20, 23, 23, 23, 21, 21, 21, 21, 21, 21, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 5, 5, 5, 5, 5, 5, 3, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 7, 13, 13, 13, 16, 0, 20, 19, 18, 18, 18, 18, 18, 18, 20, 20, 20, 20, 20, 20, 20, 18, 18, 18, 18, 19, 21, 21, 21, 21, 21, 21, 21, 21, 21, 11, 9, 9, 8, 2, 2, 2, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 13, 13, 15, 15, 15, 15, 15, 14, 14, 13, 13, 13, 8, 8, 8, 8, 19, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 20, 20, 20, 0, 0, 0, 0, 16, 23, 23, 23, 23, 23, 10, 10, 9, 9, 10, 10, 11, 20, 20, 20, 20, 23, 23, 26, 26, 26, 23, 13, 13, 13, 13, 13, 13, 12, 12, 12, 13, 17, 21, 24, 24, 24, 24, 21, 18, 13, 13, 13, 13, 15, 16, 16, 16, 16, 16, 16, 16, 14, 14, 13, 13, 13, 13, 5, 5, 5, 13, 25, 25, 25, 25, 25, 25, 25, 18, 8, 5, 5, 5, 5, 5, 5, 5, 5, 11, 17, 17, 17, 0, 0, 0, 0, 0, 11, 11, 0, 23, 0, 0, 0, 0, 18, 18, 18, 18, 18, 18, 18, 18, 17, 16, 16, 16, 16, 17, 17, 17, 17, 16, 16, 16, 16, 16, 16, 16, 16, 13, 13, 13, 13, 12, 8, 8, 8, 8, 8, 9, 9, 10, 20, 20, 20, 20, 21, 21, 21, 21, 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 17, 17, 17, 17, 15, 14, 14, 14, 14, 20, 20, 20, 20, 20, 20, 20, 18, 18, 18, 18, 13, 13, 13, 10, 9, 9, 9, 9, 9, 18, 18, 18, 20, 22, 22, 22, 22, 20, 20, 20, 20, 19, 19, 19, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 19, 19, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 25, 25, 25, 25, 21, 21, 21, 21, 21, 21, 20, 20, 20, 20, 20, 21, 21, 21, 21, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 18, 18, 18, 18, 18, 9, 9, 9, 9, 9, 18, 18, 18, 18, 18, 16, 16, 16, 16, 16, 16, 16, 16, 20, 20, 20, 20, 20, 20, 12, 11, 11, 10, 10, 10, 10, 13, 13, 13, 13, 13, 13, 13, 13, 13, 18, 21, 21, 21, 21, 21, 21, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 23, 23, 23, 23, 23, 21, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 13, 13, 13, 13, 20, 20, 21, 21, 21, 21, 20, 20, 18, 18, 18, 18, 18, 18, 18, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 6, 6, 6, 6, 6, 6, 6, 8, 21, 23, 23, 21, 18, 18, 18, 18, 18, 11, 11, 10, 10, 10, 9, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 14, 14, 14, 14, 14, 14, 14, 14, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 23, 23, 23, 17, 11, 11, 8, 5, 0, 0, 5, 0, 0, 13, 21, 21, 21, 21, 21, 21, 21, 23, 23, 23, 20, 13, 13, 13, 13, 11, 11, 11, 13, 21, 21, 21, 21, 21, 21, 12, 11, 11, 11, 11, 11, 11, 11, 11, 11, 13, 13, 13, 13, 13, 13, 13, 13, 8, 8, 8, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 20, 20, 20, 20, 20, 20, 15, 9, 9, 9, 9, 9, 9, 9, 18, 18, 20, 20, 20, 20, 20, 20, 11, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 13, 18, 18, 18, 20, 20, 20, 20, 20, 20, 20, 20, 5, 5, 5, 5, 5, 5, 1, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 13, 13, 13, 13, 11, 20, 17, 0, 25, 25, 25, 13, 5, 8, 8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 0, 0, 18, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 4, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 8, 8, 11, 11, 11, 12, 11, 11, 11, 9, 8, 7, 8, 8, 8, 8, 8, 8, 13, 13, 13, 13, 13, 13, 13, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 8, 9, 8, 8, 8, 9, 13, 17, 17, 17, 17, 10, 10, 9, 10, 10, 11, 11, 11, 11, 11, 12, 12, 13, 11, 11, 9, 8, 8, 4, 4, 0, 0, 0, 0, 0, 0, 0, 17, 20, 20, 20, 14, 14, 14, 8, 2, 2, 2, 5, 8, 8, 8, 8, 8, 8, 8, 8, 4, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 1, 0, 0, 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], "tok2midi": {"0": 0, "1": 59, "2": 60, "3": 61, "4": 62, "5": 63, "6": 64, "7": 65, "8": 66, "9": 67, "10": 68, "11": 69, "12": 70, "13": 71, "14": 72, "15": 73, "16": 74, "17": 75, "18": 76, "19": 77, "20": 78, "21": 79, "22": 80, "23": 81, "24": 82, "25": 83, "26": 84, "27": 85}, "n_tokens": 28, "fps": 8, "midi_lo": 59, "midi_hi": 85}

piano/piano_mind.py

@@ -0,0 +1,168 @@
+"""
+piano_mind.py -- a Modular Mind that plays piano, built with the SAME method as the
+boss-fight brain: several tiny specialist MLPs emit latents, a RecursiveLink merges
+them into one shared latent, and a coordinator reads it to pick the next note. Some
+specialists "own" a register (Bass/Tenor/Soprano/Rest) and add a drive to those keys;
+two are modulators (Onset/Phrase) that only write into the shared latent.
+
+Trained by next-note prediction on a note sequence transcribed from a song
+(piano/notes.json). Tiny -> trains in seconds and runs instantly for the self-playing
+piano in the Space. torch is used (already a Space dep); the architecture mirrors
+mm_torch / modular_mind.
+"""
+from __future__ import annotations
+import json, os
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+K = 40            # context window (frames of recent notes) = 5s at 8fps
+H, D_LATENT = 64, 32
+# (name, owned register or None) -- mirrors the boss's 5 owners + 2 modulators
+SPECS = [("Bass", "low"), ("Tenor", "mid"), ("Soprano", "high"),
+         ("Rest", "rest"), ("Onset", None), ("Phrase", None)]
+
+
+def _group_masks(n_tokens):
+    """token 0 = rest; notes 1..n-1 split into low/mid/high thirds."""
+    m = {g: torch.zeros(n_tokens) for g in ("low", "mid", "high", "rest")}
+    m["rest"][0] = 1.0
+    notes = list(range(1, n_tokens))
+    third = max(1, len(notes) // 3)
+    for j, t in enumerate(notes):
+        g = "low" if j < third else ("mid" if j < 2 * third else "high")
+        m[g][t] = 1.0
+    return m
+
+
+class PianoMind(nn.Module):
+    def __init__(self, n_tokens):
+        super().__init__()
+        self.n_tokens = n_tokens
+        self.fc1 = nn.ModuleList([nn.Linear(K, H) for _ in SPECS])
+        self.lat = nn.ModuleList([nn.Linear(H, D_LATENT) for _ in SPECS])
+        self.drv = nn.ModuleDict({n: nn.Linear(H, 1) for n, owns in SPECS if owns})
+        # RecursiveLink (ReGLU + residual), same shape as the boss bridge
+        self.ni = nn.LayerNorm(D_LATENT)
+        self.v = nn.Linear(D_LATENT, 2 * D_LATENT, bias=False)
+        self.g = nn.Linear(D_LATENT, 2 * D_LATENT, bias=False)
+        self.d = nn.Linear(2 * D_LATENT, D_LATENT, bias=False)
+        self.no = nn.LayerNorm(D_LATENT)
+        self.coord = nn.Linear(D_LATENT, n_tokens)
+        gm = _group_masks(n_tokens)
+        for g, t in gm.items():
+            self.register_buffer(f"mask_{g}", t)
+
+    def forward(self, feat):                      # feat [B, K] in [0,1]
+        B = feat.shape[0]
+        drives = torch.zeros(B, self.n_tokens, device=feat.device)
+        lats = []
+        for i, (name, owns) in enumerate(SPECS):
+            h = torch.tanh(self.fc1[i](feat))
+            lats.append(self.lat[i](h))
+            if owns:
+                drives = drives + self.drv[name](h) * getattr(self, f"mask_{owns}")
+        z = torch.stack(lats, 0).sum(0)
+        zn = self.ni(z)
+        shared = self.no(self.d(F.relu(self.g(zn)) * self.v(zn)) + z)
+        return drives + self.coord(shared)        # logits [B, n_tokens]
+
+    @torch.no_grad()
+    def telemetry(self, feat):                    # feat [1, K] -> logits, per-specialist info, shared
+        drives = torch.zeros(1, self.n_tokens)
+        lats, per = [], []
+        for i, (name, owns) in enumerate(SPECS):
+            hh = torch.tanh(self.fc1[i](feat))
+            lat = self.lat[i](hh); lats.append(lat)
+            d = None
+            if owns:
+                d = float(self.drv[name](hh).item())
+                drives = drives + d * getattr(self, f"mask_{owns}")
+            per.append({"name": name, "owns": owns,
+                        "drive": round(d, 3) if d is not None else None,
+                        "act": round(float(lat.norm().item()), 3)})
+        z = torch.stack(lats, 0).sum(0); zn = self.ni(z)
+        shared = self.no(self.d(F.relu(self.g(zn)) * self.v(zn)) + z)
+        logits = drives + self.coord(shared)
+        return logits[0], per, [round(float(v), 2) for v in shared[0].tolist()]
+
+
+def _seq_feats(seq, n_tokens):
+    import torch
+    s = torch.tensor(seq, dtype=torch.long)
+    X, Y = [], []
+    for t in range(K, len(s)):
+        X.append(s[t - K:t].float() / n_tokens)
+        Y.append(s[t])
+    return torch.stack(X), torch.tensor(Y)
+
+
+def train_and_save(notes_path=os.path.join(HERE, "notes.json"),
+                   out=os.path.join(HERE, "piano_weights.pt"), epochs=900, seed=0):
+    torch.manual_seed(seed)
+    meta = json.load(open(notes_path))
+    seq, n_tokens = meta["seq"], meta["n_tokens"]
+    X, Y = _seq_feats(seq, n_tokens)
+    model = PianoMind(n_tokens)
+    opt = torch.optim.Adam(model.parameters(), lr=1e-2)
+    n = X.shape[0]; bs = 512
+    for ep in range(epochs):
+        perm = torch.randperm(n)
+        tot = 0.0
+        for i in range(0, n, bs):
+            idx = perm[i:i + bs]
+            logits = model(X[idx])
+            loss = F.cross_entropy(logits, Y[idx])
+            opt.zero_grad(); loss.backward(); opt.step()
+            tot += loss.item() * len(idx)
+        if ep % 80 == 0 or ep == epochs - 1:
+            with torch.no_grad():
+                acc = (model(X).argmax(1) == Y).float().mean().item()
+            print(f"  epoch {ep:4d}  loss {tot/n:.3f}  next-note acc {acc:.3f}")
+    import numpy as _np
+    arr = _np.array(seq)                       # seed from the most-sounding window (song fades in)
+    bi = int(max(range(len(seq) - K), key=lambda i: int((arr[i:i + K] > 0).sum())))
+    torch.save({"state": model.state_dict(), "n_tokens": n_tokens,
+                "tok2midi": meta["tok2midi"], "K": K, "fps": meta.get("fps", 8),
+                "seed_seq": seq[bi:bi + K]}, out)
+    print(f"saved -> {out}")
+    return model, meta
+
+
+class PianoPlayer:
+    """Loads the trained PianoMind and autoregressively yields the next note token."""
+    def __init__(self, weights=os.path.join(HERE, "piano_weights.pt")):
+        ck = torch.load(weights, map_location="cpu")
+        self.n_tokens = ck["n_tokens"]; self.K = ck["K"]; self.fps = ck["fps"]
+        self.tok2midi = {int(k): int(v) for k, v in ck["tok2midi"].items()}
+        self.seed_seq = ck["seed_seq"]
+        self.model = PianoMind(self.n_tokens); self.model.load_state_dict(ck["state"]); self.model.eval()
+
+    @torch.no_grad()
+    def next_token(self, history, temperature=0.95, anti_silence=3, rep_penalty=1.5):
+        h = list(history)[-self.K:]
+        if len(h) < self.K:
+            h = [0] * (self.K - len(h)) + h
+        feat = torch.tensor([[x / self.n_tokens for x in h]], dtype=torch.float32)
+        logits, per, shared = self.model.telemetry(feat)
+        logits = logits / max(1e-3, temperature)
+        # keep it musical: don't collapse to silence, don't get stuck on one key
+        if anti_silence and all(t == 0 for t in h[-anti_silence:]):
+            logits[0] -= 8.0
+        for t in set(h[-3:]):
+            if t > 0:
+                logits[t] -= rep_penalty
+        tok = int(torch.multinomial(F.softmax(logits, -1), 1).item())
+        return tok, self.tok2midi.get(tok, 0), {"spec": per, "shared": shared}
+
+
+if __name__ == "__main__":
+    model, meta = train_and_save()
+    # quick listen: generate 40 notes from the song's seed
+    p = PianoPlayer()
+    hist = list(p.seed_seq)
+    out = []
+    for _ in range(40):
+        tok, midi, _ = p.next_token(hist); hist.append(tok); out.append(midi)
+    print("sample MIDI stream:", out)

piano/poly_mind.py

@@ -0,0 +1,150 @@
+"""
+poly_mind.py -- a CHORD-capable Modular Mind (same method as the boss / mono piano:
+specialists -> RecursiveLink -> coordinator), but multi-LABEL: it predicts the SET of
+notes sounding in the next frame, not a single note. Trained by multi-label next-frame
+prediction on a polyphonic transcription (poly_notes.json, a piano-roll of chords).
+"""
+from __future__ import annotations
+import json, os
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+K, H, D_LATENT = 16, 64, 32           # context frames (=2s @8fps), hidden, latent
+SPECS = [("Bass", "low"), ("Tenor", "mid"), ("Soprano", "high"),
+         ("Sustain", None), ("Onset", None), ("Phrase", None)]
+
+
+def _group_masks(n):
+    m = {g: torch.zeros(n) for g in ("low", "mid", "high")}
+    third = max(1, n // 3)
+    for i in range(n):
+        g = "low" if i < third else ("mid" if i < 2 * third else "high")
+        m[g][i] = 1.0
+    return m
+
+
+class PolyMind(nn.Module):
+    def __init__(self, n_notes):
+        super().__init__()
+        self.n = n_notes
+        nf = K * n_notes
+        self.fc1 = nn.ModuleList([nn.Linear(nf, H) for _ in SPECS])
+        self.lat = nn.ModuleList([nn.Linear(H, D_LATENT) for _ in SPECS])
+        self.drv = nn.ModuleDict({nm: nn.Linear(H, 1) for nm, o in SPECS if o})
+        self.ni = nn.LayerNorm(D_LATENT)
+        self.v = nn.Linear(D_LATENT, 2 * D_LATENT, bias=False)
+        self.g = nn.Linear(D_LATENT, 2 * D_LATENT, bias=False)
+        self.d = nn.Linear(2 * D_LATENT, D_LATENT, bias=False)
+        self.no = nn.LayerNorm(D_LATENT)
+        self.coord = nn.Linear(D_LATENT, n_notes)
+        for gname, t in _group_masks(n_notes).items():
+            self.register_buffer("mask_" + gname, t)
+
+    def _core(self, feat, tel=False):
+        drives = torch.zeros(feat.shape[0], self.n, device=feat.device)
+        lats, per = [], []
+        for i, (nm, o) in enumerate(SPECS):
+            h = torch.tanh(self.fc1[i](feat))
+            lat = self.lat[i](h); lats.append(lat)
+            dd = None
+            if o:
+                dd = self.drv[nm](h)
+                drives = drives + dd * getattr(self, "mask_" + o)
+            if tel:
+                per.append({"name": nm, "owns": o,
+                            "drive": round(float(dd.mean().item()), 3) if dd is not None else None,
+                            "act": round(float(lat.norm().item()), 3)})
+        z = torch.stack(lats, 0).sum(0); zn = self.ni(z)
+        shared = self.no(self.d(F.relu(self.g(zn)) * self.v(zn)) + z)
+        logits = drives + self.coord(shared)
+        return logits, per, shared
+
+    def forward(self, feat):
+        return self._core(feat)[0]
+
+    @torch.no_grad()
+    def telemetry(self, feat):
+        logits, per, shared = self._core(feat, tel=True)
+        return logits[0], per, [round(float(v), 2) for v in shared[0].tolist()]
+
+
+def _rolls(seq, n):
+    R = np.zeros((len(seq), n), dtype=np.float32)
+    for i, fr in enumerate(seq):
+        for t in fr:
+            R[i, t] = 1.0
+    return R
+
+
+def train_and_save(notes=os.path.join(HERE, "poly_notes.json"),
+                   out=os.path.join(HERE, "poly_weights.pt"), epochs=700, seed=0):
+    torch.manual_seed(seed)
+    meta = json.load(open(notes)); seq, n = meta["seq"], meta["n_tokens"]
+    R = _rolls(seq, n)
+    X = np.stack([R[t - K:t].reshape(-1) for t in range(K, len(R))])
+    Y = np.stack([R[t] for t in range(K, len(R))])
+    X, Y = torch.tensor(X), torch.tensor(Y)
+    model = PolyMind(n)
+    opt = torch.optim.Adam(model.parameters(), lr=8e-3)
+    pw = torch.tensor(float((Y.numel() - Y.sum()) / (Y.sum() + 1)))   # balance sparse positives
+    N, bs = X.shape[0], 512
+    for ep in range(epochs):
+        perm = torch.randperm(N); tot = 0.0
+        for i in range(0, N, bs):
+            idx = perm[i:i + bs]
+            loss = F.binary_cross_entropy_with_logits(model(X[idx]), Y[idx], pos_weight=pw)
+            opt.zero_grad(); loss.backward(); opt.step(); tot += loss.item() * len(idx)
+        if ep % 100 == 0 or ep == epochs - 1:
+            with torch.no_grad():
+                p = (torch.sigmoid(model(X)) > 0.5).float()
+                tp = (p * Y).sum(); prec = tp / (p.sum() + 1); rec = tp / (Y.sum() + 1)
+            print(f"  ep {ep:4d}  loss {tot/N:.3f}  precision {prec:.2f}  recall {rec:.2f}")
+    cnt = R.sum(1)
+    bi = int(np.argmax(np.convolve(cnt, np.ones(K), "valid")))
+    torch.save({"state": model.state_dict(), "n_tokens": n, "tok2midi": meta["tok2midi"],
+                "K": K, "fps": meta.get("fps", 8), "seed": [seq[bi + j] for j in range(K)]}, out)
+    print("saved ->", out)
+    return model, meta
+
+
+class PolyPlayer:
+    def __init__(self, weights=os.path.join(HERE, "poly_weights.pt")):
+        ck = torch.load(weights, map_location="cpu")
+        self.n, self.K, self.fps = ck["n_tokens"], ck["K"], ck["fps"]
+        self.tok2midi = {int(k): int(v) for k, v in ck["tok2midi"].items()}
+        self.seed = ck["seed"]
+        self.model = PolyMind(self.n); self.model.load_state_dict(ck["state"]); self.model.eval()
+
+    @torch.no_grad()
+    def next_frame(self, history, thresh=0.45, maxn=4):
+        h = list(history)[-self.K:]
+        while len(h) < self.K:
+            h = [[]] + h
+        R = np.zeros((self.K, self.n), dtype=np.float32)
+        for i, fr in enumerate(h):
+            for t in fr:
+                if 0 <= t < self.n:
+                    R[i, t] = 1.0
+        feat = torch.tensor(R.reshape(1, -1))
+        logits, per, shared = self.model.telemetry(feat)
+        probs = torch.sigmoid(logits)
+        # anti-silence: if the last 2 frames were empty, force the most likely note(s)
+        if all(len(f) == 0 for f in h[-2:]):
+            thresh = min(thresh, float(probs.max()) * 0.6 + 1e-3)
+        idx = (probs > thresh).nonzero().flatten().tolist()
+        if len(idx) > maxn:
+            idx = torch.topk(probs, maxn).indices.tolist()
+        toks = sorted(int(t) for t in idx)
+        return toks, [self.tok2midi.get(t, 0) for t in toks], {"spec": per, "shared": shared}
+
+
+if __name__ == "__main__":
+    train_and_save()
+    p = PolyPlayer()
+    hist = list(p.seed)
+    print("sample chords (MIDI sets):")
+    for _ in range(10):
+        toks, mid, _ = p.next_frame(hist); hist.append(toks); print("  ", mid)

piano/poly_notes.json

@@ -0,0 +1 @@
+{"seq": [[], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [6], [6], [6], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [7], [6], [], [], [], [], [], [], [], [], [], [6], [9], [9], [9], [], [9], [9], [9], [9], [9], [], [9], [9], [9], [9], [9, 11], [9, 11], [9], [11], [], [3], [3, 6], [9], [11], [11], [11], [11], [], [11], [11], [11], [11], [1], [1], [1, 11], [1], [1], [1], [], [1], [1], [1, 13], [13], [1], [1], [1, 16], [1, 16], [1, 23], [], [13], [25], [25], [13, 25, 37], [4, 7, 13], [4, 19], [4, 19], [4], [4], [4, 23], [4, 23], [23], [14], [14], [14, 23], [4, 40], [4], [4, 33], [4], [4], [4, 14, 33], [14, 23], [14, 23], [4, 14, 23], [14], [], [2], [2], [2], [2], [2], [2], [2], [2], [2], [14], [2], [2, 24], [2, 24], [2], [2], [2], [2], [2], [2, 21], [14], [], [], [11, 15], [15], [15], [15], [15, 27], [11, 21], [11], [], [15], [15], [15], [15], [15], [15, 21], [], [], [], [15], [15], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [4, 7, 26, 37], [4, 7], [4, 7, 28, 38], [7, 28, 31, 35], [7, 28, 31, 35], [7, 16], [7, 16, 28, 30], [19, 28, 30, 35], [7, 16, 28, 30], [7, 11, 28, 30], [9, 30, 37], [7, 11, 14, 30], [11, 14, 26], [11, 14, 26], [11, 14, 16], [11, 14, 16], [11, 14, 26], [11, 14, 18, 26], [11, 20, 26], [11, 14, 19, 31], [11, 19], [12, 19], [9, 13, 19], [9, 14, 19, 26], [12, 14, 19, 26], [12, 14, 19, 26], [4, 12, 26], [12], [12, 18], [11], [12, 16, 24], [11, 24], [11, 16], [11, 19], [18, 23], [11, 18, 23], [11, 17, 23], [11, 18, 23], [9, 18], [17], [9, 18], [9, 18], [9], [11, 19, 20], [19, 22], [19, 23], [19, 23], [19, 23], [19, 23], [11, 20, 43], [11, 21, 43], [7, 12, 21], [11, 43], [9, 11], [9, 18, 30], [9, 18, 30], [6, 9, 18, 30], [9, 12, 18, 30], [7, 18, 30], [7, 18, 30, 31], [7, 12, 18, 30], [6, 11, 28], [6, 11, 16, 28], [6, 11, 28], [11, 16], [16, 23, 28], [16, 23, 28, 30], [11, 16, 23, 28], [11, 16, 28], [11, 16, 28], [11, 29], [11, 16], [9, 16], [9, 19], [7], [6, 9], [6, 9, 18], [6, 9], [6, 9, 18], [6, 9, 21], [6, 9, 18], [6, 9, 18], [6, 9, 18], [6, 9], [6, 11, 19], [6, 11, 31], [23, 30, 33, 38], [30, 33, 35, 38], [7, 33], [7, 19], [6], [7, 16, 19], [6, 16, 26, 28], [6, 16, 26, 28], [16, 19, 26, 28], [7, 19], [7, 9, 22, 31], [28, 30, 36, 37], [28, 30, 33, 37], [12, 18, 28, 30], [9, 30], [7, 20], [12, 20, 24, 33], [12, 24, 28, 33], [12, 21, 28, 33], [7, 12, 21], [7], [7, 11, 15, 18], [11, 18], [30, 33], [6, 11, 15, 23], [9], [7, 9, 20, 32], [19, 21, 27, 33], [7, 33], [7, 11, 21, 28], [9, 11, 19], [9, 11, 19], [11, 19], [11, 30, 31, 40], [11, 30, 31, 40], [11, 30, 37], [11, 30], [19, 23, 31, 35], [11, 19], [11], [7, 11], [11, 18], [12, 18], [2, 18, 30, 33], [12, 18, 30, 33], [6, 12, 30, 33], [12, 26, 30, 33], [12, 26, 30, 33], [12, 18, 26, 33], [12, 26, 33, 42], [12, 16, 28, 38], [12, 28], [12, 27], [12, 18, 27, 34], [12, 18, 27, 34], [11, 18, 27, 34], [6, 11, 18, 26], [11, 18, 26], [11, 15, 18], [11, 15, 18], [11, 18, 27, 33], [11, 15, 18, 27], [11, 15, 18], [11, 15, 18], [11, 15, 18], [11], [6, 11], [11], [], [11], [11], [15], [15], [11, 15], [0, 3], [], [], [6], [], [], [], [], [21], [], [], [], [27], [23], [], [], [21], [], [], [], [6], [17, 19, 23], [4, 15, 19, 30], [4, 16, 19, 28], [16, 19], [4, 16, 19], [4, 19], [7, 15, 19], [16, 18, 28, 30], [7, 16, 18, 30], [18, 30, 35, 40], [18, 28, 30, 40], [7, 18, 28, 30], [7, 11, 14, 30], [7, 11, 18], [11, 16, 26], [16, 26, 28], [11, 16, 26], [11, 18, 26, 33], [14, 19, 26, 33], [11, 19, 26, 31], [11, 19, 26, 33], [11, 19, 26, 33], [9, 12, 19, 31], [12, 20, 26], [12, 14, 19], [12, 14, 19], [12], [10, 12, 18], [12, 18], [12, 16, 18], [12, 16], [11, 16], [11, 16], [11, 16], [11, 18], [11, 18], [11, 18, 30], [18, 33], [11, 18], [9, 11, 18], [9, 11, 18], [9, 11, 18, 30], [9, 11], [0, 9, 21, 33], [11, 19, 31, 35], [19, 31, 35, 38], [11, 31, 35, 38], [11, 19, 23, 35], [11, 23, 35], [11, 33], [11, 21, 33], [21, 24, 33], [11], [11, 25], [18, 24, 33], [24], [9, 18, 24], [6, 9, 18, 29], [9, 18, 23], [7, 23], [18, 23, 35, 42], [7, 23], [6, 16, 28], [6, 9], [6, 21], [4, 19, 30, 33], [23, 31, 35, 38], [23, 31, 35, 38], [32, 35], [19, 23, 33, 35], [21, 31, 33, 38], [19, 31, 33, 38], [21, 30, 33, 37], [7, 21, 28, 33], [16, 19, 21, 28], [6, 16, 21, 33], [6, 16, 21, 28], [6, 33], [6, 21], [6, 21], [6], [6], [6], [6], [6], [6, 14, 24], [7, 31, 33, 35], [31, 33, 35, 42], [31, 35], [7], [7], [6, 14, 17], [6, 16, 20], [6, 16], [7, 16], [7, 16], [6, 21, 31], [21, 30, 33, 36], [9, 30, 33, 40], [9, 30, 33], [9], [9], [7, 22], [24, 33, 35, 36], [24, 33, 35, 40], [7, 21, 24, 35], [19, 36], [7, 15, 17, 23], [7, 15, 18, 23], [23], [6, 15, 18, 23], [9], [9, 21, 33], [7, 21, 33], [7, 21, 33], [7, 21, 27, 33], [], [9, 15, 19, 23], [19, 31, 35], [23, 31, 35, 40], [31, 34, 35, 40], [23, 31, 35, 40], [19, 23, 31, 40], [11, 23, 31, 40], [11, 28], [11], [11, 16], [11, 16], [12, 23, 29, 35], [2, 12, 25, 42], [12, 26, 30, 33], [12, 27, 30, 33], [12, 27, 30, 33], [12, 27, 30, 42], [12, 26, 33], [12, 33, 42], [12, 24, 30, 33], [12, 16, 28], [12, 16, 28, 35], [11, 16, 23], [11, 15, 35], [11, 15, 18, 35], [12, 15, 18, 35], [12, 15, 23, 35], [15, 18, 23, 35], [15, 18, 23, 35], [11, 15, 18, 35], [15, 18, 22, 35], [15, 18, 23, 35], [15, 18, 23, 35], [11, 15, 22, 34], [11, 15, 23, 35], [11, 15, 35], [11, 15, 23], [23], [], [11], [11], [6], [], [8], [3, 6], [], [1], [], [5], [2], [21], [6, 23], [4, 23], [], [5], [], [], [], [0], [4, 10], [2], [1, 5, 10], [0, 10], [10], [0, 10], [4, 28], [4, 18, 28], [4, 20, 28], [4, 19, 28], [4, 11, 19, 28], [4, 11, 19, 28], [4, 11, 19, 28], [4, 11, 19, 26], [12, 20, 26, 32], [0, 27, 31], [0, 26, 31], [7, 12, 26, 30], [7, 12, 30], [0, 7, 12, 27], [12, 28, 30, 37], [7, 12, 27, 28], [2, 26, 28, 35], [2, 9, 38], [2, 30, 37, 38], [9, 26, 30, 37], [2, 9, 27, 30], [2, 26, 30, 37], [2, 26, 30, 37], [2, 14, 23, 30], [4], [4, 11, 22, 43], [4, 24, 38], [4, 16], [38], [4, 8, 11], [4, 11], [4, 9, 11], [18, 27], [20, 28], [16, 19, 28], [16, 19, 28], [2, 19, 28], [4, 19, 30], [4, 11, 16, 30], [4, 11, 19, 30], [0, 4, 18, 30], [0, 7, 19], [0, 7, 19, 30], [0, 16, 19, 31], [0, 16, 30], [0, 16, 19, 28], [7, 16, 28], [7, 16, 28], [9, 16, 26, 28], [9, 18, 26, 30], [18, 26, 30, 38], [18, 26, 30, 38], [9, 26, 30, 38], [2, 18, 26, 30], [2, 9, 18, 26], [4, 26, 40], [4], [4], [4, 28], [4, 11, 28], [4, 11, 28], [4, 8, 11], [4], [4, 30], [4, 30, 37], [4, 29, 31, 38], [4, 19, 31, 38], [19, 28], [4, 7, 19, 28], [4, 19, 28], [4, 11, 19, 28], [4, 19], [4, 7, 18], [7, 19, 26, 31], [0, 19, 26, 31], [0, 19, 26], [0, 4, 26], [0, 18, 24], [0, 7, 18, 24], [0, 18, 24], [2, 9, 22, 30], [9, 18, 23, 30], [2, 9, 23, 30], [9, 18, 23, 30], [9, 18, 21, 30], [2, 18, 21], [9, 18, 21, 30], [4, 16, 19, 21], [4, 38], [4, 38, 40], [4], [4, 11, 28, 35], [4, 11], [4], [4], [4], [4, 19, 30], [31, 35], [2, 20], [4, 7, 19, 24], [4, 7, 19, 23], [19, 28], [4, 11, 19, 28], [4, 18, 28], [0, 3, 19, 30], [0, 19], [0, 16, 19, 31], [0, 16, 30, 31], [0, 16, 30], [0, 16, 28, 30], [0, 7, 16], [4, 16, 28], [9, 18, 28], [9, 18, 30], [2, 9, 18, 30], [2, 9, 18, 30], [4, 9, 18, 26], [9, 18, 27, 30], [9, 18, 30], [9, 16, 26], [4, 11, 26, 28], [11, 28, 35, 40], [3, 11, 28], [1, 11, 28], [11, 27, 28, 35], [4, 27, 28], [4, 8, 28], [4, 28], [4, 19, 31, 38], [4, 19, 31, 40], [28, 31, 38, 40], [4, 28, 31, 40], [4, 28, 31, 40], [28, 31, 40], [11, 19, 31, 38], [4, 19, 27], [4, 19, 31, 38], [0, 26, 31, 38], [0, 31, 38], [0, 26, 31, 38], [26, 31], [7, 19, 26, 31], [0, 7, 19, 26], [0, 7, 16], [6, 9, 29], [9, 30], [2, 9, 18, 26], [2, 9], [2, 6, 9], [2, 9, 18, 24], [2, 9, 24], [2], [4, 24], [4, 23], [4], [4, 11], [4, 11], [11, 29, 35], [16, 28, 35], [7, 14, 16], [30, 38, 43], [4, 31, 38, 40], [4, 31, 38, 40], [4, 28, 31, 38], [4, 28, 31], [4, 30, 31], [4, 16, 30, 31], [4, 19, 30], [0, 4, 31], [0, 31, 38], [16, 31, 35, 38], [0, 31, 42], [2, 7, 16], [16, 19, 27, 28], [28, 31, 38, 40], [0, 31, 38, 40], [18], [26, 30, 36], [18, 26], [2, 4, 18, 30], [2, 4, 9], [2, 8, 18, 28], [2, 18, 28], [2, 4, 37], [4, 16, 28], [4, 16, 19, 28], [4, 19, 28], [4, 11], [4, 19], [4, 20, 29], [4, 19], [4, 8], [4, 31], [4, 19, 31], [4, 18, 31], [19, 28], [4, 11, 19], [4, 19, 29], [19, 28], [4, 19, 27], [0, 4, 7, 31], [0, 7, 31], [0, 7, 31, 38], [27, 31, 38], [26, 31], [0, 7, 43], [0, 24], [0, 7, 10], [2, 21, 28, 33], [9, 30, 35, 37], [2, 9, 30, 35], [30, 33, 35, 42], [9, 21, 29, 33], [2, 6, 18, 22], [2, 9, 19], [2, 16, 19], [4, 19], [4, 16, 19], [4, 19], [4, 11, 19], [11, 19, 23], [4, 8, 11], [4, 38], [4, 7, 16, 18], [4, 11, 19, 31], [11, 31], [2, 19, 31, 38], [7, 19], [2, 4, 7], [1, 4, 19, 28], [4, 19, 28], [19, 28, 29], [0, 4, 19], [19, 31, 38], [0, 7, 31], [0, 30, 31], [0, 16], [0, 16, 20, 29], [0, 16], [0, 7, 16], [9, 29, 30], [2, 9], [2, 9, 18], [9, 18, 26], [4, 18, 26], [2, 18, 26], [2, 10, 18, 28], [3, 18], [4], [4, 16], [4, 29], [0, 11, 16, 28], [11, 16, 28], [4, 11], [4], [4, 7, 12], [4, 28, 31], [19, 28, 35, 38], [4, 19, 28, 31], [4, 28, 31, 35], [4, 6, 16, 19], [4, 7, 19, 31], [30, 33, 37, 40], [18, 21], [4, 11, 19, 21], [7, 11, 19, 23], [19, 24, 31, 36], [19, 23, 35], [11, 23, 31, 37], [19, 23, 31, 38], [19, 23, 31, 38], [11, 31, 38], [12, 31, 32, 33], [4, 33, 36, 40], [24, 33, 36, 40], [12, 28, 33, 40], [12, 19, 28, 33], [23, 28, 31, 33], [11, 28, 31, 35], [11, 28], [4, 18, 21], [18, 21, 26], [6, 18, 22, 27], [6, 18, 21, 27], [18, 23], [6, 9, 18], [9, 18], [11, 16, 18, 22], [17, 22, 29], [19, 23, 29, 31], [7, 19, 23, 31], [7, 19, 31, 35], [7, 23, 28, 31], [19, 23, 28, 31], [19, 23, 29, 31], [11, 19, 20, 27], [3, 6, 9, 30], [9, 21, 23, 30], [30, 32, 35, 40], [7, 28, 31, 35], [2, 7, 9], [7, 15, 18], [6, 15, 18, 23], [6, 9, 15], [7, 19, 27, 30], [4, 19, 28, 31], [4, 28, 31, 35], [4, 28, 35, 38], [4, 19, 28, 35], [4, 19, 28], [4, 28, 35, 38], [4, 19, 21, 28], [4, 18, 27, 30], [6, 15, 27], [6, 15, 27, 43], [6, 27, 43], [6], [6], [6], [6], [2, 15, 18], [16, 19], [6, 16, 18, 23], [6, 15, 23], [6, 15, 19], [6, 28, 35, 38], [9, 28], [7, 13], [4, 9, 33, 41], [30, 33, 37, 40], [19, 24, 29, 33], [9, 16, 19], [19, 28, 31, 38], [4, 19, 28, 38], [7, 19, 28], [4, 7], [7, 30, 33], [6, 28, 30, 33], [6, 20, 29], [6, 16, 28, 35], [6, 11, 16, 35], [18, 27, 30, 33], [27, 30, 33], [6, 21, 33], [4, 29, 30, 33], [23, 28, 31, 35], [11, 28, 31, 35], [11, 28, 31, 35], [11, 31], [4, 6, 11, 31], [11, 19, 31], [6, 11], [12, 19, 23], [12, 21, 24], [6, 12, 24, 28], [12, 24, 28, 33], [12, 24, 28, 33], [12, 28, 33], [12, 21, 28, 33], [7, 12], [3, 20, 33, 35], [27, 30, 35], [30, 35], [2, 30, 35], [30, 35], [11, 28, 30, 34], [11, 27, 30, 35], [23, 27, 30, 35], [11, 27, 30, 34], [11, 27, 30], [11, 28, 30], [22, 28, 30, 35], [3, 11, 30], [30, 35], [11, 18, 30, 35], [11, 30, 35], [4, 18, 30, 33], [3], [3, 10], [3, 10, 33], [3, 10], [2, 10], [3, 10], [3, 10], [2], [3, 10], [3, 10], [3, 10], [3, 10, 33], [3, 10], [3, 10], [3, 10], [4, 10], [3, 10], [3, 10], [3, 10], [3, 10], [2, 10], [9], [8], [4, 30, 31, 34], [19, 31, 35], [4, 23, 31, 38], [4, 18, 31, 38], [7, 18, 23, 35], [4, 18, 21, 30], [30, 33, 35, 37], [4, 11, 30, 33], [4, 18, 21, 33], [19, 23, 35], [11, 20, 23, 35], [11, 20, 23, 35], [19, 23], [11, 23, 35, 42], [7, 11, 19], [11, 18, 20, 23], [4, 12, 22, 35], [12, 33, 36], [12, 24, 33, 36], [9, 12, 33, 36], [9, 12, 19], [19, 23, 35, 40], [11, 31, 35, 38], [11, 21], [3, 11, 18, 21], [11, 19, 21], [9, 11, 19, 21], [11, 19, 21], [6, 21], [6, 9, 21], [9, 21], [9, 18], [0, 18, 21], [7, 19, 23, 35], [19, 23, 31, 42], [11, 19, 35, 42], [19, 23, 30, 35], [11, 19, 23], [11, 19, 23, 35], [11, 18, 26, 35], [4, 9, 18, 33], [9, 18, 21, 33], [28, 32, 33, 35], [28, 31, 35, 38], [7, 28, 31], [2, 6, 15, 17], [6, 9, 15, 30], [6, 15, 18], [4, 27, 30], [16, 28, 31, 38], [16, 19, 28, 31], [4, 19, 28, 31], [19, 28, 31, 33], [19, 28, 31], [7, 28, 31, 38], [4, 19, 28, 31], [6, 27, 30, 35], [6, 27, 30, 35], [6, 26, 30, 35], [6, 30, 35], [6, 30, 35], [6, 35], [6], [6], [14, 17, 19], [16, 19, 43], [7, 15, 19], [6, 9, 15, 18], [6, 9, 15, 31], [28, 31, 35, 38], [7, 31], [7, 16], [28, 31, 33, 38], [21, 30, 33, 37], [16, 30, 33], [16, 33], [19, 28, 31, 35], [16, 28, 31, 38], [4, 9, 19, 31], [4, 7, 16], [23, 34, 36, 41], [30, 33, 37, 40], [20, 23, 33, 40], [19, 23, 40], [6, 11], [0, 19, 21], [11, 24, 33], [6, 19, 24], [4, 36, 43], [31, 35, 40], [31, 35, 38, 40], [20, 28, 35, 40], [11, 28, 35, 40], [28, 35, 42], [6, 28, 35, 42], [6, 23], [12, 16, 24, 29], [18, 25, 30], [6, 18, 24, 40], [18, 24, 30, 40], [18, 24, 36, 40], [0, 18, 24, 40], [12, 18, 24, 28], [12], [4, 24], [11, 15, 27, 35], [11, 27, 35], [11, 15, 27, 35], [3, 11, 27, 35], [11, 15, 27, 35], [11, 23, 27, 35], [27, 35, 42], [8, 11, 27, 35], [3, 23, 27, 35], [3, 27, 35], [3, 27, 35], [23, 27, 35], [15, 26, 35, 42], [15, 23, 26, 35], [23, 27, 35], [2, 6, 15, 23], [11, 27, 35], [6], [], [], [6, 15], [15], [6, 15], [6], [], [], [], [], [2, 9], [1], [11], [3, 5, 11], [11], [], [], [], [], [35], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [4, 40], [4], [4], [40], [], [40], [40], [40], [], [40], [], [], [], [40], [40], [], [], [], [], [], [], [], [40], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [4], [], [4], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [4, 40], [4, 40], [4], [], [], [], [40], [40], [], [40], [33, 40], [], [], [40], [40], [40], [], [], [], [], [], [], [40], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [4], [4], [4], [], [], [], [], [], [], [9], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [40], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [40], [], [], [40], [40], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [8], [8], [8], [8], [0, 8], [8], [2, 5, 8], [4, 7, 11, 23], [4, 8, 11], [4, 7, 11], [4, 8, 11], [4, 8, 11], [3, 7, 19], [4, 8, 11], [5, 7, 11, 40], [4, 8, 11], [4, 7, 11], [6, 9, 14, 21], [1, 9, 16, 21], [16, 21], [1, 10, 16, 21], [10, 16, 20, 21], [4, 16, 20, 21], [4, 7, 11, 20], [8, 16, 19], [4, 8], [4, 8, 20], [8, 19, 28], [4, 7, 11, 16], [4, 8, 11, 18], [8, 18], [4, 7, 11, 18], [4, 18, 30], [10, 19, 33], [9, 14, 21], [16, 22], [1, 10, 16, 21], [1, 10, 16, 21], [1, 7, 16, 19], [4, 7, 19, 28], [8, 16, 19, 28], [7, 16, 19, 28], [3, 16, 19], [8, 16, 19], [0, 4, 7], [8, 16, 19], [0, 7, 16], [4, 7, 11], [4, 8, 11, 16], [0, 10, 16, 33], [1, 16, 28, 42], [16], [10, 16, 28], [16, 28], [2, 8, 28], [4, 7, 19, 28], [8, 16], [6, 11, 16], [4, 11, 16], [4, 8, 28], [2, 7, 11, 16], [5, 7, 16], [1, 8, 16], [4, 7, 11], [4, 8, 43], [1, 10, 33], [5, 9], [6, 9], [1, 10], [0, 10], [0, 5, 10], [4, 7, 11], [4, 8], [4, 8, 19, 40], [0, 4, 8], [8, 23], [4, 7, 11, 43], [8, 11], [4, 7], [4, 7, 11, 23], [0, 4, 8], [1, 9, 15, 20], [10, 16, 21, 43], [16, 21], [1, 10, 16, 21], [2, 10, 16, 21], [3, 8, 16, 19], [4, 7, 19, 28], [8, 16, 19, 23], [7, 16, 19, 28], [4, 16, 19, 23], [16, 19], [4, 7], [4, 8, 16, 18], [3, 8, 16, 18], [4, 7, 16, 30], [4, 18, 30, 40], [5, 9, 15], [2, 16, 22, 24], [3, 16, 24, 28], [0, 10, 30], [10], [0, 5, 23], [7, 16, 23, 28], [8, 16, 23], [4, 7, 16, 23], [0, 16, 23], [16, 19, 23, 28], [4, 7, 19, 28], [8, 16, 19, 28], [8, 19, 23], [4, 7, 11, 19], [4, 9, 18], [10, 15, 18, 21], [16, 18], [16, 18], [10, 16, 18, 30], [0, 16, 18, 30], [8, 16, 18, 28], [4, 16, 19], [4, 8, 16], [4, 7, 40], [4, 8, 11, 16], [4, 8, 16], [4, 7, 11], [1, 4, 8, 16], [4, 8, 16], [4, 7, 11], [4, 9, 16], [6, 9, 16, 33], [5, 9, 16], [2, 6], [0, 10, 33], [0, 5, 10], [0, 6, 10, 33], [9], [0], [1, 6, 10], [1, 10], [0, 10], [4, 7], [16, 19, 28, 31], [16, 19, 28, 31], [4, 7, 19, 28], [8, 19, 28, 31], [4, 7, 28, 31], [4, 7, 20, 28], [8, 16, 20, 28], [4, 7, 19, 28], [4, 11, 19], [2, 5, 8, 16], [10, 17, 20, 30], [18, 21, 30], [18, 21, 30, 33], [21, 30, 33, 36], [10, 30, 33], [4, 7, 28, 31], [19, 28, 31, 35], [19, 28, 31, 35], [4, 28, 31, 35], [16, 19, 28, 31], [4, 8, 28, 43], [8, 19, 28, 35], [19, 28, 35], [4, 7, 19], [4, 11, 18], [2, 5, 18, 27], [15, 27, 30, 37], [27, 30, 34, 37], [1, 10, 27, 30], [1, 10], [33], [4, 7, 16], [1, 8, 16], [7, 16], [4, 11, 16], [16, 19, 43], [0, 7, 16], [4, 8, 23], [4, 40], [3, 7, 11], [0, 23, 43], [6], [4, 8, 11, 19], [4, 8], [4, 6, 11, 40], [4, 8, 11], [4, 9], [0, 10, 19, 36], [9], [1, 21, 33], [10, 16, 21], [21], [2, 7, 16, 31], [7, 16, 19, 31], [16, 19, 31], [4, 7, 11, 31], [7, 19, 31], [7, 31], [4, 11, 18, 30], [3, 8, 18, 30], [1, 6, 30], [4, 11, 18, 30], [9, 22], [10, 19, 31, 33], [1, 4, 21], [2, 33, 40], [1, 10, 28, 33], [10, 22], [4, 7, 19], [19], [8, 16, 19], [7, 11, 19, 28], [0, 4, 19], [7, 19], [4, 7, 19, 30], [8, 18, 30], [0, 3, 6, 8], [4, 8, 18, 30], [9, 19, 38], [0, 10, 16], [10, 16, 28], [16, 24, 28], [1, 10, 16, 28], [16, 28, 35, 36], [4, 7, 12, 16], [11, 16, 23, 28], [8, 16, 23, 28], [4, 7, 16, 28], [0, 4, 16, 23], [4, 11, 16, 23], [4, 7, 11, 16], [8, 11, 16], [3, 7, 11, 16], [4, 8, 11, 16], [4, 11, 16], [0, 10, 16, 33], [0, 10, 16], [9, 16], [10, 16], [10, 16, 36], [7, 11, 16], [4, 8, 11], [8], [4, 6, 11, 40], [0, 4, 8], [7, 23], [4, 7, 33], [8, 16, 23, 35], [3, 6, 35], [4, 23, 35], [0, 4, 11, 35], [0, 10, 21, 33], [16, 21, 43], [9, 21, 43], [10, 21, 43], [4, 21, 23, 43], [4, 7, 19], [11, 19, 28, 31], [8, 19, 23, 31], [7, 11, 31], [0, 8, 23], [8, 19, 31], [4, 7, 11, 18], [4, 8, 18], [3, 7, 18, 30], [4, 7, 11, 18], [4, 19, 21], [0, 3, 10, 33], [2, 31, 35, 36], [1, 31, 36, 40], [0, 31, 36, 40], [31, 35, 36], [4, 7, 35, 43], [4, 30, 35], [8, 23, 30, 35], [7, 28, 35, 40], [0], [19], [4, 8, 11], [8, 16, 31], [0, 3, 19, 31], [4, 8, 11, 31], [4, 7, 31], [3, 10, 18], [4, 9, 18, 30], [2, 10, 18, 30], [0, 10, 18, 30], [4, 33], [2, 7, 12, 16], [11, 16], [4, 8, 16, 28], [7, 11, 16, 28], [1, 11, 16, 28], [8, 16, 19], [7, 11, 16, 28], [8, 16, 23, 28], [4, 7, 11, 16], [4, 8, 11, 16], [4, 11, 16, 28], [10, 16], [0, 9, 16, 28], [11, 16, 28], [0, 10, 16], [10, 16], [3, 6, 10, 28], [16], [1, 40], [0, 3, 6, 10], [0, 3, 6, 10], [7, 9], [4, 11, 23, 31], [4, 8, 28, 31], [4, 7, 19, 31], [4, 19, 28, 31], [8, 19, 28, 31], [4, 7, 28, 31], [4, 8, 28, 31], [4, 19, 28, 31], [11, 19, 28, 35], [0, 4, 9], [2, 5, 16, 19], [21, 36, 37], [6, 21, 37], [3, 6, 10, 37], [6, 9, 11, 37], [5, 8], [4, 7], [4, 8, 11, 31], [7, 16], [4, 11, 19], [4, 11, 43], [1, 7, 16], [1, 16, 19], [4, 7, 10, 28], [4, 10, 19], [10, 19], [4, 10, 27, 30], [4, 8, 30, 33], [2, 8, 33, 42], [2, 18], [4, 11, 33], [8, 16, 33], [4, 16, 28], [4, 11, 16], [2, 7, 16, 23], [4, 16, 23, 28], [4, 11, 16, 23], [2, 7, 11, 16], [], [], [40], [], [], [], [40], [6], [], [26, 38], [26, 38], [], [23], [], [], [4, 19], [9, 19], [19], [21], [21], [], [], [18], [19], [19], [19], [19], [], [23], [11, 23], [11, 23], [], [7, 16], [7, 16], [16], [16], [], [], [19], [6, 21, 40], [21, 40], [40], [19], [19], [], [21], [21, 40], [7, 23], [7, 40], [7, 40], [30], [31], [30], [31], [], [6, 27], [27], [27], [30], [30], [40], [40], [40], [4, 7, 23], [4, 7, 23], [4, 7, 23], [23], [], [], [], [], [6, 11], [11, 30], [30], [30], [30], [30], [40], [30], [4, 9], [9], [9], [9, 23], [9, 23], [9], [9], [26], [4, 9], [26], [26, 38], [], [24], [23], [23], [23, 40], [4, 7], [7, 23], [7, 23], [19], [19], [], [], [], [6], [21], [40], [19], [19], [19], [30, 37], [], [4, 7, 23], [4, 23], [23], [23], [23], [23], [23], [23], [6], [27], [27], [40], [], [30], [30], [], [0, 6], [], [], [32], [32], [], [], [], [8], [8], [8], [8, 40], [28], [32], [32], [32], [6, 23], [23], [23], [23, 40], [28, 40], [], [30], [], [], [], [], [6], [30], [32], [32], [32], [37], [], [], [], [30], [], [], [], [4, 8, 32], [8, 32], [32], [], [], [40], [40], [40], [6, 23], [9, 23], [23], [23], [23], [23, 25], [23, 25], [], [5, 23], [23], [23, 25], [25], [23, 25], [], [23, 30], [30], [6], [30], [], [25], [25], [25], [32], [32], [8, 32], [8, 32], [], [25], [25], [25], [], [25], [6, 11], [], [25], [25], [25], [], [35], [35], [6, 35], [35], [], [25], [25], [], [25], [37], [6], [], [], [], [37], [], [35], [35], [4, 8], [4], [35], [], [37], [37], [38], [11, 38], [6, 21], [6], [37], [37], [37], [37], [37], [], [1, 5, 35], [1, 35], [1, 35], [1, 35], [8, 35], [1], [5, 35], [8, 13, 16], [0, 20, 29, 36], [10, 30, 37], [18, 21, 30, 33], [21, 30, 33, 37], [6, 9, 30], [0, 21, 23], [3, 8, 11, 23], [11, 20], [3, 6, 9, 23], [9, 23, 24], [4, 9, 25], [4, 9, 13, 25], [4, 9, 25], [1, 8, 25, 33], [2, 8, 21, 25], [13, 21, 25, 33], [6, 25, 33], [14, 26, 35, 38], [14, 26, 35, 38], [6, 14, 26, 35], [6, 14, 35], [0, 9, 21, 26], [9, 21, 25], [2, 13, 21, 25], [4, 8], [1, 8, 11, 23], [8, 20, 24], [8, 20, 23, 32], [0, 4, 8, 20], [2, 8, 11, 20], [5, 11, 20], [4, 11], [9, 19, 24, 31], [9, 26, 33, 40], [9, 25, 33, 40], [9, 25, 33, 40], [9, 26, 33, 40], [21, 26, 33, 40], [25, 33, 40], [9, 13, 25], [4, 20, 23], [3, 11, 20], [11, 18, 21, 37], [18, 21, 30, 33], [6, 11, 18, 21], [4, 8, 17], [4, 11, 17, 29], [4, 8, 11], [6, 29, 32, 36], [6, 18, 30, 33], [6, 21, 30, 33], [6, 21, 30, 33], [6, 21, 30, 33], [0, 9, 30, 33], [9, 21, 30, 33], [21, 30], [6, 8, 17, 33], [3, 17, 29, 32], [17, 20, 29], [8, 11, 17, 29], [8, 11, 17, 29], [2, 8, 17, 29], [3, 8], [5, 8, 29], [4, 9, 20, 32], [4, 30, 33, 37], [4, 9, 30], [4, 9, 17, 29], [9, 17, 20, 29], [4, 9, 30], [4, 21, 30, 33], [4, 8, 18, 21], [6, 11, 21, 32], [6, 11, 20, 32], [6, 11, 20, 32], [6, 11, 32], [11, 18, 21, 30], [1, 5, 18, 21], [18, 21], [9, 19, 24, 36], [1, 8, 32, 35], [1, 8, 32, 35], [1, 8, 22, 35], [8, 18, 30, 37], [8, 30, 33, 37], [8, 23, 32, 36], [20, 23, 32, 35], [1, 11, 20, 24], [4, 8], [1, 8, 25], [1, 8, 25], [1, 9, 25], [0, 25, 33], [1, 8], [0, 8, 25], [13, 21, 22, 26], [9, 25, 31, 33], [9, 14, 25], [9, 26, 35, 42], [9, 14, 26, 35], [9, 14, 26, 35], [9, 14, 23, 26], [9, 23, 26, 33], [14, 20, 23], [2, 6, 8, 32], [8, 25, 32, 37], [1, 8, 32, 37], [8, 25, 32, 37], [8, 25, 32, 37], [8, 20, 32, 37], [0, 32, 37, 39], [25, 32, 37, 39], [5, 9, 32, 37], [20, 25, 32, 37], [5, 9, 32, 37], [5, 9, 25, 32], [9, 20, 25, 32], [2, 9, 25, 32], [9, 25, 32], [2, 9, 25, 32], [5, 20, 26, 32], [20, 25, 32], [17, 25, 32], [17, 20, 25, 32], [0, 5], [0, 5, 9], [5, 9, 11], [5], [2, 5, 9, 11], [5, 9], [5, 9], [5, 9], [2, 5, 9, 11], [2, 5, 9, 11], [0, 9], [2, 5, 9], [4], [5], [5, 11], [5, 11], [5], [5, 11], [5, 11], [5, 11], [10, 27, 30], [10, 18, 30, 37], [1, 10, 18, 30], [1, 25, 30, 37], [0, 10], [0, 4, 20, 25], [3, 8, 11, 20], [8, 11, 20, 23], [4, 6, 9, 20], [4, 9, 25], [9, 21], [9, 13, 25], [4, 9, 25, 30], [8, 21, 25, 30], [1, 8, 21, 25], [8, 21, 25, 37], [3, 11, 33, 40], [6, 11, 35, 39], [14, 23, 35, 38], [6, 23, 35, 38], [6, 11, 14], [6, 11, 22, 27], [6, 11, 21], [6, 11, 19, 25], [4, 6, 11, 20], [1, 8, 11], [1, 8, 11, 35], [8, 23], [8, 11, 23, 35], [8, 11, 23, 32], [11], [3, 11], [4, 9, 20, 27], [9, 25], [9, 25, 37], [9, 37], [9, 37], [9, 25, 33, 37], [2, 9, 25, 33], [1, 9], [6, 20, 23, 25], [4, 11, 18, 20], [4, 11, 18], [4, 11, 18, 33], [2, 18, 21, 33], [3, 17, 20, 29], [11, 20, 29, 32], [6, 11, 29, 32], [6, 17, 29, 32], [6, 21, 31, 38], [6, 30, 33, 40], [6, 21, 33, 40], [6, 29, 33, 40], [2, 6, 33, 40], [10, 21, 30, 40], [10, 17, 32, 40], [3, 8, 17, 29], [8, 17, 29, 32], [8, 17, 20, 29], [8, 11, 20, 32], [6, 8, 11, 32], [2, 9], [2, 9], [3, 8], [4, 9, 31], [4, 30, 33, 40], [4, 9], [9, 17, 29, 32], [9, 17, 20], [2, 9, 30, 33], [0, 8, 30, 33], [2, 8, 18, 33], [4, 11, 30], [11, 20, 32, 35], [11, 20, 32, 35], [11, 35], [6, 11, 21], [18, 21, 33], [18, 21], [3, 9, 11], [0, 23, 35, 42], [1, 8, 11, 35], [1, 8, 11, 18], [8, 25, 30, 37], [8, 18, 30, 33], [0, 8, 20], [8, 26, 32, 38], [8, 28, 31, 38], [0, 4, 8, 20], [1, 8, 25], [8, 25], [8, 25], [8, 22, 25], [8, 21, 25], [21, 25], [4, 25, 26, 29], [2, 9, 28], [2, 9, 23], [9, 14, 23, 35], [9, 14, 23, 38], [9, 23, 26, 35], [9, 14, 23, 35], [9, 23, 26, 38], [9, 14, 20, 26], [4, 8, 20, 26], [1, 8, 25, 32], [8, 32, 37], [8, 37], [8, 32, 37], [5, 8, 32], [0, 20, 32, 37], [20, 25, 32], [5, 9, 32, 37], [5, 20, 32, 39], [2, 32, 37, 39], [2, 20, 25, 32], [4, 8, 25, 32], [2, 25, 37, 39], [6, 20, 32, 37], [20, 32, 37], [3, 13, 20, 32], [5, 13, 37], [5, 37], [25], [], [], [], [11], [5, 9, 25], [2, 5], [0, 4, 11], [1, 4, 11], [1], [1], [0], [3], [4, 13], [], [5], [1], [13], [1], [1, 5], [13], [2, 6, 13], [6, 25, 32], [25, 32], [1, 25, 33], [1, 21, 25, 33], [6, 13, 21, 33], [33], [13, 21, 33], [9, 13, 32], [9, 21, 33], [], [6], [], [32], [13, 20, 39], [], [9], [9, 16], [18, 21, 30], [30], [18, 21, 30], [21, 30], [29], [], [], [], [], [9], [9], [18, 30, 33], [18, 21, 30, 33], [18, 30, 33, 40], [19, 22], [20, 22], [20, 23], [6, 20, 23], [20, 23], [20, 23], [20, 23], [20, 23], [20], [20, 21], [20, 21], [20, 21], [21], [21], [21], [21], [20, 29], [17, 20, 29, 36], [29, 32], [17, 20, 29], [33], [33], [29], [29], [], [], [], [], [], [], [], [], [23], [20, 32, 37], [21, 24, 33], [6, 21, 33], [25, 33], [21, 33], [21, 33], [33], [33], [20, 32, 35], [23, 32, 35], [20, 32], [], [21], [6, 18, 21], [18, 21, 33], [16], [16, 20], [15, 32], [4, 16, 32], [4, 16], [16], [], [16], [], [20], [21, 33], [8, 21, 33], [8, 21, 33], [11, 21, 33], [11, 21, 33, 40], [12], [6, 20], [13, 25], [21, 25, 32, 33], [6, 25, 32, 33], [25, 33], [25, 32, 40], [9, 25, 32, 33], [32, 33], [13, 39], [13, 33], [13, 21, 33], [13, 39], [21, 25, 32], [6, 21, 26, 33], [14, 26], [], [8], [8, 20, 25, 32], [12, 20], [32], [33], [33], [], [], [], [], [], [], [], [], [], [], [9, 21], [9, 21, 24], [21, 25], [21, 24], [21, 24], [21], [9, 25], [9, 19, 21], [18, 21, 33], [18, 21, 30, 33], [18, 30, 33], [18, 21, 30, 33], [18, 21, 30, 33], [18, 21, 30, 33], [18, 33], [23], [19, 23], [20, 23], [21, 23], [6, 20], [37], [21, 25, 33, 37], [33], [11], [21, 24], [23, 26], [23, 26], [26], [26], [21, 25], [21, 25], [21, 25, 33], [21, 33, 37, 40], [21, 33, 37, 40], [25, 33, 40], [33, 40], [25, 33], [8, 20, 26], [8, 21, 26, 33], [8, 21, 25, 33], [8, 13, 26], [8, 13], [13, 20], [8, 20, 23], [8, 20, 23, 35], [8, 20, 23], [8, 23], [], [21, 30, 33], [18, 21, 33], [32, 33], [6, 32], [], [], [], [], [18, 21], [18, 21, 30, 33], [18, 21, 30, 33], [18, 21, 30, 33], [18], [6, 18, 30], [20, 32, 35], [20, 23, 32, 35], [4, 20], [20, 23], [20, 23, 35], [20, 23], [23, 35], [8, 23], [8, 23], [8, 20], [8, 21, 23], [20, 32, 35], [20, 32], [8, 17], [8, 17], [17, 29], [17, 20, 29, 32], [], [1], [13, 17, 20, 32], [13, 20, 29, 32], [20, 29, 32, 36], [20, 29, 32], [20, 29, 32, 36], [17, 20, 29, 32], [29, 32], [16, 20], [13, 17, 32], [29], [16, 32], [17, 32], [17], [16], [], [], [], [], [], [], [], [], [41], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [0, 3, 7, 11], [7, 11], [7, 11], [4, 7, 11], [4, 7, 11], [4, 7, 10], [7, 11], [7], [7, 11], [], [11], [7, 11], [11], [7, 11], [6, 11], [7, 16], [7, 16, 28], [7, 16], [16], [16], [7, 16, 28], [7, 16, 28], [16], [7, 16, 28, 35], [7, 16, 28], [16, 28], [], [7], [7], [7, 16], [7, 16, 28], [7, 16], [7, 9, 16], [7, 16, 18], [9, 18], [4, 9, 18], [9, 18], [9, 18], [9, 18], [18], [7, 18], [7, 18, 30], [7, 18], [7, 18], [7, 18], [7, 18], [7, 18], [], [6, 14], [6, 15], [6, 15], [6, 15], [6, 15], [6, 15], [6, 9, 15], [6, 9, 15], [15], [15], [15], [9], [9], [9], [3], [], [10, 19], [11, 31, 38], [11, 19, 31], [19, 31, 35, 38], [19, 31, 35, 38], [11, 19, 31], [11, 31], [], [9, 19, 30, 31], [9, 18, 30], [9, 18, 28, 30], [9, 18, 30], [], [7, 15], [7, 16], [7, 12, 16], [6, 14], [2, 6, 14, 26], [6, 14, 26], [6, 14, 26], [6, 14, 26], [14, 26], [6, 14, 26], [6, 14], [6, 14], [], [], [9], [], [6, 10, 12], [6, 12], [11], [6, 11], [4, 7, 11], [4, 7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [7, 11], [11], [6, 11], [6, 11], [6, 11], [6, 11], [6, 11], [6, 11], [6, 9, 11], [6, 11], [6, 11], [6, 11], [6, 11], [6, 11], [], [], [], [], [7, 12, 21, 23], [7, 14, 23], [14, 23], [14, 23], [23], [23], [11], [11, 19], [11, 19], [11, 19, 31], [11, 19], [11, 19, 31], [11, 19, 31], [11, 19], [11, 19], [], [11, 19, 21], [12, 21], [21], [21], [], [23, 26], [23], [], [23, 24], [16, 24, 28, 36], [16, 24, 28], [16, 24, 28, 36], [36], [14, 23], [23], [23], [23, 26], [23], [23, 35, 42], [6, 23, 35], [23], [23], [23, 35], [23], [23], [23, 35], [11, 21], [12, 21], [12, 21], [12, 21], [6, 12, 21], [21], [11, 19], [11, 19], [11, 19], [7, 11, 19], [11], [], [], [11], [11, 19, 31], [11, 19, 30, 31], [11, 19, 31, 35], [11, 19, 31, 35], [11, 19, 31, 38], [11, 21, 33, 43], [12, 21, 31, 33], [12, 21, 33], [2, 12, 21], [12, 21], [12, 21, 33], [6, 12, 21, 33], [12, 21, 33], [12, 21, 33], [12, 21], [12, 21], [21, 24, 33], [31, 33], [31, 33], [33], [], [6], [30, 37], [30], [11], [11, 18, 30], [11, 18, 30], [11, 30, 37], [11, 18, 30, 37], [18, 30], [11, 18, 30, 37], [11, 30, 37], [11, 30, 37], [11, 18, 30, 37], [11, 18, 30, 37], [11, 18, 30, 37], [11, 18, 30, 37], [11, 18, 30, 37], [11, 18, 30, 37], [11, 18, 30, 37], [5, 10, 30, 37], [3], [], [], [2, 5], [], [], [], [10], [10], [3], [3, 10], [3, 10], [3, 10], [10], [3, 10], [2, 9], [3, 10], [3, 10], [3, 10], [3, 10], [3, 5, 10], [3, 10], [3, 10], [3, 10], [3, 10], [3, 6, 10], [2, 10], [5, 10], [2, 5, 10], [3, 10], [3, 5, 10], [4, 30], [4, 35], [4, 19, 35], [23, 31, 35, 38], [3, 6, 35, 38], [4, 8, 23, 35], [4, 23, 31, 35], [4, 23, 35], [2, 23, 31, 35], [2, 7, 23, 31], [1, 4], [1, 18, 21], [1, 6, 21], [1, 10], [1, 6, 18], [1, 5, 10, 21], [1, 6, 18, 22], [1, 6, 10, 21], [1, 6, 10], [1, 6, 10], [2, 10, 12], [4, 8, 34], [4, 8, 35], [4, 8, 35], [0, 8, 35], [1, 23, 35, 38], [4, 8, 35], [4, 8, 35], [4, 8, 35], [2, 40], [2, 33, 40], [2, 4, 18], [0, 6, 21], [1, 10, 18, 21], [1, 10, 18, 21], [2, 21], [1, 6, 10], [1, 6, 9], [1, 10], [1, 5, 10], [2, 6, 10], [1, 6], [0, 6, 21], [4, 18, 30, 34], [4, 35, 38], [23, 35, 38], [23, 35, 38], [4, 8, 35, 38], [4, 8, 35], [4, 8, 35], [23, 31, 35, 38], [2, 7, 23, 35], [3, 23], [0, 18, 21], [1, 6, 10, 21], [1, 10, 18, 21], [18, 20], [18, 21], [0, 3, 6, 21], [0, 7, 21], [0, 3, 7, 21], [3, 6], [2], [3, 6], [4, 26, 29, 33], [4, 8, 19], [16, 19, 29, 31], [4, 8, 19, 31], [4, 8, 11], [4, 8, 21], [4, 8, 21, 33], [4, 21, 30, 33], [2, 7], [2, 4, 19], [1, 4], [1, 6, 11, 18], [1, 6, 15, 18], [1, 10, 15, 18], [0, 6, 18], [1, 5, 10, 18], [5, 10, 18, 23], [1, 10, 15, 18], [0, 6, 9, 18], [2, 7], [4, 7], [0, 3, 8], [4, 8, 11], [4, 8], [0, 4, 8], [0, 4, 9], [4], [4, 8], [4, 8], [4, 8, 11], [0, 4, 11], [1, 4, 8, 16], [3, 8, 43], [4, 8, 31, 43], [4, 8, 31, 43], [4, 7, 31], [2, 6, 28, 31], [2, 16, 31], [2, 6, 11], [2, 7, 28], [0, 6, 23], [6, 23], [2, 11, 23], [0, 11, 23, 38], [0, 7, 11, 38], [23, 31, 38], [2, 6, 12, 38], [0, 4, 7, 12], [0, 7, 12, 38], [0, 38], [1, 12, 38], [2, 7, 12, 38], [2, 7, 12, 38], [2, 5, 12, 38], [0, 7], [0, 43], [1, 24], [0, 7, 12], [0, 7, 12], [0, 7, 12], [0, 3, 12], [0, 3, 9, 12], [2, 9, 11, 43], [2, 9, 11, 43], [4], [4, 9, 11, 21], [4, 42], [0, 4, 23], [4, 11], [4, 11], [4, 11, 40], [4, 11, 40], [3, 6, 11], [11, 16, 32, 42], [0], [0, 3, 8, 31], [4, 8, 31], [4, 8, 31], [1, 4, 31, 43], [0, 6], [0, 6, 16, 32], [6, 40], [1, 7], [4, 6], [4, 7], [4, 9, 11], [2, 9, 11, 38], [9, 11, 26, 38], [1, 9, 38], [0, 3, 6, 33], [2, 5, 9], [2, 9, 33], [2, 40], [2, 9, 38, 43], [4, 9, 38, 43], [4, 9, 38, 43], [2, 5, 19], [9, 19, 38], [1, 9, 14], [4, 14], [2, 9, 19, 31], [9, 14, 31], [2, 9, 14, 19], [1, 38], [0, 14, 21, 33], [0, 7, 21, 43], [12, 21], [6, 12], [6, 12, 21], [0, 11, 23], [1, 4, 11], [3, 6, 11], [1, 23, 30], [2, 11], [0, 6, 11], [0, 11], [0, 23], [4, 6, 11, 23], [2, 6, 11], [6, 12, 27], [14, 27, 39], [0, 15, 27], [5, 15, 27, 39], [6, 15, 39], [6, 16, 39, 42], [0, 3, 42], [1, 16, 42], [2, 16], [1, 6, 11], [6, 11], [30], [6, 16], [6, 11, 16], [2, 6, 11, 16], [0, 15, 35], [2, 5, 15], [1, 10, 15], [1, 15], [15, 30, 35, 37], [0, 6, 30, 37], [6, 11, 37], [16], [16], [5, 16], [6, 16], [6, 15, 35], [2, 5, 35], [15, 34], [0, 3, 5], [2, 11, 16], [4, 16], [4, 8, 16], [4, 8, 40], [4, 8, 40], [4, 8, 40], [4, 11, 40], [4, 11], [0, 3, 9, 16], [4, 8, 16], [4, 8, 16], [1, 4, 16], [4, 8, 11, 16], [4, 8, 16], [4, 8], [4, 8, 11, 40], [2, 7, 16], [2, 7, 16], [2, 7, 16], [6, 16, 35], [6, 16, 36], [6, 16, 36], [0, 7, 16, 38], [0, 7, 16], [0, 7, 16, 38], [0, 7, 22, 38], [0, 7, 23, 38], [0, 7, 23, 38], [0, 7, 38], [0, 7, 23, 36], [0, 3, 7, 36], [0, 7, 23], [0, 4, 7, 43], [0, 7, 23, 43], [0, 7, 21, 33], [0, 7, 21, 31], [0, 7, 21, 31], [0, 7, 43], [0, 7, 33], [0, 7, 23, 33], [2, 5, 9, 23], [2, 9], [2, 5, 9, 23], [0, 4], [4], [4, 11], [4, 11], [4, 11, 31], [4, 11, 43], [4, 11, 31], [4, 11, 43], [0, 3, 6], [6, 11, 24, 42], [0, 4], [4, 8, 40], [4, 8, 40], [4, 40], [4, 8, 24, 40], [4, 8, 24, 40], [0, 6, 23], [6, 23], [23], [4, 21, 23], [4, 21], [5, 23, 31, 38], [2, 9, 19, 31], [2, 9, 31, 38], [0, 9, 30, 38], [0, 3, 9, 38], [2, 9, 16, 38], [2, 9, 38], [0, 9, 16, 38], [2, 9, 40], [2, 9, 16, 21], [0, 8, 16], [2, 5, 9, 16], [2, 9, 16, 18], [2, 9, 16, 38], [2, 9, 16, 31], [5, 15, 31, 38], [2, 9, 19], [2, 9], [1, 9], [0, 4, 12, 21], [2, 7, 12, 21], [1, 7, 11], [6, 11], [6, 12, 23], [12, 42], [12, 23], [6, 11, 23], [6, 12, 23], [11, 18], [0, 6, 11, 18], [3, 5, 11], [11, 23], [0, 6, 23, 39], [6, 27, 39], [0, 6, 27, 39], [2, 6, 11, 23], [6, 11, 23], [6, 11], [1, 6, 27, 39], [1, 9, 11, 39], [9, 21, 39], [6, 11], [2, 6, 11], [0, 6, 11], [0, 6, 11], [6, 11], [0, 6, 23, 35], [0, 6, 11], [2, 6, 11, 35], [6, 11, 35], [0, 6, 11], [2, 9, 35], [6, 11], [6, 11], [3, 12], [14], [2, 15], [15], [4, 6, 15], [6, 11, 16], [3, 6, 11, 16], [6, 11, 16], [2], [2, 6, 35], [0, 8, 18, 30], [4, 8, 30, 34], [4, 8, 31, 33], [4, 8, 35, 38], [4, 19, 35, 38], [4, 23, 35, 38], [4, 23, 31, 35], [4, 8, 23, 35], [4, 35, 38, 42], [2, 19, 23, 31], [2, 7, 11, 19], [1, 21], [1, 6, 18, 21], [1, 6, 10, 21], [1, 6, 10, 21], [1, 6, 10, 21], [1, 6, 14], [1, 6, 10], [1, 10], [0, 3, 7], [2, 7], [0, 7, 16, 20], [4, 12, 18, 22], [4, 8, 19, 23], [4, 19, 23], [2, 19, 23], [4, 8, 19, 23], [4, 8, 14, 23], [4, 8, 19, 23], [2, 19, 21, 23], [2, 4, 7, 21], [2, 18, 21], [1, 6], [1, 10, 18, 22], [1, 10, 18], [1, 6, 18, 21], [1, 6, 21], [1, 6, 10], [1, 6, 10], [1, 10], [0, 3, 6, 9], [0, 7], [3, 7], [0, 4, 29, 34], [4, 8, 36], [4, 23, 31, 35], [4, 8, 23, 35], [23, 31, 35, 38], [4, 8, 35, 38], [4, 19, 23, 35], [1, 4, 31, 35], [1, 23, 31, 35], [2, 19, 23, 31], [2, 7], [0, 6, 21], [1, 10, 18, 20], [1, 10, 18, 21], [1, 18, 21], [1, 6, 10, 21], [6, 10, 21], [0, 3, 10], [1, 6, 10], [0, 7], [2, 7], [0, 7, 18, 30], [4, 8, 19, 31], [4, 8, 19, 28], [1, 4, 19, 31], [0, 4, 8], [0, 4, 8], [4, 29, 31, 32], [4, 8, 30, 33], [1, 7, 33, 40], [2, 7, 11, 19], [2, 7, 28], [0, 6, 15, 18], [1, 11, 15, 18], [0, 10, 15, 18], [1, 18], [1, 6, 15, 18], [1, 6, 15, 18], [1, 6, 15, 18], [1, 6, 10, 15], [0, 3, 7], [1, 7], [7], [7], [7, 35], [4, 7, 11, 35], [4, 7, 11], [4, 11], [4], [4], [4], [4], [4, 30], [], [6], [6], [6, 11], [11], [6, 11], [11], [11], [], [40], [28, 40], [4], [9], [4, 9], [4, 9], [4, 9], [4, 9], [4, 9], [9], [9], [9, 16], [9], [9], [9], [9], [9, 31, 43], [30], [9, 19], [9, 19, 23], [9, 19, 23], [7], [19, 38], [4, 6], [7], [0, 7], [0, 7], [7], [7], [7, 12], [0, 7], [0, 7], [0], [0], [2, 5, 16], [2, 6, 9, 16], [2, 9, 16], [2, 9], [2, 9], [2, 9, 14], [2, 9, 23], [2, 9, 23], [9, 14, 23], [23], [40], [7, 11, 16, 23], [4, 7, 11], [4, 23], [4, 11], [4], [4, 23], [4, 23], [4], [4], [2, 16], [6, 16], [6, 11, 15], [6, 11, 15], [6, 11, 15], [6, 11, 16], [6, 16], [6, 11], [6, 11], [6, 11], [6, 11, 21], [4, 11, 21], [4, 7], [4, 7, 19], [4, 19, 38], [4, 7], [2, 7, 19], [19], [11, 40], [7, 40], [14, 21], [9], [6], [11, 23], [6, 11, 23], [11, 23], [40], [1, 6, 10, 40], [1, 10, 30], [1, 6, 10, 30], [6, 10], [31, 43], [43], [9, 31], [9, 31], [4, 9], [9], [9], [4, 9], [4, 7], [4, 9], [4], [4, 8], [4, 8], [9, 16], [16], [9, 16], [4, 7], [4, 9], [4, 9], [9, 35], [35], [19], [6, 19], [1, 7, 19], [0, 7], [7, 16], [7, 16], [0, 7], [2, 7, 38], [2, 38], [7, 12, 38], [2, 7, 38], [4, 7, 38], [4], [2, 6], [2, 6, 9, 38], [2, 9, 38], [2, 38], [2, 6, 9, 38], [9, 37], [6, 9, 14], [2, 4, 9, 14], [2, 6, 9, 35], [2, 9, 35], [2, 4, 35], [4, 7, 16], [4, 7, 35], [4, 7, 11], [3], [4, 7, 11], [4, 11], [4, 11], [4, 7], [4], [4], [4], [6, 11], [6, 11], [6, 11], [6], [11, 15], [6, 11], [6, 11], [6, 11], [6, 11, 15], [6, 11, 15, 35], [11, 34], [4, 8, 11, 33], [4, 8, 35], [0, 4], [0, 4, 7, 35], [23, 31, 35, 38], [4, 8, 23, 35], [4, 8, 23, 35], [2, 7, 23, 35], [2, 7, 23, 35], [2, 19, 22, 31], [1, 6, 10, 18], [1, 6, 10, 21], [1, 10, 22], [3, 10, 21], [3, 6, 10, 21], [1, 6, 10, 21], [1, 6, 9], [1, 6, 10], [0, 4, 7], [0, 3, 7], [0, 4, 21, 33], [4, 8, 21, 34], [4, 8, 35], [4, 8, 23, 35], [2, 8, 23, 35], [4, 8, 18], [4, 8, 24], [4, 8, 36, 43], [4, 24, 33, 36], [2, 4, 23, 35], [2, 7, 11, 23], [2, 6, 9], [1, 6, 18, 21], [1, 10, 18, 21], [1, 6, 10, 21], [2, 4, 9, 21], [1, 6, 10, 21], [1, 10], [1, 6, 10], [0, 3, 5, 9], [0, 7], [0, 6, 12], [4, 8, 20, 22], [4, 7, 42], [4, 8, 19, 23], [0, 19, 23, 35], [0, 4, 8, 23], [4, 8, 23], [4, 7, 23], [4, 23], [4, 7, 19, 23], [2, 7, 19, 23], [2, 5], [1, 6, 10, 33], [1, 6, 33, 40], [1, 10, 33, 39], [0, 21, 32, 39], [1, 10, 33], [1, 10, 21, 33], [0, 6, 10, 21], [1, 6, 10], [0, 4, 7], [0, 3, 7], [4, 8, 14, 19], [4, 8, 18, 29], [4, 19, 28, 31], [19, 28, 31], [0, 4, 8], [4, 14, 18], [4, 19, 31, 33], [4, 21, 30, 33], [1, 4, 7, 30], [2, 7, 11, 19], [2], [0, 6, 9, 18], [1, 6, 15, 18], [2, 10, 18], [0, 6, 18], [0, 3, 6, 10], [1, 4, 10, 18], [1, 4, 10, 18], [0, 5, 9, 18], [0, 3, 7], [0, 7], [2, 7], [4, 39], [4, 8, 11, 40], [4, 8, 40], [4, 8, 40], [4, 8, 11, 40], [4], [4, 11], [2, 40], [2, 7, 43], [2, 7, 40], [3, 7, 40], [0, 7, 40], [0, 7, 40], [0, 7, 41], [4, 7, 40, 42], [4, 6, 40, 42], [0, 7, 40, 42], [0, 7, 40, 42], [0, 4, 6, 40], [0, 4, 35, 42], [0, 7, 40], [4, 9, 35, 42], [2, 9, 35, 42], [9], [9], [4, 9, 31, 38], [2, 9, 39, 42], [2, 9], [1, 9, 31, 38], [1, 4, 9, 38], [2, 9], [0, 4], [4, 11], [4, 42], [0, 4, 11, 40], [4, 11, 40], [4, 11, 40], [4, 40], [4, 11, 40], [4, 7, 38, 40], [3, 6, 40], [4, 6, 40], [0, 4, 38, 40], [4, 8, 40], [4, 8, 40, 43], [4, 8, 38, 40], [4, 8, 40], [4, 8], [4, 8, 11, 40], [4, 8, 42], [4, 7, 40, 43], [2, 7, 40, 43], [2, 7, 40, 43], [0, 4, 7, 42], [0, 3, 7], [0, 7, 43], [0, 7, 42], [0, 4, 7, 40], [0, 7, 40], [0, 7, 40], [1, 7, 38, 40], [0, 4, 38, 43], [2, 11], [2, 7, 42], [4, 6, 9, 31], [9, 31, 35], [2, 9, 31], [9, 31, 35, 43], [2, 6, 9], [2, 9], [2, 9, 43], [2, 9, 34, 42], [4, 9], [2, 9, 38], [0, 7, 35, 38], [4, 11], [4, 19, 38], [6, 11], [6, 11, 35], [4], [4, 8, 42], [1, 4, 8, 11], [4, 8], [0, 4, 8], [4], [4, 6], [4, 8], [4, 8, 11], [4, 11, 38, 40], [4, 7], [4, 8, 11], [4, 8, 11], [4, 8, 11, 40], [4, 7, 11, 40], [2, 7, 11, 40], [2, 7], [0, 4, 7], [0, 7, 43], [7, 16, 40], [0, 7, 40], [0, 3, 7, 43], [3, 7, 28, 40], [7, 11, 40, 43], [2, 7, 28, 40], [0, 3, 7, 40], [0, 7, 40], [0, 5, 9, 38], [2, 9], [2, 9, 38], [2, 9, 40], [4, 9], [4, 9, 38], [2, 9], [2, 9, 38, 40], [4, 7, 9, 33], [4, 9, 30], [2, 9, 38], [0, 4], [4, 11, 40], [4, 7, 38, 40], [6, 11, 38, 40], [2, 5, 11, 31], [0, 4, 40], [0, 4, 8, 43], [0, 4, 40], [0, 5, 8, 34], [1, 4, 8, 38], [4, 38, 40, 43], [4, 8, 11, 38], [4, 8, 43], [4, 8, 38, 40], [4, 8, 31, 38], [4, 8, 38, 43], [2, 7, 38], [2, 7, 11, 40], [2, 7, 28], [4, 6], [6, 38, 40, 43], [1, 4, 7, 36], [0, 4, 7], [0, 7, 38, 43], [0, 7, 40, 43], [0, 7, 36], [0, 7], [0, 7, 40], [0, 7, 38, 40], [0, 5, 36], [2, 7, 11, 40], [2, 7, 38, 40], [4, 9, 38], [2, 9, 42], [2, 9, 42], [2, 9], [4, 9], [1, 9, 38], [2, 9, 38], [2, 9, 35, 38], [4, 9], [2, 9, 28], [4, 28], [4, 11, 40], [4, 11], [4, 11], [6, 11, 16, 35], [4, 11], [0, 4, 8, 35], [0, 4, 8, 38], [4, 8], [0, 4, 11], [11, 34], [0, 4, 7], [4, 8, 11], [4, 8, 11, 31], [4, 8, 31], [4, 8], [0, 4, 7, 31], [2, 7, 11], [2, 11, 40], [2, 7, 31, 42], [6, 31], [6, 11, 42], [0, 4, 7, 34], [0, 7, 16, 23], [0, 7, 16, 23], [0, 7, 23], [0, 4, 7, 23], [2, 23], [2, 7, 11, 23], [2, 7, 23], [4, 7], [0, 7, 43], [0, 7, 23, 43], [2, 9], [2, 9, 30], [2, 6, 9], [2, 9, 43], [0, 3, 9, 40], [2, 9, 38], [2, 9, 43], [2, 9, 43], [2, 9, 38, 43], [2, 9, 38], [0, 3, 5, 11], [4, 11, 31], [4, 11], [3, 11, 43], [4, 11, 33, 38], [0], [4, 8], [1, 4, 38, 43], [4, 7], [0, 4, 8], [4, 8], [4], [4, 8, 42], [4, 8], [4, 11], [4, 6, 11], [4, 38, 40], [2, 7, 28], [2, 11, 40], [4, 38, 40], [0, 6, 29, 40], [0, 38, 40], [0, 7, 40, 43], [0, 7, 42, 43], [1, 7, 43], [0, 7, 43], [0, 6, 31, 43], [2, 7, 11, 43], [2, 7, 11, 43], [2, 7, 11, 43], [0, 4, 7, 43], [0, 7, 40], [2, 4, 9, 31], [2, 9, 31, 43], [2, 9, 31], [2, 9, 31], [4, 6, 9, 43], [2, 9, 31, 35], [2, 9, 35], [2, 9, 35], [2, 5, 9, 35], [2, 9, 34], [4, 10, 33], [4, 6, 11], [4, 11], [0, 4], [33, 35], [4, 11, 31], [0, 4, 35, 43], [0, 4, 8], [4, 8], [4, 7, 31], [4, 8], [4], [4, 8, 11], [4, 8], [0, 4, 8, 30], [4, 8, 11], [4, 11, 26, 38], [1, 4, 7], [2, 7], [2, 7], [4, 7, 11, 40], [6, 38, 40], [3, 6, 38], [0, 4, 7], [0, 7, 16], [0, 7, 16, 30], [0, 4, 7, 38], [2, 9, 42], [2, 7, 11, 43], [2, 7, 11, 43], [2, 6], [0, 7], [0, 7], [2, 6, 9], [2, 9, 31], [2, 9, 38], [2, 9, 31], [5, 9, 31], [2, 9, 31], [2, 9, 42], [2, 9, 38], [4, 9, 30, 38], [0, 9, 30], [4, 43], [4, 11, 31], [4, 11, 30, 40], [0, 4, 11], [6, 11, 28, 40], [4, 11, 40], [4, 8], [4, 8, 11], [0, 4], [0, 4, 8, 23], [4, 8, 23, 38], [0, 4, 7, 38], [4, 8, 39, 40], [4, 8, 11, 40], [1, 4, 8, 40], [4, 8, 11, 40], [4, 8, 40], [2, 40], [2, 4, 7, 39], [2, 4, 11, 38], [6, 11, 38], [6, 11, 30], [0, 4, 7], [0, 3, 7], [0, 7, 43], [0, 7], [0, 4, 7, 9], [2, 7], [2, 7, 11, 40], [2, 7, 11], [0, 3, 33, 38], [0, 3, 7, 40], [1, 4, 6, 38], [2, 9, 35, 38], [2, 9, 38, 43], [0, 9, 35, 38], [9, 31, 35, 38], [2, 9, 38], [2, 9, 30], [2, 9, 38], [0, 6, 9, 43], [2, 9, 38], [4, 9, 40], [3, 6, 11], [4, 11, 40], [4, 11, 40], [0, 4, 11], [0, 3, 6, 11], [3, 28], [4, 8, 43], [4, 8, 11, 43], [0, 3, 8], [4, 8, 42], [4, 8], [4, 7, 33, 40], [4, 8, 40], [4, 8, 35, 38], [4, 8, 23, 35], [4, 35, 38, 40], [4, 8, 35, 40], [4, 8, 21, 33], [4, 19, 33, 40], [2, 4, 7, 21], [2, 11, 40], [2, 6, 40], [1, 6, 22, 34], [1, 10, 33, 40], [1, 10, 33, 40], [0, 9, 32, 39], [1, 4, 10, 40], [1, 10, 33, 40], [1, 10, 33, 40], [1, 6, 10, 40], [0, 4, 7, 40], [0, 7, 40], [4, 8, 12, 21], [4, 8, 35, 40], [4, 8, 23, 35], [14, 23, 31, 35], [1, 4, 7, 40], [0, 4, 8, 11], [4, 8, 35], [4, 24, 33, 36], [7, 24, 33, 36], [2, 11, 19, 23], [2, 7, 40], [0, 4, 18, 21], [1, 6, 10, 21], [1, 6, 10], [1, 10, 42], [1, 6, 10], [1, 10], [1, 6, 10, 42], [1, 6, 10, 42], [0, 3, 6, 43], [0, 7, 11, 43], [7, 11, 16, 20], [4, 8, 29, 33], [4, 8, 35, 40], [14, 23, 31, 35], [4, 19, 31, 35], [4, 8, 31, 35], [4, 8, 23, 35], [4, 8, 35, 40], [4, 7, 23], [2, 7, 23, 40], [2, 7, 40], [2, 5, 39], [1, 10, 30, 33], [1, 6, 10, 32], [1, 10, 39], [1, 4, 33, 39], [0, 7, 21, 33], [0, 7, 39], [0, 3, 7, 39], [0, 3, 7], [2, 6, 39], [0, 6], [4, 19, 27, 40], [4, 8, 19, 40], [4, 19, 28], [3], [0, 3, 6, 8], [4, 8, 11, 19], [4, 8, 30, 33], [4, 30, 33], [2, 4, 7, 11], [2, 7, 11, 40], [1, 5, 10], [0, 6, 10, 18], [1, 10, 15, 18], [0, 15, 18], [0, 7, 15, 18], [4, 7, 18], [0, 15, 18], [6], [2, 6, 42], [1, 6, 10], [1, 6, 10], [0, 3, 8, 23], [4, 8, 40, 41], [4, 8, 35, 42], [3, 28, 35, 42], [8, 28, 35, 42], [4, 8, 35, 42], [4, 8, 42], [4, 8, 35, 42], [4, 7, 35, 42], [2, 7, 35, 42], [2, 11, 28, 35], [0, 35, 40, 42], [2, 35, 38, 42], [0, 8, 35, 42], [0, 7, 35, 40], [0, 4, 7, 35], [0, 7, 35, 40], [0, 7, 35, 42], [31, 35, 38, 42], [2, 7, 11, 40], [2, 7, 31, 40], [2, 31, 38], [2, 9, 32, 39], [2, 9, 32], [0, 9, 33, 40], [9, 33], [2, 9, 33], [2, 9, 33], [2, 9], [2, 9], [2, 9, 33], [0, 3, 33, 40], [4, 11, 33, 40], [4, 7, 11, 31], [4, 11], [6, 32, 35, 40], [6, 31, 35], [4, 31, 35], [4, 8, 11, 43], [4, 8, 11, 43], [4, 8, 40, 42], [3, 28, 35, 40], [4, 8, 11], [0, 4, 8], [4, 8], [4, 8, 11, 33], [0, 4, 8, 35], [4, 8, 17, 35], [4, 25, 33, 42], [8, 34, 35, 41], [8, 23, 35, 42], [1, 6, 35, 43], [2, 7, 35, 42], [2, 7, 26, 33], [0, 7, 33, 43], [0, 7, 33, 40], [0, 7, 33, 38], [0, 7, 33, 38], [0, 4, 33, 38], [0, 7, 33, 38], [2, 7, 11, 38], [2, 7, 38, 40], [0, 7, 33, 40], [0, 7, 33], [2, 9, 35, 42], [2, 9, 38], [4, 6, 9, 38], [2, 33, 35, 40], [0, 9, 38], [1, 6, 9, 38], [4, 33, 38, 40], [4, 9, 33, 40], [9, 33, 40], [2, 9, 38], [3, 28, 35, 38], [4, 11, 19, 38], [4, 11, 37, 42], [4, 6, 30, 38], [0, 6, 35], [2, 6, 35], [1, 4, 33], [4, 8, 11, 31], [4, 8, 31], [4, 11, 31], [4, 11, 31, 38], [4, 19, 38, 43], [0, 4, 8, 35], [4, 8, 11], [4, 8, 11], [4, 8, 11], [0, 4, 8, 11], [1, 27, 28, 35], [2, 11, 28, 35], [2, 7, 35, 40], [6, 28, 35, 40], [6, 28, 40, 43], [0, 7, 30, 40], [0, 37, 40], [0, 7, 40], [0, 7, 39, 40], [0, 7, 40], [0, 40], [2, 7, 28, 40], [2, 7, 11, 28], [2, 7], [0, 7, 30], [0, 7, 40, 43], [2, 9, 31, 38], [2, 9, 30, 38], [2, 9, 38], [2, 9, 38], [2, 9, 38], [2, 4, 9, 38], [4, 9, 26, 38], [4, 9, 26, 38], [4, 9, 26, 38], [4, 9], [4, 33], [4, 11, 33, 35], [4, 11], [4, 6, 35], [0, 6, 11, 33], [11, 33, 35], [8, 31], [4, 8, 11, 31], [0, 4, 31, 38], [4, 11, 31], [4, 11, 31, 38], [0, 4, 7, 43], [4, 8, 31, 35], [4, 8, 31], [4, 31, 38, 42], [4, 8, 11, 31], [4, 11, 31, 38], [2, 7, 31, 38], [2, 31, 33, 38], [30, 31, 37, 40], [6, 30, 33, 37], [11, 31, 33, 40], [7, 33], [0, 7, 30, 33], [7, 33, 40], [7, 33, 40], [3, 7, 33, 40], [2, 7, 33, 43], [2, 7, 31, 33], [2, 7, 33, 40], [0, 7, 33, 36], [0, 7, 31, 36], [0, 7, 31], [2, 9, 31], [2, 9, 33], [2, 9, 33, 38], [2, 9, 33, 38], [2, 6, 31, 33], [2, 9, 18, 37], [4, 31, 36, 37], [4, 30, 37, 38], [4, 9, 30, 38], [1, 9, 30, 37], [4, 6, 35, 40], [4, 35], [4, 35], [4, 35, 42], [4, 28, 35], [4, 35], [4, 35], [4, 35], [3, 28, 35], [2, 28, 35], [6], [0, 3], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [0, 18, 30, 33], [19, 29, 31, 36], [19, 28, 31, 35], [19, 28, 31, 35], [16, 28, 31, 35], [19, 31], [28, 30], [18, 28, 30, 35], [16, 28, 30, 35], [7, 18, 28, 30], [18, 30, 33], [7, 30], [7, 18], [14, 26], [14, 19], [19, 26], [19, 26], [20], [11, 19, 26, 31], [11, 14, 19, 26], [11, 19], [12, 19, 31], [12, 19], [9, 12, 19, 26], [9, 12, 19, 26], [4, 12, 19], [12, 19], [12, 19], [12, 21], [11, 20], [12, 19, 24], [12, 19], [11, 20], [12, 18], [11, 18, 23], [11, 18], [11, 18, 23], [10, 18], [19, 23], [11, 19], [18], [9, 18], [9], [17], [19, 31, 35], [19, 31, 35, 42], [19, 35, 42], [19, 35, 38, 43], [31, 35], [19, 21, 36, 43], [33, 36, 40, 43], [21, 36, 43], [11, 22], [], [18, 30, 34], [30, 36, 43], [6, 30, 36, 43], [30, 36, 43], [30, 36], [18, 30, 36, 43], [18, 30, 36, 43], [7, 16, 30], [6, 16], [6, 16, 28], [4, 28, 35], [4, 28, 35], [28, 35], [16, 28, 35], [16, 28, 35], [16, 28, 35], [28, 35], [11, 23], [7, 18, 20, 21], [19, 21, 33, 40], [7, 19], [6, 19], [6, 21], [6, 21, 33, 37], [6, 22], [6, 22, 33, 40], [6, 21, 30, 40], [6, 21, 30], [6], [6, 9], [6, 14, 19, 22], [6, 19, 23, 33], [31, 33, 35, 38], [31, 33, 35, 42], [], [], [14], [6, 14, 16, 19], [6, 14, 16, 26], [6, 19, 26, 28], [16, 19, 26, 31], [7], [7, 24, 28, 33], [28, 30, 33, 37], [30, 33, 37, 40], [4, 28, 30, 40], [30], [14, 21], [21, 24, 28, 33], [21, 24, 28, 33], [21, 24, 28, 33], [25, 28], [7, 24], [7, 15, 19], [18, 23], [15, 19, 22, 24], [6, 15, 23, 30], [], [19, 27, 31, 33], [15, 21, 28, 33], [7, 21, 28, 33], [7, 27], [9, 19], [19, 22, 27, 31], [19, 31, 35, 40], [30, 31, 35, 40], [31, 35, 38, 40], [23, 31, 35, 40], [31, 32, 35, 40], [11, 31, 35, 40], [11, 28, 30, 35], [11], [7, 11], [11], [12, 35, 37, 41], [18, 30, 33, 42], [18, 30, 33, 38], [6, 12, 38, 42], [12, 26, 33, 42], [12, 30, 38, 42], [12, 18, 30, 42], [12, 18, 33], [12, 24, 31, 36], [12, 16, 28, 31], [12, 15], [11, 15, 18], [11, 15, 18, 27], [11, 23, 27, 34], [18, 23, 27, 34], [18, 23, 28], [18, 23, 26, 33], [18, 23, 27], [15, 18, 23, 30], [23, 26, 30, 33], [15, 23, 30], [11, 18, 23, 30], [11, 18, 23], [11, 23], [6, 11], [], [], [11, 15, 27], [11, 15], [15], [15, 23], [11], [3, 11], [3], [3], [], [], [6], [11], [11], [11], [11], [11], [11, 25], [], [], [25], [], [], [], [], [30], [3, 30], [4], [4, 7, 26, 29], [19, 28, 31], [19, 28, 31], [7, 28, 31, 35], [4, 7], [4, 21, 30, 38], [30, 35, 37, 40], [30, 35, 37, 40], [4, 7, 35, 40], [28, 30, 35, 40], [7, 18, 30, 40], [7, 30, 33, 37], [7, 16, 42], [14, 16, 28], [16, 26, 28, 35], [15, 26, 33], [11, 26, 29, 33], [26, 31, 33], [11, 19, 31, 33], [11, 19, 31, 33], [11, 31, 33], [9, 19, 24, 31], [19, 31, 33], [19, 31], [19, 26, 31], [12], [10, 12, 19], [12, 21], [12, 19, 21, 33], [12, 19], [12, 19, 31, 38], [18], [11, 18, 30, 37], [11, 18, 37], [11, 18], [11, 18, 23], [18, 23, 30, 37], [18, 23, 30, 37], [11, 18, 37], [11, 18, 30, 37], [9, 11, 30], [9, 11], [11, 19, 22, 34], [19, 23, 35], [19, 23, 31, 35], [11, 19, 31, 35], [11, 19, 23, 35], [19, 23, 31], [11, 19, 23, 35], [11, 21, 33, 36], [21, 24, 33, 36], [11, 21, 33], [11, 25], [24], [18, 24], [18, 24, 36], [6, 23], [9, 19, 23], [19, 23], [18, 23], [7, 18, 23], [6, 16, 28], [6, 16, 28], [6], [4, 17, 19, 29], [19, 23, 31, 35], [4, 19, 31, 35], [4, 19, 31, 35], [19, 31, 35], [11, 19, 31, 33], [19, 31, 33, 38], [11, 19, 33, 40], [7, 21, 33, 40], [19, 31], [6], [6, 21, 40], [6, 21, 31], [6, 21], [6, 18], [6], [6], [6], [6], [6, 12, 15], [6, 14, 19, 23], [31, 33, 36, 42], [31, 33, 35, 42], [19, 23, 26, 35], [7, 35], [7, 19], [7, 14, 16], [6, 14, 20], [6, 16, 28], [16, 19, 26], [16], [6, 21, 33], [30, 31, 33, 40], [30, 31, 33, 40], [21, 30, 33, 40], [30, 43], [24, 33], [19, 24, 27, 30], [24, 28, 33, 36], [24, 28, 33], [24, 28, 36], [19, 36], [7, 15, 18, 22], [18, 23], [23], [6, 15, 18, 23], [9, 18, 23], [20, 21, 32], [21, 33], [7, 21, 33], [7, 33], [15, 22, 33], [15, 19, 23, 33], [23, 31, 35], [35, 38, 40, 43], [11, 31, 35, 40], [23, 31, 35, 40], [23, 31, 40], [11, 31, 40], [11, 16, 28], [], [11], [11], [11, 26], [25, 33, 35, 42], [26, 30, 33, 42], [12, 26, 33, 42], [12, 26, 33, 42], [26, 30, 33, 42], [12, 26, 33, 42], [12, 26, 33, 42], [12, 24], [12, 24, 28, 35], [12, 16, 28], [12, 15, 23], [15, 23, 35], [15, 23, 35], [15, 23, 35], [15, 23, 35], [15, 23, 35], [11, 15, 23, 35], [15, 23, 35], [15, 23, 35], [15, 23, 35], [11, 18, 23, 35], [11, 18, 35], [15, 18, 23, 35], [11, 23, 35], [15, 23, 35], [], [21], [11, 15], [15], [11, 15], [15], [3], [3, 15], [15], [], [], [30], [2], [], [], [], [], [], [], [21], [], [], [], [1], [5, 8], [8], [5], [26, 29], [4, 6, 18, 29], [4, 18, 28], [4, 19, 28], [4, 11, 19, 28], [4, 11, 19, 28], [4, 11, 19, 28], [4, 11, 19, 28], [11, 19, 27], [2, 6, 19, 26], [12, 26, 31], [0, 12, 27, 31], [12, 26, 30, 31], [7, 12, 18, 27], [0, 26, 30, 38], [12, 28, 30, 37], [12, 27], [26, 29, 36, 38], [2, 26, 30, 38], [18, 26, 30, 37], [26, 30, 37, 38], [9, 18, 26, 30], [2, 6, 18, 26], [2, 18, 26, 30], [2, 14, 26], [4, 23], [4, 22, 23], [16, 23], [4, 16, 23, 28], [4, 16, 38], [0, 4], [4, 7, 11], [10, 16], [18, 27], [20, 29], [16, 19, 28], [16, 19, 28], [4, 16, 28, 30], [16, 19, 31], [4, 16, 30], [11, 16, 28, 30], [0, 4, 18, 30], [19], [7, 16, 19, 31], [0, 7, 19, 31], [7, 16, 31], [2, 16, 18, 28], [0, 16, 18, 28], [7, 16, 27, 28], [2, 26, 29, 38], [18, 26, 30, 38], [18, 26, 30, 38], [2, 26, 30, 37], [18, 26, 30, 38], [2, 18, 26, 30], [6, 18, 26, 30], [1, 18, 26, 30], [4, 11, 26], [4, 11, 28], [4, 11, 28], [4, 28], [28], [2, 7, 28], [4, 7, 28], [4, 31], [27, 30, 37], [4, 19, 28, 31], [4, 19, 28, 31], [4, 19, 28, 31], [4, 19, 28, 31], [4, 19, 28, 31], [4, 19, 28], [4, 16, 19, 28], [4, 27, 30, 38], [0, 7, 27], [0, 7, 27, 31], [0, 24, 26, 31], [0, 7, 18, 24], [18, 24], [18, 24], [11, 24], [16, 22, 29, 35], [9, 23, 30, 36], [23, 30, 35, 37], [18, 21, 30, 37], [18, 21, 30, 35], [0, 9, 18, 21], [9, 18, 21, 30], [9, 16, 20, 30], [4, 19, 38], [28, 32, 35, 39], [20, 32, 35, 39], [4, 19, 23, 28], [4], [4], [4, 11], [4], [4, 16, 19], [19], [4, 19], [4, 19, 23, 35], [4, 19, 23], [19, 28, 35], [4, 19, 28], [4, 16, 19, 28], [18, 19, 30], [0, 16, 19, 32], [16, 19, 30, 32], [0, 16, 19], [0, 16, 32], [16, 18, 28, 30], [0, 7, 16], [2, 16, 29], [16, 29], [9, 18, 30], [2, 9, 18, 30], [9, 30], [4, 18, 27], [18, 26], [18, 27, 30], [2, 9, 26], [4, 26, 39, 40], [28, 35], [4, 16, 28, 35], [27, 29, 35], [4, 28, 29, 35], [28, 29], [4, 28, 29], [4, 40], [4, 19, 39], [4, 31, 38, 40], [4, 28, 31, 40], [4, 31, 38, 40], [4, 28, 31], [4, 28, 31, 38], [4, 28, 31], [4, 7, 19, 40], [4, 6, 31, 39], [26, 31, 38], [26, 31, 35, 38], [19, 26, 31, 38], [25, 27, 31, 38], [27, 31, 38], [26, 31, 38], [26], [1, 25, 29, 30], [18, 27, 30], [26, 30, 37, 38], [18, 26, 30, 37], [2, 9, 26, 30], [2, 24, 30, 36], [2, 18, 30, 36], [2, 16, 23], [4, 25], [23, 35], [28, 35], [16, 35], [4, 28, 35], [4, 11, 16], [4, 7, 11], [7, 43], [16, 27, 30, 31], [16, 19, 28, 31], [16, 28, 31, 38], [28, 31], [16, 28], [16, 19, 28, 30], [16, 30], [4, 11, 16], [0, 4, 30, 31], [0, 16, 19, 31], [0, 31], [0, 16, 31], [16, 30, 31], [2, 28, 29], [16, 28, 30], [0, 16], [16, 26, 28], [2, 26, 30, 38], [9, 26, 30, 38], [2, 9, 26, 30], [2, 9, 30, 38], [2, 26, 30], [2, 6, 18, 30], [2, 6, 26, 30], [4, 11, 28, 39], [11, 19, 28, 35], [4, 19, 28, 35], [28, 35], [4, 28], [6, 19], [3, 7], [4], [19, 31, 38], [19, 28, 31, 38], [19, 28, 31, 38], [28, 31, 38, 40], [4, 19, 28, 31], [4, 19, 28, 31], [4, 19], [4, 19, 26], [0, 4, 26, 31], [27, 31, 38], [7, 19, 26, 31], [27, 31, 38], [24], [0, 43], [7, 24, 31], [19, 31], [30, 33, 34, 40], [21, 23, 30], [9, 23, 30, 35], [18, 21, 23, 30], [2, 9, 21, 33], [2, 21, 22, 42], [19, 21], [2, 6, 9], [4, 16, 20], [4, 16, 19], [4, 19], [4, 16, 31, 43], [16, 23, 28, 31], [4], [4, 16, 23, 38], [4, 7], [4, 18, 19, 23], [4, 19, 23, 31], [4, 23, 31, 35], [4, 19, 23], [4, 23], [28, 31, 38, 40], [19, 31, 38, 40], [19, 28], [16, 19, 30, 31], [19, 31, 38], [30, 31, 38], [19, 30, 38], [0, 19, 28, 29], [16, 19, 28, 30], [0, 16, 19, 28], [0, 16, 27, 30], [30, 38], [2, 30], [2, 9, 30], [9, 18, 30], [6, 18, 30], [18, 26, 30, 38], [18], [2, 16, 30], [4], [16, 28], [4, 11, 16, 28], [0, 4, 11, 29], [0, 11, 16, 29], [4, 28, 33], [4, 7, 28], [11, 16, 19], [19, 28, 31, 34], [4, 28, 31, 35], [28, 31, 35, 38], [19, 28, 31, 35], [4, 19, 28, 31], [7, 19, 31, 34], [21, 31, 33, 40], [4, 21, 30, 33], [4, 18, 21, 30], [11, 19, 23, 31], [7, 19, 23, 31], [19, 23, 31, 38], [7, 23, 31, 38], [11, 23, 31, 38], [11, 31, 38], [11, 19, 23], [23, 31, 33, 35], [12, 24, 33, 36], [12, 24, 33, 36], [12, 24, 33, 40], [9, 12, 23, 33], [23, 31, 33, 35], [31, 33, 35], [11, 19, 21], [4, 6, 18, 21], [18, 21], [18, 21], [18, 21], [18, 23], [18, 33], [9, 18], [11, 15, 21], [1, 18, 22], [19, 23], [11, 19, 23], [19, 23, 31], [19, 23, 31, 35], [21, 23, 31, 42], [19, 23, 35, 38], [19, 23, 30, 33], [3, 9, 30, 33], [30, 33], [19, 28, 31, 35], [9, 28, 31, 35], [2, 7, 9], [7, 9, 15, 18], [6, 15, 18], [6, 15, 18, 27], [19, 21, 28, 30], [19, 21, 28, 31], [19, 21, 28, 30], [19, 28, 33, 35], [19, 28, 31, 33], [28, 30], [28, 31, 33, 38], [19, 21, 28, 31], [6, 26, 31], [6, 27, 30, 43], [6, 27, 30], [6, 27, 30], [6, 27, 30], [6], [6], [6, 16], [15, 18, 19], [16, 19], [6, 15, 31], [6, 15, 18, 27], [6, 14, 16, 31], [33, 34, 38, 43], [7, 28], [7, 13, 16, 19], [4, 9, 19, 33], [9, 21, 30, 33], [19, 30, 33, 40], [9, 17, 19, 28], [19, 28, 31, 33], [28, 31, 33, 35], [7, 29], [7, 17, 19], [17, 21, 29, 33], [18, 21, 30, 33], [6], [6, 16, 19], [6], [18, 21], [6, 18, 30, 33], [6, 18], [4, 11, 18, 21], [19, 23], [11, 19, 23], [11, 19, 23], [19, 23], [4, 6, 11, 19], [19, 23, 31], [11, 19], [4, 12, 20, 22], [21, 24, 31, 33], [12, 21, 24], [12, 21, 24, 33], [12, 21, 24, 33], [12, 21, 24, 33], [12, 21, 24, 33], [12, 24], [3, 24, 31], [23, 30, 35], [23, 30, 35], [2, 23, 30, 35], [18, 23, 30, 35], [23, 30, 35], [23, 30, 35], [23, 30, 35], [18, 23, 30, 35], [18, 23, 30, 35], [23, 30, 35], [23, 30, 35], [3, 23, 30, 35], [22, 30, 35], [18, 23, 30, 35], [3, 11, 30, 35], [4, 30, 35], [18, 22, 30, 34], [22, 30, 35, 37], [23, 30, 35], [30, 35], [30, 35], [9, 30, 35], [9], [1], [10, 33], [10], [10], [10], [10, 15], [10], [10], [4, 10], [10], [3, 5, 10], [3], [6], [0, 3, 7, 10], [3, 10], [2, 7, 11], [26, 31, 33], [4, 19, 31, 41], [19, 28, 31, 35], [19, 28, 31, 35], [7, 16, 28, 35], [4, 11, 30, 33], [18, 30, 33, 37], [1, 9, 22, 30], [4, 7, 18, 33], [20, 30, 35, 42], [20, 23], [19, 23], [19, 23], [11, 19, 35, 42], [20, 23], [11], [20, 32, 35, 38], [9, 21, 33, 36], [12, 21, 33, 36], [20, 33, 36, 40], [12, 19, 24], [19, 31, 35, 40], [11, 31, 35, 38], [11, 19, 28, 31], [3, 11, 18, 22], [11, 18, 21], [18, 21], [18, 21], [21], [21], [21], [11, 18], [7, 18, 22, 30], [7, 19, 23], [23, 31, 40, 42], [18, 23, 30, 35], [19, 23, 35, 42], [19, 23, 35, 42], [11, 23, 35, 42], [18, 25, 27, 31], [4, 9, 18, 33], [18, 21, 33], [9, 28, 32, 36], [28, 31, 35, 38], [19, 28], [2, 6, 14, 35], [6, 15, 18], [6, 15, 30], [19, 25, 27, 34], [28, 31], [28, 31], [19, 28, 31, 38], [27, 31, 38], [28, 31], [28, 31, 38], [16, 28, 31, 38], [3, 7, 27, 30], [6, 27, 30, 35], [6, 27, 30, 35], [6, 30, 35], [6, 30, 35], [6], [6, 10], [6], [2, 7, 20, 26], [7, 14, 19], [7, 11, 16, 19], [6, 15, 18, 35], [6, 15, 27, 42], [7, 19, 29, 31], [7, 28, 31, 35], [7, 18], [4, 9, 32, 39], [9, 30, 33, 37], [18, 30, 33, 37], [9], [4, 6, 30], [28, 31, 35, 38], [7, 19, 31, 38], [7, 19, 21, 28], [7, 18, 30, 33], [18, 21, 33, 40], [6, 16, 20], [6, 16, 19], [6, 28], [6, 22, 30], [21], [11, 16, 18, 19], [4, 18], [20], [20, 23, 28], [11, 20, 23], [23, 28, 35], [11], [23, 28], [12, 23], [12, 28, 33, 38], [30, 33, 36, 37], [12, 30, 33, 36], [30, 33, 36, 40], [30, 33, 36, 43], [30, 36, 37, 43], [12, 36], [6, 12], [4, 11, 25], [6, 11, 15], [11, 15], [11, 18, 27, 35], [11, 15, 27, 35], [11, 15, 35], [11, 15, 35], [11, 15, 27, 35], [11, 15, 27, 35], [11, 15, 35], [15, 23, 31, 35], [15, 23, 27, 35], [3, 15, 23, 35], [4, 15, 23, 35], [11, 15, 35], [3, 11, 15, 35], [3, 6, 11, 35], [11, 14, 27, 35], [2, 11, 15, 35], [23, 35], [15, 31], [23], [], [6, 11, 21], [5, 10], [3, 10], [3, 9], [3, 10], [10], [2, 9], [2, 10], [3, 10, 35], [3, 5], [3, 10, 12], [12], [9, 12], [6, 35], [6, 42], [4, 18], [4, 18], [4, 18], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [9], [11], [11], [11], [0], [], [], [7], [6, 9], [6, 9], [6, 9], [9], [11], [11], [11], [11], [], [11], [], [], [], [], [11], [0, 12], [0], [0], [0], [1], [0, 12], [23, 30], [23, 30], [11], [7], [6, 9], [6, 9], [6, 9, 16], [6, 9], [], [9], [], [], [], [], [], [9, 16], [10], [11, 18], [18, 23], [24], [11], [11], [11, 18], [11], [11], [7, 21], [6, 9], [6, 9], [6, 9], [7], [7], [6, 16], [6], [6], [6], [6], [6], [7], [7], [7, 23], [7, 16], [], [7, 16], [7, 16], [7, 16], [6], [6], [6], [], [6], [], [], [], [], [], [], [], [], [6], [7], [7, 19], [6], [6], [6], [7], [7], [7, 16], [], [6, 20, 27], [6, 9], [6, 9], [9], [8], [7], [7], [7], [7], [], [8, 21], [6, 9, 16], [6, 9, 21], [7, 11], [7, 11], [], [7, 11, 23], [0, 12, 16, 24], [16, 21], [], [], [11], [7, 11], [7, 11], [7], [], [], [], [], [], [], [30], [11, 30], [0], [0], [0], [0, 9], [0, 9, 12], [0, 12], [0], [0], [], [6, 11], [6, 11, 18], [6, 18], [6, 11], [6, 11], [6, 11], [6], [6, 11], [6, 11], [6], [6, 11], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [11, 30], [12], [25], [12], [0, 12], [], [12], [12], [12], [], [], [], [], [], [11], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []], "tok2midi": {"0": 48, "1": 49, "2": 50, "3": 51, "4": 52, "5": 53, "6": 54, "7": 55, "8": 56, "9": 57, "10": 58, "11": 59, "12": 60, "13": 61, "14": 62, "15": 63, "16": 64, "17": 65, "18": 66, "19": 67, "20": 68, "21": 69, "22": 70, "23": 71, "24": 72, "25": 73, "26": 74, "27": 75, "28": 76, "29": 77, "30": 78, "31": 79, "32": 80, "33": 81, "34": 82, "35": 83, "36": 84, "37": 85, "38": 86, "39": 87, "40": 88, "41": 89, "42": 90, "43": 91}, "n_tokens": 44, "fps": 8, "midi_lo": 48, "midi_hi": 91}

requirements.txt

@@ -0,0 +1,4 @@
+gradio==6.15.2
+numpy>=1.24
+torch>=2.2          # the bottom "Mixture of Experts" experiment (lazy-loaded)
+transformers>=4.40  # SpikeWhale config/model + SpikeTokenizer (agents/modmind/)

web/README.md

@@ -0,0 +1,168 @@
+---
+title: "Quazim0t0's 🍄 Thousand Token Wood Entry"
+emoji: 🍄
+colorFrom: green
+colorTo: indigo
+sdk: gradio
+sdk_version: 6.15.2
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# ⚔️ Modular Mind: Boss Fight
+
+A mini **Dark-Souls-style** duel where the boss is controlled by a **Modular Mind** —
+a handful of tiny neural *specialists* that communicate through a **shared latent**
+(a `RecursiveLink` bridge) and a *coordinator* that reads the latent to choose the
+boss's next move. **The brain was trained by self-play reinforcement learning** — its
+tactics emerged from playing thousands of duels, nothing is scripted.
+
+You play the **Fire Knight**. Defeat the **Demon Slime**.
+
+## How the Modular Mind works
+
+This is the [ModularMind-on-V2](https://github.com/your-username/ModularMind) concept at *specialist scale*: instead of one
+monolithic policy, six small networks each handle one concern and talk to each other
+through a latent channel.
+
+```
+ game state ─▶ ┌──────────────┐   each specialist emits a latent
+               │ Aggressor    │──┐  (LatentProjection) and, if it OWNS
+               │ Stalker      │──┤   an action, a "drive" for that action
+               │ Survivor     │──┤
+               │ Baiter       │──┤        ┌───────────────┐      ┌─────────────┐
+               │ Punisher (M) │──┼─ sum ─▶│ RecursiveLink │─────▶│ Coordinator │─▶ action
+               │ Enrage   (M) │──┘        │ ReGLU+residual│ shared│  read-out   │
+               └──────────────┘           └───────────────┘ latent└─────────────┘
+```
+
+- **Four action-owning specialists** push their move's score directly:
+  **Aggressor → CLEAVE**, **Stalker → APPROACH**, **Survivor → RETREAT**, **Baiter → IDLE**.
+- **Two modulators (M)** — **Punisher** ("the player is open!") and **Enrage**
+  ("we're low on HP — go berserk") — **own no action**. Their *only* way to affect the
+  fight is the latent they write into the shared `RecursiveLink`, which the coordinator
+  turns into modulation. So training has to *learn to use the latent channel* — the whole
+  point of the architecture.
+
+The right-hand panel shows all of this live: each specialist's activity, the shared
+latent bridge, and the coordinator's modulation, for every decision the boss makes.
+
+## What emerged from training
+
+Trained on a reward that values *dealing damage* and *pressuring in range* over
+playing it safe (landing a cleave ≫ whiffing, and stalling / staying out of range is
+penalised), the boss learned an **aggressive pressure** style:
+
+- **closes the distance** when you're far or at mid-range,
+- **cleaves on contact** — once you're in range and it's off cooldown it commits to a
+  lunging swing essentially every time (verified: in-range attack-rate ≈ **0.8–1.0**),
+- **retreats only when it can't swing** (mid-cooldown) to reset spacing,
+- **blocks your punish** — a **Defender** specialist raises a guard (negating ~90% of
+  your melee) when you swing at it and it can't cleave back,
+- **punishes your recovery** and gets **even more aggressive at low HP** — the Enrage
+  modulator raises CLEAVE through the shared latent.
+
+It reaches a **~55–65% win rate** against a near-optimal scripted dodger (avg reward
++8, up from −12 before the reward was tuned for aggression). Against a human it's a
+fair, readable fight: **dodge the red telegraph, then punish the recovery.**
+
+> The earlier version of the brain learned a degenerate "space forever, never commit"
+> policy that *technically* won but barely attacked — so the trainer now selects the
+> checkpoint on **win-rate + in-range attack-rate**, and a non-attacking policy can no
+> longer be saved. (`behavior()` in `train.py` measures this directly.)
+
+## It learns from your fights (online finetuning)
+
+The model is tiny, so a gradient step is microseconds — the boss finetunes from real
+play **on the free CPU**. Each HARD-tier fight is logged (state, action, HP per boss
+decision) and POSTed to `/learn`; the server rebuilds per-decision rewards (damage
+dealt − taken, + kill / − death), computes REINFORCE returns, and takes **one Adam
+step** ([`mm_grad.py`](mm_grad.py), numpy backprop verified against PyTorch to ~1e-8).
+A frozen copy of the sim-trained weights anchors the update so it can't drift into
+nonsense; the adapted weights feed straight back into the live boss.
+
+- **On by default, in-memory.** Set `MM_ONLINE=0` to disable.
+- **Persistent across restarts:** add Space secrets `HF_TOKEN` (write) and
+  `MM_DATASET_REPO` (e.g. `you/boss-fight-online`) and the adapted weights are pushed
+  to / pulled from that Dataset. Only HARD-tier fights train (keeps the data on-policy).
+
+## Difficulty = the trained brain's decision-noise
+
+The difficulty selector doesn't change the boss's stats — it runs the **same trained
+Modular Mind at a different *mistake-rate*** (`explore` = probability of a random legal
+action). vs a near-optimal scripted dodger:
+
+| Tier | Mistake-rate | Boss win-rate | Feel |
+|------|------|------|------|
+| **Easy** | 50% | ~0.35 | erratic, leaves big openings — beatable |
+| **Normal** | 22% | ~0.65 | competent pressure, occasional slip |
+| **Hard** | 4% | ~0.95 | closes in, blocks your punish, relentless |
+
+The browser sends the chosen tier with every decision; the server routes it through
+`modular_mind.decide` with that tier's mistake-rate. *(Originally Easy/Normal were
+genuinely-undertrained checkpoints — but once the boss learned to BLOCK it dominates
+the sim almost immediately, so there's no longer a weak checkpoint; decision-noise is
+the controllable, honest dial. `train.py` still snapshots checkpoints if you want them.)*
+
+## Controls
+
+| Key | Action |
+|-----|--------|
+| ← → | Move |
+| Space | Roll / dodge (i-frames, costs stamina) |
+| J | Attack |
+| K (hold) | **Block** — cuts incoming damage to 20% and drains stamina; if stamina hits 0 your guard **breaks** into a stagger |
+| M / 🔊 | Mute / unmute music + SFX |
+
+Background music and combat SFX play during the fight (a random track per fight,
+plus per-action sound effects). Audio is served statically from `audio/`.
+
+You begin each fight with a one-time **Aegis shield** (a cyan bubble + the *Aegis*
+HUD bar): for the first few seconds it absorbs **all** damage so you can learn the
+controls. Once it fades it does **not** come back.
+
+> Click **Enter the Fog**, then click the game once so it has keyboard focus.
+
+## Architecture / files
+
+| File | Role |
+|------|------|
+| `app.py` | Gradio Space: serves the game, exposes the trained brain at `/decide` |
+| `modular_mind.py` | **numpy** inference of the trained Modular Mind (no torch at runtime) |
+| `mm_torch.py` | the trainable Modular Mind (specialists + RecursiveLink + coordinator) |
+| `train.py` | self-play **REINFORCE** trainer → `mm_weights.npz` |
+| `mm_grad.py` | pure-numpy forward+backward (REINFORCE gradient), verified vs torch — the online learner |
+| `online.py` | finetunes the HARD brain from real player fights; optional HF-Dataset persistence |
+| `duel_sim.py` | the headless duel simulator (the RL environment) |
+| `features.py` | shared feature/action definitions (single source of truth) |
+| `web/` | the HTML5 canvas game (60fps render; calls `/decide` at decision points) |
+| `audio/` | background music (`mp3/`) and sound effects (`sfx/`), served statically |
+| `serve_local.py` | run the whole thing locally **without gradio** (stdlib + numpy) |
+
+The model is **tiny** (~4.5k parameters) and inference is pure numpy, so the Space
+needs only `gradio` + `numpy` and starts instantly.
+
+## Run / retrain locally
+
+```bash
+pip install -r requirements.txt          # gradio + numpy (runtime)
+python app.py                            # the Space, locally
+# or, with no gradio at all:
+python serve_local.py                    # http://localhost:7861
+
+# retrain the boss (needs torch):
+pip install torch
+python train.py                          # -> mm_weights.npz  (+ train_log.json)
+```
+
+## Credits
+
+- **Sprites:** *Fire Knight* and *Demon Slime* free asset packs by **LuizMelo**
+  (itch.io). Please check their licenses for your own use.
+- **Audio:** background music tracks (`audio/mp3`) and combat SFX (`audio/sfx`).
+  Check the licenses of your audio packs before publishing.
+- **Brain:** the *Modular Mind* concept (latent-communicating specialists via
+  `RecursiveLink`), trained here at specialist scale by self-play RL.
+
+Built for a HuggingFace hackathon.

web/game.css

@@ -0,0 +1,108 @@
+/* Modular Mind: Boss Fight -- dark-souls-ish UI */
+* { box-sizing: border-box; }
+#mm-root {
+  --bg:#0d0b10; --panel:#15121b; --edge:#2a2436; --ink:#e8e2d6; --dim:#8a8198;
+  --hp:#a01b1b; --hpe:#d23b2f; --php:#c8a24a; --stam:#3a8f5a; --accent:#caa15a;
+  font-family: "Trebuchet MS", system-ui, sans-serif;
+  color: var(--ink); display:flex; gap:14px; flex-wrap:wrap;
+  justify-content:center; align-items:flex-start; padding:8px;
+  background: radial-gradient(circle at 50% 0%, #1a1622, #0d0b10 70%);
+  border:1px solid var(--edge); border-radius:10px; user-select:none;
+}
+#mm-stage { position:relative; }
+#mm-canvas {
+  display:block; background:#000; border:1px solid var(--edge); border-radius:6px;
+  image-rendering: pixelated; image-rendering: crisp-edges;
+  width:720px; max-width:92vw; height:auto;
+}
+/* health bars overlaid on the stage */
+.mm-bars { position:absolute; left:0; right:0; top:10px; padding:0 18px;
+  display:flex; flex-direction:column; gap:8px; pointer-events:none; }
+.mm-bar-row { display:flex; align-items:center; gap:8px; }
+.mm-bar-label { width:96px; font-size:12px; letter-spacing:1px; color:var(--dim);
+  text-transform:uppercase; text-shadow:0 1px 2px #000; }
+.mm-bar { flex:1; height:14px; background:#06040a; border:1px solid #000;
+  box-shadow:inset 0 0 0 1px #2a2436; position:relative; overflow:hidden; }
+.mm-bar > i { position:absolute; left:0; top:0; bottom:0; display:block;
+  transition: width .12s linear; }
+.mm-fill-boss  > i { background:linear-gradient(#d23b2f,#7e1414); }
+.mm-fill-php   > i { background:linear-gradient(#e3c06a,#9c7a2e); }
+.mm-fill-stam  > i { background:linear-gradient(#4fae74,#256b41); height:8px; top:3px; }
+.mm-fill-shield > i { background:linear-gradient(#bff0ff,#3aa6d6); height:8px; top:3px;
+  box-shadow:0 0 6px rgba(95,217,255,.7); }
+#mm-shield-row { transition:opacity .4s; }
+.mm-boss-name { text-align:center; font-size:13px; letter-spacing:3px;
+  color:var(--hpe); text-transform:uppercase; margin-bottom:2px; text-shadow:0 1px 3px #000;}
+
+#mm-mute { position:absolute; top:10px; right:12px; z-index:5; width:34px; height:34px;
+  border-radius:6px; border:1px solid var(--edge); background:rgba(13,11,16,.7);
+  color:var(--ink); font-size:16px; cursor:pointer; line-height:1; }
+#mm-mute:hover { border-color:var(--accent); }
+
+/* centre overlay messages (YOU DIED / VICTORY / start) */
+#mm-overlay { position:absolute; inset:0; display:flex; flex-direction:column;
+  align-items:center; justify-content:center; text-align:center; gap:14px;
+  background:rgba(4,3,7,.55); backdrop-filter:blur(1px); cursor:pointer; }
+#mm-overlay.hidden { display:none; }
+#mm-big { font-size:52px; letter-spacing:8px; font-weight:bold;
+  text-shadow:0 2px 18px #000; }
+#mm-big.died { color:#9a1b1b; }
+#mm-big.win  { color:#caa15a; }
+#mm-sub { color:var(--ink); font-size:15px; max-width:520px; line-height:1.5; }
+#mm-start-btn { padding:10px 22px; background:#1d1726; color:var(--accent);
+  border:1px solid var(--accent); border-radius:6px; font-size:16px; cursor:pointer;
+  letter-spacing:2px; text-transform:uppercase; }
+#mm-start-btn:hover { background:#2a2136; }
+.mm-diff { display:flex; align-items:center; gap:8px; flex-wrap:wrap; justify-content:center; }
+.mm-diff-label { font-size:12px; color:var(--dim); letter-spacing:1px; text-transform:uppercase; }
+.mm-diff-btn { display:flex; flex-direction:column; align-items:center; gap:1px;
+  padding:6px 14px; background:#161019; color:var(--dim); border:1px solid var(--edge);
+  border-radius:6px; cursor:pointer; font-size:14px; letter-spacing:1px; min-width:84px; }
+.mm-diff-btn small { font-size:9px; opacity:.7; letter-spacing:.5px; }
+.mm-diff-btn:hover { border-color:var(--accent); color:var(--ink); }
+.mm-diff-btn.mm-diff-on { background:#2a1f12; color:var(--accent); border-color:var(--accent);
+  box-shadow:0 0 8px rgba(202,161,90,.35); }
+.mm-keys { color:var(--dim); font-size:12.5px; line-height:1.9; }
+.mm-keys b { color:var(--ink); background:#241d30; padding:1px 7px; border-radius:4px;
+  border:1px solid var(--edge); }
+
+/* ---------- Modular Mind telemetry panel ---------- */
+#mm-panel { width:330px; max-width:92vw; background:var(--panel);
+  border:1px solid var(--edge); border-radius:8px; padding:12px 13px; }
+#mm-panel h3 { margin:0 0 2px; font-size:14px; letter-spacing:2px; color:var(--accent);
+  text-transform:uppercase; }
+#mm-panel .mm-tag { font-size:11px; color:var(--dim); margin-bottom:10px; }
+.mm-decision { display:flex; align-items:center; justify-content:space-between;
+  background:#0e0b14; border:1px solid var(--edge); border-radius:6px;
+  padding:7px 10px; margin-bottom:10px; }
+.mm-decision .lbl { font-size:11px; color:var(--dim); letter-spacing:1px; }
+.mm-decision .act { font-size:20px; font-weight:bold; letter-spacing:2px; color:#fff; }
+.mm-phase { font-size:11px; padding:2px 8px; border-radius:10px; border:1px solid var(--edge);}
+.mm-phase.p1 { color:#7fb2e6; } .mm-phase.p2 { color:#e6705f; border-color:#7e1414;
+  background:#1c0e0e; }
+
+.mm-sec-title { font-size:11px; color:var(--dim); letter-spacing:1px;
+  text-transform:uppercase; margin:12px 0 6px; }
+.mm-spec { margin-bottom:7px; }
+.mm-spec .top { display:flex; justify-content:space-between; align-items:baseline; }
+.mm-spec .nm { font-size:12.5px; }
+.mm-spec .nm .dot { display:inline-block; width:8px; height:8px; border-radius:50%;
+  margin-right:6px; vertical-align:middle; }
+.mm-spec .owns { font-size:10px; color:var(--dim); margin-left:5px; }
+.mm-spec .mod-tag { font-size:9px; color:#e67e22; border:1px solid #5a3a16;
+  padding:0 5px; border-radius:8px; margin-left:5px; }
+.mm-spec .val { font-size:11px; color:var(--dim); font-variant-numeric:tabular-nums; }
+.mm-spec .track { height:7px; background:#06040a; border:1px solid #000; margin-top:3px;
+  border-radius:3px; overflow:hidden; }
+.mm-spec .track > i { display:block; height:100%; transition:width .15s; }
+.mm-spec.win .nm { color:#fff; font-weight:bold; }
+.mm-spec.win .track { box-shadow:0 0 6px rgba(202,161,90,.6); }
+
+.mm-latent { display:flex; gap:2px; align-items:flex-end; height:34px; margin-top:4px;
+  background:#0e0b14; border:1px solid var(--edge); border-radius:4px; padding:3px; }
+.mm-latent > i { flex:1; background:linear-gradient(#caa15a,#5a4422); border-radius:1px;
+  min-height:1px; transition:height .15s; }
+.mm-flow { font-size:10.5px; color:var(--dim); margin-top:8px; line-height:1.5; }
+.mm-flow b { color:var(--accent); }
+.mm-note { font-size:10px; color:#6f6880; margin-top:10px; border-top:1px solid var(--edge);
+  padding-top:8px; line-height:1.5; }

web/game.js

@@ -0,0 +1,653 @@
+/* Modular Mind: Boss Fight -- HTML5 canvas duel.
+ * Rendering / physics / animation run at 60fps in the browser. The boss's NEXT
+ * ACTION is chosen by the trained Modular Mind (Python) via window.MM_DECIDE,
+ * called only at decision points (when the boss is free to commit) -- exactly how
+ * a souls boss commits to a move. Combat balance mirrors duel_sim.py so the boss
+ * behaves the way it was trained.
+ */
+(function () {
+  "use strict";
+
+  // ---- world / balance (world units; speeds in units/sec) ----------------
+  const W = 900, Hgt = 420, GROUND = 372;
+  const CFG = {
+    BOSS_HP: 100, PLAYER_HP: 100,
+    BOSS_MOVE: 190, PLAYER_MOVE: 188, ROLL_SPEED: 230,
+    MIN_GAP: 46,
+    CLEAVE_REACH: 170, CLEAVE_DMG: 22, CLEAVE_LUNGE: 270,
+    CLEAVE_WINDUP: 0.30, CLEAVE_ACTIVE: 0.17, CLEAVE_RECOVER: 0.42, CLEAVE_COOLDOWN: 0.34,
+    PATK_REACH: 120, PATK_DMG: 6,
+    PATK_WINDUP: 0.13, PATK_ACTIVE: 0.10, PATK_RECOVER: 0.30,
+    ROLL_DUR: 0.53, ROLL_IFR_A: 0.10, ROLL_IFR_B: 0.37,
+    BLOCK_MIT: 0.2, STAGGER: 0.5,
+    BOSS_BLOCK_TIME: 0.4, BOSS_BLOCK_MIT: 0.1,   // boss guard: duration + dmg taken multiplier
+    STAM_MAX: 100, STAM_ROLL: 28, STAM_ATK: 18, STAM_BLOCK: 24, STAM_REGEN: 26,
+    COMMIT_MOVE: 0.30, COMMIT_IDLE: 0.34,
+    THINK_MIN: 0.10,
+    SHIELD_TIME: 5.0,   // one-time "learning grace": absorbs all damage at the
+                        // start of the fight, then it's gone for good.
+  };
+
+  // ---- assets ------------------------------------------------------------
+  const A = window.GAME_ASSETS;
+  const imgs = {};
+  function loadImg(src) { return new Promise(r => { const i = new Image(); i.onload = () => r(i); i.src = src; }); }
+
+  // ---- audio (served statically; base injected by the server) ------------
+  const AUDIO_BASE = window.MM_AUDIO_BASE || "audio/";
+  const SFX = {
+    p_attack: "sfx/attack_knight.wav", p_hurt: "sfx/hurt_knight.wav",
+    p_roll: "sfx/jump_knight.wav", p_die: "sfx/die_knight.wav",
+    shield: "sfx/gem.wav", ui: "sfx/coin.wav",
+    b_cleave: "sfx/axe_boss.wav", b_hurt: "sfx/hurt_monster.wav",
+    b_die: "sfx/die_boss.wav", roar: "sfx/roar_monster.wav",
+    b_block: "sfx/bit_monster.wav",
+  };
+  const MUSIC = Array.from({ length: 12 }, (_, i) => `mp3/Pixel ${i + 1}.mp3`);
+  const sfxBuf = {};
+  let musicEl = null, muted = false, audioReady = false;
+  const aurl = p => AUDIO_BASE + encodeURI(p);
+
+  function initAudio() {
+    if (audioReady) return; audioReady = true;
+    for (const k in SFX) { const a = new Audio(aurl(SFX[k])); a.preload = "auto"; sfxBuf[k] = a; }
+  }
+  function playSfx(k, vol = 0.6) {
+    if (muted || !sfxBuf[k]) return;
+    const a = sfxBuf[k].cloneNode(); a.volume = vol; a.play().catch(() => {});
+  }
+  function startMusic() {
+    if (muted) return;
+    const track = MUSIC[Math.floor(Math.random() * MUSIC.length)];
+    if (musicEl) musicEl.pause();
+    musicEl = new Audio(aurl(track));
+    musicEl.volume = 0.3;
+    musicEl.addEventListener("ended", () => { if (!muted) startMusic(); });
+    musicEl.play().catch(() => {});
+  }
+  function stopMusic() { if (musicEl) { musicEl.pause(); musicEl = null; } }
+  function toggleMute() {
+    muted = !muted;
+    if (muted) { if (musicEl) musicEl.pause(); }
+    else if (musicEl) musicEl.play().catch(() => {});
+    const b = document.getElementById("mm-mute"); if (b) b.textContent = muted ? "🔇" : "🔊";
+  }
+
+  // ---- animation -----------------------------------------------------------
+  class Anim {
+    constructor(who) { this.man = A[who].manifest; this.img = imgs[who]; this.who = who;
+      // native facing of the source art: the knight faces RIGHT, the demon faces LEFT.
+      // We flip when the desired world-facing differs from the art's native facing.
+      this.native = who === "boss" ? -1 : 1;
+      this.name = "idle"; this.t = 0; this.idx = 0; this.done = false; this.loop = true; this.speed = 1; this.rev = false; }
+    set(name, loop = true, speed = 1, rev = false) {
+      // don't restart an animation that is already playing (it is re-requested
+      // every frame by the state machine); a real change of name restarts it.
+      if (this.name === name) { this.loop = loop; this.speed = speed; this.rev = rev; return; }
+      this.name = name; this.loop = loop; this.speed = speed; this.rev = rev; this.t = 0; this.done = false;
+      this.idx = rev ? this.man.anims[name].frames - 1 : 0;
+    }
+    update(dt) {
+      const a = this.man.anims[this.name]; if (!a) return;
+      this.t += dt * a.fps * this.speed;
+      if (this.t >= 1) {
+        const steps = Math.floor(this.t); this.t -= steps;
+        this.idx += steps * (this.rev ? -1 : 1);
+        if (this.rev) {
+          if (this.idx < 0) {
+            if (this.loop) this.idx = ((this.idx % a.frames) + a.frames) % a.frames;
+            else { this.idx = 0; this.done = true; }
+          }
+        } else if (this.idx >= a.frames) {
+          if (this.loop) this.idx %= a.frames;
+          else { this.idx = a.frames - 1; this.done = true; }
+        }
+      }
+    }
+    progress() { const a = this.man.anims[this.name]; return (this.idx + this.t) / a.frames; }
+    draw(ctx, x, facing, scale) {
+      const m = this.man, a = m.anims[this.name];
+      const sx = this.idx * m.frameW, sy = a.row * m.frameH;
+      const dw = m.frameW * scale, dh = m.frameH * scale;
+      const dy = GROUND - m.footY * scale;
+      // translate to the entity's feet/centre, mirror by facing, draw so the
+      // frame's centreX maps to local 0 and footY maps to GROUND.
+      ctx.save();
+      ctx.translate(x, dy);
+      // flip when the wanted world-facing differs from the art's native facing
+      ctx.scale(facing * this.native < 0 ? -1 : 1, 1);
+      ctx.drawImage(this.img, sx, sy, m.frameW, m.frameH, -m.centerX * scale, 0, dw, dh);
+      ctx.restore();
+    }
+  }
+
+  // ---- entities ----------------------------------------------------------
+  const boss = { x: 250, hp: CFG.BOSS_HP, facing: 1, anim: null,
+    state: "idle", t: 0, cd: 0, think: 0, pending: false, action: "IDLE",
+    actT: 0, cleavePhase: "", cleaveHit: false, scale: 1.7, telemetry: null, blockFlash: 0 };
+  const player = { x: 650, hp: CFG.PLAYER_HP, stam: CFG.STAM_MAX, facing: -1, anim: null,
+    state: "idle", t: 0, atkHit: false, scale: 2.4, shield: 0, shieldFlash: 0 };
+
+  const keys = {};
+  let game = "menu";  // menu | fight | dead | win
+  let lastDecision = null;
+  let difficulty = "hard";  // easy | normal | hard (which trained brain runs the boss)
+  let fightLog = [];        // per-decision log sent to the online learner at fight end
+
+  // ---- helpers -----------------------------------------------------------
+  const dist = () => Math.abs(player.x - boss.x);
+  // Characters face the way they MOVE while walking/running/rolling, and face
+  // their opponent when idle or attacking (so swings connect & telegraphs aim
+  // correctly). Called once per frame after the updates, before rendering.
+  function updateFacings() {
+    const towardBossFromPlayer = boss.x >= player.x ? 1 : -1;
+    if (player.state === "run") {
+      const left = keys["ArrowLeft"] || keys["a"] || keys["A"];
+      const right = keys["ArrowRight"] || keys["d"] || keys["D"];
+      if (right && !left) player.facing = 1;
+      else if (left && !right) player.facing = -1;   // both/neither -> keep
+    } else if (player.state === "roll") {
+      player.facing = player.rollDir;                // roll in the direction it travels
+    } else if (player.state !== "dead") {
+      player.facing = towardBossFromPlayer;          // idle/attack/block/hit face the boss
+    }
+
+    // the boss is locked onto the player: it ALWAYS faces you (it never turns its
+    // back). Retreat is rendered as a backstep (reversed walk) instead of a turn.
+    if (boss.state !== "dead") boss.facing = player.x >= boss.x ? 1 : -1;
+  }
+  function clampX(o) { o.x = Math.max(40, Math.min(W - 40, o.x)); }
+  function enforceGap() {
+    // a roll lets the player dodge THROUGH the boss to the other side; the boss's
+    // always-face-the-player logic then spins it around. Otherwise bodies don't overlap.
+    if (player.state === "roll") return;
+    if (dist() < CFG.MIN_GAP) {
+      if (player.x < boss.x) player.x = boss.x - CFG.MIN_GAP; else player.x = boss.x + CFG.MIN_GAP;
+      clampX(player);
+    }
+  }
+  const phase = () => (boss.hp < CFG.BOSS_HP * 0.5 ? 2 : 1);
+
+  // ===================== PLAYER =====================
+  function playerUpdate(dt) {
+    if (player.shield > 0) player.shield = Math.max(0, player.shield - dt);
+    if (player.shieldFlash > 0) player.shieldFlash = Math.max(0, player.shieldFlash - dt);
+    if (player.state === "dead") { player.anim.set("death", false); return; }
+    player.stam = Math.min(CFG.STAM_MAX, player.stam + CFG.STAM_REGEN * dt);
+
+    // committed states
+    if (player.state === "roll") {
+      player.t += dt; player.x += player.rollDir * CFG.ROLL_SPEED * dt; clampX(player); enforceGap();
+      if (player.t >= CFG.ROLL_DUR) { player.state = "idle"; }
+      return;
+    }
+    if (player.state === "attack") {
+      player.t += dt;
+      const a0 = CFG.PATK_WINDUP, a1 = CFG.PATK_WINDUP + CFG.PATK_ACTIVE;
+      if (player.t >= a0 && player.t < a1 && !player.atkHit) {
+        if (dist() <= CFG.PATK_REACH) { hitBoss(CFG.PATK_DMG); player.atkHit = true; }
+      }
+      if (player.t >= a1 + CFG.PATK_RECOVER) player.state = "idle";
+      return;
+    }
+    if (player.state === "stagger") { player.t += dt; if (player.t >= CFG.STAGGER) player.state = "idle"; return; }
+    if (player.state === "hit") { player.t += dt; if (player.anim.done) player.state = "idle"; }
+
+    // free: read input
+    let moving = false;
+    const left = keys["ArrowLeft"] || keys["a"] || keys["A"];
+    const right = keys["ArrowRight"] || keys["d"] || keys["D"];
+    const blocking = keys["k"] || keys["K"];
+    if (blocking) { player.state = "block"; }
+    else if (player.state === "block") { player.state = "idle"; }
+
+    if (player.state !== "block") {
+      if (left) { player.x -= CFG.PLAYER_MOVE * dt; moving = true; }
+      if (right) { player.x += CFG.PLAYER_MOVE * dt; moving = true; }
+      clampX(player); enforceGap();
+      player.state = moving ? "run" : "idle";
+    }
+  }
+  function playerAttack() {
+    if (["attack", "roll", "stagger", "hit", "dead"].includes(player.state)) return;
+    if (player.stam < CFG.STAM_ATK) return;
+    player.state = "attack"; player.t = 0; player.atkHit = false; player.stam -= CFG.STAM_ATK;
+    playSfx("p_attack", 0.5);
+  }
+  function playerRoll() {
+    if (["roll", "stagger", "hit", "dead"].includes(player.state)) return;
+    if (player.stam < CFG.STAM_ROLL) return;
+    player.state = "roll"; player.t = 0; player.stam -= CFG.STAM_ROLL;
+    playSfx("p_roll", 0.5);
+    player.rollDir = -player.facing; // roll backward (away from boss) by default
+    if (keys["ArrowLeft"] || keys["a"]) player.rollDir = -1;
+    if (keys["ArrowRight"] || keys["d"]) player.rollDir = 1;
+  }
+  function playerIframe() {
+    return player.state === "roll" && player.t >= CFG.ROLL_IFR_A && player.t <= CFG.ROLL_IFR_B;
+  }
+  function playerRecovering() {
+    if (player.state === "stagger") return true;
+    if (player.state === "attack" && player.t >= CFG.PATK_WINDUP + CFG.PATK_ACTIVE) return true;
+    if (player.state === "roll" && player.t > CFG.ROLL_IFR_B) return true;
+    return false;
+  }
+  function setPlayerAnim() {
+    const s = player.state;
+    if (s === "dead") player.anim.set("death", false);
+    else if (s === "hit") player.anim.set("take_hit", false);
+    else if (s === "stagger") player.anim.set("take_hit", false);
+    else if (s === "attack") player.anim.set("attack", false, 1.25);
+    else if (s === "roll") player.anim.set("roll", false, 1.1);
+    else if (s === "block") player.anim.set("defend", true);
+    else if (s === "run") player.anim.set("run", true);
+    else player.anim.set("idle", true);
+  }
+
+  // ===================== BOSS =====================
+  function hitBoss(dmg) {
+    if (boss.state === "dead") return;
+    // the boss's guard negates most of an incoming melee (no flinch either)
+    if (boss.state === "block") {
+      boss.blockFlash = 0.18; playSfx("b_block", 0.5);
+      boss.hp = Math.max(0, boss.hp - dmg * CFG.BOSS_BLOCK_MIT);
+      return;
+    }
+    const wasPhase1 = boss.hp >= CFG.BOSS_HP * 0.5;
+    boss.hp = Math.max(0, boss.hp - dmg);
+    if (boss.hp <= 0) { boss.state = "dead"; boss.anim.set("death", false); playSfx("b_die", 0.8); return; }
+    playSfx("b_hurt", 0.5);
+    if (wasPhase1 && boss.hp < CFG.BOSS_HP * 0.5) playSfx("roar", 0.8);  // phase-2 enrage roar
+    // hyperarmor during a cleave: damage lands but no flinch
+    if (boss.state !== "cleave") { boss.state = "hit"; boss.t = 0; boss.anim.set("take_hit", false); }
+  }
+  function hitPlayer(dmg) {
+    if (player.state === "dead" || playerIframe()) return;
+    if (player.shield > 0) { player.shieldFlash = 0.22; playSfx("shield", 0.5); return; }  // grace shield absorbs it
+    let d = dmg;
+    if (player.state === "block") {
+      player.stam -= CFG.STAM_BLOCK;
+      if (player.stam <= 0) { player.stam = 0; player.state = "stagger"; player.t = 0; }
+      else { d *= CFG.BLOCK_MIT; }
+    }
+    player.hp = Math.max(0, player.hp - d);
+    if (player.hp <= 0) { player.state = "dead"; player.t = 0; player.anim.set("death", false); playSfx("p_die", 0.8); return; }
+    playSfx("p_hurt", 0.5);
+    if (player.state !== "stagger" && player.state !== "block") { player.state = "hit"; player.t = 0; }
+  }
+
+  function bossState() {
+    return {
+      arenaW: W, cleaveReach: CFG.CLEAVE_REACH,
+      bossX: boss.x, playerX: player.x,
+      bossHP: boss.hp / CFG.BOSS_HP, playerHP: player.hp / CFG.PLAYER_HP,
+      bossCooldown: boss.cd > 0 ? boss.cd : 0,
+      difficulty: difficulty,
+      playerAttacking: player.state === "attack",
+      playerApproaching: (player.state === "run") && (Math.sign(player.facing) === Math.sign(boss.x - player.x)),
+      playerRecovering: playerRecovering(),
+      playerBlocking: player.state === "block",
+      playerThreat: player.state === "attack" && dist() <= CFG.PATK_REACH + 12,
+    };
+  }
+
+  async function requestDecision() {
+    boss.pending = true;
+    const st = bossState();
+    let tel;
+    try { tel = await window.MM_DECIDE(st); }
+    catch (e) { tel = fallbackBrain(st); }
+    boss.pending = false;
+    if (boss.state === "dead" || game !== "fight") return;
+    boss.telemetry = tel; lastDecision = tel;
+    applyBossAction(tel.action);
+    // log this decision for the online learner (state + action + HP at decision time)
+    fightLog.push({ state: st, action: tel.action, bossHP: st.bossHP, playerHP: st.playerHP });
+    updatePanel(tel);
+  }
+  function applyBossAction(action) {
+    boss.action = action; boss.actT = 0;
+    if (action === "CLEAVE" && boss.cd <= 0) { startCleave(); }
+    else if (action === "APPROACH") { boss.state = "approach"; }
+    else if (action === "RETREAT") { boss.state = "retreat"; }
+    else if (action === "BLOCK") { startBlock(); }
+    else { boss.state = "idle"; }
+  }
+  function startCleave() {
+    boss.state = "cleave"; boss.cleavePhase = "windup"; boss.t = 0; boss.cleaveHit = false;
+    const sp = phase() === 2 ? 1.25 : 1.0;
+    boss.anim.set("cleave", false, sp);
+    playSfx("b_cleave", 0.6);
+  }
+  function startBlock() {
+    boss.state = "block"; boss.t = 0; boss.blockFlash = 0;
+    boss.anim.set("idle", true);     // no block frame in the sheet -> braced idle + guard FX
+    playSfx("b_block", 0.35);
+  }
+
+  function bossUpdate(dt) {
+    if (boss.cd > 0) boss.cd -= dt;
+    if (boss.state === "dead") { boss.anim.set("death", false); return; }
+    const ph = phase();
+    const moveMul = ph === 2 ? 1.18 : 1.0;
+
+    if (boss.state === "hit") {
+      boss.t += dt; if (boss.anim.done) { boss.state = "idle"; boss.think = CFG.THINK_MIN; }
+      boss.anim.set("take_hit", false); return;
+    }
+    if (boss.state === "block") {
+      boss.t += dt; if (boss.blockFlash > 0) boss.blockFlash -= dt;
+      boss.anim.set("idle", true);
+      if (boss.t >= CFG.BOSS_BLOCK_TIME) { boss.state = "idle"; boss.actT = 0; boss.think = CFG.THINK_MIN; }
+      return;
+    }
+    if (boss.state === "cleave") { cleaveUpdate(dt, ph); return; }
+
+    if (boss.state === "approach" || boss.state === "retreat") {
+      boss.actT += dt;
+      const sign = boss.state === "approach" ? 1 : -1;
+      const toward = player.x > boss.x ? 1 : -1;
+      boss.x += sign * toward * CFG.BOSS_MOVE * moveMul * dt;
+      clampX(boss); enforceGap();
+      // approach = walk forward; retreat = reversed walk so it backsteps (feet move
+      // backward) while still facing the player, instead of moonwalking.
+      const backstep = boss.state === "retreat";
+      boss.anim.set("walk", true, backstep ? 1.0 : 1.1, backstep);
+      if (boss.actT >= CFG.COMMIT_MOVE) tryDecide();
+      return;
+    }
+
+    // idle
+    boss.anim.set("idle", true);
+    boss.actT += dt;
+    if (boss.actT >= CFG.COMMIT_IDLE) tryDecide();
+  }
+  function tryDecide() {
+    if (boss.pending) return;
+    if (boss.think > 0) { boss.think -= 1 / 60; return; }
+    requestDecision();
+    boss.think = CFG.THINK_MIN;
+  }
+  function cleaveUpdate(dt, ph) {
+    boss.t += dt;
+    const spMul = ph === 2 ? 1.25 : 1.0;
+    const wu = CFG.CLEAVE_WINDUP / spMul, ac = CFG.CLEAVE_ACTIVE / spMul, rc = CFG.CLEAVE_RECOVER / spMul;
+    if (boss.t < wu) { boss.cleavePhase = "windup"; }
+    else if (boss.t < wu + ac) {
+      boss.cleavePhase = "active";
+      const toward = player.x > boss.x ? 1 : -1;
+      boss.x += toward * CFG.CLEAVE_LUNGE * spMul * dt; clampX(boss); enforceGap();
+      if (!boss.cleaveHit && dist() <= CFG.CLEAVE_REACH && !playerIframe()) {
+        hitPlayer(CFG.CLEAVE_DMG); boss.cleaveHit = true;
+      }
+    } else if (boss.t < wu + ac + rc) { boss.cleavePhase = "recover"; }
+    else {
+      boss.cd = CFG.CLEAVE_COOLDOWN; boss.state = "idle"; boss.actT = 0;
+      boss.think = CFG.THINK_MIN;
+    }
+  }
+
+  // ---- JS fallback brain (only if the Python call fails) -----------------
+  function fallbackBrain(s) {
+    const inRange = Math.abs(s.playerX - s.bossX) <= s.cleaveReach;
+    const ready = !(s.bossCooldown > 0);
+    let action = "IDLE";
+    if (inRange && ready) action = "CLEAVE";
+    else if (!inRange) action = "APPROACH";
+    else if (inRange && !ready) action = "RETREAT";
+    const mk = a => ({ name: a, owns: null, color: "#888", drive: 0, latent_norm: 0 });
+    return { action, phase: s.bossHP < 0.5 ? 2 : 1, trained: false, fallback: true,
+      specialists: [], base_drive: {}, modulation: {}, final_drive: {}, probs: {},
+      legal: {}, shared_latent: [] };
+  }
+
+  // ===================== RENDER =====================
+  function drawArena(ctx) {
+    // sky
+    const g = ctx.createLinearGradient(0, 0, 0, Hgt);
+    g.addColorStop(0, "#241726"); g.addColorStop(0.6, "#160f1c"); g.addColorStop(1, "#0a0710");
+    ctx.fillStyle = g; ctx.fillRect(0, 0, W, Hgt);
+    // distant pillars
+    ctx.fillStyle = "rgba(40,30,52,.6)";
+    for (let i = 0; i < 6; i++) { const x = 60 + i * 150; ctx.fillRect(x, 120, 46, GROUND - 120); }
+    // ground
+    ctx.fillStyle = "#0c0a12"; ctx.fillRect(0, GROUND, W, Hgt - GROUND);
+    ctx.fillStyle = "rgba(202,161,90,.10)"; ctx.fillRect(0, GROUND, W, 3);
+    // fog
+    ctx.fillStyle = "rgba(160,27,27,.05)"; ctx.fillRect(0, GROUND - 40, W, 40);
+  }
+  function drawShadow(ctx, x, w) {
+    ctx.save(); ctx.globalAlpha = .35; ctx.fillStyle = "#000";
+    ctx.beginPath(); ctx.ellipse(x, GROUND + 2, w, 7, 0, 0, Math.PI * 2); ctx.fill(); ctx.restore();
+  }
+  function drawTelegraph(ctx) {
+    if (boss.state === "cleave" && boss.cleavePhase === "windup") {
+      const reach = CFG.CLEAVE_REACH;
+      ctx.save();
+      ctx.fillStyle = "rgba(210,59,47,.18)";
+      const x0 = boss.facing > 0 ? boss.x : boss.x - reach;
+      ctx.fillRect(x0, GROUND - 90, reach, 90);
+      ctx.strokeStyle = "rgba(210,59,47,.55)"; ctx.lineWidth = 2; ctx.strokeRect(x0, GROUND - 90, reach, 90);
+      ctx.restore();
+    }
+  }
+
+  function drawShield(ctx) {
+    if (player.shield <= 0) return;
+    const frac = player.shield / CFG.SHIELD_TIME;
+    const cx = player.x, cy = GROUND - 52;
+    const pulse = 1 + 0.05 * Math.sin(performance.now() / 140);
+    const rx = 46 * pulse, ry = 64 * pulse;
+    ctx.save();
+    // soft fill
+    ctx.globalAlpha = 0.10 + 0.16 * frac + (player.shieldFlash > 0 ? 0.4 : 0);
+    ctx.fillStyle = "#5fd9ff";
+    ctx.beginPath(); ctx.ellipse(cx, cy, rx, ry, 0, 0, Math.PI * 2); ctx.fill();
+    // ring
+    ctx.globalAlpha = 0.5 + 0.4 * frac + (player.shieldFlash > 0 ? 0.4 : 0);
+    ctx.lineWidth = 2; ctx.strokeStyle = "#bff0ff";
+    ctx.beginPath(); ctx.ellipse(cx, cy, rx, ry, 0, 0, Math.PI * 2); ctx.stroke();
+    ctx.restore();
+  }
+
+  function drawBossGuard(ctx) {
+    if (boss.state !== "block") return;
+    const cx = boss.x + boss.facing * 52, cy = GROUND - 70;
+    const flash = boss.blockFlash > 0 ? 0.5 : 0;
+    ctx.save();
+    // a hexagonal guard ward in front of the boss, facing the player
+    ctx.translate(cx, cy);
+    ctx.strokeStyle = "#ff7a3c"; ctx.fillStyle = "rgba(255,120,60," + (0.12 + flash) + ")";
+    ctx.lineWidth = 2.5;
+    ctx.beginPath();
+    for (let i = 0; i < 6; i++) {
+      const a = Math.PI / 2 + i * Math.PI / 3;
+      const px = Math.cos(a) * 26 * boss.facing, py = Math.sin(a) * 56;
+      i ? ctx.lineTo(px, py) : ctx.moveTo(px, py);
+    }
+    ctx.closePath(); ctx.fill();
+    ctx.globalAlpha = 0.7 + flash; ctx.stroke();
+    ctx.restore();
+  }
+
+  function render() {
+    const ctx = window.__mmctx;
+    drawArena(ctx);
+    drawTelegraph(ctx);
+    drawShadow(ctx, boss.x, 64); drawShadow(ctx, player.x, 34);
+    // draw order by x depth feel: boss behind if further; simple: boss first
+    boss.anim.draw(ctx, boss.x, boss.facing, boss.scale);
+    drawBossGuard(ctx);
+    player.anim.draw(ctx, player.x, player.facing, player.scale);
+    drawShield(ctx);
+  }
+
+  // ===================== HUD / PANEL =====================
+  function setW(id, frac) { const e = document.getElementById(id); if (e) e.style.width = (Math.max(0, Math.min(1, frac)) * 100) + "%"; }
+  function updateHUD() {
+    setW("mm-hp-boss", boss.hp / CFG.BOSS_HP);
+    setW("mm-hp-php", player.hp / CFG.PLAYER_HP);
+    setW("mm-stam", player.stam / CFG.STAM_MAX);
+    const row = document.getElementById("mm-shield-row");
+    if (row) {
+      setW("mm-shield", player.shield / CFG.SHIELD_TIME);
+      row.style.opacity = player.shield > 0 ? "1" : "0.25";
+    }
+  }
+
+  const ACTIONS = ["IDLE", "APPROACH", "RETREAT", "CLEAVE", "BLOCK"];
+  function updatePanel(t) {
+    const dec = document.getElementById("mm-act"); if (dec) dec.textContent = t.action;
+    const ph = document.getElementById("mm-phase");
+    if (ph) { ph.textContent = "PHASE " + t.phase; ph.className = "mm-phase p" + t.phase; }
+    // specialists
+    const wrap = document.getElementById("mm-specs"); if (!wrap) return;
+    let maxDrive = 0.001;
+    (t.specialists || []).forEach(s => { if (s.drive != null) maxDrive = Math.max(maxDrive, Math.abs(s.drive)); });
+    let html = "";
+    (t.specialists || []).forEach(s => {
+      const isMod = s.owns === null;
+      const winning = (s.owns === t.action);
+      const val = isMod ? s.latent_norm : s.drive;
+      const norm = isMod ? Math.min(1, (s.latent_norm || 0) / 3) : Math.max(0, (s.drive || 0) / maxDrive);
+      html += `<div class="mm-spec ${winning ? "win" : ""}">
+        <div class="top"><span class="nm"><span class="dot" style="background:${s.color}"></span>${s.name}`
+        + (isMod ? `<span class="mod-tag">latent-only</span>` : `<span class="owns">→ ${s.owns}</span>`)
+        + `</span><span class="val">${val == null ? "" : (isMod ? "‖z‖ " : "") + val.toFixed(2)}</span></div>
+        <div class="track"><i style="width:${(norm * 100).toFixed(0)}%;background:${s.color}"></i></div></div>`;
+    });
+    wrap.innerHTML = html;
+    // shared latent bars
+    const lat = document.getElementById("mm-latent");
+    if (lat && t.shared_latent) {
+      const mx = Math.max(0.5, ...t.shared_latent.map(Math.abs));
+      lat.innerHTML = t.shared_latent.map(v =>
+        `<i style="height:${(Math.abs(v) / mx * 100).toFixed(0)}%;opacity:${v < 0 ? .45 : 1}"></i>`).join("");
+    }
+    const flow = document.getElementById("mm-flow");
+    if (flow) {
+      const mod = t.modulation || {};
+      const cl = mod.CLEAVE || 0, ap = mod.APPROACH || 0;
+      flow.innerHTML = t.fallback
+        ? `<b>offline fallback</b> — Python brain unreachable, using heuristic.`
+        : `RecursiveLink → coordinator modulation: <b>CLEAVE ${cl >= 0 ? "+" : ""}${cl.toFixed(2)}</b>, `
+          + `APPROACH ${ap >= 0 ? "+" : ""}${ap.toFixed(2)}. Modulators (Punisher/Enrage) act only here.`;
+    }
+  }
+
+  // ===================== LOOP =====================
+  let last = 0;
+  function loop(ts) {
+    const dt = Math.min(0.05, (ts - last) / 1000 || 0); last = ts;
+    if (game === "fight") {
+      playerUpdate(dt); bossUpdate(dt);
+      updateFacings();
+      setPlayerAnim();
+      player.anim.update(dt); boss.anim.update(dt);
+      updateHUD();
+      if (player.hp <= 0 && game === "fight") endGame(false);
+      else if (boss.hp <= 0 && game === "fight" && boss.anim.name === "death" && boss.anim.done) endGame(true);
+      else if (boss.hp <= 0 && game === "fight") { /* play death anim out */ }
+    } else {
+      player.anim.update(dt); boss.anim.update(dt);
+    }
+    render();
+    requestAnimationFrame(loop);
+  }
+
+  function endGame(win) {
+    if (win) { game = "win"; }
+    else { game = "dead"; }
+    stopMusic();
+    // hand the fight to the online learner (it only trains on HARD-tier fights)
+    if (window.MM_LEARN && fightLog.length > 1) {
+      try { window.MM_LEARN({ difficulty, steps: fightLog, result: { bossDied: win, playerDied: !win } }); }
+      catch (e) { /* best-effort */ }
+    }
+    showOverlay(win ? "win" : "dead");
+  }
+
+  // ===================== OVERLAY / FLOW =====================
+  function showOverlay(kind) {
+    const ov = document.getElementById("mm-overlay");
+    const big = document.getElementById("mm-big");
+    const sub = document.getElementById("mm-sub");
+    const btn = document.getElementById("mm-start-btn");
+    ov.classList.remove("hidden");
+    if (kind === "menu") {
+      big.className = ""; big.textContent = "BOSS FIGHT";
+      sub.innerHTML = `A Modular Mind controls the <b>Demon Slime</b>. Six tiny specialists vote through a shared latent; the trained brain picks each move. You start with a brief <b style="color:#bff0ff">Aegis shield</b> — a few seconds to learn the controls before it fades. Defeat the boss.`;
+      btn.textContent = "Enter the Fog";
+    } else if (kind === "dead") {
+      big.className = "died"; big.textContent = "YOU DIED";
+      sub.innerHTML = `The Modular Mind read you. Watch the panel — punish its <b>recovery</b>, dodge the <b>red telegraph</b>.`;
+      btn.textContent = "Try Again";
+    } else {
+      big.className = "win"; big.textContent = "VICTORY";
+      sub.innerHTML = `Demon Slime felled. You out-played a brain trained by self-play reinforcement learning.`;
+      btn.textContent = "Fight Again";
+    }
+  }
+  function startFight() {
+    boss.x = 250; boss.hp = CFG.BOSS_HP; boss.state = "idle"; boss.cd = 0; boss.t = 0;
+    boss.actT = 0; boss.pending = false; boss.action = "IDLE"; boss.think = 0;
+    player.x = 650; player.hp = CFG.PLAYER_HP; player.stam = CFG.STAM_MAX; player.state = "idle"; player.t = 0;
+    player.shield = CFG.SHIELD_TIME; player.shieldFlash = 0;
+    fightLog = [];
+    boss.anim.set("idle", true); player.anim.set("idle", true);
+    document.getElementById("mm-overlay").classList.add("hidden");
+    game = "fight";
+    initAudio(); playSfx("ui", 0.4); playSfx("roar", 0.7); startMusic();
+  }
+
+  // ===================== INPUT =====================
+  function bindInput() {
+    document.addEventListener("keydown", e => {
+      if (["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown", " "].includes(e.key)) e.preventDefault();
+      keys[e.key] = true;
+      if (e.key === "m" || e.key === "M") toggleMute();
+      if (game !== "fight") return;
+      if (e.key === " ") playerRoll();
+      if (e.key === "j" || e.key === "J") playerAttack();
+    }, { passive: false });
+    document.addEventListener("keyup", e => { keys[e.key] = false; });
+    document.getElementById("mm-start-btn").addEventListener("click", startFight);
+    document.getElementById("mm-overlay").addEventListener("click", e => {
+      if (e.target.closest(".mm-diff")) return;     // clicking the selector isn't "start"
+      if (e.target.id === "mm-start-btn") return;
+      if (game !== "fight") startFight();
+    });
+    const mute = document.getElementById("mm-mute");
+    if (mute) mute.addEventListener("click", e => { e.stopPropagation(); toggleMute(); });
+    // difficulty selector
+    document.querySelectorAll(".mm-diff-btn").forEach(btn => {
+      btn.addEventListener("click", e => {
+        e.stopPropagation();
+        difficulty = btn.dataset.diff;
+        document.querySelectorAll(".mm-diff-btn").forEach(b => b.classList.toggle("mm-diff-on", b === btn));
+        const tag = document.getElementById("mm-difftag");
+        if (tag) tag.textContent = difficulty.toUpperCase();
+      });
+    });
+  }
+
+  // ===================== BOOT =====================
+  async function boot() {
+    imgs.boss = await loadImg(A.boss.image);
+    imgs.knight = await loadImg(A.knight.image);
+    boss.anim = new Anim("boss"); player.anim = new Anim("knight");
+    const cv = document.getElementById("mm-canvas");
+    cv.width = W; cv.height = Hgt; window.__mmctx = cv.getContext("2d");
+    window.__mmctx.imageSmoothingEnabled = false;
+    bindInput();
+    showOverlay("menu");
+    // lightweight debug hook (handy for testing; harmless in normal play)
+    window.__mmDebug = {
+      get boss() { return boss; }, get player() { return player; },
+      get game() { return game; }, get keys() { return keys; },
+      hurtBoss: d => hitBoss(d), hurtPlayer: d => hitPlayer(d), faces: () => updateFacings(),
+    };
+    requestAnimationFrame(loop);
+  }
+  window.__mmBoot = boot;
+})();

web/index.html

@@ -0,0 +1,48 @@
+<div id="mm-root">
+  <div id="mm-stage">
+    <canvas id="mm-canvas" width="900" height="420"></canvas>
+    <button id="mm-mute" title="Mute (M)">🔊</button>
+    <div class="mm-bars">
+      <div class="mm-boss-name">⚔ Demon Slime ⚔</div>
+      <div class="mm-bar-row"><span class="mm-bar-label">Boss</span>
+        <div class="mm-bar mm-fill-boss"><i id="mm-hp-boss" style="width:100%"></i></div></div>
+      <div class="mm-bar-row"><span class="mm-bar-label">Ashen One</span>
+        <div class="mm-bar mm-fill-php"><i id="mm-hp-php" style="width:100%"></i></div></div>
+      <div class="mm-bar-row"><span class="mm-bar-label">Stamina</span>
+        <div class="mm-bar mm-fill-stam"><i id="mm-stam" style="width:100%"></i></div></div>
+      <div class="mm-bar-row" id="mm-shield-row"><span class="mm-bar-label">Aegis</span>
+        <div class="mm-bar mm-fill-shield"><i id="mm-shield" style="width:100%"></i></div></div>
+    </div>
+    <div id="mm-overlay">
+      <div id="mm-big">BOSS FIGHT</div>
+      <div id="mm-sub"></div>
+      <div id="mm-diff" class="mm-diff">
+        <span class="mm-diff-label">Boss brain:</span>
+        <button class="mm-diff-btn" data-diff="easy">Easy<small>partly trained</small></button>
+        <button class="mm-diff-btn" data-diff="normal">Normal<small>mid training</small></button>
+        <button class="mm-diff-btn mm-diff-on" data-diff="hard">Hard<small>fully trained</small></button>
+      </div>
+      <button id="mm-start-btn">Enter the Fog</button>
+      <div class="mm-keys">
+        <b>← →</b> move &nbsp; <b>Space</b> roll/dodge &nbsp; <b>J</b> attack &nbsp; <b>K</b> hold to block
+      </div>
+    </div>
+  </div>
+
+  <div id="mm-panel">
+    <h3>Modular Mind</h3>
+    <div class="mm-tag">6 specialists · RecursiveLink shared latent · brain: <b id="mm-difftag">HARD</b></div>
+    <div class="mm-decision">
+      <div><div class="lbl">CURRENT DECISION</div><div class="act" id="mm-act">—</div></div>
+      <span class="mm-phase p1" id="mm-phase">PHASE 1</span>
+    </div>
+    <div class="mm-sec-title">Specialist activity</div>
+    <div id="mm-specs"></div>
+    <div class="mm-sec-title">Shared latent · RecursiveLink bridge</div>
+    <div class="mm-latent" id="mm-latent"></div>
+    <div class="mm-flow" id="mm-flow">Awaiting first decision…</div>
+    <div class="mm-note">Each move is chosen by a tiny neural Modular Mind. Four specialists own an
+      action; two <b>modulators</b> (Punisher, Enrage) own none — they steer the fight only by what
+      they write into the shared latent.</div>
+  </div>
+</div>