TapeOut × Behemoth

LATCHTAC

Nine latches. You write Q0 (X). Behemoth writes Q1 (O). Three-in-line clocks WIN_X and mints 18 $BEM.

Default mix skips Behemoth block. Drive P0, P1, P2 to strobe a mint.

On-chain logic game

LATCHTAC

Tic-tac-toe as a NAND/LATCH machine. You are TapeOut (X, Q0). Behemoth is the opponent (O, Q1). Three-in-line raises WIN_X, a rising-edge strobe mints 18 $BEM as Proof of Design.

Transistors
2.3k
NAND / LATCH
493 / 38
$BEM
0
Power
12.7 µW

Nine-cell latch array

Board state · Q1 Q0

P0–P8 → one-hot write enable

WIN_X
0
WIN_O
0
DRAW
0
ILLEGAL
0
BEM_STROBE
0
TURN
0

Clock log

NAND / LATCH events

  1. Board latches cleared. TURN=0 (TapeOut / X). Pins P0–P8 armed.

Wallet / PoD

$BEM register

0

Idle · nine empty cells (00)

Score X (4-bit)
0
Score O (4-bit)
0
Win mint
18 BEM
PoD receipts
0

Signal map

UI → pins → indicators

  • Cell 0–8 click

    P0–P8 · one-hot WE

    Latch Q1Q0 + mark

  • Reset board

    RESET · 1 = clear D

    All cells → 00, flags 0

  • TapeOut X

    D0 · Q0 write 1

    Steel cell, mark X

  • Behemoth O

    D1 · Q1 write 1

    Ceramic cell, mark O

  • WIN_X LED

    WIN_X · OR8(lineX)

    High flag + $BEM mint

  • WIN_O LED

    WIN_O · OR8(lineO)

    High flag, no mint

  • DRAW LED

    DRAW · FULL ∧ ¬WIN

    Dust mint 2 $BEM

  • Illegal flash

    ILLEGAL · WE ∧ ¬empty

    Red outline, no clock

Hardware blueprint

LATCHTAC · TapeOut × Behemoth

LATCH map

  • 18 TapeOut LATCH — nine cells × (Q0=X, Q1=O). Empty is 00.
  • 6 TapeOut LATCH — TURN, ILLEGAL, WIN_X, WIN_O, DRAW, WE.
  • 12 Behemoth LATCH — 4-bit scores, $BEM strobe hold, PoD nonce.

NAND map

  • isX / isO / empty per cell (3+3+5 NAND) — identity of the 2-bit mark.
  • AND3 × 8 lines × 2 marks — win-condition flags, TapeOut dense.
  • OR8 + rising-edge on WIN_X — Behemoth fan-in, 6× drive, fires BEM_STROBE.
  • Collision: WE ∧ ¬empty → ILLEGAL, write suppressed.
TapeOut denseBehemoth drive 40%
TapeOut NAND
253
TapeOut LATCH
24
Behemoth NAND
240
Behemoth LATCH
14
Transistors
2.3k
Delay
9.5 ns
Energy
1.59 pJ
Power
12.7 µW

AND3 line truth

X0X1X2LINE
0000
1000
1100
1111
0110

Gate pipeline

PINS[9]
  → OCCUPIED NAND → WE · LATCH D
  → ILLEGAL = WE ∧ ¬empty

LATCH[9×2] → isX / isO (3 NAND)
  → AND3 × 8 lines
  → OR8 → WIN_X → rising → BEM_STROBE
  → OR8 → WIN_O
FULL ∧ ¬WIN → DRAW

Behemoth: AND3(threat) → priority encoder

WIN_X = 1 → $BEM

Combinational WIN_X is OR8 of the eight AND3 line flags. That bit is clocked into a TapeOut LATCH. A 2-NAND edge detector (WIN_X ∧ ¬WIN_X_prev) raises BEM_STROBE for one tick. The Behemoth reward core treats the strobe as Proof of Design: hash the 18-bit board, then mint 18 $BEM (Behemoth power 6 × three cells in the winning line). Draw releases 2. Loss releases 0 — Behemoth already holds the line.

on WIN_X_rise: BEM.mint(player, 18); emit PoD(boardHash, circuitId);