Intel Arc Puzzle 71

OpenCL solver for Bitcoin Puzzle 71, built to run on Intel Arc GPUs.

Developed and measured on an Intel Arc A770. The same binary targets the Intel Arc family: Alchemist (A380 / A580 / A750 / A770), Battlemage consumer cards (B570 / B580), and workstation Arc Pro B70 — anything the Intel NEO OpenCL driver lists as a GPU.

One sentence: the program asks the Intel GPU to try private keys inside a public, deliberately short range. If one key hashes to the puzzle address, it writes that key to a file. Those coins are then spendable.

This is not a miner. This is not a wallet. It does not “unlock random Bitcoin.” It only works on this puzzle style. A normal Bitcoin key is 256 bits and is not guessable.

---

How to start (do this)

Windows blocks .ps1 scripts. Do not run run_puzzle.ps1. Use the .cmd file.

1. Open PowerShell or Command Prompt.
2. Go to the project folder (the directory that contains README.md):

cd path\to\intel-arc-puzzle-71

3. Start Puzzle 71 on Intel Arc device 0 (the A770 on this PC):

.\scripts\run_puzzle.cmd -Name puzzle71 -Device 0

Default visit order is random-blocks: the (2^{70}) range is cut into chunks of (2^{40}) keys (~2.6 hours each at 116 MKey/s). Chunks are visited in a secret permutation (saved seed) so this GPU is not stuck on the prefix everyone else scans. Other modes: start, end, outward (from the middle, left/right), inward (both ends toward the center).

.\scripts\run_puzzle.cmd -Name puzzle71 -Device 0 -Mode outward

Leave that window open. First start of a chunk spends ~30–40 seconds building starting points, then a status line with MKey/s appears.

Ctrl+C stops the hunt. Progress is saved. Run the same command (same -Mode) and it resumes from the last bookmark — it does not restart Puzzle 71 from zero and it does not reshuffle chunks (same seed). You lose at most about one minute of GPU work (BitCrack writes the in-chunk bookmark every ~60 seconds, not at the exact Ctrl+C instant). If you stop in the first minute of a new chunk, that chunk restarts from its beginning. Do not pass -Reset and do not change -Mode, or you start a new hunt and throw the old one away.

If the key is found, the window does not stay quiet. BitCrack prints that it wrote a file, then the launcher shows a FOUND THE KEY banner and the path results\puzzle71.txt. Open that file on this PC. The private key is not repeated in the console (so it is less likely to land in a screenshot). Until that banner and file exist, nothing was found.

Optional check that the GPU is visible:

.\bin\clBitCrack.exe --list-devices

Use the ID of the line that says Intel Arc, not the CPU and not FPGA.

---

The Bitcoin Puzzle (background)

In January 2015 an anonymous user (often cited as saatoshi_rising) funded a public challenge. Real bitcoin went to many addresses, each locked by a private key shorter than a real wallet key:

• Puzzle 1 → 1-bit range (trivial)
• Puzzle 2 → 2-bit range
• …
• Puzzle 71 → 71-bit range ((2^{70}) candidates, about 1.18 sextillion)

The first transaction funded 256 addresses and only ~33 BTC. In July 2017 the creator moved coins from puzzles 161–256 onto 53–160, raising prizes about 10×. That is why people say “1000 BTC Challenge.”

Puzzles 1–70 are solved. 71 is the easiest unsolved address-only target (no public key on-chain). It holds about 7.1 BTC.

Puzzle 71 address (check on any explorer):

1PWo3JeB9jrGwfHDNpdGK54CRas7fsVzXU

Whoever finds that private key can move the coins. There is no referee and no payout website. The key is the prize.

Sources: privatekeys.pw, btcpuzzle.info, original tx 08389f34c98c606322740c0be6a7125d9860bb8d5cb182c02f98461e5fa6cd15.

---

What this program does

1. Uses the Intel GPU through OpenCL (the compute API Arc supports). Not CUDA — CUDA is NVIDIA-only.
2. Walks the puzzle 71 range (0x4000…000 … 0x7fff…fff) in chunks. Default order is a secret permutation (random-blocks), not “always from the first key.”
3. For each candidate it builds a compressed Bitcoin address and compares it to 1PWo3JeB9jrGwfHDNpdGK54CRas7fsVzXU.
4. On mismatch the candidate is discarded. There is no list of “keys already tried” — that list would not fit on disk.
5. About every 60 seconds it writes a bookmark only: “resume from this key next time.”
6. On a match it writes one plaintext line to results/puzzle71.txt and stops.

The engine is BitCrack OpenCL (clBitCrack), built for Windows and patched in this repo. One host-side bug made the program think the range was finished too early and skip the real key. See third_party/PATCHES.md.

Measured on this Intel Arc A770 at default grid: about 116 million keys per second. At that rate puzzle 71 is, on average, hundreds of thousands of years. This is an honest lottery on Intel silicon CUDA tools ignore — not a plan to cash the prize.

Correctness checks (old puzzles; keys already public):

Puzzle	Range	Recovered
20	80000 … fffff	d2c55
32	80000000 … ffffffff	b862a62e

---

Intel Arc GPUs — including Arc Pro B70

The code does not hard-code the A770. It talks to whatever Intel OpenCL GPU the driver exposes.

Intel GPU	Status
Arc A770	Verified here (OpenCL device 0, ~116 MKey/s)
Other Alchemist: A750, A580, A380	Same binary. Slower in proportion to Xe-cores / EU count
Battlemage consumer: B570, B580	Expected to work if --list-devices shows them. Intel NEO has OpenCL support for Xe2
Arc Pro B70 (and B65)	Same Battlemage / Xe2 family, launched 2026, 32 Xe-cores and 32 GB on B70. Expected to work with current Intel Graphics + OpenCL (NEO) drivers. Not tested on this PC. More Xe-cores and VRAM than the A770, so it should be as fast or faster once the driver is current
Arc iGPU (laptop)	Often visible in OpenCL; much slower
NVIDIA	No. Use CUDA BitCrack, not this build
AMD	The same .exe might see an OpenCL device; untested

Arc Pro B70 in practice: install the latest Intel Arc Pro / Graphics driver so Intel(R) OpenCL Graphics lists Arc Pro B70. Then:

.\bin\clBitCrack.exe --list-devices
.\scripts\run_puzzle.cmd -Name puzzle71 -Device 0

Pick the Intel Arc GPU row, not the CPU runtime and not “FPGA Emulation”. -Threads must be a multiple of 32. If VRAM is tight, lower -Blocks and -Points. Speed changes; the search math does not.

A new Intel GPU only fails if the driver does not expose OpenCL, or if a future OpenCL compiler breaks BitCrack’s kernels. That is a driver/runtime issue, not an A770 lock-in.

---

Requirements

• Windows
• An Intel Arc GPU (discrete A-series, B-series, or Arc Pro) plus a recent Intel graphics driver (OpenCL / NEO included)
• To rebuild: Visual Studio 2022 C++ Build Tools and Intel oneAPI (OpenCL headers and OpenCL.lib)

Reference hardware used for the A770 numbers: Intel Arc A770 16 GB, OpenCL 3.0 NEO. If the CPU also appears as an OpenCL device, do not use it for the hunt.

---

Other commands

Puzzle 71 start is in How to start above. Other useful commands from C:\Bipot:

# list Intel OpenCL devices
.\bin\clBitCrack.exe --list-devices

# known-answer test (must recover puzzle 20)
.\scripts\run_puzzle.cmd -Name puzzle20 -Blocks 8 -Threads 64 -Points 1

# Puzzle 71 with an explicit order (default is random-blocks)
.\scripts\run_puzzle.cmd -Name puzzle71 -Device 0 -Mode outward

# rebuild after C++ changes
.\scripts\build_clbitcrack.cmd

If you insist on .ps1 (Windows will error unless you change policy):

powershell -ExecutionPolicy Bypass -File .\scripts\run_puzzle.ps1 -Name puzzle71 -Device 0
Set-ExecutionPolicy -Scope CurrentUser RemoteSigned

Ctrl+C stops. The same command resumes from the checkpoint.

Default grid for puzzle 71: -b 256 -t 256 -p 16

• -b blocks
• -t threads per block (multiple of 32)
• -p keys each thread handles per step

Raising -p usually increases MKey/s and memory use. Log the numbers when you tune.

---

Checkpoints (always on)

A hunt this long must save progress. There is no mode without a checkpoint.

results/puzzle71.hunt.json — which chunks, which order

Mode, random seed, how many chunks are done (i), current chunk id. No private keys.

results/chunks/puzzle71_c<id>.ckpt — BitCrack bookmark inside a chunk

The next key inside the current (2^{40}) block. No private keys. Ctrl+C or a crash loses at most about one minute of GPU work (last in-chunk write is on a ~60 s timer).

“Already tried” = finished chunks plus keys before next= in the current chunk. Keys are not stored one-by-one. Resume = same command, same -Mode.

results/puzzle71.txt — only if you win

Created by --out. Appears only on a match. One line:

<bitcoin address> <private key hex> <compressed public key>

Real example (puzzle 20, emptied years ago):

1HsMJxNiV7TLxmoF6uJNkydxPFDog4NQum 0000…000D2C55 033C4A45CBD6…

That hex is control of the coins. Anyone who reads the file can spend them. Do not paste it into chat, mail, cloud, or online converters.

If puzzle71.txt does not exist, nothing was found. The .ckpt file only records how far the scan went.

---

If you find the key (beginner path)

Bitcoin has no helpdesk. The address is a lock; the private key is the only key. Importing it into a wallet is copying that key onto your keyring. Then you can send the coins to an address you already own.

A — hex → WIF (on this PC; unplug the network if you can)

Wallets want WIF (a K… / L… string), not raw hex. Puzzle 71 is a compressed P2PKH address. The wrong compression flag yields a different address and a zero balance.

python .\tools\hex_to_wif.py 00000000000000000000000000000000000000000000000000000000000D2C55

Use the hex from the second field of results/puzzle71.txt. The script never talks to the network.

B — empty wallet

1. Install Electrum or Sparrow from the official site.
2. Create a new, empty wallet.
3. Import the WIF (Private keys → Import).
4. You must see exactly
   1PWo3JeB9jrGwfHDNpdGK54CRas7fsVzXU
   and the balance (~7.1 BTC, plus any extra UTXOs).
5. Prepare a destination address you control before you spend.

C — one transaction

Send everything to that destination. High fee (next block). Do not send a “test” amount first.

Why speed and a private channel matter

Spending publishes the public key. Puzzle 71 is only 70 unknown bits: from pubkey → private key, other solvers (Kangaroo) need minutes. Puzzles 66 and 69 were stolen that way: a watcher sees your tx in the public mempool, recomputes the key, and replaces you with a higher fee.

So:

• never paste the key into explorers, Telegram, or web “hex to WIF” tools;
• sign offline and broadcast through a private path (your node, a miner, something like Slipstream) rather than a public “broadcast and pray”;
• do not leave coins on the puzzle address “for later.”

Until you spend, puzzle 71’s public key is not on-chain. Everyone else is brute-forcing, same as you.

---

Layout

Path	Role
bin/clBitCrack.exe	solver binary
scripts/run_puzzle.cmd	start / resume a hunt (use this on Windows)
scripts/build_clbitcrack.cmd	rebuild clBitCrack.exe
tools/hex_to_wif.py	local hex → WIF
puzzles/targets.json	addresses and ranges
results/	local only: bookmarks and a hit file (not in git)
third_party/BitCrack/	patched upstream tree
third_party/PATCHES.md	what we changed
docs/github-social.png	1280×640 image for GitHub Settings → General → Social preview
LICENSE	MIT for this project’s own files
THIRD_PARTY.md	BitCrack and other dependencies

GitHub social preview (after you publish): Settings → General → Social preview → upload docs/github-social.png (1280×640).

---

Honest odds

(2^{70}) keys. ~116 MKey/s on one A770. Expected time ~3×10⁵ years. A million similar GPUs is still months. Puzzles 66–70 were cracked with farms of NVIDIA cards, not a single desktop.

Intel Arc Puzzle 71 exists so Intel GPUs (A770, other Arc, and likely B70) can join a verified OpenCL hunt with a resume file. It does not promise the prize.

---

License

This project’s own files (launcher, docs, hunt scripts) are MIT. See LICENSE.

The GPU solver is BitCrack by Ben Richard, also MIT, vendored under third_party/BitCrack/ with local patches. Keep third_party/BitCrack/LICENSE.MIT if you redistribute the source or bin/clBitCrack.exe. Full list: THIRD_PARTY.md.