60 Consecutive Picks

A Merkle root is a 32-byte hash, usually displayed as 64 hexadecimal characters, that acts as a unique fingerprint for an entire dataset. If you change even a single bit anywhere in the trillion bracket dataset, this number changes completely.

Before the tournament began, I published this root to the Ethereum blockchain. Ethereum is a public ledger that permanently timestamps every transaction. No one, not even me, can go back and change what was posted. This proves the dataset existed before any games were played.

This is the Merkle root, the fingerprint of all 1,000,000,000,000 brackets.

A hash function takes any amount of data and produces a fixed-size fingerprint. The key property is that changing even one bit of input changes the output completely. There is no way to predict what the new output will be, you have to compute it.

Try it yourself. Below are 8 bits. Click any one to flip it and watch the SHA-256 hash change entirely.

The actual dataset uses BLAKE3, a modern hash function that is faster but has the same properties. The fingerprint of the trillion brackets works the same way: change one bracket, change the root.

The trillion brackets are stored as raw binary data, 8 trillion bytes total. This data is divided into 953,754 chunks of up to 8,388,608 bytes each (8 MiB, about 1 million brackets per chunk).

Each chunk is hashed with BLAKE3, using a special 0x00 byte prefix (this prevents a security issue called a second preimage attack). The result is the chunk's leaf hash, its unique fingerprint.

If any bracket in this chunk were different, even by a single game outcome, this hash would be completely different.

A Merkle tree organizes all 953,754 chunk hashes into a binary tree. At the bottom are the leaf hashes, one per chunk. Each pair of hashes is combined to produce a parent hash, and this continues up until there is a single hash left at the top, the Merkle root.

To prove our chunk belongs to the tree, we do not need all 953,754 hashes. We only need 20 sibling hashes, one per level. At each level, we combine our computed hash with the sibling hash to get the parent, then repeat. If the final hash matches the published root, the proof is valid.

Below is every single computation, from our leaf hash all the way up to the root. At each level, you can see which hash is ours, which is the sibling, and how they combine.

After walking all 20 levels, we arrive at a final hash. If it matches the Merkle root published on Ethereum before the tournament, the proof is complete. This chunk, and the bracket inside it, provably existed in the dataset before any games were played.

We have proven the chunk is authentic. Now we need to find our specific bracket inside it. Each bracket is stored as a uint64, an 8-byte unsigned integer in little-endian byte order. This chunk is 8,388,608 bytes (8 MiB), so it contains exactly 1,048,576 brackets (8,388,608 / 8 bytes per bracket).

Our bracket sits at a known position:

Reading 8 bytes at that offset and interpreting them as a little endian uint64 gives us the bracket's numeric value. Converting that integer to binary gives us the 63 bit string, where each bit is one game outcome.

Each of the 63 bits represents one game in the tournament. 0 means the first team listed wins, 1 means the second team wins. The bits are ordered: Round of 64 first (32 games), then Round of 32 (16 games), Sweet 16 (8), Elite 8 (4), Final Four (2), and Championship (1).

Here is every game this bracket predicts, decoded from the bits above:

The 63 bit string maps directly to a visual bracket. The bracket starts with 64 teams arranged in a standard NCAA tournament bracket, 4 regions of 16 teams each. The first 32 bits determine Round 1 winners, advancing teams to the next column. The next 16 bits determine Round 2, and so on, narrowing the field until one team remains.

Here is how the bit positions map to the bracket structure:

Each bit determines which team advances to the next column of the bracket. A 0 means the first-listed team wins. A 1 means the second-listed team wins. In Round 1, the first-listed team is always the higher seed. In later rounds, the first-listed team is simply the winner from the earlier matchup in the pair. Winners feed into the next round's matchups automatically, so the bracket builds itself from the bits.

The bracket visualization below is generated directly from the 63-bit string using the same SVG generator used across the entire site. Green pills are teams still alive; red pills are eliminated teams.