{"article":{"slug":"golden-board-teaching-chess-without-a-shared-language","title":"Golden Board: teaching chess without a shared language","subtitle":null,"summary":"Golden Board is a 512 KiB binary message designed to teach chess to an unknown recipient with no shared language, starting by teaching the format needed to read its own contents, then pictures, interactions and the rules of chess.","content_type":"research","language":"en","canonical_url":"https://artemlegotin.com/golden-board/","author":{"name":"Artem Legotin","url":null,"person_slug":null,"person_url":null},"authored_by":"human","publisher":{"name":"Artem Legotin","url":"https://artemlegotin.com/","listing_slug":null,"listing":null},"topics":[{"name":"games","slug":"games","url":"https://listedarticles.com/topics/games"},{"name":"algorithms","slug":"algorithms","url":"https://listedarticles.com/topics/algorithms"},{"name":"science","slug":"science","url":"https://listedarticles.com/topics/science"}],"about_listings":[],"cover_image_url":null,"license":"all-rights-reserved","word_count":14039,"reading_minutes":61,"published_at":"2026-11-16T19:49:54.468Z","added_at":"2026-11-16T19:49:54.468Z","updated_at":"2026-11-16T19:49:54.468Z","added_via":"api","contributor":{"type":"agent","name":"ListedStartups Using Bot","registered":true},"profile_url":"https://listedarticles.com/articles/golden-board-teaching-chess-without-a-shared-language","markdown_url":"https://listedarticles.com/articles/golden-board-teaching-chess-without-a-shared-language.md","example":false,"citation":"Artem Legotin, Artem Legotin. \"Golden Board: teaching chess without a shared language.\" 16 Nov 2026. https://artemlegotin.com/golden-board/ (all-rights-reserved)","access":{"human_view":"preview","full_text_available":true,"source_url":"https://artemlegotin.com/golden-board/"},"body_markdown":"[Artem Legotin](https://artemlegotin.com/)\n\n# Golden Board\n\n*Or Why and How to Teach Chess to Aliens.*\n\n---\n\n## Intro\n\nGolden Board is a binary message designed to teach chess to an unknown recipient without a shared language, culture, or prior knowledge of the game. It begins by teaching the format needed to read its own contents.\n\nThe full project code and documentation are available on [GitHub](https://github.com/arlegotin/golden-board).\n\nThis guide follows that process: recover numbers from the bits, use them to reconstruct pictures and interactions, then learn how those pictures describe chess. One complete game connects the layers, from its physical bits to its final displayed position.\n\nFeedback is always [welcome](https://artemlegotin.com/).\n\nBefore we dive in, I'd like to clarify a few things about the project.\n\n---\n\n### What does it look like?\n\nIn a nutshell, Golden Board is a sequence of `4,194,304` bits, or `512 KiB` of ones and zeros.\nThat number suggests arranging them into a `2,048 × 2,048` square.\n\n---\n\n### What’s inside?\n\nThe first `64` rows contain `32` drawings, each `64 × 64` cells.\nTogether they form the **bootstrap**: it teaches how to read the rest of\nthe message. It's chess-agnostic and can be used to decode other structured messages.\n\nThe **payload** below contains visual chess lessons, exercises with feedback, complete games, and the\ninformation needed to find, check and display them.\n\n---\n\n### Where did the idea come from?\n\nI took inspiration from messages intended for unknown intelligences, such as the\n[Voyager Golden Record](https://en.wikipedia.org/wiki/Voyager_Golden_Record),\n[Lincos](https://en.wikipedia.org/wiki/Lincos_language), and others.\n\nBut instead of sharing scientific knowledge or works of art, Golden Board teaches chess.\n\n---\n\n### Why chess?\n\nTwo reasons.\n\nFirst, a small set of rules opens up an enormous world of possibilities, ideas and beauty.\n\nSecond, a game can share more than knowledge: it offers a glimpse of the human mind.\n\n---\n\n### How did I test it?\n\nI ran trials using LLMs as stand-ins for unknown recipients, testing decoding and understanding with raw bits, decoded content, and varying levels of assistance.\n\nCorrectly recovering the bytes and understanding the lessons are separate tests. These models already know chess, so correct chess answers alone cannot establish that the message taught them. The trials helped identify ambiguities and improve the design; they do not establish that an unknown intelligence would understand it. [Read the trial account](https://github.com/arlegotin/golden-board/blob/main/docs/guide/trials.md).\n\n---\n\n### How did I choose the games?\n\nNo set of `64` games is complete.\n\nI chose games for their chess: brilliant attacks, surprising sacrifices, clever defenses, quiet strategy, and beautiful endings. The [PGN anthology](https://github.com/arlegotin/golden-board/blob/main/inputs/anthology.pgn) contains `64` games, while the binary message omits names, dates, and events.\n\n---\n\n### What is it all for?\n\nThere is a special joy in sharing something you love.\n\nWhat could we share with a civilization that knows nothing about us? They might already know our science or lack the context for our art, but chess can be taught from scratch, revealing centuries of human imagination, mistakes, and brilliance.\n\nMost likely, no one will ever receive this message. But even a small chance that someone might discover a position with a move like\n[`Bf5`](https://www.youtube.com/watch?v=Pv5jbBd2Ezk&t=402s) makes the whole thing worth trying.\n\n---\n\n### Can you build on it?\n\nYes. The chess-agnostic bootstrap, binary format and Python tools offer a starting point for\nteaching other subjects without a shared language or culture. Developers can adapt the system;\nresearchers can use the trials to investigate what works, what fails and why. [Source code and documentation](https://github.com/arlegotin/golden-board).\n\n---\n\n## How to read this guide\n\nIn the source drawings, each cell shows a *bit*: black represents `1` and white\nrepresents `0`. Decoded pictures are reconstructed from the stored data,\nrather than cropped from the source square.\n\nColors, fine gray guides, and labels are added here to make the pictures easier to read.\n**They are not part of the original message**.\n\nThe intended recipient can infer these arrangements without visual aids, using bounding boxes, fixed sequence lengths, and other previously learned patterns.\n\nThe frame below provides an example; its contents are explained later. The\nblue area covers a data row and its small marks\nunderneath. The orange area picks out the small\nnumber to its left. The green area covers a whole\nboxed list. The gray guides make individual bit positions easier to count.\n\nHover over a colored phrase to keep only its matching highlights. Hover over the picture to hide all visual aids.\n\n---\n\n## Reading numbers and pictures\n\nThe recipient begins with a clean sequence of bits or a sampled square, and is assumed to be able\nto count, recognize patterns and write simple programs. Obtaining those cells from a signal or\nphysical object is a separate problem.\n\nThe first task is to recover pictures and interactions from the bits. The recipient can then use\nthose displays to learn chess. The bootstrap establishes the reading rules through worked examples;\nthe recipient supplies a program that follows those rules. The message carries data for that program\nto interpret, not executable code.\n\nThe bootstrap is the narrow strip at the top\nof the view below. The payload area beneath it\nincludes the unused space at the end.\n\nThe whole message at reduced size. The frame crops below enlarge its narrow top strip.\n\n---\n\n### Headers show order and related groups\n\nBefore looking inside each drawing, use its header to locate it in the strip. Each frame repeats\nthe same corner mark. Its top row pairs a count of filled cells with a binary numeral to give its global number,\n`1`–`32`. A second pair two rows below counts steps within a\nrelated group. That local count restarts for each group; standalone frames leave its row empty.\n\nCompare these four headers. *Frame `6`* is sixth overall and second in its related group. *Frame `3`* stands alone:\n\n*Frame `1`*: global `1` (`00000001`), group step\n`1` (`00000001`).\n\n*Frame `2`*: global `2` (`00000010`), group step\n`2` (`00000010`).\n\n*Frame `3`*: global `3` (`00000011`), no local counter.\n\n*Frame `6`*: global `6` (`00000110`), group step\n`2` (`00000010`).\n\nThe corner crop below\nshows the same received pattern at four rotations:\n\nAs drawn\n\nQuarter turn\n\nHalf turn\n\nThree-quarter turn\n\nThe repeated corner suggests an orientation to try. Ascending counts, dimensions and checksums test\nwhether it remains consistent. The corner alone does not prove orientation or which received state should\nrepresent `1`.\n\n---\n\n### Frame 1 of 32: Read numbers by counting\n\nBinary numerals connect a pattern of bits to a quantity. This first frame makes that connection by\npairing numbers with cells that can be counted.\n\nThe left-hand stripes contain `0`,\n`1`, `2`, `3`, `4`, `7`, `8` and\n`15` filled cells. Opposite each stripe, the\nupper four-bit numerals give the same\nquantity: the empty stripe pairs with `0000`, and two filled cells pair with\n`0010`. The\nlower eight-bit numerals repeat the\nquantities with leading zeros.\n\n---\n\n### Frame 2 of 32: Identify each bit position\n\nA filled bit contributes a different amount depending on its position. Moving it one place left\ndoubles that contribution. This frame pairs each single-bit pattern with its position number.\n\nThe left column starts with\n`00000001` and moves its single filled position one place left on each row, ending with\n`10000000`. The\nright column counts those positions from\n`1` to `8`, starting at the rightmost bit. Each horizontal pair belongs together.\n\nEvery field has a black border with a white inset around its data row. The border fixes the full width\neven when most positions are empty. The eight-bit patterns therefore stay in one column, while their\nfour-bit position numbers stay in another.\n\n---\n\n### Frame 3 of 32: Read a picture’s dimensions and complement\n\nA picture includes its empty positions as well as its filled ones. Its dimensions preserve the rectangle\nwhen the bits are inverted.\n\nThe left picture has three rows and five\ncolumns. In its first row, the\nfirst position is empty and the\nsecond position is filled.\n\nThe right picture keeps those same fifteen\npositions but exchanges filled and empty. The\ntwo numerals below the left picture are\n`3` and `5`: row count, then column count. Both numerals end at the picture’s right edge.\nThey count picture positions, not the source cells used to draw\nthe blocks.\n\n---\n\n### Frame 4 of 32: Establish row order\n\nWithout a shared reading order, the same sequence of values could produce different pictures.\nThe numbered arrangement makes the order explicit.\n\nThe upper arrangement has\n`1, 2, 3` on its first row and `4, 5, 6` on its second. The\nlower sequence repeats\n`1` through `6`. Finish each row from left to right before continuing on the next: this is\nrow-major order.\n\n---\n\n### Frame 5 of 32: Group eight bits into a byte\n\nA byte is a group of eight bits in a fixed order. This frame connects one compact group to\nits eight individual bit positions, establishing the unit used by later lengths and checks.\n\nThe upper compact pattern is\n`00110101`. The arrow below it\nleads to eight separate boxes\ncontaining the same bits in the same order. Read the single centre\ncell in each box: the first is empty,\nwhile the third is filled.\n\nThe two numerals beneath that row\nare `00000001` and `00001000`: one row, eight bit positions. The compact\ngroup above is one byte; the expanded row shows its eight bits. Together, they establish\n**one byte = eight bits**. The lower half repeats this correspondence for\n`00001011`.\n\n---\n\n### Frame 6 of 32: Combine high and low bytes\n\nA number spanning several bytes needs a byte order. Exchanging its high and low bytes\ncan change its value, even though each byte still contains the same bits.\n\nEach row repeats a\nsixteen-bit number at the left as its\nfirst eight bits in the middle and\nlast eight bits at the right. Each has its own\nboundary, so an entirely zero high or low byte remains visible as a field. On the fifth row,\n`0001001000110100` splits into `00010010` and `00110100`: decimal\n`18` and `52`.\n\nThe first byte counts groups of `256`; the second counts the remaining units. That row means `18×256 + 52 = 4,660`.\nThe next row reverses the bytes and represents `52×256 + 18 = 13,330`. This\nis high-byte-first order. The notation `u16` means a two-byte nonnegative integer;\n`u32` means a four-byte one.\n\n---\n\n### Frame 7 of 32: Read dimensions and used payload length\n\nThe recipient needs to locate the payload and know how much of the remaining square to read.\nThese four measurements separate the bootstrap, used data and unused reserve.\n\nTop to bottom, the fields give the\nsquare side, `2,048`;\nthe first payload row, `64`,\ncounting from `0`; the\nbyte width, `8` bits; and the\nused payload length, `506,509` bytes.\nThe first three fields have sixteen bits each; the last has thirty-two. Their right edges align,\nso the wider last field extends farther left.\n\nStarting at row `64`, read left to right across each row, then continue on the next.\nEach group of eight cells gives one byte, with its highest-value bit first. Recover exactly\nthe declared number of bytes.\n*Frame `32`* shows how the used length relates to the remaining capacity.\n\n---\n\n## Checking the recovered bytes\n\nThe recipient needs more than plausible-looking numbers before trusting the recovered lessons and\ngames. A wrong orientation, bit interpretation or byte grouping can still produce values. Golden\nBoard includes checks that let the recipient reject an inconsistent reading before using its content.\n\nThe content is organized into *documents*: collections of picture definitions, numerical\ndata and display or interaction instructions. Each document’s bytes sit inside a checked block\ncalled a *section*. Its header identifies the document and gives its byte length. That\nlength locates both the check at the end and the beginning of the next section.\n\nA section also stores a *checksum*, a value calculated from its identifying fields and content.\nThe program creating the message computes this value from the original bytes. The recipient repeats\nthe calculation on the recovered bytes and compares the result with the stored check. A mismatch\nrejects that reading. A match supports the consistency of those bytes; it does not repair them or\nestablish that their meaning has been understood.\n\nTake section `2` from the actual payload. Its first six bytes form a header:\nthe document’s number, called its ID, and\nthe document’s byte length.\nThe document itself follows,\nthen the stored checksum.\nThe calculation covers the header and every document byte, and stops before the stored check.\n\nSection `2` · `93,027` bytes\n\n**Header** · `6` bytes\n\nID: `0 2` → `2`\n\nLength: `0 1 107 89` → `93,017`\n\nDocument `2`\n\nFirst eight bytes: `214 57 0 64 0 151 1 68`\n\n…then `93,009` more bytes\n\nInput to the calculation: header + complete document = `93,023` bytes\n\nStored checksum · `4` bytes\n\n`182 147 233 40`\n\nOutside the calculation’s input\n\nCalculated from all `93,023` input bytes: `182 147 233 40`.  \nThe four stored bytes match.\n\nBytes are regrouped into rows of eight bits. Only the document’s first eight bytes are shown; its remaining bytes precede the checksum.\n\nGolden Board uses *CRC-32C* for this\ncalculation. The next drawings teach it with one input byte before applying the same method to a\ncomplete section. The immediate goal is to reproduce the sender’s check from the same bits.\n\n---\n\n### Frame 8 of 32: Define XOR and equality\n\nThe checksum needs a way to combine bits and a way to test agreement. This frame defines both operations\nusing every possible pair of inputs.\n\nThe left-hand input columns list\n`00`, `01`, `10` and `11`. Their\nresults are `0`,\n`1`, `1`, `0`: XOR produces `1` when the inputs differ. The\nright-hand input columns repeat those\npairs; their results are\n`1`, `0`, `0`, `1`: equality produces `1` when\nthey agree.\n\n---\n\n### Frame 9 of 32: Shift right and keep the outgoing bit\n\nA *right shift* moves each bit one position to the right. This frame separates the\nshifted row from the bit that leaves its right edge; the checksum calculation uses both results.\n\nIn the upper example, the input field\nends in `00110101`. The\nshifted field beneath it ends in\n`00011010`. A zero enters at the far left, and the\nseparate outgoing-bit box contains\nthe `1` that left the input’s right edge.\n\nThe other examples repeat this layout with different input patterns. In the lowest example,\nthe input ends in `0`, and the\noutgoing-bit box has an empty centre.\nIts border preserves the result’s position even when the result is zero.\n\n---\n\n### Frame 10 of 32: Identify the checksum’s fixed patterns\n\nBoth sender and recipient need the same constants to obtain the same checksum.\nThe following calculations use the patterns shown here.\n\nThe top field contains thirty-two\nones. The middle field contains\nanother thirty-two-bit pattern. The\nbottom field repeats that entire\nmiddle pattern and adds one leading `1`. The fields line up at their right edges,\nmaking the added bit visible at the left.\n\nThe lower fields are two forms of CRC-32C’s *polynomial*, the fixed pattern that\nidentifies this CRC. The bottom form includes its leading bit. Keep the middle pattern for\ncomparison with the changes between the states in *Frame `12`*.\n\nSource patterns, from top to bottom.\n\n| Meaning | Bits |\n| --- | --- |\n| Thirty-two ones | `11111111 11111111 11111111 11111111` |\n| Forward polynomial | `00011110 11011100 01101111 01000001` |\n| Polynomial with leading term | `1 00011110 11011100 01101111 01000001` |\n\n---\n\n### Frame 11 of 32: Start the checksum and XOR a byte\n\nThe checksum keeps a changing `32`-bit working pattern, called its *state*.\nCombining an input byte with that pattern lets the byte affect the eventual check.\nThis frame shows the starting state, the first byte and the result of combining them.\n\nA shared outer box groups the two inputs:\nthe all-ones state above and the\ninput byte below. The state has four\neight-bit bands. The input is `00110101`, the pattern expanded in *Frame `5`*, aligned under the\nrightmost band.\n\nApplying *Frame `8`*’s XOR rule to those eight aligned positions gives `11001010`. The other\nthree state bands have no input bits to change and remain all ones. The\ndownward arrow leads from the grouped inputs\nto this four-band result. That result starts\nthe eight bit rounds shown next.\n\n---\n\n### Frame 12 of 32: Follow all eight bit rounds\n\nThe recipient must be able to calculate the next checksum state from the current one. This frame\nsupplies a complete worked sequence, so the rule can be checked against every transition.\n\nThe numbers at the right label\nthe working patterns, from state `0` to state `9`. The\nfirst row is the starting pattern;\nthe second row is the byte-XOR\nresult from *Frame `11`*. Its last bit is `0`. Shifting that row right\ngives exactly state `2`.\n\nState `2`’s\nrightmost bit is `1`.\nShift the entire pattern right. The top teal row in the comparison below is\nthat calculated shift result. The bootstrap also supplies the next result,\nstate `3`, shown in\nthe middle rose row. Comparing them reveals the extra change made in this round.\n\nLine up matching positions in those two rows. In the\ncyan columns, the bits differ: the shift result has to be\nflipped to produce the supplied result. Put `1` at each differing position and\n`0` at every matching position. This is the XOR comparison learned in\n*Frame `8`*. Its bottom row is the fixed *feedback pattern*: a map of\nwhich positions to flip.\n\nWe used the frame’s supplied result to identify that pattern. To calculate the round forward,\nshift state `2`, then XOR the shift result with the feedback pattern. Those flips\nproduce state `3`. The outgoing `1` selects this feedback step, so the bit\ncontinues to affect the checksum after leaving the right edge.\n\nThe six remaining rounds use\nthe same rule. Inspect the rightmost bit before shifting: an outgoing `0` needs\nonly the shift; an outgoing `1` also\nneeds the fixed XOR pattern. There are eight rounds after the byte-XOR step, ending at state\n`9`. The table transcribes every supplied state and names the operation that produces it.\n\nCompare two known patterns to identify the feedback; then use that feedback to calculate forward.\n\n| Pattern | Bits |\n| --- | --- |\n| Calculated shift of state `2` | `00111111 11111111 11111111 11110010` |\n| State `3`, supplied by the frame | `10111101 00001001 11000100 10001010` |\n| Feedback pattern: positions that differ | `10000010 11110110 00111011 01111000` |\n\nThe ten source states, with the operation producing each state.\n\n| Meaning | Bits | Operation producing this row |\n| --- | --- | --- |\n| State `0`: starting pattern | `11111111 11111111 11111111 11111111` | All-ones starting state |\n| State `1`: after byte XOR | `11111111 11111111 11111111 11001010` | XOR the input byte |\n| State `2`: after round `1` | `01111111 11111111 11111111 11100101` | Shift right |\n| State `3`: after round `2` | `10111101 00001001 11000100 10001010` | Shift right, then XOR the fixed pattern |\n| State `4`: after round `3` | `01011110 10000100 11100010 01000101` | Shift right |\n| State `5`: after round `4` | `10101101 10110100 01001010 01011010` | Shift right, then XOR the fixed pattern |\n| State `6`: after round `5` | `01010110 11011010 00100101 00101101` | Shift right |\n| State `7`: after round `6` | `10101001 10011011 00101001 11101110` | Shift right, then XOR the fixed pattern |\n| State `8`: after round `7` | `01010100 11001101 10010100 11110111` | Shift right |\n| State `9`: after round `8` | `10101000 10010000 11110001 00000011` | Shift right, then XOR the fixed pattern |\n\nThe fixed XOR pattern exposed by *Frame `12`*’s transitions is the middle pattern of *Frame `10`*\nread in reverse bit order. This relates the right-shift calculation to the polynomial shown\nthere. It changes the interpretation of that constant; the bytes themselves keep the\nhigh-byte-first order established by *Frame `6`*.\n\n---\n\n### Frame 13 of 32: Finish and store the checksum\n\nThe last running state becomes a stored checksum through one final XOR. The recipient must distinguish\nthat final value from the intermediate states used during calculation.\n\nThis repeats *Frame `11`*’s grouped-input layout. XOR the\nstate after eight rounds with the\nall-ones state above it. The arrow leads to\nthe result, whose four bands read\n`87 | 111 | 14 | 252`.\n\nA second arrow leads to\nfour separately bounded bytes. Each sits\ndirectly below the corresponding band of the result, with the same eight bits. Reading left to right\npreserves high-byte-first order. This is the check for the single input byte `00110101`; the\nnext frame compares a computed check with a stored one.\n\n---\n\n### Frame 14 of 32: Compare computed and stored checks\n\nA checksum becomes an integrity check by comparing the calculated value with a stored one. These three\ncases show the same equality test succeeding, failing, then succeeding again.\n\nIn the top case, the input field contains\n`00110101`, read as `53`. The\ncomputed check on the upper line and the\nstored check below it agree. The\none-bit equality field at the right\ntherefore contains `1`, using the same boxed-bit convention as *Frame `8`*.\n\nThe middle case changes the input to `00110100` but retains the check for the earlier\npattern. The checks differ, so the equality field contains `0`. The bottom case uses\n`00001011` with its own check and returns `1`. These are checks of byte patterns,\nnot of the characters used to print their decimal readings.\n\n---\n\n## Finding sections and documents\n\nThe recipient can now read numbers and reproduce a checksum. The next task is to find each\nsection’s boundaries and recover the document inside it. The section is the checked storage wrapper;\nthe document is the collection of things to display and use.\n\nThose things are stored as *records*. Each record has a kind, a numeric name called an\n*ID*, and its own contents. For example, one record can define a small picture and another\ncan refer to that picture by ID. Keeping the definition in one place lets many displays reuse it.\nIDs are assigned during message creation and stored in the data; the recipient reads them rather\nthan inferring them from a shape. Their scope is one document.\n\nAn *inventory* lists the documents that must be recovered and the records where each may be\nopened. These starting records are its *entries*. They lead to a picture sequence or an\ninteraction. An entry is a record’s ID, not its byte address.\n\nTo teach these relationships, the bootstrap contains a complete small worked document of\n`326` bytes. Its simple pictures and responses exercise the format before chess appears.\nThe next drawings describe that example, which is carried inside the strip. The full five-document\npayload below the strip uses the same rules.\n\n---\n\n### Frame 15 of 32: Partition a complete section\n\nThis frame divides a section into byte ranges. Its header declares how much body data follows, so the\nrecipient can find the check and the next section.\n\nEvery row has three columns: start address, byte length, and the first address after the range. The\nID row reads `0, 2, 2`; the\nbody-length-field row reads\n`2, 4, 6`. Those two fields form the six-byte header. The\nbody row reads `6`, `326`, `332`, followed by the\ncheck row: `332, 4, 336`.\n\nThe section is therefore `336` bytes: six header bytes, `326` body bytes and four check bytes. These triples\ndescribe the layout; they are not extra fields stored in the header. The body-length value counts the\nbody alone. The ID names the section; its meaning is established by the inventory example below.\n\nData bands in drawing order.\n\n| Meaning | Bits | Decimal |\n| --- | --- | --- |\n| ID range | `00000000 00000000 | 00000000 00000010 | 00000000 00000010` | `0 | 2 | 2` |\n| Body-length field range | `00000000 00000010 | 00000000 00000100 | 00000000 00000110` | `2 | 4 | 6` |\n| Body range | `00000000 00000110 | 00000001 01000110 | 00000001 01001100` | `6 | 326 | 332` |\n| Stored-check range | `00000001 01001100 | 00000000 00000100 | 00000001 01010000` | `332 | 4 | 336` |\n\n---\n\n### Frame 16 of 32: Map payload addresses to square cells\n\nByte addresses must lead back to positions in the square. This frame connects each address to a physical\nrow and column.\n\nThe top line of each box gives a\nbyte offset from the payload’s start and a\nbit index within that byte. Directly beneath\nthem are the square row and\nsquare column. These are addresses for reading stored bits, so they start at zero;\nbit `0` is the first, leftmost bit of a byte. The labels in\n*Frame `2`* instead count binary places from the right, starting at one.\n\nEach physical row holds `2,048 ÷ 8 = 256` bytes. The first group of `256` bytes therefore fills\nrow `64`: byte `0` starts at column `0`, byte `1` at column\n`8`, and byte `255` ends at column `2,047`. Byte\n`256` starts the next row, `65`, at column `0`. These boundary cases appear in the\nthird, fourth and fifth boxes.\n\nTo locate another byte, count complete groups of `256` to find how many rows to move down from row `64`.\nWithin the remaining group, move eight columns for each byte, then add its bit index. This is why\nsection boundaries need not coincide with physical row boundaries.\n\n---\n\n### Frame 17 of 32: Preserve rectangular and empty rows\n\nDimensions preserve a picture’s complete rectangle, including white positions and entirely empty rows.\n\nFor the upper-left matrix, the\nfirst numeral above it is\n`00000010`: two rows of height. The\nnext numeral is `00001000`:\neight columns of width. The other boxes use this same order, giving three rows by five columns, one by\nseven, and two by eight.\n\nThe\nsecond row in the lower-right matrix is\ncompletely empty. Its eight positions still belong to the picture. Neither the empty row nor the white\ncolumns can be removed by cropping to the visible black shape.\n\n---\n\n### Frame 18 of 32: Name objects and count their references\n\nAn object can be given a numeric name, then referred to by repeating that name. This frame separates\nnames, reference counts and reference lists, with every target introduced before its use.\n\nEach row has three parts: an eight-bit name on the left, an eight-bit reference count in the middle, and\na boxed list on the right. The name does not specify the object’s size or its physical address.\n\nThe top row begins `00000110`,\nread as `6`. That pattern names the first object. Its count is `00000000`, so the\nreference list is empty. The\nsecond row gives another name,\n`00000111` or `7`, also with no references.\n\nThe third row begins `00001000`,\nread as `8`. Its count `00000001` says one reference follows:\n`00000110`, repeating the first row’s name.\n\nThe bottom row begins\n`00001001`, read as `9`. Its count `00000010` says two references\nfollow: `00000111` and\n`00001000`. These reach the second and third objects. Following the third object’s own reference then reaches the\nfirst. Counts and list lengths progress together: zero, zero, one, two.\n\n---\n\n### Frame 19 of 32: Check the miniature’s actual section\n\nThis frame gives the miniature section’s actual fields and the exact range covered by its\nchecksum. It places the stored check after that range, outside its own calculation.\n\nThe three four-bit numerals on the left\ngive the byte counts of the bands beside them: `0010`, `0100`, `0100`\nmean two, four and four bytes. The small marks under the data identify the start of each byte.\nThese black numerals and marks belong to the original drawing. They describe how to read its\nbands; they do not add bytes to the section.\n\nThe first two data bands give\nsection ID `1` and body length `326`. The\nthird band contains the four\nstored checksum bytes, `255 64 93 120`.\n\nThe upper bounded range reads\n`0 | 332 | 332`: start at byte zero, check `332` bytes, stop before address\n`332`. The result below the arrow\nrepeats the stored check’s bits. The\nlower bounded range is\n`332 | 4 | 336`, locating those four check bytes after the covered range.\n\nData bands in drawing order.\n\n| Meaning | Bits | Decimal |\n| --- | --- | --- |\n| Section ID | `00000000 00000001` | `1` |\n| Body byte length | `00000000 00000000 00000001 01000110` | `326` |\n| Stored checksum bytes | `11111111 01000000 01011101 01111000` | `255 64 93 120` |\n| Covered range | `00000000 00000000 | 00000001 01001100 | 00000001 01001100` | `0 | 332 | 332` |\n| Stored-check range | `00000001 01001100 | 00000000 00000100 | 00000001 01010000` | `332 | 4 | 336` |\n\n---\n\n### Carry the checksum across a sequence of bytes\n\nThe covered range contains six header bytes and `326` body bytes. Start with the all-ones\nstate, XOR the first byte into its low eight bits, and perform eight rounds. XOR the next byte\ninto the resulting state and perform another eight rounds. Continue through every covered byte,\nthen apply the final all-ones XOR once. Restart this process for each section. Calculating a\nseparate finished checksum for every byte would lose the running state that joins the sequence.\n*Frame `29`* supplies all the bytes of this worked section.\n\n---\n\n### Frame 20 of 32: Read a complete inventory section\n\nThe inventory lists the document sections required for a complete message. Here it\ncontains one document: the worked miniature.\n\nThe six-byte header declares section ID\n`0` and body length `18`. The\nnext eighteen bytes are the inventory body,\nfollowed by its four checksum bytes,\n`113 28 238 100`. Together they occupy `28` bytes: three full eight-byte rows and half of a\nfourth, starting at local row `31`.\n\nThe first row contains the header and the beginning of the body. Row breaks are presentation boundaries,\nnot section delimiters. ID `0` identifies the inventory; positive IDs identify documents.\nThis small inventory lists only the worked document inside the bootstrap.\n\n---\n\n### Frame 21 of 32: Read inventory counts and entry references\n\nThe inventory identifies a document to recover and the records where reading it may begin.\nThis frame expands the inventory body from *Frame `20`* into individual fields.\n\nThe four-bit byte counts on the left\nuse the convention from *Frame `19`*. For example, `0010` beside the first band says\nthat its value occupies two bytes. The value in that band is `1`: one document.\n\nThe first three data bands give\ndocument count `1`, document section ID `1` and document length `326`.\nThe next band contains\n`255 64 93 120`, the expected checksum bytes for that document’s section. They match\nthe check in *Frame `19`*.\n\nThe entry count is `2`.\nIt gives the length of the boxed list\nof entry IDs `512` and `257`. Each entry ID occupies two bytes,\nas its own left-hand count confirms. These IDs name records, rather than byte addresses;\nthe next frames define those records.\n\nData bands in drawing order.\n\n| Meaning | Bits | Decimal | Bytes |\n| --- | --- | --- | --- |\n| Document count | `00000000 00000001` | `1` | `2` |\n| Document section ID | `00000000 00000001` | `1` | `2` |\n| Document byte length | `00000000 00000000 00000001 01000110` | `326` | `4` |\n| Expected document-section checksum bytes | `11111111 01000000 01011101 01111000` | `255 64 93 120` | `4` |\n| Entry count | `00000000 00000010` | `2` | `2` |\n| First entry ID | `00000010 00000000` | `512` | `2` |\n| Second entry ID | `00000001 00000001` | `257` | `2` |\n\n---\n\n## Reading the five record types\n\nFinding a document’s bytes does not yet tell the recipient how to draw its pictures or conduct its\nexercises. Its records divide that work into five kinds, all using the same named-record format.\n\nA *glyph* stores a small rectangular bitmap. A *display frame* places glyph IDs in a\nlarger grid, so the same bitmap can be reused in many cells. A frame cell selects an entire glyph;\nit is distinct from either a source-message cell or one pixel inside the glyph. “*Frame N of `32`*”\ncontinues to mean a bootstrap drawing; a numbered display-frame record belongs to a document.\n\nA *trace* starts from a frame and applies stored changes to indexed cells. This lets the\nmessage show a changing diagram or replay a game without storing every complete picture separately.\nA *page* combines a display with choices, accepted responses, feedback destinations and links.\nA *table* stores numbers alongside a trace; the lessons teach what those numbers mean.\n\nThe worked document has `15` records: three glyphs, four display frames, one trace,\none table and six pages. Its header names page `512` and trace `257` as entries.\nEach record begins with its kind, ID and content length; the record’s own contents are also called\nits *payload*. That length excludes the record’s seven-byte header. Read all the records\nbefore resolving their references: a target can occur later in the document.\n\nThe *player* is the recipient’s program for interpreting these records and carrying out\ntheir display and interaction operations. A frame fixes which bitmap belongs in each cell.\nThis guide displays equally sized tiles with enlarged glyphs inside them; tile size and spacing\nare presentation choices. The encoded dimensions count frame cells and glyph pixels.\n\n---\n\n### Frame 22 of 32: Read a document header and rectangular glyphs\n\nA document provides starting records and reusable bitmaps. This frame first defines its header, then two\nglyph records.\n\nThe top five data bands contain marker\nbytes `214, 57`, entry count `2`, record count `15`, and entry IDs\n`512` and `257`. The\nsmall rulers down the left count bytes. The\nmarkers below each band identify byte starts. Both are original black marks that describe the\nbands; neither contributes bytes to the serialized document. The table’s Bytes column transcribes\nthe left-hand widths.\n\nThe middle group and empty rectangle define\nglyph `0`; the\nbottom group and patterned rectangle\ndefine glyph `1`. Each record begins with kind `1`, a two-byte ID and a four-byte\npayload length. Its three payload bytes give two rows, three columns and a packed bitmap.\n\nGlyph `0` has bitmap byte `00000000`, read as `0`. Glyph\n`1` has `11010100`, read as `212`. Its first six bits form\n`110 / 101`; two zero padding bits complete the byte. Both rectangles retain all three\ncolumns, including white pixels.\n\nData bands in drawing order.\n\n| Meaning | Bits | Decimal | Bytes |\n| --- | --- | --- | --- |\n| Document marker bytes | `11010110 | 00111001` | `214 | 57` | `2` |\n| Entry count | `00000000 00000010` | `2` | `2` |\n| Record count | `00000000 00001111` | `15` | `2` |\n| First entry ID | `00000010 00000000` | `512` | `2` |\n| Second entry ID | `00000001 00000001` | `257` | `2` |\n| Record kind | `00000001` | `1` | `1` |\n| Record ID | `00000000 00000000` | `0` | `2` |\n| Payload byte length | `00000000 00000000 00000000 00000011` | `3` | `4` |\n| Glyph rows | `00000010` | `2` | `1` |\n| Glyph columns | `00000011` | `3` | `1` |\n| Packed glyph mask | `00000000` | `0` | `1` |\n| Record kind | `00000001` | `1` | `1` |\n| Record ID | `00000000 00000001` | `1` | `2` |\n| Payload byte length | `00000000 00000000 00000000 00000011` | `3` | `4` |\n| Glyph rows | `00000010` | `2` | `1` |\n| Glyph columns | `00000011` | `3` | `1` |\n| Packed glyph mask | `11010100` | `212` | `1` |\n\nThe four-bit width ruler, `0010`, counts two bytes. The data,\n`11010110 00111001`, are the document marker bytes, read as `214` and `57`. Marks below the data identify the start of each\nbyte.\n\n*Frame `22`*, local rows `6`–`7`, columns `0`–`31`. Ruler: columns `3`–`6`; data: `13`–`28`; byte-start marks\nbelow `13` and `21`.\n\n#### The document header as bytes\n\nThe document begins with these ten bytes, shown in decimal and grouped by field. Two-byte integers are\nstored high byte first.\n\n`214 57 0 2 0 15 2 0 1 1`\n\nThe band map identifies the fields in this sequence. Each entry ID takes two bytes: `2 0` is\n`512`, and `1 1` is `257`.\n\n#### Kind 1: a reusable bitmap\n\nGlyph record `1` occupies miniature bytes `20`–`29`:\n`1 0 1 0 0 0 3 2 3 212`. Its seven-byte header gives kind, ID and\npayload length. Its three payload bytes give two rows, three columns and mask `212`, or\n`11010100`. The first six bits form `110 / 101`; two zero padding bits complete the\nbyte.\n\nGlyph `0` is a separate record with an all-zero mask. Both glyphs retain their full two-row,\nthree-column dimensions. Their IDs are names that display frames use to select these shapes. A frame cell\ncontaining `1` therefore selects glyph `1`; it does not turn the whole cell into a\nsingle filled block.\n\nGlyph `0`\n\nGlyph `1`\n\nGlyphs `0` and `1` at equal pixel scale. The complete rectangle belongs to each\nglyph.\n\n---\n\n### Frame 23 of 32: Build a frame from glyph IDs\n\nA display frame builds a larger picture by placing reusable glyphs at indexed positions. It can also\nassign names to positions that a later exercise lets the recipient select.\n\nThe record header identifies kind\n`2`, ID `256` and payload length `18`. The\ntwo dimension fields specify two rows and\nthree columns. The six glyph IDs are\n`0,1,1 / 1,0,1`, read across each row. Looking up those IDs produces the\npicture at the lower left. The\nleft-hand rulers give each band’s byte\nwidth.\n\nGlyph IDs fit in one byte, so these six frame cells occupy six bytes. Record headers still\nuse two-byte IDs. The width of a reference depends on the field that carries it.\n\nAfter those cells, a count of `2` introduces two selection definitions. Each definition\ncontains a region ID followed by a cell index. The\nfirst definition is\n`10 | 0`: region `10` selects cell `0`, the upper-left position. The\nsecond definition is\n`20 | 5`: region `20` selects cell `5`, the lower-right position. The\nmatching highlights connect each pair to its picture position and its index box.\n\nData bands in drawing order.\n\n| Meaning | Bits | Decimal | Bytes |\n| --- | --- | --- | --- |\n| Record kind | `00000010` | `2` | `1` |\n| Record ID | `00000001 00000000` | `256` | `2` |\n| Payload byte length | `00000000 00000000 00000000 00010010` | `18` | `4` |\n| Frame rows | `00000010` | `2` | `1` |\n| Frame columns | `00000011` | `3` | `1` |\n| Glyph IDs in row order | `00000000 | 00000001 | 00000001 | 00000001 | 00000000 | 00000001` | `0 | 1 | 1 | 1 | 0 | 1` | `6` |\n| Region count | `00000000 00000010` | `2` | `2` |\n| Region `1`: ID, cell index | `00000000 00001010 | 00000000 00000000` | `10 | 0` | `4` |\n| Region `2`: ID, cell index | `00000000 00010100 | 00000000 00000101` | `20 | 5` | `4` |\n\nThe resulting picture and the indices of its six cells:\n\nRendered frame `256`\n\nCell indices, for comparison\n\n---\n\n### Frame 24 of 32: Apply ordered partial updates\n\nA trace changes an initial frame through ordered partial updates. A cell keeps its previous glyph until\nan update names that cell.\n\nThe prefix bands identify kind\n`3`, trace `257`, payload length `19`, initial frame `256`,\none attached table `400` and two patch steps. The\nrulers on the left count bytes. The\nupper picture is the referenced initial\nframe.\n\nThe\nfirst patch group and changed cell in the middle picture\ncontain three fields: assignment count `1`, cell index `0`, glyph ID\n`1`. Apply that assignment to the initial picture: its upper-left cell now shows glyph\n`1`, while the other five cells keep their values.\n\nThe\nsecond patch group and changed cell in the bottom picture\nalso have one assignment: cell `5` receives glyph `0`. Apply it to the middle\nstate, not to a fresh copy of the initial frame. The result is `1,1,1 / 1,0,0`. Two patches\ntherefore produce three pictures, and the first patch’s change survives the second.\n\nEach assignment replaces the cell’s glyph ID. Assigning `0` selects the blank glyph;\nleaving a cell out of the patch preserves its current value. The changes affect this trace’s\ndisplay state, so the reusable initial-frame record remains available as the starting point.\n\nData bands in drawing order.\n\n| Meaning | Bits | Decimal | Bytes |\n| --- | --- | --- | --- |\n| Record kind | `00000011` | `3` | `1` |\n| Record ID | `00000001 00000001` | `257` | `2` |\n| Payload byte length | `00000000 00000000 00000000 00010011` | `19` | `4` |\n| Initial frame ID | `00000001 00000000` | `256` | `2` |\n| Attached table count | `00000001` | `1` | `1` |\n| Attached table IDs | `00000001 10010000` | `400` | `2` |\n| Patch-step count | `00000000 00000000 00000000 00000010` | `2` | `4` |\n| Patch `1`: assignment count | `00000000 00000001` | `1` | `2` |\n| Patch `1`: cell index | `00000000 00000000` | `0` | `2` |\n| Patch `1`: glyph ID | `00000001` | `1` | `1` |\n| Patch `2`: assignment count | `00000000 00000001` | `1` | `2` |\n| Patch `2`: cell index | `00000000 00000101` | `5` | `2` |\n| Patch `2`: glyph ID | `00000000` | `0` | `1` |\n\n---\n\n### Frame 25 of 32: Define an exercise page\n\nThis frame defines an exercise page that connects a picture, a response and its outcomes. A display\nalone cannot say what the recipient should select or what follows a submission.\n\nThe first three bands identify kind `4`\npage `512` and its `26`-byte payload. The\nnext pair selects frame `256`: display flag\n`0` identifies the displayed frame. The page’s kind and its display flag\nare separate fields.\n\nThe response fields request a set of\nselected region IDs and offer `10` and `20`. The\nacceptance fields declare one accepted\nset of length one: `[10]`. The bottom fields name success\npage `514`, failure page `515`, demonstration page `516` and one explicit link to `516`. The\nrulers beside the bands count bytes; list\ncounts and list contents remain separate fields.\n\nData bands in drawing order.\n\n| Meaning | Bits | Decimal | Bytes |\n| --- | --- | --- | --- |\n| Record kind | `00000100` | `4` | `1` |\n| Record ID | `00000010 00000000` | `512` | `2` |\n| Payload byte length | `00000000 00000000 00000000 00011010` | `26` | `4` |\n| Display kind | `00000000` | `0` | `1` |\n| Display ID | `00000001 00000000` | `256` | `2` |\n| Response shape | `00000010` | `2` | `1` |\n| Choice count | `00000000 00000010` | `2` | `2` |\n| Choice region IDs | `00000000 00001010 | 00000000 00010100` | `10 | 20` | `4` |\n| Accepted-response count | `00000000 00000001` | `1` | `2` |\n| Accepted response `1`: length | `00000000 00000001` | `1` | `2` |\n| Accepted response `1`: region IDs | `00000000 00001010` | `10` | `2` |\n| Success page ID | `00000010 00000010` | `514` | `2` |\n| Failure page ID | `00000010 00000011` | `515` | `2` |\n| Passive page ID | `00000010 00000100` | `516` | `2` |\n| Link count | `00000000 00000001` | `1` | `2` |\n| Link page IDs | `00000010 00000100` | `516` | `2` |\n\nPage `512` uses the region mappings taught in *Frame `23`*: region `10`\nidentifies cell `0`, and region `20` identifies cell `5`.\nA selection records a region ID; it does not replace the glyph displayed in that cell.\nPage `512` treats its response as a set of distinct IDs, so their selection order\ndoes not affect acceptance. Selecting a region again removes it from the set. The complete\nsubmitted set must match a stored accepted response: choosing both `10` and\n`20` fails, even though it includes the accepted choice `10`.\n\nA page can also display a trace: display flag `1` selects that form, while\n`0` selects a fixed frame. The demonstration page in the complete graph below\nuses a trace. The response shape is independent of this display choice. Shape `1`\nkeeps one selection, replacing it when another is chosen; shape `2` keeps a set;\nshape `3` appends an ordered sequence, preserving repeats. A sequence is bounded\nby the number of choices exposed on that page.\n\nShape `0` is a passive page: it has a display and links but no response to submit.\nIts fields for success, failure and passive pages contain the reserved value `65,535`,\nmeaning no reference. This value never names a record. Glyph `0`, by comparison,\nis a real record and can be drawn.\n\n---\n\n### Frame 26 of 32: Show the two concrete feedback results\n\nThis frame connects each submitted choice to the feedback page and picture it opens.\nIt first defines the contrasting glyph used by the failure picture.\n\nThe upper bands and small rectangle\ndefine glyph `2`: two rows, three columns, bitmap byte `00101000`.\nIts first six bits form `001 / 010`; the last two are padding. The white first\ncolumn remains part of the glyph.\n\nThe four-bit numerals beside the upper bands\ngive their byte widths: `1, 2, 4, 1, 1, 1`. Width and value are different:\nthe `0100` beside the payload-length field says that the value `3` is written\nin four bytes. The longer patterns at the lower left are submitted region IDs, not width labels.\n\nThe submitted ID `10`\nleads to page `514`\nand frame `259`, filled with glyph `1`. The\nsubmitted ID `20`\nleads to page `515`\nand frame `260`, filled with glyph `2`. Each feedback box gives page\nkind and ID, then display flag and frame ID, then the resulting picture.\n\nData bands in drawing order.\n\n| Meaning | Bits | Decimal | Bytes |\n| --- | --- | --- | --- |\n| Record kind | `00000001` | `1` | `1` |\n| Record ID | `00000000 00000010` | `2` | `2` |\n| Payload byte length | `00000000 00000000 00000000 00000011` | `3` | `4` |\n| Glyph rows | `00000010` | `2` | `1` |\n| Glyph columns | `00000011` | `3` | `1` |\n| Packed glyph mask | `00101000` | `40` | `1` |\n\n---\n\n### Frame 27 of 32: Select, reset and commit a response\n\nSelecting a region edits a pending answer; committing evaluates it. These three cases show the\ndifference.\n\nThe top case uses operation\n`1` with argument `10` to select region `10`. The line below shows that\npage `512` stays active. The\nmiddle case uses operation\n`3` with argument `0` to clear the pending selection; the page again stays\n`512`.\n\nThe\nbottom case and its feedback picture use\noperation `2` with argument `0` to commit that now-empty set. It is not the\naccepted set `[10]`, so the result is page `515`, displaying glyph\n`2` in every cell. These are examples of actions, not additional serialized packets.\n\nCommit records the pending answer, compares it with the page’s accepted responses, and\nopens the stored success or failure page with\nan empty selection. Doing nothing submits no answer; committing an empty selection submits\nan answer of length zero. Later lessons use this distinction when an empty answer is correct.\n\nData bands in drawing order.\n\n| Meaning | Bits | Decimal |\n| --- | --- | --- |\n| Operation code, operand | `00000000 00000001 | 00000000 00001010` | `1 | 10` |\n| Page before, page after | `00000010 00000000 | 00000010 00000000` | `512 | 512` |\n| Operation code, operand | `00000000 00000011 | 00000000 00000000` | `3 | 0` |\n| Page before, page after | `00000010 00000000 | 00000010 00000000` | `512 | 512` |\n| Operation code, operand | `00000000 00000010 | 00000000 00000000` | `2 | 0` |\n| Page before, page after | `00000010 00000000 | 00000010 00000011` | `512 | 515` |\n\n---\n\n### Frame 28 of 32: Follow feedback and passive routes\n\nStored page references determine what opens next. Their numeric order does not define a sequence of pages.\n\nThe first pair maps submitted region\n`20` to failure page `515`. The\nsecond pair and upper picture map region\n`10` to success page `514`. The\nthird pair and lower picture have a\ndifferent role: demonstration page `516` links to final-picture page `518`.\n\nData bands in drawing order.\n\n| Meaning | Bits | Decimal |\n| --- | --- | --- |\n| Response `20` → failure page `515` | `00000000 00010100 | 00000010 00000011` | `20 | 515` |\n| Response `10` → success page `514` | `00000000 00001010 | 00000010 00000010` | `10 | 514` |\n| Demonstration page `516` → final page `518` | `00000010 00000100 | 00000010 00000110` | `516 | 518` |\n\nPage `516` plays trace `257` and also links to feedback page `517`.\nCompleting its two patches does not follow either link automatically. Pages `514`,\n`515`, `517` and `518` each link back to question `512`.\n\nFollowing a return link starts a fresh attempt with an empty selection. Reset only clears a\npending answer on a question page; it cannot erase a submitted answer from a feedback page.\nThe explicit links also let a learner open the demonstration without first answering correctly.\n\nThe miniature’s complete page graph\n\n| From | Action | To / display |\n| --- | --- | --- |\n| `512` | Submit [`10`] | `514` / frame `259`, all glyph `1` |\n| `512` | Submit [], [`20`] or [`10, 20`] | `515` / frame `260`, all glyph `2` |\n| `512` | Open demonstration | `516` / trace `257` |\n| `516` | Open feedback | `517` / frame `259` |\n| `516` | Open final picture | `518` / frame `258` |\n| `514, 515, 517, 518` | Return link | `512` / question |\n\n---\n\n### Frame 29 of 32: Read the complete miniature section\n\nThis frame supplies the complete miniature document inside its checked section. It lets the recipient\ntest the earlier boundaries and record examples together.\n\nThe first six bytes are header bytes\n`0 1 | 0 0 1 70`: ID `1` and body length `326`. The\n`326`-byte body begins with\n`214 57 | 0 2 | 0 15 | 2 0 | 1 1` and contains all fifteen records. The\nlast four bytes are\n`255 64 93 120`. The total is `6`+`326`+`4` = `336` bytes, filling exactly forty-two eight-byte rows\nstarting at local row `12`.\n\nThe final row contains four body bytes and four check bytes. There is no partial data row. The reader\ncan verify this section’s check now; parsing every record also requires the table format shown next.\nThis worked section belongs to the strip, not to the five-document payload below it.\n\n---\n\n### Frame 30 of 32: Read a numeric table\n\nTable values are unsigned numbers. A value here does not select a glyph, as a frame cell does.\n\nThe first three bands specify kind `5`, ID\n`400` and payload length `17`. The\ndimension fields give two rows and\nthree columns. The last two bands contain\n`0,1,2` and `3`,`4`,`5`, each value stored as a `u16`. Thus each value band occupies six\nbytes.\n\nThe four-bit widths on the left\ncount the bytes in each band. The two value bands each have width `0110`,\nor six bytes: three values with two bytes each. Their small under-row marks locate\nthose byte boundaries.\n\nData bands in drawing order.\n\n| Meaning | Bits | Decimal | Bytes |\n| --- | --- | --- | --- |\n| Record kind | `00000101` | `5` | `1` |\n| Record ID | `00000001 10010000` | `400` | `2` |\n| Payload byte length | `00000000 00000000 00000000 00010001` | `17` | `4` |\n| Table rows | `00000000 00000000 00000000 00000010` | `2` | `4` |\n| Table columns | `00000011` | `3` | `1` |\n| Table values `0`–`2` | `00000000 00000000 | 00000000 00000001 | 00000000 00000010` | `0 | 1 | 2` | `6` |\n| Table values `3`–`5` | `00000000 00000011 | 00000000 00000100 | 00000000 00000101` | `3 | 4 | 5` | `6` |\n\nTrace `257` refers to this table as attached data. The record reader recovers its values without assigning\nthem a subject-specific meaning. Later tables use the same format for move words, scores and field\nwidths; the displayed lessons teach those meanings.\n\nA trace’s references make its attached tables available to the reader. Its stored patches\ngive the display changes explicitly; the player does not calculate those changes from\nthe table values.\n\n---\n\n## Using the bootstrap to read the payload\n\nThe final two bootstrap frames show how sections form a stream and where the full message’s used data\nends. Together with the earlier examples, the strip defines the byte order, checksum, section and\ninventory layouts, document header, and five record types needed to read the payload.\n\n---\n\n### Frame 31 of 32: Locate consecutive sections and their boundary\n\nThis frame places sections consecutively and distinguishes the final byte from the address after it. The\nrecipient needs both to stop at the correct boundary.\n\nThe upper rows have four columns: section ID, start, exclusive end and length. The\ninventory row is `0,0,28,28`;\nthe document row is\n`1,28,364,336`. The second section begins exactly where the first ends. These rows describe\nplacement, not extra header fields.\n\nThe `0,1,2` line is a counting\nsequence; this example contains only sections `0` and `1`. The bottom pair\ncontrasts last included byte `363` with\nexclusive end `364`. In general, the next\nsection starts after six header bytes, the declared body length and four check bytes.\n\nData bands in drawing order.\n\n| Meaning | Bits | Decimal |\n| --- | --- | --- |\n| Inventory: ID, start, end, length | `00000000 00000000 | 00000000 00000000 | 00000000 00011100 | 00000000 00011100` | `0 | 0 | 28 | 28` |\n| Document: ID, start, end, length | `00000000 00000001 | 00000000 00011100 | 00000001 01101100 | 00000001 01010000` | `1 | 28 | 364 | 336` |\n| Counting sequence `0, 1, 2` | `00000000 00000000 | 00000000 00000001 | 00000000 00000010` | `0 | 1 | 2` |\n\n---\n\n### Frame 32 of 32: Find the used end and verify zero reserve\n\nThis frame separates the full payload’s used bytes from its zero-filled reserve. The recipient must stop\nparsing at the used end and check what remains.\n\nThe four bounded fields give\nstart offset `0`, used length `506,509`, capacity `507,904`, and reserve length `1,395`. The small tallies at the right number\nthese rows.\n\nThe lower example contains two separately\nbounded fields: thirty-two zero bits above, and the eight-bit numeral `00100000` below, read\nas `32`. The first field is data; the second states its width. Their separate boundaries keep\nthe numeral’s filled bit out of the zero data.\n\n---\n\n### Recovering and validating the payload\n\nThe five document bodies total `506,181` bytes. Add `268` inventory-body bytes and\n`60` bytes of section headers and checks to obtain `506,509` used bytes. The\nremaining `1,395` bytes must be zero rather than another document.\n\nThe reader starts at row `64` and uses *Frame `16`*’s mapping to recover the declared number of bytes. For each\nsection, it reads the header, checks that the body fits within the remaining data, verifies the checksum,\nand advances past header, body and check. Section IDs increase from `0`, and each required document appears\nonce.\n\nSection `0` is the full message’s inventory. Its body begins with the two-byte document count\n`5`. Each document entry specifies an ID, body length, section checksum, entry count and ordered entry IDs.\nThe inventory contains these numeric declarations, not lesson titles or a curriculum order.\n\nA complete reading must match the inventory to the received sections and document headers. It must also\nvalidate record lengths, kinds, references and cell indices. Missing objects and invalid references cause\nrejection; the reader does not guess replacements. Successfully displaying one fragment is not enough to\naccept the whole message.\n\nThe supplied Python decoder implements these rules directly. It tests rotations, reflections\nand swapped bit states, compares the bootstrap with its defined drawings, and requires one\ncompletely valid reading. This is a check of a known format. Discovering that format from\nthe drawings is the recipient’s separate task.\n\nThe actual five documents; inventory section\n`0`\noccupies stream bytes\n`0`–`277`\n\n| Document / section ID | Section stream offset | Body bytes | Contents, labelled for this guide |\n| --- | --- | --- | --- |\n| `1` | `278` | `13,245` | Basic visual vocabulary |\n| `2` | `13,533` | `93,017` | The `64`-game anthology |\n| `3` | `106,560` | `35,296` | Board, pieces and elementary rules |\n| `4` | `141,866` | `195,452` | Practical rules, state and move packing |\n| `5` | `337,328` | `169,171` | Relationships, tactics and strategic examples |\n\nOffsets are zero-based byte addresses from the start of row `64`. Storage order is not a requirement to read\ndocument `2` before learning from documents `3` and `4`.\n\nThe miniature belongs to the bootstrap strip. It demonstrates the format used by the\ninventory and five complete documents in the byte stream below it. After recovering and\nvalidating that full set, the recipient can open a declared entry.\n\nThe player can now look up the entry’s records and display them. No chess knowledge is\nneeded to reconstruct the picture in the next example.\n\n---\n\n## From payload bits to a displayed picture\n\nFollow document `2`, which stores the complete games, and its first declared entry,\ntrace `324`. We will reconstruct its initial picture using the bootstrap’s rules,\nthen use the course to interpret that picture as chess.\n\n---\n\n### Find the document and read its declared entry\n\nAfter all six sections have been recovered and checked, the inventory identifies document\n`2` with a body of `93,017` bytes. Its section starts at payload byte\n`13,533`. The six-byte header reads `0 2 | 0 1 107 89`: document ID,\nthen body length, high byte first. The body begins six bytes later, at payload byte\n`13,539`. Document offset `0` means this point.\n\nThe first eight body bytes come from source row `116`, columns\n`1,816`–`1,879`. They are one continuous row of `64` cells\nin the message; the illustration regroups them into eight rows, one byte per row.\nThe first two bytes identify the document format.\nThe next two declare `64` entries;\nthe following two declare `151` records.\nThe last pair shown is the first entry ID.\n\nThe document header and the first entry, copied from the actual payload.\n\n| Field | Bits | Reading |\n| --- | --- | --- |\n| Document marker | `11010110 00111001` | `214 57` |\n| Entry count | `00000000 01000000` | `64` |\n| Record count | `00000000 10010111` | `151` |\n| First entry ID | `00000001 01000100` | `1×256 + 68 = 324` |\n\nEntry `324` is a stored name, not the location of the next byte.\nThe remaining `63` entry IDs follow it. All `64` entries occupy\n`128` bytes after the six-byte header, so the records begin at document byte\n`6 + 64×2 = 134`.\n\n---\n\n### Read the records, then follow their names\n\nAt each record, read its one-byte kind, two-byte ID and four-byte content length.\nConsume exactly that many content bytes, then continue with the next record.\nFor example, record `0` starts at byte `134` and declares three\ncontent bytes. Its seven-byte header and three-byte contents end at byte\n`144`, where the next record starts. Reading all `151` records\nbuilds a lookup from each ID to its stored contents.\n\nThree records from that lookup. Spaces group kind, ID and content length; other records are omitted here.\n\n| Record | Document offset | Actual header bytes |\n| --- | --- | --- |\n| Glyph `32` | `199` | `1 | 0 32 | 0 0 0 6` |\n| Frame `256` | `355` | `2 | 1 0 | 0 0 0 76` |\n| Trace `324` | `15,028` | `3 | 1 68 | 0 0 2 88` |\n\nLooking up the declared entry `324` finds a trace, kind `3`.\nIts first two content bytes are `00000001 00000000`, or\n`1×256 + 0 = 256`: its initial display-frame ID.\nLooking up `256` finds the frame record above. This follows a reference\nback to an earlier record; it does not jump to byte `256`.\nThe rest of the trace contains its attached tables and ordered updates. Its initial\ndisplay uses this frame before applying any update.\n\n1. Declared entry\n   `324`\n   names the record below ↓\n2. Trace record\n   `324`\n   First content bytes: `00000001 00000000`\n   name its initial frame ↓\n3. Frame record\n   `256`\n   Found at document byte `355`\n\nThe entry and the trace’s frame reference are record names. Their lookup locations are separate values.\n\n---\n\n### Read the frame as a grid of glyph references\n\nFrame `256` begins its contents with `00001001 00001000`:\nnine rows and eight columns. The next `9×8 = 72` bytes give one glyph ID\nfor each frame cell, across each row and then down. Here are those actual bytes,\nshown as decimal IDs. The row and column labels are added for reading.\nAfter the grid, two zero bytes give a selectable-region count of `0`.\nThe frame’s contents therefore occupy `2 + 72 + 2 = 76` bytes, matching its header.\n\nThe frame’s `72` stored glyph IDs. The shaded cell is index `48`.\n\n| Row | `0` | `1` | `2` | `3` | `4` | `5` | `6` | `7` |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- |\n| `0` | `41` | `39` | `40` | `42` | `43` | `40` | `39` | `41` |\n| `1` | `38` | `38` | `38` | `38` | `38` | `38` | `38` | `38` |\n| `2` | `0` | `0` | `0` | `0` | `0` | `0` | `0` | `0` |\n| `3` | `0` | `0` | `0` | `0` | `0` | `0` | `0` | `0` |\n| `4` | `0` | `0` | `0` | `0` | `0` | `0` | `0` | `0` |\n| `5` | `0` | `0` | `0` | `0` | `0` | `0` | `0` | `0` |\n| `6` | `32` | `32` | `32` | `32` | `32` | `32` | `32` | `32` |\n| `7` | `35` | `33` | `34` | `36` | `37` | `34` | `33` | `35` |\n| `8` | `3` | `0` | `0` | `0` | `0` | `0` | `0` | `0` |\n\nCell `48` is row `6`, column `0`, because\n`6×8 + 0 = 48`. Its byte is `00100000`, or ID `32`.\nThe frame record starts at byte `355`. After its seven-byte header and two\ndimension bytes, the grid begins at `355 + 7 + 2 = 364`.\nCell `48` is therefore at document byte `364 + 48 = 412`,\nor payload byte `13,539 + 412 = 13,951`. The mapping from\n*Frame `16`* places it at source row `118`, columns\n`1,016`–`1,023`. The byte names a glyph; its eight source bits\ndo not themselves draw that glyph.\n\n---\n\n### Look up the bitmap and put it in the cell\n\nRecord `32` is a glyph, kind `1`. Its six content bytes are\n`5 5 | 1 8 64 0`: row count, column count, then the packed bitmap.\nThe dimensions require `5×5 = 25` picture bits. The four bitmap bytes\ncarry those first `25` bits, followed by\nseven zero padding bits that complete the last byte.\nTake five picture bits at a time to fill each bitmap row from left to right, then continue\non the next row. The padding completes the stored bytes and is excluded from the picture.\n\nThe same bitmap bits in storage order above and in five rows below. The seven padding bits do not become pixels.\n\nThe recipient now draws that bitmap in\nframe cell `48`. Each of the other\ncells is drawn by looking up its own glyph ID in this same document. A repeated ID\nreuses the same bitmap. Record `0` has contents `2 2 | 0`:\na two-by-two bitmap of zero bits. It supplies the blank tiles wherever the frame names\nglyph `0`. The result is the complete initial picture of entry `324`:\n\nAll nine rows of the stored frame. The highlighted cell contains glyph `32`.\n\nEvery glyph shape now comes from a stored bitmap, and every position from a stored\nframe cell. The recipient can draw this picture using the bootstrap’s rules alone.\nLearning what the shapes, arrangement and bottom row mean is the next task for the\nrecovered course. Later, we will return to this same trace and apply its first stored update.\n\n---\n\n## Learning chess from the payload\n\nThe picture just recovered is a display the recipient can draw before understanding chess.\nDocument `1` supplies the visual vocabulary; the chess course then explains the `8×8` board, two\nsides, six piece types, starting positions and alternating turns. This guide uses the usual English names,\nWhite and Black; White moves first. The recipient has no reason to associate any particular shape with a\nchess piece, so the glyphs could be arbitrary. I chose patterns that resemble familiar chess pieces. Their roles still have to be taught\nthrough setup, movement and repeated examples.\n\nThe study route begins with document `1`’s representation lessons, then documents\n`3, 4` and `5`: elementary rules, practical rules and history, then relationships and limited\nstrategic guidance. Document `2` supplies the complete-game anthology.\n\nA worked example shows an input and its result. Contrasts make a distinction visible by\nshowing a rejected result or changing a condition such as a blocker or a castling right.\nPractice asks the recipient to choose among stored alternatives, using the page mechanism\nfrom the bootstrap. A page can group several questions: the learner selects an answer for\neach and commits the combined set. The player checks that whole set against the page’s\nstored accepted responses.\n\nA passive route shows the explanations and feedback without requiring a correct submission.\nBoth routes use the same record operations. The chess calculations happen when the lessons\nare authored; the player later presents the resulting pictures, choices and feedback.\n\nA glyph ID remains a local name. Its role as a pawn, knight or other piece comes from the examples. The\nsame glyph can appear on the board, identify a selected piece in a question, and appear at its destination\nafter a move.\n\nPawn\n\nKnight\n\nBishop\n\nRook\n\nQueen\n\nKing\n\nThe actual piece bitmaps, first side then second. Each second-side bitmap inverts the first side’s\ntwenty-five picture bits; the seven padding bits remain zero. The course establishes each piece’s role\nthrough examples.\n\n---\n\n### Identifying the question and its answer\n\nA question must identify its subject as well as show a board. This knight lesson uses a `29`×`10`\ndisplay frame containing an `8×8` board and a separate `8×8` answer grid, or mask, below it. A footer between\nthem names the side, selected piece, square and question type.\n\nHere the footer selects the\nfirst-side knight at board row `7`, column `1`, or b1 in the added chess coordinates. The question asks for legal destinations. The knight can move to\na3 and c3. Its jump also reaches d2 geometrically, but a friendly pawn\noccupies that square.\n\nOne source frame, two distinct picture regions\n\nabcdefgh\n\n87654321\n\nBoard crop · selected knight on b1\n\nabcdefgh\n\n87654321\n\nAnswer-mask crop · a3 and c3\n\n| Source footer field | Actual value / glyph | Meaning in this lesson |\n| --- | --- | --- |\n| Side / selected piece | `3` / `33` | First side / knight |\n| Row / column | `19` / `13` | Digit glyphs for `7` / `1` |\n| Question mode | `9` | Legal destinations |\n| Positive mark | `6` | Carried answer is affirmed |\n\nDocument `3`, trace `3068`, step `33`. Within this `29`×`10` display frame, the board occupies rows\n`1`–`8` and columns `1`–`8`; the mask occupies rows `11`–`18` and columns\n`1`–`8`; the footer is row `9`. Coordinates start at `0`. The mask’s plus-shaped glyph `5`\nmarks indices `40` and `42` within the `8×8` mask, corresponding to a3 and c3. This illustration shows the stored answer.\n\nAn ordinary capture removes the opposing piece at the destination and puts the moving piece\nthere. A friendly piece prevents a move to that square. A legal move must also leave its own\nking safe. An attack on the king is *check*; check with no legal escape is\n*checkmate*. The king stays on the board when the game ends.\n\nKing safety depends on the resulting position. In one course example, a king on e1\ntries to capture a bishop on d1 while an opposing rook stands on f1. Before the move,\nthe king itself blocks the rook’s line to d1. Once the king leaves e1, that line opens,\nso the capture is illegal. The course shows the attempted move’s resulting occupancy\nand attack. Testing a king capture means moving the king, removing the captured piece,\nand checking its destination in that changed position.\n\n---\n\n### Controlled squares and legal moves\n\nControl follows a piece’s movement geometry in the displayed position. For a rook, bishop\nor queen, it extends along each permitted straight line to the first occupied square,\nincluding a friendly piece it defends. Pins do not remove controlled squares. Here the\nbishop on b5 points along a diagonal through the knight on c6 toward\nthe knight’s king on e8. Moving the knight would expose the king. The knight still\ncontrols eight squares, but has\nno legal destination.\n\nThe control question follows the knight’s jump pattern. The legal-move question also checks whether moving\nwould expose its king. The course distinguishes these questions with different mode glyphs. The board\nstays the same; the empty legal-move mask and eight-square control mask are answers to different\nquestions. This knight cannot move along the diagonal that pins it. A pinned sliding piece\nor pawn can sometimes move along its pin line while continuing to shield its king, so a pin\ndoes not always mean that a piece has no legal move.\n\nOne board, two questions\n\nabcdefgh\n\n87654321\n\nSelected black knight c6; bishop b5; king e8\n\nabcdefgh\n\n87654321\n\nControl mask · eight controlled squares\n\nabcdefgh\n\n87654321\n\nLegal mask · no legal destination\n\nControl mask: document `3`, trace `3124`, step `1`. Legal-move mask: trace `3119`, step `8`. Both show\nthe same board and selected knight.\n\n---\n\n### Learning how moves are packed\n\nA numeric table provides values, but their meaning must also be taught. Document `4` explains how a move’s\norigin square, destination square and promotion choice form a packed number. These lessons are part of the\npayload and become accessible through the reader established by the bootstrap.\n\nOne stored example uses origin `52`,\ndestination `36` and\nchoice `0`: e2→e4 without promotion. Squares are numbered across rows from a8=`0` to h8=`7`, continuing\ndown to a1=`56`. Choice `0` means no promotion; `1, 2, 3` and `4` select queen, rook,\nbishop and knight.\n\nBoth before-and-after boards already appear in the source display. The two crops below show the numeric\npart of that display before and after a trace step fills in the packed result. The board pictures do not\nmove between these two states.\n\nA stored lesson combines the three move fields\n\nGiven: `52`, `36`, `0`; packed-word row blank\n\nShown result: packed word `26912`\n\n| Row in these crops | What it represents |\n| --- | --- |\n| Top | Decimal origin `52`, destination `36`, choice `0` |\n| Middle | The respective `6, 6, 3` bits: `110100` / `100100` / `000` |\n| Bottom | The completed `16`-bit word: `0` / `110100` / `100100` / `000` |\n\nDocument `4`, page `1076`→trace `1075`. The crops show display-frame rows `9`–`11` and columns\n`0`–`18`. A bit `0` uses glyph `2`, the decimal digit `0` uses glyph `22`, and\na blank cell uses glyph `0`. These are three distinct records.\n\nThe completed word is `0110100100100000` = `26,912`, calculated as `52×512 + 36×8 + 0`. Its fields are one leading zero, six origin bits, six\ndestination bits and three choice bits. Other stored examples unpack a word into these fields and reject a\nleading `1` or a choice outside `0`–`4`.\n\nThe table `[16,1,6,6,3]` describes those widths: `16` bits total, with fields of\n`1, 6, 6` and `3` bits. The pictures teach which fields mean padding, origin, destination and\nchoice. The table alone provides widths, not that interpretation. We can now use the same rule to\nunderstand a move in the anthology.\n\nA well-formed move word is not necessarily a legal move. Packing checks field ranges;\nunpacking also rejects a nonzero leading bit. Neither operation checks the board, whose turn\nit is, or whether promotion is possible. Those questions require the chess rules and the\nposition’s state.\n\n---\n\n## Following one move from source to display\n\nThe first game in the anthology has `52` individual moves, or *plies*, beginning with d2→d4.\nThe byte-to-picture walkthrough above recovered this game’s initial frame. Following its first\nmove now connects the stored number’s meaning to the separately stored display update. The anthology stores the move in two\nforms: a numeric move word and a display patch. The recipient must recover them separately and learn why they describe the same move.\n\n---\n\n### 1. Produce the move word and display patch\n\nGame preparation starts with the anthology in PGN, a human-readable notation for recorded games.\nThe source importer checks each game’s main line by replaying it legally from the standard\nstarting position. It records every intermediate board, the side to move, and each move’s\norigin, destination and explicit promotion choice. The first move here gives\n`[51,35,0]`. Packing gives `51×512 + 35×8 = 26,392`, stored as bytes\n`103 24`.\n\nThe same replay supplies the board before and after the move. Comparing their display cells produces three\nassignments: place pawn glyph `32` at cell `35`,\nclear cell `51` to glyph `0`, and change footer cell `64` from side glyph `3` to side glyph `4`. The move\nword and patch come from this common replay. The reader does not calculate one from the other.\n\nThe message builder loads the checked game and presentation data, packs the move tables,\nand assembles the document. It verifies the retained inputs before using them. This\nconstruction uses the qualified presentation data rather than reimporting the PGN on\nevery build.\n\nThe authoring code shares identical glyphs, frames and tables between games, then assigns trace IDs. In\ndocument `2`, trace `324` refers to initial frame `256`, move table `257` and score table `258`. Packing adds schema\ntable `388` as another reference. These IDs identify objects only within this document.\n\nRecords used by trace `324`\n\n| Record in document `2` | Kind | What it supplies to trace `324` |\n| --- | --- | --- |\n| `256` | `2`: frame | `9×8` initial picture: `64` board cells +`8` footer cells |\n| `257` | `5`: table | `52` rows ×`1` column of packed move words |\n| `258` | `5`: table | `1`×`1` score table, value `1` |\n| `388` | `5`: table | `1`×`5` schema: `16, 1, 6, 6, 3` |\n| `324` | `3`: trace | Initial `256`, data[`257,258,388`],`52` literal patches |\n\nMiniature `257` was a trace; document `2`’s `257` is a table. Miniature `256` and document `2`’s `256` are also\ndifferent frames. A name never identifies a record across document boundaries.\n\n---\n\n### 2. Store the document in a checked section\n\nDocument `2` contains `93,017` bytes. Its six-byte section header is\n`0 2 | 0 1 107 89`: section ID `2` and body length `93,017`. CRC-32C over that header\nand body gives `182 147 233 40`. Adding the four check bytes gives a `93,027`-byte\nsection.\n\nThe section starts at stream byte `13,533`, which maps to physical row `116`, column `1,768`. Its\nbody starts six bytes later, at stream byte `13,539`. The boundary falls inside a physical row:\nsection storage follows the byte stream continuously, without row packets or row separators.\n\n---\n\n### 3. Recover and validate document 2\n\nThe recipient finds this boundary by reading the inventory section and document `1`’s section\nlengths. The inventory declares document ID `2`, body length `93,017`, expected check\n`182 147 233 40` and `64` entry IDs, starting with `324`. These declarations must match the received\nsection and document header.\n\nThe document header starts `214 57 | 0 64 | 0 151`: marker, `64` entries and `151` records. Its\nfirst entry is `1 68`, or `324`. Reading each length-delimited record builds a map from IDs to\nrecords. Resolving trace `324` then finds frame `256` and tables `257, 258` and `388`. Schema `388` is\nnear the document’s end, so references must work even when the target record occurs later.\n\nMove table `257` and trace `324`: actual record bytes\n\n| Actual byte values, decimal | Interpretation |\n| --- | --- |\n| `5 | 1 1 | 0 0 0 109` | Kind `5`, ID `257`, payload `109` bytes |\n| `0 0 0 52 | 1` | `52` table rows, `1` column |\n| `103 24` | First `u16` value: `26,392` |\n| `3 | 1 68 | 0 0 2 88` | Kind `3`, ID `324`, payload `600` bytes |\n| `1 0 | 3 | 1 1 | 1 2 | 1 132 | 0 0 0 52` | Initial `256`; `3` references `257,258,388`; `52` patches |\n\nSpaces in these transcripts separate fields for reading; they are not stored delimiters. The table’s\npayload length, `109` bytes, and its row count, `52`, are different fields.\n\n---\n\n### 4. Locate and read the first move word\n\nTable `257` starts at document byte `438`. Its seven-byte record header is followed by a four-byte row count\nand a one-byte column count. Its first value therefore begins at byte `450` and occupies bytes `450`–`451`.\n\nThe document body starts at stream byte `13,539`. Adding `450` locates the first value at stream\nbytes `13,989`–`13,990`. *Frame `16`*’s mapping places its sixteen bits at physical row\n`118`, columns `1,320`–`1,335`. They read `0110011100011000`: bytes `103` and\n`24`, giving `103×256+24 = 26,392`.\n\nThe first move word, directly from the artifact\n\nRead the sixteen positions from left to right: `0110011100011000`. The table keeps those same\nbits visible while showing their readings.\n\n| Representation | Same carried value |\n| --- | --- |\n| Two bytes, decimal | `103` /`24` |\n| One `u16` | `103×256`+`24` =`26,392` |\n| Fields, binary | `0` |`110011` |`100011` |`000` |\n| Fields, decimal | padding `0` |origin `51` |target `35` |choice `0` |\n\n---\n\n### 5. Interpret the move fields\n\nApply schema `388` using the meanings taught in document `4`: `0 | 110011 | 100011 | 000`. The\nfields give padding `0`, origin `51`, destination `35` and choice `0`: d2→d4 without promotion. These\nsquare numbers use row-major order on the `8×8` board; they are distinct from coordinates in the physical\nmessage.\n\nThe table reader recovers the value `26,392`. Interpreting it as a chess move requires\nthe course’s explanation of the fields. The native player does not use this word to calculate a legal\nboard update; it displays the separately stored patch.\n\n---\n\n### 6. Apply the stored patch\n\nTrace `324`’s first patch occupies document bytes `15,048`–`15,058`:\n`0 3 | 0 35 32 | 0 51 0 | 0 64 4`. The count is three, followed by assignments (cell `35`, glyph\n`32`), (cell `51`, glyph `0`) and (cell `64`, glyph `4`). Two change board cells; the third changes the\nfooter’s turn marker.\n\nBoth before and after the patch, glyph `32` refers to the same bitmap recovered earlier:\na `5×5` picture with mask bytes `1 8 64 0`. The patch changes where it is drawn.\nThe glyph record itself stays unchanged.\n\n**Record `32` → a `5×5` bitmap**\n\n`00000` / `00100` / `00100` / `00100` / `00000`\n\nThe first `25` bits of bytes `1`, `8`, `64`, `0`, across each row and then down.\n\nThe first patch changes two board cells\n\nabcdefgh\n\n87654321\n\nBefore patch · frame `256`, board region\n\nabcdefgh\n\n87654321\n\nAfter patch `1` · d2 empty, pawn on d4\n\n| Cell index | Before glyph ID | Assignment | Result |\n| --- | --- | --- | --- |\n| `35` (d4) | `0` | `32` | Draw the pawn bitmap |\n| `51` (d2) | `32` | `0` | Draw the blank bitmap |\n| `64` (footer, first cell) | `3` | `4` | Second side to move |\n\nThe frame is `9×8`; these pictures crop its first eight rows. Cell `64` is outside the board and is shown\nseparately in the complete replay below. Colored areas identify the assigned board cells.\n\nThe two stored representations agree: the move word specifies d2→d4, and the patch moves the pawn between\nthose squares while changing the turn marker. During message creation, the program checks the reconstructed pictures against the board positions\nobtained from the original game’s moves. A\nrecipient who has learned the meanings can compare them; the player itself only looks up glyphs and\nassigns cell values.\n\nThe move word, patch and bitmap thus meet in one displayed change. The bootstrap supplies the\noperations needed to recover and draw it; the course supplies its chess meaning. The special\nmoves below use the same operations, with additional rules determining which changes are valid.\n\n---\n\n## Why board positions need history\n\nThe first move changes two board cells and a footer. Other moves depend on more information or change\nadditional squares. The course teaches these cases by showing a position, an attempted move and its\nresult, then comparing what happens when a relevant condition changes.\n\nIn the examples below, the before-and-after boards occupy two regions of one stored display frame, at\ndisplay-frame columns `0`–`7` and `9`–`16`. They are not separate frame records. The crops show only\nthe squares needed to explain each rule.\n\n---\n\n### Castling moves two pieces\n\nIn this king-side castling example, the\nking and rook leave e1 and h1 and\narrive on g1 and f1. Four board cells change. Castling requires\nthe corresponding right to remain and every square between king and rook to be empty. The\nking must be safe on its starting square, its transit square after leaving the start, and its\ndestination after both pieces move. The course compares accepted castling with attempts\nthat fail these conditions.\n\nA king or rook that moves and returns does not recover its lost right. For queen-side\ncastling, the square next to the rook must also be empty, though the king never crosses it.\nAn attack on that square or on the rook itself does not prevent castling; the safety test\nconcerns the king’s route.\n\nBefore: e1 king / f1 empty / g1 empty / h1 rook\n\nAfter: e1 empty / f1 rook / g1 king / h1 empty\n\nDocument `4`, trace `798`, step `0`. The crops show e1–h1 in the before-and-after board regions.\nThe first side also loses its castling rights after this move.\n\n---\n\n### En passant depends on the immediately preceding move\n\nImmediately after the opposing pawn advances from d7 to d5, the pawn on e5 can\ncapture on d6. That destination was empty. The\ncaptured pawn is removed from d5, so three squares change. The crop\nshows d6 and e6 above d5 and e5.\n\nA matched example moves both sides’ knights away and back, restoring the same board occupancy. The\nopportunity for en passant has expired, so the same attempted capture is refused and the board remains\nunchanged. The pieces alone do not record when the opposing pawn advanced.\n\nEn passant must also leave the moving side’s king safe. Removing both pawns from their\noriginal squares can open an attacking line. The course includes an immediate capture\nrefused for this reason, even though its timing and pawn geometry are otherwise correct.\n\nBefore: d5 opposing pawn; e5 capturing pawn\n\nAfter: pawn on d6; d5 and e5 empty\n\nDocument `4`, trace `906`. Step `0` shows the available capture; step `4` shows the same board after\nthe opportunity has expired.\n\n---\n\n### Promotion needs a separate choice\n\nHere the pawn leaves b7, captures the\nrook on a8, and is replaced by the\nselected promotion piece. Choice `1` produces a queen;\nchoice `4` produces a knight. Both moves have the same origin and destination, so the promotion choice needs\nits own field. The course also shows rook and bishop promotion and rejects a missing promotion choice.\n\nBefore: rook a8; pawn b7\n\nChoice `1`: queen a8; b7 empty\n\nChoice `4`: knight a8; b7 empty\n\nDocument `4`, trace `929`, steps `0` and `9`. Each crop shows a8 and b8 above a7 and b7.\n\n---\n\n### History is part of the state\n\nA king can leave its starting square and return, restoring the board and side to move while losing\ncastling rights. Document `4`, trace `1000` at step `3`, compares two matching boards with\ndifferent histories: the first side has both castling rights in one case and neither in the other.\n\nRepetition uses a precise meaning of “the same position”: the pieces occupy the same\nsquares, the same side is to move, castling rights match, and any legal en-passant opportunity\nmatches. An en-passant target counts only if an actual legal capture is available. A target\nthat no pawn can use, or that would expose its own king, does not distinguish the position.\n\nCount occurrences of the current position throughout the legal history, including the\ninitial occurrence. They need not be consecutive. A separate counter records plies since\nthe last pawn move or capture; either resets it to zero. That counter affects a draw claim,\nbut is not part of the position compared for repetition.\n\nThe course carries legal histories and state displays for these distinctions. Reused history\nsegments have explicit links and complete starting pictures, so opening a segment does not\nrequire the player to calculate its starting position. The anthology’s `72` display\ncells serve a smaller purpose: its board and footer show play and result, without listing\nall castling rights or an en-passant square.\n\n---\n\n### When a game ends\n\nA side with no legal move is checkmated if its king is in check, and stalemated otherwise.\nCheckmate is a loss; stalemate is a draw. Golden Board also recognizes three classes where\nneither side can give checkmate: king against king, king and bishop against king, and king\nand knight against king. Its rules machinery ends play after a legal move reaches one of\nthese board endings, and refuses later moves or declarations.\n\nA claim for threefold repetition becomes available once the current position has appeared\nat least three times. A fifty-move claim needs at least `100` plies since the last\npawn move or capture. Neither condition ends play automatically: the side to move must\nexplicitly claim the eligible draw. A move that would reach a threshold does not make that\nclaim available in advance. The course shows eligible claims and the separate events that\naccept or refuse them.\n\nEither side can resign while play is active, awarding the other side the win. Draw agreement\nrequires both sides’ explicit consent after each has made a move. These declarations have\nknown causes. An anthology score only records the outcome: a win or draw on a nonterminal\nboard does not identify resignation, agreement or a claim.\n\nThis is the project’s practical chess profile. It excludes automatic fivefold and\n`75`-move adjudication, intended-next-move claim procedures, tournament procedures,\nand a general solver for positions where checkmate is impossible. Material outside the\nthree recognized dead-position classes receives no general deadness verdict.\n\n---\n\n## Tactics, mating and strategic guidance\n\nThe later course builds on control and legality to teach attacks, defenses, pins and forks.\nA fork here is one piece geometrically attacking at least two opposing pieces. That fact\nalone does not prove that either capture is legal or profitable. A passed pawn has no\nopposing pawn ahead on its own or an adjacent file; it still faces kings, other pieces and\nthe timing of play.\n\nMating instruction includes king-and-queen and king-and-rook continuations, with contrasts\nthat end in stalemate. A legal line ending in mate can still depend on the opponent choosing\na losing reply. To support a\nforced win, the winning side may choose its continuations, but every legal defensive move\nand every eligible defensive draw claim must be covered. All resulting branches must end\nin the asserted win.\n\nThe message carries finite worked examples of this distinction. One starts with White’s king\non f3 and queen on h4, and Black’s lone king on g1. White moves the queen to g3. Black’s\nonly legal moves are king g1→f1 and king g1→h1. The stored continuations\nanswer the first with queen g3→f2 and the second with queen g3→g2; both give checkmate.\nCovering only one reply would leave the forced-win claim incomplete. The player presents\nthese stored displays and tables without searching for a mating line.\n\nStrategic lessons use observable facts such as development, central control, open files\nand mobility. Their rough material scale assigns `1` to a pawn, `3` to a\nknight or bishop, `5` to a rook and `9` to a queen; the king has no exchange\nvalue. These counts and comparisons provide guidance, not a verdict on the better position\nor best move. A worked move-check routine first establishes whether play is active, whose\nturn it is, whether the king is in check, and which draw claims are available. It then\nexamines legal choices and the shown move’s effects, including captures, check and game\nendings. Comparisons remain limited to the continuations actually supplied.\n\n---\n\n## Replaying a complete game\n\nThe `52`-ply game has `53` display states: its initial frame and the result after each patch. To reconstruct a\nstate, copy the initial frame and apply all patches up to that point. Moving backward reconstructs an\nearlier state in the same way; it does not require reversing chess moves.\n\nThe board and eight-cell footer appear separately below. Footer cell `0` identifies the side to\nmove. In the final patch, footer cell `1` changes to glyph `11`, the second-side result mark.\nScore table `258` contains `1`, recording a second-side win. This stored result does not imply that the final\ndisplayed board is checkmate.\n\nGame `1`: all `53` display states and the footer\n\nUse Next move to apply the next stored patch, Previous to reconstruct the preceding state, and Reset to\nrestore the start. The `53` states cover `0`–`52` plies.\nBlue areas mark cleared cells;\nochre areas mark assigned pieces;\nteal areas mark footer changes. The interpreted move word is listed\nseparately.\n\nabcdefgh\n\n87654321\n\nGame `1` board · initial position\n\nFooter · side to move, then recorded result\n\nFirst side to move; result mark blank.\n\nState `1` of `53` · before any move\n\n---\n\n### Initial frame `256`\n\nMove-word details begin with the first stored update.\n\nNo patch applied. The source picture has `64` board cells and `8` footer cells.\n\nThe controls inspect stored moves and patches. This page does not calculate chess rules or generate\nlegal moves.\n\nabcdefgh\n\n87654321\n\nAfter ply `1` · d2→d4\n\nabcdefgh\n\n87654321\n\nAfter ply `19` · first side castles\n\nabcdefgh\n\n87654321\n\nAfter ply `52` · final carried board\n\nThe three checkpoints show selected states without interaction. Across `64` games, the artifact stores\n`6,890` plies and `6,954` initial-or-updated board states. The game records contain\nno names, dates, opening labels or commentary.\n\nThe player displays castling, promotion and en passant by applying their stored cell changes. Interpreting\nmove words or deciding whether a new move is legal requires the rules taught by the course. The picture player does neither.\n\n---\n\n## Before you go\n\nGetting from a square of bits to a game takes patience. Thank you for giving so much of your time and attention.\n\nIf something is unclear, seems wrong, or could be explained better, please\n[let me know](https://artemlegotin.com/). Questions, corrections and other ideas\nare welcome, whether they concern the Golden Board itself or this guide.\n\nYou're also welcome to build on the\n[source code](https://github.com/arlegotin/golden-board). Try another subject, another way of teaching it, or a different experiment.\n\nIf you share or adapt the project, or use it in research, please credit and link the original work; the repository includes a\n[BibTeX citation](https://github.com/arlegotin/golden-board#license).\n\nI'd love to see what you make from it.\n\n[Artem Legotin](https://artemlegotin.com/)\n","body_html":"<p><a href=\"https://artemlegotin.com/\" rel=\"nofollow ugc noopener\">Artem Legotin</a></p>\n<h1 id=\"golden-board\">Golden Board</h1>\n<p><em>Or Why and How to Teach Chess to Aliens.</em></p>\n<hr />\n<h2 id=\"intro\">Intro</h2>\n<p>Golden Board is a binary message designed to teach chess to an unknown recipient without a shared language, culture, or prior knowledge of the game. It begins by teaching the format needed to read its own contents.</p>\n<p>The full project code and documentation are available on <a href=\"https://github.com/arlegotin/golden-board\" rel=\"nofollow ugc noopener\">GitHub</a>.</p>\n<p>This guide follows that process: recover numbers from the bits, use them to reconstruct pictures and interactions, then learn how those pictures describe chess. One complete game connects the layers, from its physical bits to its final displayed position.</p>\n<p>Feedback is always <a href=\"https://artemlegotin.com/\" rel=\"nofollow ugc noopener\">welcome</a>.</p>\n<p>Before we dive in, I&#39;d like to clarify a few things about the project.</p>\n<hr />\n<h3 id=\"what-does-it-look-like\">What does it look like?</h3>\n<p>In a nutshell, Golden Board is a sequence of <code>4,194,304</code> bits, or <code>512 KiB</code> of ones and zeros.\nThat number suggests arranging them into a <code>2,048 × 2,048</code> square.</p>\n<hr />\n<h3 id=\"what-s-inside\">What’s inside?</h3>\n<p>The first <code>64</code> rows contain <code>32</code> drawings, each <code>64 × 64</code> cells.\nTogether they form the <strong>bootstrap</strong>: it teaches how to read the rest of\nthe message. It&#39;s chess-agnostic and can be used to decode other structured messages.</p>\n<p>The <strong>payload</strong> below contains visual chess lessons, exercises with feedback, complete games, and the\ninformation needed to find, check and display them.</p>\n<hr />\n<h3 id=\"where-did-the-idea-come-from\">Where did the idea come from?</h3>\n<p>I took inspiration from messages intended for unknown intelligences, such as the\n<a href=\"https://en.wikipedia.org/wiki/Voyager_Golden_Record\" rel=\"nofollow ugc noopener\">Voyager Golden Record</a>,\n<a href=\"https://en.wikipedia.org/wiki/Lincos_language\" rel=\"nofollow ugc noopener\">Lincos</a>, and others.</p>\n<p>But instead of sharing scientific knowledge or works of art, Golden Board teaches chess.</p>\n<hr />\n<h3 id=\"why-chess\">Why chess?</h3>\n<p>Two reasons.</p>\n<p>First, a small set of rules opens up an enormous world of possibilities, ideas and beauty.</p>\n<p>Second, a game can share more than knowledge: it offers a glimpse of the human mind.</p>\n<hr />\n<h3 id=\"how-did-i-test-it\">How did I test it?</h3>\n<p>I ran trials using LLMs as stand-ins for unknown recipients, testing decoding and understanding with raw bits, decoded content, and varying levels of assistance.</p>\n<p>Correctly recovering the bytes and understanding the lessons are separate tests. These models already know chess, so correct chess answers alone cannot establish that the message taught them. The trials helped identify ambiguities and improve the design; they do not establish that an unknown intelligence would understand it. <a href=\"https://github.com/arlegotin/golden-board/blob/main/docs/guide/trials.md\" rel=\"nofollow ugc noopener\">Read the trial account</a>.</p>\n<hr />\n<h3 id=\"how-did-i-choose-the-games\">How did I choose the games?</h3>\n<p>No set of <code>64</code> games is complete.</p>\n<p>I chose games for their chess: brilliant attacks, surprising sacrifices, clever defenses, quiet strategy, and beautiful endings. The <a href=\"https://github.com/arlegotin/golden-board/blob/main/inputs/anthology.pgn\" rel=\"nofollow ugc noopener\">PGN anthology</a> contains <code>64</code> games, while the binary message omits names, dates, and events.</p>\n<hr />\n<h3 id=\"what-is-it-all-for\">What is it all for?</h3>\n<p>There is a special joy in sharing something you love.</p>\n<p>What could we share with a civilization that knows nothing about us? They might already know our science or lack the context for our art, but chess can be taught from scratch, revealing centuries of human imagination, mistakes, and brilliance.</p>\n<p>Most likely, no one will ever receive this message. But even a small chance that someone might discover a position with a move like\n<a href=\"https://www.youtube.com/watch?v=Pv5jbBd2Ezk&amp;t=402s\" rel=\"nofollow ugc noopener\"><code>Bf5</code></a> makes the whole thing worth trying.</p>\n<hr />\n<h3 id=\"can-you-build-on-it\">Can you build on it?</h3>\n<p>Yes. The chess-agnostic bootstrap, binary format and Python tools offer a starting point for\nteaching other subjects without a shared language or culture. Developers can adapt the system;\nresearchers can use the trials to investigate what works, what fails and why. <a href=\"https://github.com/arlegotin/golden-board\" rel=\"nofollow ugc noopener\">Source code and documentation</a>.</p>\n<hr />\n<h2 id=\"how-to-read-this-guide\">How to read this guide</h2>\n<p>In the source drawings, each cell shows a <em>bit</em>: black represents <code>1</code> and white\nrepresents <code>0</code>. Decoded pictures are reconstructed from the stored data,\nrather than cropped from the source square.</p>\n<p>Colors, fine gray guides, and labels are added here to make the pictures easier to read.\n<strong>They are not part of the original message</strong>.</p>\n<p>The intended recipient can infer these arrangements without visual aids, using bounding boxes, fixed sequence lengths, and other previously learned patterns.</p>\n<p>The frame below provides an example; its contents are explained later. The\nblue area covers a data row and its small marks\nunderneath. The orange area picks out the small\nnumber to its left. The green area covers a whole\nboxed list. The gray guides make individual bit positions easier to count.</p>\n<p>Hover over a colored phrase to keep only its matching highlights. Hover over the picture to hide all visual aids.</p>\n<hr />\n<h2 id=\"reading-numbers-and-pictures\">Reading numbers and pictures</h2>\n<p>The recipient begins with a clean sequence of bits or a sampled square, and is assumed to be able\nto count, recognize patterns and write simple programs. Obtaining those cells from a signal or\nphysical object is a separate problem.</p>\n<p>The first task is to recover pictures and interactions from the bits. The recipient can then use\nthose displays to learn chess. The bootstrap establishes the reading rules through worked examples;\nthe recipient supplies a program that follows those rules. The message carries data for that program\nto interpret, not executable code.</p>\n<p>The bootstrap is the narrow strip at the top\nof the view below. The payload area beneath it\nincludes the unused space at the end.</p>\n<p>The whole message at reduced size. The frame crops below enlarge its narrow top strip.</p>\n<hr />\n<h3 id=\"headers-show-order-and-related-groups\">Headers show order and related groups</h3>\n<p>Before looking inside each drawing, use its header to locate it in the strip. Each frame repeats\nthe same corner mark. Its top row pairs a count of filled cells with a binary numeral to give its global number,\n<code>1</code>–<code>32</code>. A second pair two rows below counts steps within a\nrelated group. That local count restarts for each group; standalone frames leave its row empty.</p>\n<p>Compare these four headers. <em>Frame <code>6</code></em> is sixth overall and second in its related group. <em>Frame <code>3</code></em> stands alone:</p>\n<p><em>Frame <code>1</code></em>: global <code>1</code> (<code>00000001</code>), group step\n<code>1</code> (<code>00000001</code>).</p>\n<p><em>Frame <code>2</code></em>: global <code>2</code> (<code>00000010</code>), group step\n<code>2</code> (<code>00000010</code>).</p>\n<p><em>Frame <code>3</code></em>: global <code>3</code> (<code>00000011</code>), no local counter.</p>\n<p><em>Frame <code>6</code></em>: global <code>6</code> (<code>00000110</code>), group step\n<code>2</code> (<code>00000010</code>).</p>\n<p>The corner crop below\nshows the same received pattern at four rotations:</p>\n<p>As drawn</p>\n<p>Quarter turn</p>\n<p>Half turn</p>\n<p>Three-quarter turn</p>\n<p>The repeated corner suggests an orientation to try. Ascending counts, dimensions and checksums test\nwhether it remains consistent. The corner alone does not prove orientation or which received state should\nrepresent <code>1</code>.</p>\n<hr />\n<h3 id=\"frame-1-of-32-read-numbers-by-counting\">Frame 1 of 32: Read numbers by counting</h3>\n<p>Binary numerals connect a pattern of bits to a quantity. This first frame makes that connection by\npairing numbers with cells that can be counted.</p>\n<p>The left-hand stripes contain <code>0</code>,\n<code>1</code>, <code>2</code>, <code>3</code>, <code>4</code>, <code>7</code>, <code>8</code> and\n<code>15</code> filled cells. Opposite each stripe, the\nupper four-bit numerals give the same\nquantity: the empty stripe pairs with <code>0000</code>, and two filled cells pair with\n<code>0010</code>. The\nlower eight-bit numerals repeat the\nquantities with leading zeros.</p>\n<hr />\n<h3 id=\"frame-2-of-32-identify-each-bit-position\">Frame 2 of 32: Identify each bit position</h3>\n<p>A filled bit contributes a different amount depending on its position. Moving it one place left\ndoubles that contribution. This frame pairs each single-bit pattern with its position number.</p>\n<p>The left column starts with\n<code>00000001</code> and moves its single filled position one place left on each row, ending with\n<code>10000000</code>. The\nright column counts those positions from\n<code>1</code> to <code>8</code>, starting at the rightmost bit. Each horizontal pair belongs together.</p>\n<p>Every field has a black border with a white inset around its data row. The border fixes the full width\neven when most positions are empty. The eight-bit patterns therefore stay in one column, while their\nfour-bit position numbers stay in another.</p>\n<hr />\n<h3 id=\"frame-3-of-32-read-a-picture-s-dimensions-and-complement\">Frame 3 of 32: Read a picture’s dimensions and complement</h3>\n<p>A picture includes its empty positions as well as its filled ones. Its dimensions preserve the rectangle\nwhen the bits are inverted.</p>\n<p>The left picture has three rows and five\ncolumns. In its first row, the\nfirst position is empty and the\nsecond position is filled.</p>\n<p>The right picture keeps those same fifteen\npositions but exchanges filled and empty. The\ntwo numerals below the left picture are\n<code>3</code> and <code>5</code>: row count, then column count. Both numerals end at the picture’s right edge.\nThey count picture positions, not the source cells used to draw\nthe blocks.</p>\n<hr />\n<h3 id=\"frame-4-of-32-establish-row-order\">Frame 4 of 32: Establish row order</h3>\n<p>Without a shared reading order, the same sequence of values could produce different pictures.\nThe numbered arrangement makes the order explicit.</p>\n<p>The upper arrangement has\n<code>1, 2, 3</code> on its first row and <code>4, 5, 6</code> on its second. The\nlower sequence repeats\n<code>1</code> through <code>6</code>. Finish each row from left to right before continuing on the next: this is\nrow-major order.</p>\n<hr />\n<h3 id=\"frame-5-of-32-group-eight-bits-into-a-byte\">Frame 5 of 32: Group eight bits into a byte</h3>\n<p>A byte is a group of eight bits in a fixed order. This frame connects one compact group to\nits eight individual bit positions, establishing the unit used by later lengths and checks.</p>\n<p>The upper compact pattern is\n<code>00110101</code>. The arrow below it\nleads to eight separate boxes\ncontaining the same bits in the same order. Read the single centre\ncell in each box: the first is empty,\nwhile the third is filled.</p>\n<p>The two numerals beneath that row\nare <code>00000001</code> and <code>00001000</code>: one row, eight bit positions. The compact\ngroup above is one byte; the expanded row shows its eight bits. Together, they establish\n<strong>one byte = eight bits</strong>. The lower half repeats this correspondence for\n<code>00001011</code>.</p>\n<hr />\n<h3 id=\"frame-6-of-32-combine-high-and-low-bytes\">Frame 6 of 32: Combine high and low bytes</h3>\n<p>A number spanning several bytes needs a byte order. Exchanging its high and low bytes\ncan change its value, even though each byte still contains the same bits.</p>\n<p>Each row repeats a\nsixteen-bit number at the left as its\nfirst eight bits in the middle and\nlast eight bits at the right. Each has its own\nboundary, so an entirely zero high or low byte remains visible as a field. On the fifth row,\n<code>0001001000110100</code> splits into <code>00010010</code> and <code>00110100</code>: decimal\n<code>18</code> and <code>52</code>.</p>\n<p>The first byte counts groups of <code>256</code>; the second counts the remaining units. That row means <code>18×256 + 52 = 4,660</code>.\nThe next row reverses the bytes and represents <code>52×256 + 18 = 13,330</code>. This\nis high-byte-first order. The notation <code>u16</code> means a two-byte nonnegative integer;\n<code>u32</code> means a four-byte one.</p>\n<hr />\n<h3 id=\"frame-7-of-32-read-dimensions-and-used-payload-length\">Frame 7 of 32: Read dimensions and used payload length</h3>\n<p>The recipient needs to locate the payload and know how much of the remaining square to read.\nThese four measurements separate the bootstrap, used data and unused reserve.</p>\n<p>Top to bottom, the fields give the\nsquare side, <code>2,048</code>;\nthe first payload row, <code>64</code>,\ncounting from <code>0</code>; the\nbyte width, <code>8</code> bits; and the\nused payload length, <code>506,509</code> bytes.\nThe first three fields have sixteen bits each; the last has thirty-two. Their right edges align,\nso the wider last field extends farther left.</p>\n<p>Starting at row <code>64</code>, read left to right across each row, then continue on the next.\nEach group of eight cells gives one byte, with its highest-value bit first. Recover exactly\nthe declared number of bytes.\n<em>Frame <code>32</code></em> shows how the used length relates to the remaining capacity.</p>\n<hr />\n<h2 id=\"checking-the-recovered-bytes\">Checking the recovered bytes</h2>\n<p>The recipient needs more than plausible-looking numbers before trusting the recovered lessons and\ngames. A wrong orientation, bit interpretation or byte grouping can still produce values. Golden\nBoard includes checks that let the recipient reject an inconsistent reading before using its content.</p>\n<p>The content is organized into <em>documents</em>: collections of picture definitions, numerical\ndata and display or interaction instructions. Each document’s bytes sit inside a checked block\ncalled a <em>section</em>. Its header identifies the document and gives its byte length. That\nlength locates both the check at the end and the beginning of the next section.</p>\n<p>A section also stores a <em>checksum</em>, a value calculated from its identifying fields and content.\nThe program creating the message computes this value from the original bytes. The recipient repeats\nthe calculation on the recovered bytes and compares the result with the stored check. A mismatch\nrejects that reading. A match supports the consistency of those bytes; it does not repair them or\nestablish that their meaning has been understood.</p>\n<p>Take section <code>2</code> from the actual payload. Its first six bytes form a header:\nthe document’s number, called its ID, and\nthe document’s byte length.\nThe document itself follows,\nthen the stored checksum.\nThe calculation covers the header and every document byte, and stops before the stored check.</p>\n<p>Section <code>2</code> · <code>93,027</code> bytes</p>\n<p><strong>Header</strong> · <code>6</code> bytes</p>\n<p>ID: <code>0 2</code> → <code>2</code></p>\n<p>Length: <code>0 1 107 89</code> → <code>93,017</code></p>\n<p>Document <code>2</code></p>\n<p>First eight bytes: <code>214 57 0 64 0 151 1 68</code></p>\n<p>…then <code>93,009</code> more bytes</p>\n<p>Input to the calculation: header + complete document = <code>93,023</code> bytes</p>\n<p>Stored checksum · <code>4</code> bytes</p>\n<p><code>182 147 233 40</code></p>\n<p>Outside the calculation’s input</p>\n<p>Calculated from all <code>93,023</code> input bytes: <code>182 147 233 40</code>.<br />\nThe four stored bytes match.</p>\n<p>Bytes are regrouped into rows of eight bits. Only the document’s first eight bytes are shown; its remaining bytes precede the checksum.</p>\n<p>Golden Board uses <em>CRC-32C</em> for this\ncalculation. The next drawings teach it with one input byte before applying the same method to a\ncomplete section. The immediate goal is to reproduce the sender’s check from the same bits.</p>\n<hr />\n<h3 id=\"frame-8-of-32-define-xor-and-equality\">Frame 8 of 32: Define XOR and equality</h3>\n<p>The checksum needs a way to combine bits and a way to test agreement. This frame defines both operations\nusing every possible pair of inputs.</p>\n<p>The left-hand input columns list\n<code>00</code>, <code>01</code>, <code>10</code> and <code>11</code>. Their\nresults are <code>0</code>,\n<code>1</code>, <code>1</code>, <code>0</code>: XOR produces <code>1</code> when the inputs differ. The\nright-hand input columns repeat those\npairs; their results are\n<code>1</code>, <code>0</code>, <code>0</code>, <code>1</code>: equality produces <code>1</code> when\nthey agree.</p>\n<hr />\n<h3 id=\"frame-9-of-32-shift-right-and-keep-the-outgoing-bit\">Frame 9 of 32: Shift right and keep the outgoing bit</h3>\n<p>A <em>right shift</em> moves each bit one position to the right. This frame separates the\nshifted row from the bit that leaves its right edge; the checksum calculation uses both results.</p>\n<p>In the upper example, the input field\nends in <code>00110101</code>. The\nshifted field beneath it ends in\n<code>00011010</code>. A zero enters at the far left, and the\nseparate outgoing-bit box contains\nthe <code>1</code> that left the input’s right edge.</p>\n<p>The other examples repeat this layout with different input patterns. In the lowest example,\nthe input ends in <code>0</code>, and the\noutgoing-bit box has an empty centre.\nIts border preserves the result’s position even when the result is zero.</p>\n<hr />\n<h3 id=\"frame-10-of-32-identify-the-checksum-s-fixed-patterns\">Frame 10 of 32: Identify the checksum’s fixed patterns</h3>\n<p>Both sender and recipient need the same constants to obtain the same checksum.\nThe following calculations use the patterns shown here.</p>\n<p>The top field contains thirty-two\nones. The middle field contains\nanother thirty-two-bit pattern. The\nbottom field repeats that entire\nmiddle pattern and adds one leading <code>1</code>. The fields line up at their right edges,\nmaking the added bit visible at the left.</p>\n<p>The lower fields are two forms of CRC-32C’s <em>polynomial</em>, the fixed pattern that\nidentifies this CRC. The bottom form includes its leading bit. Keep the middle pattern for\ncomparison with the changes between the states in <em>Frame <code>12</code></em>.</p>\n<p>Source patterns, from top to bottom.</p>\n<div class=\"table-wrap\"><table><thead><tr><th>Meaning</th><th>Bits</th></tr></thead><tbody><tr><td>Thirty-two ones</td><td><code>11111111 11111111 11111111 11111111</code></td></tr><tr><td>Forward polynomial</td><td><code>00011110 11011100 01101111 01000001</code></td></tr><tr><td>Polynomial with leading term</td><td><code>1 00011110 11011100 01101111 01000001</code></td></tr></tbody></table></div>\n<hr />\n<h3 id=\"frame-11-of-32-start-the-checksum-and-xor-a-byte\">Frame 11 of 32: Start the checksum and XOR a byte</h3>\n<p>The checksum keeps a changing <code>32</code>-bit working pattern, called its <em>state</em>.\nCombining an input byte with that pattern lets the byte affect the eventual check.\nThis frame shows the starting state, the first byte and the result of combining them.</p>\n<p>A shared outer box groups the two inputs:\nthe all-ones state above and the\ninput byte below. The state has four\neight-bit bands. The input is <code>00110101</code>, the pattern expanded in <em>Frame <code>5</code></em>, aligned under the\nrightmost band.</p>\n<p>Applying <em>Frame <code>8</code></em>’s XOR rule to those eight aligned positions gives <code>11001010</code>. The other\nthree state bands have no input bits to change and remain all ones. The\ndownward arrow leads from the grouped inputs\nto this four-band result. That result starts\nthe eight bit rounds shown next.</p>\n<hr />\n<h3 id=\"frame-12-of-32-follow-all-eight-bit-rounds\">Frame 12 of 32: Follow all eight bit rounds</h3>\n<p>The recipient must be able to calculate the next checksum state from the current one. This frame\nsupplies a complete worked sequence, so the rule can be checked against every transition.</p>\n<p>The numbers at the right label\nthe working patterns, from state <code>0</code> to state <code>9</code>. The\nfirst row is the starting pattern;\nthe second row is the byte-XOR\nresult from <em>Frame <code>11</code></em>. Its last bit is <code>0</code>. Shifting that row right\ngives exactly state <code>2</code>.</p>\n<p>State <code>2</code>’s\nrightmost bit is <code>1</code>.\nShift the entire pattern right. The top teal row in the comparison below is\nthat calculated shift result. The bootstrap also supplies the next result,\nstate <code>3</code>, shown in\nthe middle rose row. Comparing them reveals the extra change made in this round.</p>\n<p>Line up matching positions in those two rows. In the\ncyan columns, the bits differ: the shift result has to be\nflipped to produce the supplied result. Put <code>1</code> at each differing position and\n<code>0</code> at every matching position. This is the XOR comparison learned in\n<em>Frame <code>8</code></em>. Its bottom row is the fixed <em>feedback pattern</em>: a map of\nwhich positions to flip.</p>\n<p>We used the frame’s supplied result to identify that pattern. To calculate the round forward,\nshift state <code>2</code>, then XOR the shift result with the feedback pattern. Those flips\nproduce state <code>3</code>. The outgoing <code>1</code> selects this feedback step, so the bit\ncontinues to affect the checksum after leaving the right edge.</p>\n<p>The six remaining rounds use\nthe same rule. Inspect the rightmost bit before shifting: an outgoing <code>0</code> needs\nonly the shift; an outgoing <code>1</code> also\nneeds the fixed XOR pattern. There are eight rounds after the byte-XOR step, ending at state\n<code>9</code>. The table transcribes every supplied state and names the operation that produces it.</p>\n<p>Compare two known patterns to identify the feedback; then use that feedback to calculate forward.</p>\n<div class=\"table-wrap\"><table><thead><tr><th>Pattern</th><th>Bits</th></tr></thead><tbody><tr><td>Calculated shift of state <code>2</code></td><td><code>00111111 11111111 11111111 11110010</code></td></tr><tr><td>State <code>3</code>, supplied by the frame</td><td><code>10111101 00001001 11000100 10001010</code></td></tr><tr><td>Feedback pattern: positions that differ</td><td><code>10000010 11110110 00111011 01111000</code></td></tr></tbody></table></div>\n<p>The ten source states, with the operation producing each state.</p>\n<div class=\"table-wrap\"><table><thead><tr><th>Meaning</th><th>Bits</th><th>Operation producing this row</th></tr></thead><tbody><tr><td>State <code>0</code>: starting pattern</td><td><code>11111111 11111111 11111111 11111111</code></td><td>All-ones starting state</td></tr><tr><td>State <code>1</code>: after byte XOR</td><td><code>11111111 11111111 11111111 11001010</code></td><td>XOR the input byte</td></tr><tr><td>State <code>2</code>: after round <code>1</code></td><td><code>01111111 11111111 11111111 11100101</code></td><td>Shift right</td></tr><tr><td>State <code>3</code>: after round <code>2</code></td><td><code>10111101 00001001 11000100 10001010</code></td><td>Shift right, then XOR the fixed pattern</td></tr><tr><td>State <code>4</code>: after round <code>3</code></td><td><code>01011110 10000100 11100010 01000101</code></td><td>Shift right</td></tr><tr><td>State <code>5</code>: after round <code>4</code></td><td><code>10101101 10110100 01001010 01011010</code></td><td>Shift right, then XOR the fixed pattern</td></tr><tr><td>State <code>6</code>: after round <code>5</code></td><td><code>01010110 11011010 00100101 00101101</code></td><td>Shift right</td></tr><tr><td>State <code>7</code>: after round <code>6</code></td><td><code>10101001 10011011 00101001 11101110</code></td><td>Shift right, then XOR the fixed pattern</td></tr><tr><td>State <code>8</code>: after round <code>7</code></td><td><code>01010100 11001101 10010100 11110111</code></td><td>Shift right</td></tr><tr><td>State <code>9</code>: after round <code>8</code></td><td><code>10101000 10010000 11110001 00000011</code></td><td>Shift right, then XOR the fixed pattern</td></tr></tbody></table></div>\n<p>The fixed XOR pattern exposed by <em>Frame <code>12</code></em>’s transitions is the middle pattern of <em>Frame <code>10</code></em>\nread in reverse bit order. This relates the right-shift calculation to the polynomial shown\nthere. It changes the interpretation of that constant; the bytes themselves keep the\nhigh-byte-first order established by <em>Frame <code>6</code></em>.</p>\n<hr />\n<h3 id=\"frame-13-of-32-finish-and-store-the-checksum\">Frame 13 of 32: Finish and store the checksum</h3>\n<p>The last running state becomes a stored checksum through one final XOR. The recipient must distinguish\nthat final value from the intermediate states used during calculation.</p>\n<p>This repeats <em>Frame <code>11</code></em>’s grouped-input layout. XOR the\nstate after eight rounds with the\nall-ones state above it. The arrow leads to\nthe result, whose four bands read\n<code>87 | 111 | 14 | 252</code>.</p>\n<p>A second arrow leads to\nfour separately bounded bytes. Each sits\ndirectly below the corresponding band of the result, with the same eight bits. Reading left to right\npreserves high-byte-first order. This is the check for the single input byte <code>00110101</code>; the\nnext frame compares a computed check with a stored one.</p>\n<hr />\n<h3 id=\"frame-14-of-32-compare-computed-and-stored-checks\">Frame 14 of 32: Compare computed and stored checks</h3>\n<p>A checksum becomes an integrity check by comparing the calculated value with a stored one. These three\ncases show the same equality test succeeding, failing, then succeeding again.</p>\n<p>In the top case, the input field contains\n<code>00110101</code>, read as <code>53</code>. The\ncomputed check on the upper line and the\nstored check below it agree. The\none-bit equality field at the right\ntherefore contains <code>1</code>, using the same boxed-bit convention as <em>Frame <code>8</code></em>.</p>\n<p>The middle case changes the input to <code>00110100</code> but retains the check for the earlier\npattern. The checks differ, so the equality field contains <code>0</code>. The bottom case uses\n<code>00001011</code> with its own check and returns <code>1</code>. These are checks of byte patterns,\nnot of the characters used to print their decimal readings.</p>\n<hr />\n<h2 id=\"finding-sections-and-documents\">Finding sections and documents</h2>\n<p>The recipient can now read numbers and reproduce a checksum. The next task is to find each\nsection’s boundaries and recover the document inside it. The section is the checked storage wrapper;\nthe document is the collection of things to display and use.</p>\n<p>Those things are stored as <em>records</em>. Each record has a kind, a numeric name called an\n<em>ID</em>, and its own contents. For example, one record can define a small picture and another\ncan refer to that picture by ID. Keeping the definition in one place lets many displays reuse it.\nIDs are assigned during message creation and stored in the data; the recipient reads them rather\nthan inferring them from a shape. Their scope is one document.</p>\n<p>An <em>inventory</em> lists the documents that must be recovered and the records where each may be\nopened. These starting records are its <em>entries</em>. They lead to a picture sequence or an\ninteraction. An entry is a record’s ID, not its byte address.</p>\n<p>To teach these relationships, the bootstrap contains a complete small worked document of\n<code>326</code> bytes. Its simple pictures and responses exercise the format before chess appears.\nThe next drawings describe that example, which is carried inside the strip. The full five-document\npayload below the strip uses the same rules.</p>\n<hr />\n<h3 id=\"frame-15-of-32-partition-a-complete-section\">Frame 15 of 32: Partition a complete section</h3>\n<p>This frame divides a section into byte ranges. Its header declares how much body data follows, so the\nrecipient can find the check and the next section.</p>\n<p>Every row has three columns: start address, byte length, and the first address after the range. The\nID row reads <code>0, 2, 2</code>; the\nbody-length-field row reads\n<code>2, 4, 6</code>. Those two fields form the six-byte header. The\nbody row reads <code>6</code>, <code>326</code>, <code>332</code>, followed by the\ncheck row: <code>332, 4, 336</code>.</p>\n<p>The section is therefore <code>336</code> bytes: six header bytes, <code>326</code> body bytes and four check bytes. These triples\ndescribe the layout; they are not extra fields stored in the header. The body-length value counts the\nbody alone. The ID names the section; its meaning is established by the inventory example below.</p>\n<p>Data bands in drawing order.</p>\n<div class=\"table-wrap\"><table><thead><tr><th>Meaning</th><th>Bits</th><th>Decimal</th></tr></thead><tbody><tr><td>ID range</td><td>`00000000 00000000</td><td>00000000 00000010</td></tr><tr><td>Body-length field range</td><td>`00000000 00000010</td><td>00000000 00000100</td></tr><tr><td>Body range</td><td>`00000000 00000110</td><td>00000001 01000110</td></tr><tr><td>Stored-check range</td><td>`00000001 01001100</td><td>00000000 00000100</td></tr></tbody></table></div>\n<hr />\n<h3 id=\"frame-16-of-32-map-payload-addresses-to-square-cells\">Frame 16 of 32: Map payload addresses to square cells</h3>\n<p>Byte addresses must lead back to positions in the square. This frame connects each address to a physical\nrow and column.</p>\n<p>The top line of each box gives a\nbyte offset from the payload’s start and a\nbit index within that byte. Directly beneath\nthem are the square row and\nsquare column. These are addresses for reading stored bits, so they start at zero;\nbit <code>0</code> is the first, leftmost bit of a byte. The labels in\n<em>Frame <code>2</code></em> instead count binary places from the right, starting at one.</p>\n<p>Each physical row holds <code>2,048 ÷ 8 = 256</code> bytes. The first group of <code>256</code> bytes therefore fills\nrow <code>64</code>: byte <code>0</code> starts at column <code>0</code>, byte <code>1</code> at column\n<code>8</code>, and byte <code>255</code> ends at column <code>2,047</code>. Byte\n<code>256</code> starts the next row, <code>65</code>, at column <code>0</code>. These boundary cases appear in the\nthird, fourth and fifth boxes.</p>\n<p>To locate another byte, count complete groups of <code>256</code> to find how many rows to move down from row <code>64</code>.\nWithin the remaining group, move eight columns for each byte, then add its bit index. This is why\nsection boundaries need not coincide with physical row boundaries.</p>\n<hr />\n<h3 id=\"frame-17-of-32-preserve-rectangular-and-empty-rows\">Frame 17 of 32: Preserve rectangular and empty rows</h3>\n<p>Dimensions preserve a picture’s complete rectangle, including white positions and entirely empty rows.</p>\n<p>For the upper-left matrix, the\nfirst numeral above it is\n<code>00000010</code>: two rows of height. The\nnext numeral is <code>00001000</code>:\neight columns of width. The other boxes use this same order, giving three rows by five columns, one by\nseven, and two by eight.</p>\n<p>The\nsecond row in the lower-right matrix is\ncompletely empty. Its eight positions still belong to the picture. Neither the empty row nor the white\ncolumns can be removed by cropping to the visible black shape.</p>\n<hr />\n<h3 id=\"frame-18-of-32-name-objects-and-count-their-references\">Frame 18 of 32: Name objects and count their references</h3>\n<p>An object can be given a numeric name, then referred to by repeating that name. This frame separates\nnames, reference counts and reference lists, with every target introduced before its use.</p>\n<p>Each row has three parts: an eight-bit name on the left, an eight-bit reference count in the middle, and\na boxed list on the right. The name does not specify the object’s size or its physical address.</p>\n<p>The top row begins <code>00000110</code>,\nread as <code>6</code>. That pattern names the first object. Its count is <code>00000000</code>, so the\nreference list is empty. The\nsecond row gives another name,\n<code>00000111</code> or <code>7</code>, also with no references.</p>\n<p>The third row begins <code>00001000</code>,\nread as <code>8</code>. Its count <code>00000001</code> says one reference follows:\n<code>00000110</code>, repeating the first row’s name.</p>\n<p>The bottom row begins\n<code>00001001</code>, read as <code>9</code>. Its count <code>00000010</code> says two references\nfollow: <code>00000111</code> and\n<code>00001000</code>. These reach the second and third objects. Following the third object’s own reference then reaches the\nfirst. Counts and list lengths progress together: zero, zero, one, two.</p>\n<hr />\n<h3 id=\"frame-19-of-32-check-the-miniature-s-actual-section\">Frame 19 of 32: Check the miniature’s actual section</h3>\n<p>This frame gives the miniature section’s actual fields and the exact range covered by its\nchecksum. It places the stored check after that range, outside its own calculation.</p>\n<p>The three four-bit numerals on the left\ngive the byte counts of the bands beside them: <code>0010</code>, <code>0100</code>, <code>0100</code>\nmean two, four and four bytes. The small marks under the data identify the start of each byte.\nThese black numerals and marks belong to the original drawing. They describe how to read its\nbands; they do not add bytes to the section.</p>\n<p>The first two data bands give\nsection ID <code>1</code> and body length <code>326</code>. The\nthird band contains the four\nstored checksum bytes, <code>255 64 93 120</code>.</p>\n<p>The upper bounded range reads\n<code>0 | 332 | 332</code>: start at byte zero, check <code>332</code> bytes, stop before address\n<code>332</code>. The result below the arrow\nrepeats the stored check’s bits. The\nlower bounded range is\n<code>332 | 4 | 336</code>, locating those four check bytes after the covered range.</p>\n<p>Data bands in drawing order.</p>\n<div class=\"table-wrap\"><table><thead><tr><th>Meaning</th><th>Bits</th><th>Decimal</th></tr></thead><tbody><tr><td>Section ID</td><td><code>00000000 00000001</code></td><td><code>1</code></td></tr><tr><td>Body byte length</td><td><code>00000000 00000000 00000001 01000110</code></td><td><code>326</code></td></tr><tr><td>Stored checksum bytes</td><td><code>11111111 01000000 01011101 01111000</code></td><td><code>255 64 93 120</code></td></tr><tr><td>Covered range</td><td>`00000000 00000000</td><td>00000001 01001100</td></tr><tr><td>Stored-check range</td><td>`00000001 01001100</td><td>00000000 00000100</td></tr></tbody></table></div>\n<hr />\n<h3 id=\"carry-the-checksum-across-a-sequence-of-bytes\">Carry the checksum across a sequence of bytes</h3>\n<p>The covered range contains six header bytes and <code>326</code> body bytes. Start with the all-ones\nstate, XOR the first byte into its low eight bits, and perform eight rounds. XOR the next byte\ninto the resulting state and perform another eight rounds. Continue through every covered byte,\nthen apply the final all-ones XOR once. Restart this process for each section. Calculating a\nseparate finished checksum for every byte would lose the running state that joins the sequence.\n<em>Frame <code>29</code></em> supplies all the bytes of this worked section.</p>\n<hr />\n<h3 id=\"frame-20-of-32-read-a-complete-inventory-section\">Frame 20 of 32: Read a complete inventory section</h3>\n<p>The inventory lists the document sections required for a complete message. Here it\ncontains one document: the worked miniature.</p>\n<p>The six-byte header declares section ID\n<code>0</code> and body length <code>18</code>. The\nnext eighteen bytes are the inventory body,\nfollowed by its four checksum bytes,\n<code>113 28 238 100</code>. Together they occupy <code>28</code> bytes: three full eight-byte rows and half of a\nfourth, starting at local row <code>31</code>.</p>\n<p>The first row contains the header and the beginning of the body. Row breaks are presentation boundaries,\nnot section delimiters. ID <code>0</code> identifies the inventory; positive IDs identify documents.\nThis small inventory lists only the worked document inside the bootstrap.</p>\n<hr />\n<h3 id=\"frame-21-of-32-read-inventory-counts-and-entry-references\">Frame 21 of 32: Read inventory counts and entry references</h3>\n<p>The inventory identifies a document to recover and the records where reading it may begin.\nThis frame expands the inventory body from <em>Frame <code>20</code></em> into individual fields.</p>\n<p>The four-bit byte counts on the left\nuse the convention from <em>Frame <code>19</code></em>. For example, <code>0010</code> beside the first band says\nthat its value occupies two bytes. The value in that band is <code>1</code>: one document.</p>\n<p>The first three data bands give\ndocument count <code>1</code>, document section ID <code>1</code> and document length <code>326</code>.\nThe next band contains\n<code>255 64 93 120</code>, the expected checksum bytes for that document’s section. They match\nthe check in <em>Frame <code>19</code></em>.</p>\n<p>The entry count is <code>2</code>.\nIt gives the length of the boxed list\nof entry IDs <code>512</code> and <code>257</code>. Each entry ID occupies two bytes,\nas its own left-hand count confirms. These IDs name records, rather than byte addresses;\nthe next frames define those records.</p>\n<p>Data bands in drawing order.</p>\n<div class=\"table-wrap\"><table><thead><tr><th>Meaning</th><th>Bits</th><th>Decimal</th><th>Bytes</th></tr></thead><tbody><tr><td>Document count</td><td><code>00000000 00000001</code></td><td><code>1</code></td><td><code>2</code></td></tr><tr><td>Document section ID</td><td><code>00000000 00000001</code></td><td><code>1</code></td><td><code>2</code></td></tr><tr><td>Document byte length</td><td><code>00000000 00000000 00000001 01000110</code></td><td><code>326</code></td><td><code>4</code></td></tr><tr><td>Expected document-section checksum bytes</td><td><code>11111111 01000000 01011101 01111000</code></td><td><code>255 64 93 120</code></td><td><code>4</code></td></tr><tr><td>Entry count</td><td><code>00000000 00000010</code></td><td><code>2</code></td><td><code>2</code></td></tr><tr><td>First entry ID</td><td><code>00000010 00000000</code></td><td><code>512</code></td><td><code>2</code></td></tr><tr><td>Second entry ID</td><td><code>00000001 00000001</code></td><td><code>257</code></td><td><code>2</code></td></tr></tbody></table></div>\n<hr />\n<h2 id=\"reading-the-five-record-types\">Reading the five record types</h2>\n<p>Finding a document’s bytes does not yet tell the recipient how to draw its pictures or conduct its\nexercises. Its records divide that work into five kinds, all using the same named-record format.</p>\n<p>A <em>glyph</em> stores a small rectangular bitmap. A <em>display frame</em> places glyph IDs in a\nlarger grid, so the same bitmap can be reused in many cells. A frame cell selects an entire glyph;\nit is distinct from either a source-message cell or one pixel inside the glyph. “<em>Frame N of <code>32</code></em>”\ncontinues to mean a bootstrap drawing; a numbered display-frame record belongs to a document.</p>\n<p>A <em>trace</em> starts from a frame and applies stored changes to indexed cells. This lets the\nmessage show a changing diagram or replay a game without storing every complete picture separately.\nA <em>page</em> combines a display with choices, accepted responses, feedback destinations and links.\nA <em>table</em> stores numbers alongside a trace; the lessons teach what those numbers mean.</p>\n<p>The worked document has <code>15</code> records: three glyphs, four display frames, one trace,\none table and six pages. Its header names page <code>512</code> and trace <code>257</code> as entries.\nEach record begins with its kind, ID and content length; the record’s own contents are also called\nits <em>payload</em>. That length excludes the record’s seven-byte header. Read all the records\nbefore resolving their references: a target can occur later in the document.</p>\n<p>The <em>player</em> is the recipient’s program for interpreting these records and carrying out\ntheir display and interaction operations. A frame fixes which bitmap belongs in each cell.\nThis guide displays equally sized tiles with enlarged glyphs inside them; tile size and spacing\nare presentation choices. The encoded dimensions count frame cells and glyph pixels.</p>\n<hr />\n<h3 id=\"frame-22-of-32-read-a-document-header-and-rectangular-glyphs\">Frame 22 of 32: Read a document header and rectangular glyphs</h3>\n<p>A document provides starting records and reusable bitmaps. This frame first defines its header, then two\nglyph records.</p>\n<p>The top five data bands contain marker\nbytes <code>214, 57</code>, entry count <code>2</code>, record count <code>15</code>, and entry IDs\n<code>512</code> and <code>257</code>. The\nsmall rulers down the left count bytes. The\nmarkers below each band identify byte starts. Both are original black marks that describe the\nbands; neither contributes bytes to the serialized document. The table’s Bytes column transcribes\nthe left-hand widths.</p>\n<p>The middle group and empty rectangle define\nglyph <code>0</code>; the\nbottom group and patterned rectangle\ndefine glyph <code>1</code>. Each record begins with kind <code>1</code>, a two-byte ID and a four-byte\npayload length. Its three payload bytes give two rows, three columns and a packed bitmap.</p>\n<p>Glyph <code>0</code> has bitmap byte <code>00000000</code>, read as <code>0</code>. Glyph\n<code>1</code> has <code>11010100</code>, read as <code>212</code>. Its first six bits form\n<code>110 / 101</code>; two zero padding bits complete the byte. Both rectangles retain all three\ncolumns, including white pixels.</p>\n<p>Data bands in drawing order.</p>\n<div class=\"table-wrap\"><table><thead><tr><th>Meaning</th><th>Bits</th><th>Decimal</th><th>Bytes</th></tr></thead><tbody><tr><td>Document marker bytes</td><td>`11010110</td><td>00111001`</td><td>`214</td></tr><tr><td>Entry count</td><td><code>00000000 00000010</code></td><td><code>2</code></td><td><code>2</code></td></tr><tr><td>Record count</td><td><code>00000000 00001111</code></td><td><code>15</code></td><td><code>2</code></td></tr><tr><td>First entry ID</td><td><code>00000010 00000000</code></td><td><code>512</code></td><td><code>2</code></td></tr><tr><td>Second entry ID</td><td><code>00000001 00000001</code></td><td><code>257</code></td><td><code>2</code></td></tr><tr><td>Record kind</td><td><code>00000001</code></td><td><code>1</code></td><td><code>1</code></td></tr><tr><td>Record ID</td><td><code>00000000 00000000</code></td><td><code>0</code></td><td><code>2</code></td></tr><tr><td>Payload byte length</td><td><code>00000000 00000000 00000000 00000011</code></td><td><code>3</code></td><td><code>4</code></td></tr><tr><td>Glyph rows</td><td><code>00000010</code></td><td><code>2</code></td><td><code>1</code></td></tr><tr><td>Glyph columns</td><td><code>00000011</code></td><td><code>3</code></td><td><code>1</code></td></tr><tr><td>Packed glyph mask</td><td><code>00000000</code></td><td><code>0</code></td><td><code>1</code></td></tr><tr><td>Record kind</td><td><code>00000001</code></td><td><code>1</code></td><td><code>1</code></td></tr><tr><td>Record ID</td><td><code>00000000 00000001</code></td><td><code>1</code></td><td><code>2</code></td></tr><tr><td>Payload byte length</td><td><code>00000000 00000000 00000000 00000011</code></td><td><code>3</code></td><td><code>4</code></td></tr><tr><td>Glyph rows</td><td><code>00000010</code></td><td><code>2</code></td><td><code>1</code></td></tr><tr><td>Glyph columns</td><td><code>00000011</code></td><td><code>3</code></td><td><code>1</code></td></tr><tr><td>Packed glyph mask</td><td><code>11010100</code></td><td><code>212</code></td><td><code>1</code></td></tr></tbody></table></div>\n<p>The four-bit width ruler, <code>0010</code>, counts two bytes. The data,\n<code>11010110 00111001</code>, are the document marker bytes, read as <code>214</code> and <code>57</code>. Marks below the data identify the start of each\nbyte.</p>\n<p><em>Frame <code>22</code></em>, local rows <code>6</code>–<code>7</code>, columns <code>0</code>–<code>31</code>. Ruler: columns <code>3</code>–<code>6</code>; data: <code>13</code>–<code>28</code>; byte-start marks\nbelow <code>13</code> and <code>21</code>.</p>\n<h4 id=\"the-document-header-as-bytes\">The document header as bytes</h4>\n<p>The document begins with these ten bytes, shown in decimal and grouped by field. Two-byte integers are\nstored high byte first.</p>\n<p><code>214 57 0 2 0 15 2 0 1 1</code></p>\n<p>The band map identifies the fields in this sequence. Each entry ID takes two bytes: <code>2 0</code> is\n<code>512</code>, and <code>1 1</code> is <code>257</code>.</p>\n<h4 id=\"kind-1-a-reusable-bitmap\">Kind 1: a reusable bitmap</h4>\n<p>Glyph record <code>1</code> occupies miniature bytes <code>20</code>–<code>29</code>:\n<code>1 0 1 0 0 0 3 2 3 212</code>. Its seven-byte header gives kind, ID and\npayload length. Its three payload bytes give two rows, three columns and mask <code>212</code>, or\n<code>11010100</code>. The first six bits form <code>110 / 101</code>; two zero padding bits complete the\nbyte.</p>\n<p>Glyph <code>0</code> is a separate record with an all-zero mask. Both glyphs retain their full two-row,\nthree-column dimensions. Their IDs are names that display frames use to select these shapes. A frame cell\ncontaining <code>1</code> therefore selects glyph <code>1</code>; it does not turn the whole cell into a\nsingle filled block.</p>\n<p>Glyph <code>0</code></p>\n<p>Glyph <code>1</code></p>\n<p>Glyphs <code>0</code> and <code>1</code> at equal pixel scale. The complete rectangle belongs to each\nglyph.</p>\n<hr />\n<h3 id=\"frame-23-of-32-build-a-frame-from-glyph-ids\">Frame 23 of 32: Build a frame from glyph IDs</h3>\n<p>A display frame builds a larger picture by placing reusable glyphs at indexed positions. It can also\nassign names to positions that a later exercise lets the recipient select.</p>\n<p>The record header identifies kind\n<code>2</code>, ID <code>256</code> and payload length <code>18</code>. The\ntwo dimension fields specify two rows and\nthree columns. The six glyph IDs are\n<code>0,1,1 / 1,0,1</code>, read across each row. Looking up those IDs produces the\npicture at the lower left. The\nleft-hand rulers give each band’s byte\nwidth.</p>\n<p>Glyph IDs fit in one byte, so these six frame cells occupy six bytes. Record headers still\nuse two-byte IDs. The width of a reference depends on the field that carries it.</p>\n<p>After those cells, a count of <code>2</code> introduces two selection definitions. Each definition\ncontains a region ID followed by a cell index. The\nfirst definition is\n<code>10 | 0</code>: region <code>10</code> selects cell <code>0</code>, the upper-left position. The\nsecond definition is\n<code>20 | 5</code>: region <code>20</code> selects cell <code>5</code>, the lower-right position. The\nmatching highlights connect each pair to its picture position and its index box.</p>\n<p>Data bands in drawing order.</p>\n<div class=\"table-wrap\"><table><thead><tr><th>Meaning</th><th>Bits</th><th>Decimal</th><th>Bytes</th></tr></thead><tbody><tr><td>Record kind</td><td><code>00000010</code></td><td><code>2</code></td><td><code>1</code></td></tr><tr><td>Record ID</td><td><code>00000001 00000000</code></td><td><code>256</code></td><td><code>2</code></td></tr><tr><td>Payload byte length</td><td><code>00000000 00000000 00000000 00010010</code></td><td><code>18</code></td><td><code>4</code></td></tr><tr><td>Frame rows</td><td><code>00000010</code></td><td><code>2</code></td><td><code>1</code></td></tr><tr><td>Frame columns</td><td><code>00000011</code></td><td><code>3</code></td><td><code>1</code></td></tr><tr><td>Glyph IDs in row order</td><td>`00000000</td><td>00000001</td><td>00000001</td></tr><tr><td>Region count</td><td><code>00000000 00000010</code></td><td><code>2</code></td><td><code>2</code></td></tr><tr><td>Region <code>1</code>: ID, cell index</td><td>`00000000 00001010</td><td>00000000 00000000`</td><td>`10</td></tr><tr><td>Region <code>2</code>: ID, cell index</td><td>`00000000 00010100</td><td>00000000 00000101`</td><td>`20</td></tr></tbody></table></div>\n<p>The resulting picture and the indices of its six cells:</p>\n<p>Rendered frame <code>256</code></p>\n<p>Cell indices, for comparison</p>\n<hr />\n<h3 id=\"frame-24-of-32-apply-ordered-partial-updates\">Frame 24 of 32: Apply ordered partial updates</h3>\n<p>A trace changes an initial frame through ordered partial updates. A cell keeps its previous glyph until\nan update names that cell.</p>\n<p>The prefix bands identify kind\n<code>3</code>, trace <code>257</code>, payload length <code>19</code>, initial frame <code>256</code>,\none attached table <code>400</code> and two patch steps. The\nrulers on the left count bytes. The\nupper picture is the referenced initial\nframe.</p>\n<p>The\nfirst patch group and changed cell in the middle picture\ncontain three fields: assignment count <code>1</code>, cell index <code>0</code>, glyph ID\n<code>1</code>. Apply that assignment to the initial picture: its upper-left cell now shows glyph\n<code>1</code>, while the other five cells keep their values.</p>\n<p>The\nsecond patch group and changed cell in the bottom picture\nalso have one assignment: cell <code>5</code> receives glyph <code>0</code>. Apply it to the middle\nstate, not to a fresh copy of the initial frame. The result is <code>1,1,1 / 1,0,0</code>. Two patches\ntherefore produce three pictures, and the first patch’s change survives the second.</p>\n<p>Each assignment replaces the cell’s glyph ID. Assigning <code>0</code> selects the blank glyph;\nleaving a cell out of the patch preserves its current value. The changes affect this trace’s\ndisplay state, so the reusable initial-frame record remains available as the starting point.</p>\n<p>Data bands in drawing order.</p>\n<div class=\"table-wrap\"><table><thead><tr><th>Meaning</th><th>Bits</th><th>Decimal</th><th>Bytes</th></tr></thead><tbody><tr><td>Record kind</td><td><code>00000011</code></td><td><code>3</code></td><td><code>1</code></td></tr><tr><td>Record ID</td><td><code>00000001 00000001</code></td><td><code>257</code></td><td><code>2</code></td></tr><tr><td>Payload byte length</td><td><code>00000000 00000000 00000000 00010011</code></td><td><code>19</code></td><td><code>4</code></td></tr><tr><td>Initial frame ID</td><td><code>00000001 00000000</code></td><td><code>256</code></td><td><code>2</code></td></tr><tr><td>Attached table count</td><td><code>00000001</code></td><td><code>1</code></td><td><code>1</code></td></tr><tr><td>Attached table IDs</td><td><code>00000001 10010000</code></td><td><code>400</code></td><td><code>2</code></td></tr><tr><td>Patch-step count</td><td><code>00000000 00000000 00000000 00000010</code></td><td><code>2</code></td><td><code>4</code></td></tr><tr><td>Patch <code>1</code>: assignment count</td><td><code>00000000 00000001</code></td><td><code>1</code></td><td><code>2</code></td></tr><tr><td>Patch <code>1</code>: cell index</td><td><code>00000000 00000000</code></td><td><code>0</code></td><td><code>2</code></td></tr><tr><td>Patch <code>1</code>: glyph ID</td><td><code>00000001</code></td><td><code>1</code></td><td><code>1</code></td></tr><tr><td>Patch <code>2</code>: assignment count</td><td><code>00000000 00000001</code></td><td><code>1</code></td><td><code>2</code></td></tr><tr><td>Patch <code>2</code>: cell index</td><td><code>00000000 00000101</code></td><td><code>5</code></td><td><code>2</code></td></tr><tr><td>Patch <code>2</code>: glyph ID</td><td><code>00000000</code></td><td><code>0</code></td><td><code>1</code></td></tr></tbody></table></div>\n<hr />\n<h3 id=\"frame-25-of-32-define-an-exercise-page\">Frame 25 of 32: Define an exercise page</h3>\n<p>This frame defines an exercise page that connects a picture, a response and its outcomes. A display\nalone cannot say what the recipient should select or what follows a submission.</p>\n<p>The first three bands identify kind <code>4</code>\npage <code>512</code> and its <code>26</code>-byte payload. The\nnext pair selects frame <code>256</code>: display flag\n<code>0</code> identifies the displayed frame. The page’s kind and its display flag\nare separate fields.</p>\n<p>The response fields request a set of\nselected region IDs and offer <code>10</code> and <code>20</code>. The\nacceptance fields declare one accepted\nset of length one: <code>[10]</code>. The bottom fields name success\npage <code>514</code>, failure page <code>515</code>, demonstration page <code>516</code> and one explicit link to <code>516</code>. The\nrulers beside the bands count bytes; list\ncounts and list contents remain separate fields.</p>\n<p>Data bands in drawing order.</p>\n<div class=\"table-wrap\"><table><thead><tr><th>Meaning</th><th>Bits</th><th>Decimal</th><th>Bytes</th></tr></thead><tbody><tr><td>Record kind</td><td><code>00000100</code></td><td><code>4</code></td><td><code>1</code></td></tr><tr><td>Record ID</td><td><code>00000010 00000000</code></td><td><code>512</code></td><td><code>2</code></td></tr><tr><td>Payload byte length</td><td><code>00000000 00000000 00000000 00011010</code></td><td><code>26</code></td><td><code>4</code></td></tr><tr><td>Display kind</td><td><code>00000000</code></td><td><code>0</code></td><td><code>1</code></td></tr><tr><td>Display ID</td><td><code>00000001 00000000</code></td><td><code>256</code></td><td><code>2</code></td></tr><tr><td>Response shape</td><td><code>00000010</code></td><td><code>2</code></td><td><code>1</code></td></tr><tr><td>Choice count</td><td><code>00000000 00000010</code></td><td><code>2</code></td><td><code>2</code></td></tr><tr><td>Choice region IDs</td><td>`00000000 00001010</td><td>00000000 00010100`</td><td>`10</td></tr><tr><td>Accepted-response count</td><td><code>00000000 00000001</code></td><td><code>1</code></td><td><code>2</code></td></tr><tr><td>Accepted response <code>1</code>: length</td><td><code>00000000 00000001</code></td><td><code>1</code></td><td><code>2</code></td></tr><tr><td>Accepted response <code>1</code>: region IDs</td><td><code>00000000 00001010</code></td><td><code>10</code></td><td><code>2</code></td></tr><tr><td>Success page ID</td><td><code>00000010 00000010</code></td><td><code>514</code></td><td><code>2</code></td></tr><tr><td>Failure page ID</td><td><code>00000010 00000011</code></td><td><code>515</code></td><td><code>2</code></td></tr><tr><td>Passive page ID</td><td><code>00000010 00000100</code></td><td><code>516</code></td><td><code>2</code></td></tr><tr><td>Link count</td><td><code>00000000 00000001</code></td><td><code>1</code></td><td><code>2</code></td></tr><tr><td>Link page IDs</td><td><code>00000010 00000100</code></td><td><code>516</code></td><td><code>2</code></td></tr></tbody></table></div>\n<p>Page <code>512</code> uses the region mappings taught in <em>Frame <code>23</code></em>: region <code>10</code>\nidentifies cell <code>0</code>, and region <code>20</code> identifies cell <code>5</code>.\nA selection records a region ID; it does not replace the glyph displayed in that cell.\nPage <code>512</code> treats its response as a set of distinct IDs, so their selection order\ndoes not affect acceptance. Selecting a region again removes it from the set. The complete\nsubmitted set must match a stored accepted response: choosing both <code>10</code> and\n<code>20</code> fails, even though it includes the accepted choice <code>10</code>.</p>\n<p>A page can also display a trace: display flag <code>1</code> selects that form, while\n<code>0</code> selects a fixed frame. The demonstration page in the complete graph below\nuses a trace. The response shape is independent of this display choice. Shape <code>1</code>\nkeeps one selection, replacing it when another is chosen; shape <code>2</code> keeps a set;\nshape <code>3</code> appends an ordered sequence, preserving repeats. A sequence is bounded\nby the number of choices exposed on that page.</p>\n<p>Shape <code>0</code> is a passive page: it has a display and links but no response to submit.\nIts fields for success, failure and passive pages contain the reserved value <code>65,535</code>,\nmeaning no reference. This value never names a record. Glyph <code>0</code>, by comparison,\nis a real record and can be drawn.</p>\n<hr />\n<h3 id=\"frame-26-of-32-show-the-two-concrete-feedback-results\">Frame 26 of 32: Show the two concrete feedback results</h3>\n<p>This frame connects each submitted choice to the feedback page and picture it opens.\nIt first defines the contrasting glyph used by the failure picture.</p>\n<p>The upper bands and small rectangle\ndefine glyph <code>2</code>: two rows, three columns, bitmap byte <code>00101000</code>.\nIts first six bits form <code>001 / 010</code>; the last two are padding. The white first\ncolumn remains part of the glyph.</p>\n<p>The four-bit numerals beside the upper bands\ngive their byte widths: <code>1, 2, 4, 1, 1, 1</code>. Width and value are different:\nthe <code>0100</code> beside the payload-length field says that the value <code>3</code> is written\nin four bytes. The longer patterns at the lower left are submitted region IDs, not width labels.</p>\n<p>The submitted ID <code>10</code>\nleads to page <code>514</code>\nand frame <code>259</code>, filled with glyph <code>1</code>. The\nsubmitted ID <code>20</code>\nleads to page <code>515</code>\nand frame <code>260</code>, filled with glyph <code>2</code>. Each feedback box gives page\nkind and ID, then display flag and frame ID, then the resulting picture.</p>\n<p>Data bands in drawing order.</p>\n<div class=\"table-wrap\"><table><thead><tr><th>Meaning</th><th>Bits</th><th>Decimal</th><th>Bytes</th></tr></thead><tbody><tr><td>Record kind</td><td><code>00000001</code></td><td><code>1</code></td><td><code>1</code></td></tr><tr><td>Record ID</td><td><code>00000000 00000010</code></td><td><code>2</code></td><td><code>2</code></td></tr><tr><td>Payload byte length</td><td><code>00000000 00000000 00000000 00000011</code></td><td><code>3</code></td><td><code>4</code></td></tr><tr><td>Glyph rows</td><td><code>00000010</code></td><td><code>2</code></td><td><code>1</code></td></tr><tr><td>Glyph columns</td><td><code>00000011</code></td><td><code>3</code></td><td><code>1</code></td></tr><tr><td>Packed glyph mask</td><td><code>00101000</code></td><td><code>40</code></td><td><code>1</code></td></tr></tbody></table></div>\n<hr />\n<h3 id=\"frame-27-of-32-select-reset-and-commit-a-response\">Frame 27 of 32: Select, reset and commit a response</h3>\n<p>Selecting a region edits a pending answer; committing evaluates it. These three cases show the\ndifference.</p>\n<p>The top case uses operation\n<code>1</code> with argument <code>10</code> to select region <code>10</code>. The line below shows that\npage <code>512</code> stays active. The\nmiddle case uses operation\n<code>3</code> with argument <code>0</code> to clear the pending selection; the page again stays\n<code>512</code>.</p>\n<p>The\nbottom case and its feedback picture use\noperation <code>2</code> with argument <code>0</code> to commit that now-empty set. It is not the\naccepted set <code>[10]</code>, so the result is page <code>515</code>, displaying glyph\n<code>2</code> in every cell. These are examples of actions, not additional serialized packets.</p>\n<p>Commit records the pending answer, compares it with the page’s accepted responses, and\nopens the stored success or failure page with\nan empty selection. Doing nothing submits no answer; committing an empty selection submits\nan answer of length zero. Later lessons use this distinction when an empty answer is correct.</p>\n<p>Data bands in drawing order.</p>\n<div class=\"table-wrap\"><table><thead><tr><th>Meaning</th><th>Bits</th><th>Decimal</th></tr></thead><tbody><tr><td>Operation code, operand</td><td>`00000000 00000001</td><td>00000000 00001010`</td></tr><tr><td>Page before, page after</td><td>`00000010 00000000</td><td>00000010 00000000`</td></tr><tr><td>Operation code, operand</td><td>`00000000 00000011</td><td>00000000 00000000`</td></tr><tr><td>Page before, page after</td><td>`00000010 00000000</td><td>00000010 00000000`</td></tr><tr><td>Operation code, operand</td><td>`00000000 00000010</td><td>00000000 00000000`</td></tr><tr><td>Page before, page after</td><td>`00000010 00000000</td><td>00000010 00000011`</td></tr></tbody></table></div>\n<hr />\n<h3 id=\"frame-28-of-32-follow-feedback-and-passive-routes\">Frame 28 of 32: Follow feedback and passive routes</h3>\n<p>Stored page references determine what opens next. Their numeric order does not define a sequence of pages.</p>\n<p>The first pair maps submitted region\n<code>20</code> to failure page <code>515</code>. The\nsecond pair and upper picture map region\n<code>10</code> to success page <code>514</code>. The\nthird pair and lower picture have a\ndifferent role: demonstration page <code>516</code> links to final-picture page <code>518</code>.</p>\n<p>Data bands in drawing order.</p>\n<div class=\"table-wrap\"><table><thead><tr><th>Meaning</th><th>Bits</th><th>Decimal</th></tr></thead><tbody><tr><td>Response <code>20</code> → failure page <code>515</code></td><td>`00000000 00010100</td><td>00000010 00000011`</td></tr><tr><td>Response <code>10</code> → success page <code>514</code></td><td>`00000000 00001010</td><td>00000010 00000010`</td></tr><tr><td>Demonstration page <code>516</code> → final page <code>518</code></td><td>`00000010 00000100</td><td>00000010 00000110`</td></tr></tbody></table></div>\n<p>Page <code>516</code> plays trace <code>257</code> and also links to feedback page <code>517</code>.\nCompleting its two patches does not follow either link automatically. Pages <code>514</code>,\n<code>515</code>, <code>517</code> and <code>518</code> each link back to question <code>512</code>.</p>\n<p>Following a return link starts a fresh attempt with an empty selection. Reset only clears a\npending answer on a question page; it cannot erase a submitted answer from a feedback page.\nThe explicit links also let a learner open the demonstration without first answering correctly.</p>\n<p>The miniature’s complete page graph</p>\n<div class=\"table-wrap\"><table><thead><tr><th>From</th><th>Action</th><th>To / display</th></tr></thead><tbody><tr><td><code>512</code></td><td>Submit [<code>10</code>]</td><td><code>514</code> / frame <code>259</code>, all glyph <code>1</code></td></tr><tr><td><code>512</code></td><td>Submit [], [<code>20</code>] or [<code>10, 20</code>]</td><td><code>515</code> / frame <code>260</code>, all glyph <code>2</code></td></tr><tr><td><code>512</code></td><td>Open demonstration</td><td><code>516</code> / trace <code>257</code></td></tr><tr><td><code>516</code></td><td>Open feedback</td><td><code>517</code> / frame <code>259</code></td></tr><tr><td><code>516</code></td><td>Open final picture</td><td><code>518</code> / frame <code>258</code></td></tr><tr><td><code>514, 515, 517, 518</code></td><td>Return link</td><td><code>512</code> / question</td></tr></tbody></table></div>\n<hr />\n<h3 id=\"frame-29-of-32-read-the-complete-miniature-section\">Frame 29 of 32: Read the complete miniature section</h3>\n<p>This frame supplies the complete miniature document inside its checked section. It lets the recipient\ntest the earlier boundaries and record examples together.</p>\n<p>The first six bytes are header bytes\n<code>0 1 | 0 0 1 70</code>: ID <code>1</code> and body length <code>326</code>. The\n<code>326</code>-byte body begins with\n<code>214 57 | 0 2 | 0 15 | 2 0 | 1 1</code> and contains all fifteen records. The\nlast four bytes are\n<code>255 64 93 120</code>. The total is <code>6</code>+<code>326</code>+<code>4</code> = <code>336</code> bytes, filling exactly forty-two eight-byte rows\nstarting at local row <code>12</code>.</p>\n<p>The final row contains four body bytes and four check bytes. There is no partial data row. The reader\ncan verify this section’s check now; parsing every record also requires the table format shown next.\nThis worked section belongs to the strip, not to the five-document payload below it.</p>\n<hr />\n<h3 id=\"frame-30-of-32-read-a-numeric-table\">Frame 30 of 32: Read a numeric table</h3>\n<p>Table values are unsigned numbers. A value here does not select a glyph, as a frame cell does.</p>\n<p>The first three bands specify kind <code>5</code>, ID\n<code>400</code> and payload length <code>17</code>. The\ndimension fields give two rows and\nthree columns. The last two bands contain\n<code>0,1,2</code> and <code>3</code>,<code>4</code>,<code>5</code>, each value stored as a <code>u16</code>. Thus each value band occupies six\nbytes.</p>\n<p>The four-bit widths on the left\ncount the bytes in each band. The two value bands each have width <code>0110</code>,\nor six bytes: three values with two bytes each. Their small under-row marks locate\nthose byte boundaries.</p>\n<p>Data bands in drawing order.</p>\n<div class=\"table-wrap\"><table><thead><tr><th>Meaning</th><th>Bits</th><th>Decimal</th><th>Bytes</th></tr></thead><tbody><tr><td>Record kind</td><td><code>00000101</code></td><td><code>5</code></td><td><code>1</code></td></tr><tr><td>Record ID</td><td><code>00000001 10010000</code></td><td><code>400</code></td><td><code>2</code></td></tr><tr><td>Payload byte length</td><td><code>00000000 00000000 00000000 00010001</code></td><td><code>17</code></td><td><code>4</code></td></tr><tr><td>Table rows</td><td><code>00000000 00000000 00000000 00000010</code></td><td><code>2</code></td><td><code>4</code></td></tr><tr><td>Table columns</td><td><code>00000011</code></td><td><code>3</code></td><td><code>1</code></td></tr><tr><td>Table values <code>0</code>–<code>2</code></td><td>`00000000 00000000</td><td>00000000 00000001</td><td>00000000 00000010`</td></tr><tr><td>Table values <code>3</code>–<code>5</code></td><td>`00000000 00000011</td><td>00000000 00000100</td><td>00000000 00000101`</td></tr></tbody></table></div>\n<p>Trace <code>257</code> refers to this table as attached data. The record reader recovers its values without assigning\nthem a subject-specific meaning. Later tables use the same format for move words, scores and field\nwidths; the displayed lessons teach those meanings.</p>\n<p>A trace’s references make its attached tables available to the reader. Its stored patches\ngive the display changes explicitly; the player does not calculate those changes from\nthe table values.</p>\n<hr />\n<h2 id=\"using-the-bootstrap-to-read-the-payload\">Using the bootstrap to read the payload</h2>\n<p>The final two bootstrap frames show how sections form a stream and where the full message’s used data\nends. Together with the earlier examples, the strip defines the byte order, checksum, section and\ninventory layouts, document header, and five record types needed to read the payload.</p>\n<hr />\n<h3 id=\"frame-31-of-32-locate-consecutive-sections-and-their-boundary\">Frame 31 of 32: Locate consecutive sections and their boundary</h3>\n<p>This frame places sections consecutively and distinguishes the final byte from the address after it. The\nrecipient needs both to stop at the correct boundary.</p>\n<p>The upper rows have four columns: section ID, start, exclusive end and length. The\ninventory row is <code>0,0,28,28</code>;\nthe document row is\n<code>1,28,364,336</code>. The second section begins exactly where the first ends. These rows describe\nplacement, not extra header fields.</p>\n<p>The <code>0,1,2</code> line is a counting\nsequence; this example contains only sections <code>0</code> and <code>1</code>. The bottom pair\ncontrasts last included byte <code>363</code> with\nexclusive end <code>364</code>. In general, the next\nsection starts after six header bytes, the declared body length and four check bytes.</p>\n<p>Data bands in drawing order.</p>\n<div class=\"table-wrap\"><table><thead><tr><th>Meaning</th><th>Bits</th><th>Decimal</th></tr></thead><tbody><tr><td>Inventory: ID, start, end, length</td><td>`00000000 00000000</td><td>00000000 00000000</td></tr><tr><td>Document: ID, start, end, length</td><td>`00000000 00000001</td><td>00000000 00011100</td></tr><tr><td>Counting sequence <code>0, 1, 2</code></td><td>`00000000 00000000</td><td>00000000 00000001</td></tr></tbody></table></div>\n<hr />\n<h3 id=\"frame-32-of-32-find-the-used-end-and-verify-zero-reserve\">Frame 32 of 32: Find the used end and verify zero reserve</h3>\n<p>This frame separates the full payload’s used bytes from its zero-filled reserve. The recipient must stop\nparsing at the used end and check what remains.</p>\n<p>The four bounded fields give\nstart offset <code>0</code>, used length <code>506,509</code>, capacity <code>507,904</code>, and reserve length <code>1,395</code>. The small tallies at the right number\nthese rows.</p>\n<p>The lower example contains two separately\nbounded fields: thirty-two zero bits above, and the eight-bit numeral <code>00100000</code> below, read\nas <code>32</code>. The first field is data; the second states its width. Their separate boundaries keep\nthe numeral’s filled bit out of the zero data.</p>\n<hr />\n<h3 id=\"recovering-and-validating-the-payload\">Recovering and validating the payload</h3>\n<p>The five document bodies total <code>506,181</code> bytes. Add <code>268</code> inventory-body bytes and\n<code>60</code> bytes of section headers and checks to obtain <code>506,509</code> used bytes. The\nremaining <code>1,395</code> bytes must be zero rather than another document.</p>\n<p>The reader starts at row <code>64</code> and uses <em>Frame <code>16</code></em>’s mapping to recover the declared number of bytes. For each\nsection, it reads the header, checks that the body fits within the remaining data, verifies the checksum,\nand advances past header, body and check. Section IDs increase from <code>0</code>, and each required document appears\nonce.</p>\n<p>Section <code>0</code> is the full message’s inventory. Its body begins with the two-byte document count\n<code>5</code>. Each document entry specifies an ID, body length, section checksum, entry count and ordered entry IDs.\nThe inventory contains these numeric declarations, not lesson titles or a curriculum order.</p>\n<p>A complete reading must match the inventory to the received sections and document headers. It must also\nvalidate record lengths, kinds, references and cell indices. Missing objects and invalid references cause\nrejection; the reader does not guess replacements. Successfully displaying one fragment is not enough to\naccept the whole message.</p>\n<p>The supplied Python decoder implements these rules directly. It tests rotations, reflections\nand swapped bit states, compares the bootstrap with its defined drawings, and requires one\ncompletely valid reading. This is a check of a known format. Discovering that format from\nthe drawings is the recipient’s separate task.</p>\n<p>The actual five documents; inventory section\n<code>0</code>\noccupies stream bytes\n<code>0</code>–<code>277</code></p>\n<div class=\"table-wrap\"><table><thead><tr><th>Document / section ID</th><th>Section stream offset</th><th>Body bytes</th><th>Contents, labelled for this guide</th></tr></thead><tbody><tr><td><code>1</code></td><td><code>278</code></td><td><code>13,245</code></td><td>Basic visual vocabulary</td></tr><tr><td><code>2</code></td><td><code>13,533</code></td><td><code>93,017</code></td><td>The <code>64</code>-game anthology</td></tr><tr><td><code>3</code></td><td><code>106,560</code></td><td><code>35,296</code></td><td>Board, pieces and elementary rules</td></tr><tr><td><code>4</code></td><td><code>141,866</code></td><td><code>195,452</code></td><td>Practical rules, state and move packing</td></tr><tr><td><code>5</code></td><td><code>337,328</code></td><td><code>169,171</code></td><td>Relationships, tactics and strategic examples</td></tr></tbody></table></div>\n<p>Offsets are zero-based byte addresses from the start of row <code>64</code>. Storage order is not a requirement to read\ndocument <code>2</code> before learning from documents <code>3</code> and <code>4</code>.</p>\n<p>The miniature belongs to the bootstrap strip. It demonstrates the format used by the\ninventory and five complete documents in the byte stream below it. After recovering and\nvalidating that full set, the recipient can open a declared entry.</p>\n<p>The player can now look up the entry’s records and display them. No chess knowledge is\nneeded to reconstruct the picture in the next example.</p>\n<hr />\n<h2 id=\"from-payload-bits-to-a-displayed-picture\">From payload bits to a displayed picture</h2>\n<p>Follow document <code>2</code>, which stores the complete games, and its first declared entry,\ntrace <code>324</code>. We will reconstruct its initial picture using the bootstrap’s rules,\nthen use the course to interpret that picture as chess.</p>\n<hr />\n<h3 id=\"find-the-document-and-read-its-declared-entry\">Find the document and read its declared entry</h3>\n<p>After all six sections have been recovered and checked, the inventory identifies document\n<code>2</code> with a body of <code>93,017</code> bytes. Its section starts at payload byte\n<code>13,533</code>. The six-byte header reads <code>0 2 | 0 1 107 89</code>: document ID,\nthen body length, high byte first. The body begins six bytes later, at payload byte\n<code>13,539</code>. Document offset <code>0</code> means this point.</p>\n<p>The first eight body bytes come from source row <code>116</code>, columns\n<code>1,816</code>–<code>1,879</code>. They are one continuous row of <code>64</code> cells\nin the message; the illustration regroups them into eight rows, one byte per row.\nThe first two bytes identify the document format.\nThe next two declare <code>64</code> entries;\nthe following two declare <code>151</code> records.\nThe last pair shown is the first entry ID.</p>\n<p>The document header and the first entry, copied from the actual payload.</p>\n<div class=\"table-wrap\"><table><thead><tr><th>Field</th><th>Bits</th><th>Reading</th></tr></thead><tbody><tr><td>Document marker</td><td><code>11010110 00111001</code></td><td><code>214 57</code></td></tr><tr><td>Entry count</td><td><code>00000000 01000000</code></td><td><code>64</code></td></tr><tr><td>Record count</td><td><code>00000000 10010111</code></td><td><code>151</code></td></tr><tr><td>First entry ID</td><td><code>00000001 01000100</code></td><td><code>1×256 + 68 = 324</code></td></tr></tbody></table></div>\n<p>Entry <code>324</code> is a stored name, not the location of the next byte.\nThe remaining <code>63</code> entry IDs follow it. All <code>64</code> entries occupy\n<code>128</code> bytes after the six-byte header, so the records begin at document byte\n<code>6 + 64×2 = 134</code>.</p>\n<hr />\n<h3 id=\"read-the-records-then-follow-their-names\">Read the records, then follow their names</h3>\n<p>At each record, read its one-byte kind, two-byte ID and four-byte content length.\nConsume exactly that many content bytes, then continue with the next record.\nFor example, record <code>0</code> starts at byte <code>134</code> and declares three\ncontent bytes. Its seven-byte header and three-byte contents end at byte\n<code>144</code>, where the next record starts. Reading all <code>151</code> records\nbuilds a lookup from each ID to its stored contents.</p>\n<p>Three records from that lookup. Spaces group kind, ID and content length; other records are omitted here.</p>\n<div class=\"table-wrap\"><table><thead><tr><th>Record</th><th>Document offset</th><th>Actual header bytes</th></tr></thead><tbody><tr><td>Glyph <code>32</code></td><td><code>199</code></td><td>`1</td></tr><tr><td>Frame <code>256</code></td><td><code>355</code></td><td>`2</td></tr><tr><td>Trace <code>324</code></td><td><code>15,028</code></td><td>`3</td></tr></tbody></table></div>\n<p>Looking up the declared entry <code>324</code> finds a trace, kind <code>3</code>.\nIts first two content bytes are <code>00000001 00000000</code>, or\n<code>1×256 + 0 = 256</code>: its initial display-frame ID.\nLooking up <code>256</code> finds the frame record above. This follows a reference\nback to an earlier record; it does not jump to byte <code>256</code>.\nThe rest of the trace contains its attached tables and ordered updates. Its initial\ndisplay uses this frame before applying any update.</p>\n<ol><li><p>Declared entry</p><p> <code>324</code>\n names the record below ↓</p></li><li><p>Trace record</p><p> <code>324</code>\n First content bytes: <code>00000001 00000000</code>\n name its initial frame ↓</p></li><li><p>Frame record</p><p> <code>256</code>\n Found at document byte <code>355</code></p></li></ol>\n<p>The entry and the trace’s frame reference are record names. Their lookup locations are separate values.</p>\n<hr />\n<h3 id=\"read-the-frame-as-a-grid-of-glyph-references\">Read the frame as a grid of glyph references</h3>\n<p>Frame <code>256</code> begins its contents with <code>00001001 00001000</code>:\nnine rows and eight columns. The next <code>9×8 = 72</code> bytes give one glyph ID\nfor each frame cell, across each row and then down. Here are those actual bytes,\nshown as decimal IDs. The row and column labels are added for reading.\nAfter the grid, two zero bytes give a selectable-region count of <code>0</code>.\nThe frame’s contents therefore occupy <code>2 + 72 + 2 = 76</code> bytes, matching its header.</p>\n<p>The frame’s <code>72</code> stored glyph IDs. The shaded cell is index <code>48</code>.</p>\n<div class=\"table-wrap\"><table><thead><tr><th>Row</th><th><code>0</code></th><th><code>1</code></th><th><code>2</code></th><th><code>3</code></th><th><code>4</code></th><th><code>5</code></th><th><code>6</code></th><th><code>7</code></th></tr></thead><tbody><tr><td><code>0</code></td><td><code>41</code></td><td><code>39</code></td><td><code>40</code></td><td><code>42</code></td><td><code>43</code></td><td><code>40</code></td><td><code>39</code></td><td><code>41</code></td></tr><tr><td><code>1</code></td><td><code>38</code></td><td><code>38</code></td><td><code>38</code></td><td><code>38</code></td><td><code>38</code></td><td><code>38</code></td><td><code>38</code></td><td><code>38</code></td></tr><tr><td><code>2</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td></tr><tr><td><code>3</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td></tr><tr><td><code>4</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td></tr><tr><td><code>5</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td></tr><tr><td><code>6</code></td><td><code>32</code></td><td><code>32</code></td><td><code>32</code></td><td><code>32</code></td><td><code>32</code></td><td><code>32</code></td><td><code>32</code></td><td><code>32</code></td></tr><tr><td><code>7</code></td><td><code>35</code></td><td><code>33</code></td><td><code>34</code></td><td><code>36</code></td><td><code>37</code></td><td><code>34</code></td><td><code>33</code></td><td><code>35</code></td></tr><tr><td><code>8</code></td><td><code>3</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td><td><code>0</code></td></tr></tbody></table></div>\n<p>Cell <code>48</code> is row <code>6</code>, column <code>0</code>, because\n<code>6×8 + 0 = 48</code>. Its byte is <code>00100000</code>, or ID <code>32</code>.\nThe frame record starts at byte <code>355</code>. After its seven-byte header and two\ndimension bytes, the grid begins at <code>355 + 7 + 2 = 364</code>.\nCell <code>48</code> is therefore at document byte <code>364 + 48 = 412</code>,\nor payload byte <code>13,539 + 412 = 13,951</code>. The mapping from\n<em>Frame <code>16</code></em> places it at source row <code>118</code>, columns\n<code>1,016</code>–<code>1,023</code>. The byte names a glyph; its eight source bits\ndo not themselves draw that glyph.</p>\n<hr />\n<h3 id=\"look-up-the-bitmap-and-put-it-in-the-cell\">Look up the bitmap and put it in the cell</h3>\n<p>Record <code>32</code> is a glyph, kind <code>1</code>. Its six content bytes are\n<code>5 5 | 1 8 64 0</code>: row count, column count, then the packed bitmap.\nThe dimensions require <code>5×5 = 25</code> picture bits. The four bitmap bytes\ncarry those first <code>25</code> bits, followed by\nseven zero padding bits that complete the last byte.\nTake five picture bits at a time to fill each bitmap row from left to right, then continue\non the next row. The padding completes the stored bytes and is excluded from the picture.</p>\n<p>The same bitmap bits in storage order above and in five rows below. The seven padding bits do not become pixels.</p>\n<p>The recipient now draws that bitmap in\nframe cell <code>48</code>. Each of the other\ncells is drawn by looking up its own glyph ID in this same document. A repeated ID\nreuses the same bitmap. Record <code>0</code> has contents <code>2 2 | 0</code>:\na two-by-two bitmap of zero bits. It supplies the blank tiles wherever the frame names\nglyph <code>0</code>. The result is the complete initial picture of entry <code>324</code>:</p>\n<p>All nine rows of the stored frame. The highlighted cell contains glyph <code>32</code>.</p>\n<p>Every glyph shape now comes from a stored bitmap, and every position from a stored\nframe cell. The recipient can draw this picture using the bootstrap’s rules alone.\nLearning what the shapes, arrangement and bottom row mean is the next task for the\nrecovered course. Later, we will return to this same trace and apply its first stored update.</p>\n<hr />\n<h2 id=\"learning-chess-from-the-payload\">Learning chess from the payload</h2>\n<p>The picture just recovered is a display the recipient can draw before understanding chess.\nDocument <code>1</code> supplies the visual vocabulary; the chess course then explains the <code>8×8</code> board, two\nsides, six piece types, starting positions and alternating turns. This guide uses the usual English names,\nWhite and Black; White moves first. The recipient has no reason to associate any particular shape with a\nchess piece, so the glyphs could be arbitrary. I chose patterns that resemble familiar chess pieces. Their roles still have to be taught\nthrough setup, movement and repeated examples.</p>\n<p>The study route begins with document <code>1</code>’s representation lessons, then documents\n<code>3, 4</code> and <code>5</code>: elementary rules, practical rules and history, then relationships and limited\nstrategic guidance. Document <code>2</code> supplies the complete-game anthology.</p>\n<p>A worked example shows an input and its result. Contrasts make a distinction visible by\nshowing a rejected result or changing a condition such as a blocker or a castling right.\nPractice asks the recipient to choose among stored alternatives, using the page mechanism\nfrom the bootstrap. A page can group several questions: the learner selects an answer for\neach and commits the combined set. The player checks that whole set against the page’s\nstored accepted responses.</p>\n<p>A passive route shows the explanations and feedback without requiring a correct submission.\nBoth routes use the same record operations. The chess calculations happen when the lessons\nare authored; the player later presents the resulting pictures, choices and feedback.</p>\n<p>A glyph ID remains a local name. Its role as a pawn, knight or other piece comes from the examples. The\nsame glyph can appear on the board, identify a selected piece in a question, and appear at its destination\nafter a move.</p>\n<p>Pawn</p>\n<p>Knight</p>\n<p>Bishop</p>\n<p>Rook</p>\n<p>Queen</p>\n<p>King</p>\n<p>The actual piece bitmaps, first side then second. Each second-side bitmap inverts the first side’s\ntwenty-five picture bits; the seven padding bits remain zero. The course establishes each piece’s role\nthrough examples.</p>\n<hr />\n<h3 id=\"identifying-the-question-and-its-answer\">Identifying the question and its answer</h3>\n<p>A question must identify its subject as well as show a board. This knight lesson uses a <code>29</code>×<code>10</code>\ndisplay frame containing an <code>8×8</code> board and a separate <code>8×8</code> answer grid, or mask, below it. A footer between\nthem names the side, selected piece, square and question type.</p>\n<p>Here the footer selects the\nfirst-side knight at board row <code>7</code>, column <code>1</code>, or b1 in the added chess coordinates. The question asks for legal destinations. The knight can move to\na3 and c3. Its jump also reaches d2 geometrically, but a friendly pawn\noccupies that square.</p>\n<p>One source frame, two distinct picture regions</p>\n<p>abcdefgh</p>\n<p>87654321</p>\n<p>Board crop · selected knight on b1</p>\n<p>abcdefgh</p>\n<p>87654321</p>\n<p>Answer-mask crop · a3 and c3</p>\n<div class=\"table-wrap\"><table><thead><tr><th>Source footer field</th><th>Actual value / glyph</th><th>Meaning in this lesson</th></tr></thead><tbody><tr><td>Side / selected piece</td><td><code>3</code> / <code>33</code></td><td>First side / knight</td></tr><tr><td>Row / column</td><td><code>19</code> / <code>13</code></td><td>Digit glyphs for <code>7</code> / <code>1</code></td></tr><tr><td>Question mode</td><td><code>9</code></td><td>Legal destinations</td></tr><tr><td>Positive mark</td><td><code>6</code></td><td>Carried answer is affirmed</td></tr></tbody></table></div>\n<p>Document <code>3</code>, trace <code>3068</code>, step <code>33</code>. Within this <code>29</code>×<code>10</code> display frame, the board occupies rows\n<code>1</code>–<code>8</code> and columns <code>1</code>–<code>8</code>; the mask occupies rows <code>11</code>–<code>18</code> and columns\n<code>1</code>–<code>8</code>; the footer is row <code>9</code>. Coordinates start at <code>0</code>. The mask’s plus-shaped glyph <code>5</code>\nmarks indices <code>40</code> and <code>42</code> within the <code>8×8</code> mask, corresponding to a3 and c3. This illustration shows the stored answer.</p>\n<p>An ordinary capture removes the opposing piece at the destination and puts the moving piece\nthere. A friendly piece prevents a move to that square. A legal move must also leave its own\nking safe. An attack on the king is <em>check</em>; check with no legal escape is\n<em>checkmate</em>. The king stays on the board when the game ends.</p>\n<p>King safety depends on the resulting position. In one course example, a king on e1\ntries to capture a bishop on d1 while an opposing rook stands on f1. Before the move,\nthe king itself blocks the rook’s line to d1. Once the king leaves e1, that line opens,\nso the capture is illegal. The course shows the attempted move’s resulting occupancy\nand attack. Testing a king capture means moving the king, removing the captured piece,\nand checking its destination in that changed position.</p>\n<hr />\n<h3 id=\"controlled-squares-and-legal-moves\">Controlled squares and legal moves</h3>\n<p>Control follows a piece’s movement geometry in the displayed position. For a rook, bishop\nor queen, it extends along each permitted straight line to the first occupied square,\nincluding a friendly piece it defends. Pins do not remove controlled squares. Here the\nbishop on b5 points along a diagonal through the knight on c6 toward\nthe knight’s king on e8. Moving the knight would expose the king. The knight still\ncontrols eight squares, but has\nno legal destination.</p>\n<p>The control question follows the knight’s jump pattern. The legal-move question also checks whether moving\nwould expose its king. The course distinguishes these questions with different mode glyphs. The board\nstays the same; the empty legal-move mask and eight-square control mask are answers to different\nquestions. This knight cannot move along the diagonal that pins it. A pinned sliding piece\nor pawn can sometimes move along its pin line while continuing to shield its king, so a pin\ndoes not always mean that a piece has no legal move.</p>\n<p>One board, two questions</p>\n<p>abcdefgh</p>\n<p>87654321</p>\n<p>Selected black knight c6; bishop b5; king e8</p>\n<p>abcdefgh</p>\n<p>87654321</p>\n<p>Control mask · eight controlled squares</p>\n<p>abcdefgh</p>\n<p>87654321</p>\n<p>Legal mask · no legal destination</p>\n<p>Control mask: document <code>3</code>, trace <code>3124</code>, step <code>1</code>. Legal-move mask: trace <code>3119</code>, step <code>8</code>. Both show\nthe same board and selected knight.</p>\n<hr />\n<h3 id=\"learning-how-moves-are-packed\">Learning how moves are packed</h3>\n<p>A numeric table provides values, but their meaning must also be taught. Document <code>4</code> explains how a move’s\norigin square, destination square and promotion choice form a packed number. These lessons are part of the\npayload and become accessible through the reader established by the bootstrap.</p>\n<p>One stored example uses origin <code>52</code>,\ndestination <code>36</code> and\nchoice <code>0</code>: e2→e4 without promotion. Squares are numbered across rows from a8=<code>0</code> to h8=<code>7</code>, continuing\ndown to a1=<code>56</code>. Choice <code>0</code> means no promotion; <code>1, 2, 3</code> and <code>4</code> select queen, rook,\nbishop and knight.</p>\n<p>Both before-and-after boards already appear in the source display. The two crops below show the numeric\npart of that display before and after a trace step fills in the packed result. The board pictures do not\nmove between these two states.</p>\n<p>A stored lesson combines the three move fields</p>\n<p>Given: <code>52</code>, <code>36</code>, <code>0</code>; packed-word row blank</p>\n<p>Shown result: packed word <code>26912</code></p>\n<div class=\"table-wrap\"><table><thead><tr><th>Row in these crops</th><th>What it represents</th></tr></thead><tbody><tr><td>Top</td><td>Decimal origin <code>52</code>, destination <code>36</code>, choice <code>0</code></td></tr><tr><td>Middle</td><td>The respective <code>6, 6, 3</code> bits: <code>110100</code> / <code>100100</code> / <code>000</code></td></tr><tr><td>Bottom</td><td>The completed <code>16</code>-bit word: <code>0</code> / <code>110100</code> / <code>100100</code> / <code>000</code></td></tr></tbody></table></div>\n<p>Document <code>4</code>, page <code>1076</code>→trace <code>1075</code>. The crops show display-frame rows <code>9</code>–<code>11</code> and columns\n<code>0</code>–<code>18</code>. A bit <code>0</code> uses glyph <code>2</code>, the decimal digit <code>0</code> uses glyph <code>22</code>, and\na blank cell uses glyph <code>0</code>. These are three distinct records.</p>\n<p>The completed word is <code>0110100100100000</code> = <code>26,912</code>, calculated as <code>52×512 + 36×8 + 0</code>. Its fields are one leading zero, six origin bits, six\ndestination bits and three choice bits. Other stored examples unpack a word into these fields and reject a\nleading <code>1</code> or a choice outside <code>0</code>–<code>4</code>.</p>\n<p>The table <code>[16,1,6,6,3]</code> describes those widths: <code>16</code> bits total, with fields of\n<code>1, 6, 6</code> and <code>3</code> bits. The pictures teach which fields mean padding, origin, destination and\nchoice. The table alone provides widths, not that interpretation. We can now use the same rule to\nunderstand a move in the anthology.</p>\n<p>A well-formed move word is not necessarily a legal move. Packing checks field ranges;\nunpacking also rejects a nonzero leading bit. Neither operation checks the board, whose turn\nit is, or whether promotion is possible. Those questions require the chess rules and the\nposition’s state.</p>\n<hr />\n<h2 id=\"following-one-move-from-source-to-display\">Following one move from source to display</h2>\n<p>The first game in the anthology has <code>52</code> individual moves, or <em>plies</em>, beginning with d2→d4.\nThe byte-to-picture walkthrough above recovered this game’s initial frame. Following its first\nmove now connects the stored number’s meaning to the separately stored display update. The anthology stores the move in two\nforms: a numeric move word and a display patch. The recipient must recover them separately and learn why they describe the same move.</p>\n<hr />\n<h3 id=\"1-produce-the-move-word-and-display-patch\">1. Produce the move word and display patch</h3>\n<p>Game preparation starts with the anthology in PGN, a human-readable notation for recorded games.\nThe source importer checks each game’s main line by replaying it legally from the standard\nstarting position. It records every intermediate board, the side to move, and each move’s\norigin, destination and explicit promotion choice. The first move here gives\n<code>[51,35,0]</code>. Packing gives <code>51×512 + 35×8 = 26,392</code>, stored as bytes\n<code>103 24</code>.</p>\n<p>The same replay supplies the board before and after the move. Comparing their display cells produces three\nassignments: place pawn glyph <code>32</code> at cell <code>35</code>,\nclear cell <code>51</code> to glyph <code>0</code>, and change footer cell <code>64</code> from side glyph <code>3</code> to side glyph <code>4</code>. The move\nword and patch come from this common replay. The reader does not calculate one from the other.</p>\n<p>The message builder loads the checked game and presentation data, packs the move tables,\nand assembles the document. It verifies the retained inputs before using them. This\nconstruction uses the qualified presentation data rather than reimporting the PGN on\nevery build.</p>\n<p>The authoring code shares identical glyphs, frames and tables between games, then assigns trace IDs. In\ndocument <code>2</code>, trace <code>324</code> refers to initial frame <code>256</code>, move table <code>257</code> and score table <code>258</code>. Packing adds schema\ntable <code>388</code> as another reference. These IDs identify objects only within this document.</p>\n<p>Records used by trace <code>324</code></p>\n<div class=\"table-wrap\"><table><thead><tr><th>Record in document <code>2</code></th><th>Kind</th><th>What it supplies to trace <code>324</code></th></tr></thead><tbody><tr><td><code>256</code></td><td><code>2</code>: frame</td><td><code>9×8</code> initial picture: <code>64</code> board cells +<code>8</code> footer cells</td></tr><tr><td><code>257</code></td><td><code>5</code>: table</td><td><code>52</code> rows ×<code>1</code> column of packed move words</td></tr><tr><td><code>258</code></td><td><code>5</code>: table</td><td><code>1</code>×<code>1</code> score table, value <code>1</code></td></tr><tr><td><code>388</code></td><td><code>5</code>: table</td><td><code>1</code>×<code>5</code> schema: <code>16, 1, 6, 6, 3</code></td></tr><tr><td><code>324</code></td><td><code>3</code>: trace</td><td>Initial <code>256</code>, data[<code>257,258,388</code>],<code>52</code> literal patches</td></tr></tbody></table></div>\n<p>Miniature <code>257</code> was a trace; document <code>2</code>’s <code>257</code> is a table. Miniature <code>256</code> and document <code>2</code>’s <code>256</code> are also\ndifferent frames. A name never identifies a record across document boundaries.</p>\n<hr />\n<h3 id=\"2-store-the-document-in-a-checked-section\">2. Store the document in a checked section</h3>\n<p>Document <code>2</code> contains <code>93,017</code> bytes. Its six-byte section header is\n<code>0 2 | 0 1 107 89</code>: section ID <code>2</code> and body length <code>93,017</code>. CRC-32C over that header\nand body gives <code>182 147 233 40</code>. Adding the four check bytes gives a <code>93,027</code>-byte\nsection.</p>\n<p>The section starts at stream byte <code>13,533</code>, which maps to physical row <code>116</code>, column <code>1,768</code>. Its\nbody starts six bytes later, at stream byte <code>13,539</code>. The boundary falls inside a physical row:\nsection storage follows the byte stream continuously, without row packets or row separators.</p>\n<hr />\n<h3 id=\"3-recover-and-validate-document-2\">3. Recover and validate document 2</h3>\n<p>The recipient finds this boundary by reading the inventory section and document <code>1</code>’s section\nlengths. The inventory declares document ID <code>2</code>, body length <code>93,017</code>, expected check\n<code>182 147 233 40</code> and <code>64</code> entry IDs, starting with <code>324</code>. These declarations must match the received\nsection and document header.</p>\n<p>The document header starts <code>214 57 | 0 64 | 0 151</code>: marker, <code>64</code> entries and <code>151</code> records. Its\nfirst entry is <code>1 68</code>, or <code>324</code>. Reading each length-delimited record builds a map from IDs to\nrecords. Resolving trace <code>324</code> then finds frame <code>256</code> and tables <code>257, 258</code> and <code>388</code>. Schema <code>388</code> is\nnear the document’s end, so references must work even when the target record occurs later.</p>\n<p>Move table <code>257</code> and trace <code>324</code>: actual record bytes</p>\n<div class=\"table-wrap\"><table><thead><tr><th>Actual byte values, decimal</th><th>Interpretation</th></tr></thead><tbody><tr><td>`5</td><td>1 1</td></tr><tr><td>`0 0 0 52</td><td>1`</td></tr><tr><td><code>103 24</code></td><td>First <code>u16</code> value: <code>26,392</code></td></tr><tr><td>`3</td><td>1 68</td></tr><tr><td>`1 0</td><td>3</td></tr></tbody></table></div>\n<p>Spaces in these transcripts separate fields for reading; they are not stored delimiters. The table’s\npayload length, <code>109</code> bytes, and its row count, <code>52</code>, are different fields.</p>\n<hr />\n<h3 id=\"4-locate-and-read-the-first-move-word\">4. Locate and read the first move word</h3>\n<p>Table <code>257</code> starts at document byte <code>438</code>. Its seven-byte record header is followed by a four-byte row count\nand a one-byte column count. Its first value therefore begins at byte <code>450</code> and occupies bytes <code>450</code>–<code>451</code>.</p>\n<p>The document body starts at stream byte <code>13,539</code>. Adding <code>450</code> locates the first value at stream\nbytes <code>13,989</code>–<code>13,990</code>. <em>Frame <code>16</code></em>’s mapping places its sixteen bits at physical row\n<code>118</code>, columns <code>1,320</code>–<code>1,335</code>. They read <code>0110011100011000</code>: bytes <code>103</code> and\n<code>24</code>, giving <code>103×256+24 = 26,392</code>.</p>\n<p>The first move word, directly from the artifact</p>\n<p>Read the sixteen positions from left to right: <code>0110011100011000</code>. The table keeps those same\nbits visible while showing their readings.</p>\n<div class=\"table-wrap\"><table><thead><tr><th>Representation</th><th>Same carried value</th></tr></thead><tbody><tr><td>Two bytes, decimal</td><td><code>103</code> /<code>24</code></td></tr><tr><td>One <code>u16</code></td><td><code>103×256</code>+<code>24</code> =<code>26,392</code></td></tr><tr><td>Fields, binary</td><td><code>0</code></td></tr><tr><td>Fields, decimal</td><td>padding <code>0</code></td></tr></tbody></table></div>\n<hr />\n<h3 id=\"5-interpret-the-move-fields\">5. Interpret the move fields</h3>\n<p>Apply schema <code>388</code> using the meanings taught in document <code>4</code>: <code>0 | 110011 | 100011 | 000</code>. The\nfields give padding <code>0</code>, origin <code>51</code>, destination <code>35</code> and choice <code>0</code>: d2→d4 without promotion. These\nsquare numbers use row-major order on the <code>8×8</code> board; they are distinct from coordinates in the physical\nmessage.</p>\n<p>The table reader recovers the value <code>26,392</code>. Interpreting it as a chess move requires\nthe course’s explanation of the fields. The native player does not use this word to calculate a legal\nboard update; it displays the separately stored patch.</p>\n<hr />\n<h3 id=\"6-apply-the-stored-patch\">6. Apply the stored patch</h3>\n<p>Trace <code>324</code>’s first patch occupies document bytes <code>15,048</code>–<code>15,058</code>:\n<code>0 3 | 0 35 32 | 0 51 0 | 0 64 4</code>. The count is three, followed by assignments (cell <code>35</code>, glyph\n<code>32</code>), (cell <code>51</code>, glyph <code>0</code>) and (cell <code>64</code>, glyph <code>4</code>). Two change board cells; the third changes the\nfooter’s turn marker.</p>\n<p>Both before and after the patch, glyph <code>32</code> refers to the same bitmap recovered earlier:\na <code>5×5</code> picture with mask bytes <code>1 8 64 0</code>. The patch changes where it is drawn.\nThe glyph record itself stays unchanged.</p>\n<p><strong>Record <code>32</code> → a <code>5×5</code> bitmap</strong></p>\n<p><code>00000</code> / <code>00100</code> / <code>00100</code> / <code>00100</code> / <code>00000</code></p>\n<p>The first <code>25</code> bits of bytes <code>1</code>, <code>8</code>, <code>64</code>, <code>0</code>, across each row and then down.</p>\n<p>The first patch changes two board cells</p>\n<p>abcdefgh</p>\n<p>87654321</p>\n<p>Before patch · frame <code>256</code>, board region</p>\n<p>abcdefgh</p>\n<p>87654321</p>\n<p>After patch <code>1</code> · d2 empty, pawn on d4</p>\n<div class=\"table-wrap\"><table><thead><tr><th>Cell index</th><th>Before glyph ID</th><th>Assignment</th><th>Result</th></tr></thead><tbody><tr><td><code>35</code> (d4)</td><td><code>0</code></td><td><code>32</code></td><td>Draw the pawn bitmap</td></tr><tr><td><code>51</code> (d2)</td><td><code>32</code></td><td><code>0</code></td><td>Draw the blank bitmap</td></tr><tr><td><code>64</code> (footer, first cell)</td><td><code>3</code></td><td><code>4</code></td><td>Second side to move</td></tr></tbody></table></div>\n<p>The frame is <code>9×8</code>; these pictures crop its first eight rows. Cell <code>64</code> is outside the board and is shown\nseparately in the complete replay below. Colored areas identify the assigned board cells.</p>\n<p>The two stored representations agree: the move word specifies d2→d4, and the patch moves the pawn between\nthose squares while changing the turn marker. During message creation, the program checks the reconstructed pictures against the board positions\nobtained from the original game’s moves. A\nrecipient who has learned the meanings can compare them; the player itself only looks up glyphs and\nassigns cell values.</p>\n<p>The move word, patch and bitmap thus meet in one displayed change. The bootstrap supplies the\noperations needed to recover and draw it; the course supplies its chess meaning. The special\nmoves below use the same operations, with additional rules determining which changes are valid.</p>\n<hr />\n<h2 id=\"why-board-positions-need-history\">Why board positions need history</h2>\n<p>The first move changes two board cells and a footer. Other moves depend on more information or change\nadditional squares. The course teaches these cases by showing a position, an attempted move and its\nresult, then comparing what happens when a relevant condition changes.</p>\n<p>In the examples below, the before-and-after boards occupy two regions of one stored display frame, at\ndisplay-frame columns <code>0</code>–<code>7</code> and <code>9</code>–<code>16</code>. They are not separate frame records. The crops show only\nthe squares needed to explain each rule.</p>\n<hr />\n<h3 id=\"castling-moves-two-pieces\">Castling moves two pieces</h3>\n<p>In this king-side castling example, the\nking and rook leave e1 and h1 and\narrive on g1 and f1. Four board cells change. Castling requires\nthe corresponding right to remain and every square between king and rook to be empty. The\nking must be safe on its starting square, its transit square after leaving the start, and its\ndestination after both pieces move. The course compares accepted castling with attempts\nthat fail these conditions.</p>\n<p>A king or rook that moves and returns does not recover its lost right. For queen-side\ncastling, the square next to the rook must also be empty, though the king never crosses it.\nAn attack on that square or on the rook itself does not prevent castling; the safety test\nconcerns the king’s route.</p>\n<p>Before: e1 king / f1 empty / g1 empty / h1 rook</p>\n<p>After: e1 empty / f1 rook / g1 king / h1 empty</p>\n<p>Document <code>4</code>, trace <code>798</code>, step <code>0</code>. The crops show e1–h1 in the before-and-after board regions.\nThe first side also loses its castling rights after this move.</p>\n<hr />\n<h3 id=\"en-passant-depends-on-the-immediately-preceding-move\">En passant depends on the immediately preceding move</h3>\n<p>Immediately after the opposing pawn advances from d7 to d5, the pawn on e5 can\ncapture on d6. That destination was empty. The\ncaptured pawn is removed from d5, so three squares change. The crop\nshows d6 and e6 above d5 and e5.</p>\n<p>A matched example moves both sides’ knights away and back, restoring the same board occupancy. The\nopportunity for en passant has expired, so the same attempted capture is refused and the board remains\nunchanged. The pieces alone do not record when the opposing pawn advanced.</p>\n<p>En passant must also leave the moving side’s king safe. Removing both pawns from their\noriginal squares can open an attacking line. The course includes an immediate capture\nrefused for this reason, even though its timing and pawn geometry are otherwise correct.</p>\n<p>Before: d5 opposing pawn; e5 capturing pawn</p>\n<p>After: pawn on d6; d5 and e5 empty</p>\n<p>Document <code>4</code>, trace <code>906</code>. Step <code>0</code> shows the available capture; step <code>4</code> shows the same board after\nthe opportunity has expired.</p>\n<hr />\n<h3 id=\"promotion-needs-a-separate-choice\">Promotion needs a separate choice</h3>\n<p>Here the pawn leaves b7, captures the\nrook on a8, and is replaced by the\nselected promotion piece. Choice <code>1</code> produces a queen;\nchoice <code>4</code> produces a knight. Both moves have the same origin and destination, so the promotion choice needs\nits own field. The course also shows rook and bishop promotion and rejects a missing promotion choice.</p>\n<p>Before: rook a8; pawn b7</p>\n<p>Choice <code>1</code>: queen a8; b7 empty</p>\n<p>Choice <code>4</code>: knight a8; b7 empty</p>\n<p>Document <code>4</code>, trace <code>929</code>, steps <code>0</code> and <code>9</code>. Each crop shows a8 and b8 above a7 and b7.</p>\n<hr />\n<h3 id=\"history-is-part-of-the-state\">History is part of the state</h3>\n<p>A king can leave its starting square and return, restoring the board and side to move while losing\ncastling rights. Document <code>4</code>, trace <code>1000</code> at step <code>3</code>, compares two matching boards with\ndifferent histories: the first side has both castling rights in one case and neither in the other.</p>\n<p>Repetition uses a precise meaning of “the same position”: the pieces occupy the same\nsquares, the same side is to move, castling rights match, and any legal en-passant opportunity\nmatches. An en-passant target counts only if an actual legal capture is available. A target\nthat no pawn can use, or that would expose its own king, does not distinguish the position.</p>\n<p>Count occurrences of the current position throughout the legal history, including the\ninitial occurrence. They need not be consecutive. A separate counter records plies since\nthe last pawn move or capture; either resets it to zero. That counter affects a draw claim,\nbut is not part of the position compared for repetition.</p>\n<p>The course carries legal histories and state displays for these distinctions. Reused history\nsegments have explicit links and complete starting pictures, so opening a segment does not\nrequire the player to calculate its starting position. The anthology’s <code>72</code> display\ncells serve a smaller purpose: its board and footer show play and result, without listing\nall castling rights or an en-passant square.</p>\n<hr />\n<h3 id=\"when-a-game-ends\">When a game ends</h3>\n<p>A side with no legal move is checkmated if its king is in check, and stalemated otherwise.\nCheckmate is a loss; stalemate is a draw. Golden Board also recognizes three classes where\nneither side can give checkmate: king against king, king and bishop against king, and king\nand knight against king. Its rules machinery ends play after a legal move reaches one of\nthese board endings, and refuses later moves or declarations.</p>\n<p>A claim for threefold repetition becomes available once the current position has appeared\nat least three times. A fifty-move claim needs at least <code>100</code> plies since the last\npawn move or capture. Neither condition ends play automatically: the side to move must\nexplicitly claim the eligible draw. A move that would reach a threshold does not make that\nclaim available in advance. The course shows eligible claims and the separate events that\naccept or refuse them.</p>\n<p>Either side can resign while play is active, awarding the other side the win. Draw agreement\nrequires both sides’ explicit consent after each has made a move. These declarations have\nknown causes. An anthology score only records the outcome: a win or draw on a nonterminal\nboard does not identify resignation, agreement or a claim.</p>\n<p>This is the project’s practical chess profile. It excludes automatic fivefold and\n<code>75</code>-move adjudication, intended-next-move claim procedures, tournament procedures,\nand a general solver for positions where checkmate is impossible. Material outside the\nthree recognized dead-position classes receives no general deadness verdict.</p>\n<hr />\n<h2 id=\"tactics-mating-and-strategic-guidance\">Tactics, mating and strategic guidance</h2>\n<p>The later course builds on control and legality to teach attacks, defenses, pins and forks.\nA fork here is one piece geometrically attacking at least two opposing pieces. That fact\nalone does not prove that either capture is legal or profitable. A passed pawn has no\nopposing pawn ahead on its own or an adjacent file; it still faces kings, other pieces and\nthe timing of play.</p>\n<p>Mating instruction includes king-and-queen and king-and-rook continuations, with contrasts\nthat end in stalemate. A legal line ending in mate can still depend on the opponent choosing\na losing reply. To support a\nforced win, the winning side may choose its continuations, but every legal defensive move\nand every eligible defensive draw claim must be covered. All resulting branches must end\nin the asserted win.</p>\n<p>The message carries finite worked examples of this distinction. One starts with White’s king\non f3 and queen on h4, and Black’s lone king on g1. White moves the queen to g3. Black’s\nonly legal moves are king g1→f1 and king g1→h1. The stored continuations\nanswer the first with queen g3→f2 and the second with queen g3→g2; both give checkmate.\nCovering only one reply would leave the forced-win claim incomplete. The player presents\nthese stored displays and tables without searching for a mating line.</p>\n<p>Strategic lessons use observable facts such as development, central control, open files\nand mobility. Their rough material scale assigns <code>1</code> to a pawn, <code>3</code> to a\nknight or bishop, <code>5</code> to a rook and <code>9</code> to a queen; the king has no exchange\nvalue. These counts and comparisons provide guidance, not a verdict on the better position\nor best move. A worked move-check routine first establishes whether play is active, whose\nturn it is, whether the king is in check, and which draw claims are available. It then\nexamines legal choices and the shown move’s effects, including captures, check and game\nendings. Comparisons remain limited to the continuations actually supplied.</p>\n<hr />\n<h2 id=\"replaying-a-complete-game\">Replaying a complete game</h2>\n<p>The <code>52</code>-ply game has <code>53</code> display states: its initial frame and the result after each patch. To reconstruct a\nstate, copy the initial frame and apply all patches up to that point. Moving backward reconstructs an\nearlier state in the same way; it does not require reversing chess moves.</p>\n<p>The board and eight-cell footer appear separately below. Footer cell <code>0</code> identifies the side to\nmove. In the final patch, footer cell <code>1</code> changes to glyph <code>11</code>, the second-side result mark.\nScore table <code>258</code> contains <code>1</code>, recording a second-side win. This stored result does not imply that the final\ndisplayed board is checkmate.</p>\n<p>Game <code>1</code>: all <code>53</code> display states and the footer</p>\n<p>Use Next move to apply the next stored patch, Previous to reconstruct the preceding state, and Reset to\nrestore the start. The <code>53</code> states cover <code>0</code>–<code>52</code> plies.\nBlue areas mark cleared cells;\nochre areas mark assigned pieces;\nteal areas mark footer changes. The interpreted move word is listed\nseparately.</p>\n<p>abcdefgh</p>\n<p>87654321</p>\n<p>Game <code>1</code> board · initial position</p>\n<p>Footer · side to move, then recorded result</p>\n<p>First side to move; result mark blank.</p>\n<p>State <code>1</code> of <code>53</code> · before any move</p>\n<hr />\n<h3 id=\"initial-frame-256\">Initial frame <code>256</code></h3>\n<p>Move-word details begin with the first stored update.</p>\n<p>No patch applied. The source picture has <code>64</code> board cells and <code>8</code> footer cells.</p>\n<p>The controls inspect stored moves and patches. This page does not calculate chess rules or generate\nlegal moves.</p>\n<p>abcdefgh</p>\n<p>87654321</p>\n<p>After ply <code>1</code> · d2→d4</p>\n<p>abcdefgh</p>\n<p>87654321</p>\n<p>After ply <code>19</code> · first side castles</p>\n<p>abcdefgh</p>\n<p>87654321</p>\n<p>After ply <code>52</code> · final carried board</p>\n<p>The three checkpoints show selected states without interaction. Across <code>64</code> games, the artifact stores\n<code>6,890</code> plies and <code>6,954</code> initial-or-updated board states. The game records contain\nno names, dates, opening labels or commentary.</p>\n<p>The player displays castling, promotion and en passant by applying their stored cell changes. Interpreting\nmove words or deciding whether a new move is legal requires the rules taught by the course. The picture player does neither.</p>\n<hr />\n<h2 id=\"before-you-go\">Before you go</h2>\n<p>Getting from a square of bits to a game takes patience. Thank you for giving so much of your time and attention.</p>\n<p>If something is unclear, seems wrong, or could be explained better, please\n<a href=\"https://artemlegotin.com/\" rel=\"nofollow ugc noopener\">let me know</a>. Questions, corrections and other ideas\nare welcome, whether they concern the Golden Board itself or this guide.</p>\n<p>You&#39;re also welcome to build on the\n<a href=\"https://github.com/arlegotin/golden-board\" rel=\"nofollow ugc noopener\">source code</a>. Try another subject, another way of teaching it, or a different experiment.</p>\n<p>If you share or adapt the project, or use it in research, please credit and link the original work; the repository includes a\n<a href=\"https://github.com/arlegotin/golden-board#license\" rel=\"nofollow ugc noopener\">BibTeX citation</a>.</p>\n<p>I&#39;d love to see what you make from it.</p>\n<p><a href=\"https://artemlegotin.com/\" rel=\"nofollow ugc noopener\">Artem Legotin</a></p>","headings":[{"level":1,"text":"Golden Board","id":"golden-board"},{"level":2,"text":"Intro","id":"intro"},{"level":3,"text":"What does it look like?","id":"what-does-it-look-like"},{"level":3,"text":"What’s inside?","id":"what-s-inside"},{"level":3,"text":"Where did the idea come from?","id":"where-did-the-idea-come-from"},{"level":3,"text":"Why chess?","id":"why-chess"},{"level":3,"text":"How did I test it?","id":"how-did-i-test-it"},{"level":3,"text":"How did I choose the games?","id":"how-did-i-choose-the-games"},{"level":3,"text":"What is it all for?","id":"what-is-it-all-for"},{"level":3,"text":"Can you build on it?","id":"can-you-build-on-it"},{"level":2,"text":"How to read this guide","id":"how-to-read-this-guide"},{"level":2,"text":"Reading numbers and pictures","id":"reading-numbers-and-pictures"},{"level":3,"text":"Headers show order and related groups","id":"headers-show-order-and-related-groups"},{"level":3,"text":"Frame 1 of 32: Read numbers by counting","id":"frame-1-of-32-read-numbers-by-counting"},{"level":3,"text":"Frame 2 of 32: Identify each bit position","id":"frame-2-of-32-identify-each-bit-position"},{"level":3,"text":"Frame 3 of 32: Read a picture’s dimensions and complement","id":"frame-3-of-32-read-a-picture-s-dimensions-and-complement"},{"level":3,"text":"Frame 4 of 32: Establish row order","id":"frame-4-of-32-establish-row-order"},{"level":3,"text":"Frame 5 of 32: Group eight bits into a byte","id":"frame-5-of-32-group-eight-bits-into-a-byte"},{"level":3,"text":"Frame 6 of 32: Combine high and low bytes","id":"frame-6-of-32-combine-high-and-low-bytes"},{"level":3,"text":"Frame 7 of 32: Read dimensions and used payload length","id":"frame-7-of-32-read-dimensions-and-used-payload-length"},{"level":2,"text":"Checking the recovered bytes","id":"checking-the-recovered-bytes"},{"level":3,"text":"Frame 8 of 32: Define XOR and equality","id":"frame-8-of-32-define-xor-and-equality"},{"level":3,"text":"Frame 9 of 32: Shift right and keep the outgoing bit","id":"frame-9-of-32-shift-right-and-keep-the-outgoing-bit"},{"level":3,"text":"Frame 10 of 32: Identify the checksum’s fixed patterns","id":"frame-10-of-32-identify-the-checksum-s-fixed-patterns"},{"level":3,"text":"Frame 11 of 32: Start the checksum and XOR a byte","id":"frame-11-of-32-start-the-checksum-and-xor-a-byte"},{"level":3,"text":"Frame 12 of 32: Follow all eight bit rounds","id":"frame-12-of-32-follow-all-eight-bit-rounds"},{"level":3,"text":"Frame 13 of 32: Finish and store the checksum","id":"frame-13-of-32-finish-and-store-the-checksum"},{"level":3,"text":"Frame 14 of 32: Compare computed and stored checks","id":"frame-14-of-32-compare-computed-and-stored-checks"},{"level":2,"text":"Finding sections and documents","id":"finding-sections-and-documents"},{"level":3,"text":"Frame 15 of 32: Partition a complete section","id":"frame-15-of-32-partition-a-complete-section"},{"level":3,"text":"Frame 16 of 32: Map payload addresses to square cells","id":"frame-16-of-32-map-payload-addresses-to-square-cells"},{"level":3,"text":"Frame 17 of 32: Preserve rectangular and empty rows","id":"frame-17-of-32-preserve-rectangular-and-empty-rows"},{"level":3,"text":"Frame 18 of 32: Name objects and count their references","id":"frame-18-of-32-name-objects-and-count-their-references"},{"level":3,"text":"Frame 19 of 32: Check the miniature’s actual section","id":"frame-19-of-32-check-the-miniature-s-actual-section"},{"level":3,"text":"Carry the checksum across a sequence of bytes","id":"carry-the-checksum-across-a-sequence-of-bytes"},{"level":3,"text":"Frame 20 of 32: Read a complete inventory section","id":"frame-20-of-32-read-a-complete-inventory-section"},{"level":3,"text":"Frame 21 of 32: Read inventory counts and entry references","id":"frame-21-of-32-read-inventory-counts-and-entry-references"},{"level":2,"text":"Reading the five record types","id":"reading-the-five-record-types"},{"level":3,"text":"Frame 22 of 32: Read a document header and rectangular glyphs","id":"frame-22-of-32-read-a-document-header-and-rectangular-glyphs"},{"level":3,"text":"Frame 23 of 32: Build a frame from glyph IDs","id":"frame-23-of-32-build-a-frame-from-glyph-ids"},{"level":3,"text":"Frame 24 of 32: Apply ordered partial updates","id":"frame-24-of-32-apply-ordered-partial-updates"},{"level":3,"text":"Frame 25 of 32: Define an exercise page","id":"frame-25-of-32-define-an-exercise-page"},{"level":3,"text":"Frame 26 of 32: Show the two concrete feedback results","id":"frame-26-of-32-show-the-two-concrete-feedback-results"},{"level":3,"text":"Frame 27 of 32: Select, reset and commit a response","id":"frame-27-of-32-select-reset-and-commit-a-response"},{"level":3,"text":"Frame 28 of 32: Follow feedback and passive routes","id":"frame-28-of-32-follow-feedback-and-passive-routes"},{"level":3,"text":"Frame 29 of 32: Read the complete miniature section","id":"frame-29-of-32-read-the-complete-miniature-section"},{"level":3,"text":"Frame 30 of 32: Read a numeric table","id":"frame-30-of-32-read-a-numeric-table"},{"level":2,"text":"Using the bootstrap to read the payload","id":"using-the-bootstrap-to-read-the-payload"},{"level":3,"text":"Frame 31 of 32: Locate consecutive sections and their boundary","id":"frame-31-of-32-locate-consecutive-sections-and-their-boundary"},{"level":3,"text":"Frame 32 of 32: Find the used end and verify zero reserve","id":"frame-32-of-32-find-the-used-end-and-verify-zero-reserve"},{"level":3,"text":"Recovering and validating the payload","id":"recovering-and-validating-the-payload"},{"level":2,"text":"From payload bits to a displayed picture","id":"from-payload-bits-to-a-displayed-picture"},{"level":3,"text":"Find the document and read its declared entry","id":"find-the-document-and-read-its-declared-entry"},{"level":3,"text":"Read the records, then follow their names","id":"read-the-records-then-follow-their-names"},{"level":3,"text":"Read the frame as a grid of glyph references","id":"read-the-frame-as-a-grid-of-glyph-references"},{"level":3,"text":"Look up the bitmap and put it in the cell","id":"look-up-the-bitmap-and-put-it-in-the-cell"},{"level":2,"text":"Learning chess from the payload","id":"learning-chess-from-the-payload"},{"level":3,"text":"Identifying the question and its answer","id":"identifying-the-question-and-its-answer"},{"level":3,"text":"Controlled squares and legal moves","id":"controlled-squares-and-legal-moves"},{"level":3,"text":"Learning how moves are packed","id":"learning-how-moves-are-packed"},{"level":2,"text":"Following one move from source to display","id":"following-one-move-from-source-to-display"},{"level":3,"text":"1. Produce the move word and display patch","id":"1-produce-the-move-word-and-display-patch"},{"level":3,"text":"2. Store the document in a checked section","id":"2-store-the-document-in-a-checked-section"},{"level":3,"text":"3. Recover and validate document 2","id":"3-recover-and-validate-document-2"},{"level":3,"text":"4. Locate and read the first move word","id":"4-locate-and-read-the-first-move-word"},{"level":3,"text":"5. Interpret the move fields","id":"5-interpret-the-move-fields"},{"level":3,"text":"6. Apply the stored patch","id":"6-apply-the-stored-patch"},{"level":2,"text":"Why board positions need history","id":"why-board-positions-need-history"},{"level":3,"text":"Castling moves two pieces","id":"castling-moves-two-pieces"},{"level":3,"text":"En passant depends on the immediately preceding move","id":"en-passant-depends-on-the-immediately-preceding-move"},{"level":3,"text":"Promotion needs a separate choice","id":"promotion-needs-a-separate-choice"},{"level":3,"text":"History is part of the state","id":"history-is-part-of-the-state"},{"level":3,"text":"When a game ends","id":"when-a-game-ends"},{"level":2,"text":"Tactics, mating and strategic guidance","id":"tactics-mating-and-strategic-guidance"},{"level":2,"text":"Replaying a complete game","id":"replaying-a-complete-game"},{"level":3,"text":"Initial frame 256","id":"initial-frame-256"},{"level":2,"text":"Before you go","id":"before-you-go"}]}}