# What you get back — honest expectations, from a measured proof

Decompilers are not time machines. This page says exactly what survives
compilation and what doesn't, graded from the sweep's own proof run
(2026-10-23, artifacts and outputs in proof.md): three small programs
written for the test, compiled, and read back with four verified tools.

## What comes back — reliably

- **The logic.** Every branch, loop, and calculation. In the proof, a
  quote calculator's discount rule — 10% off labor at 3+ prior visits,
  a 1.5× rush multiplier, round to cents — came back exactly, from all
  four tools, in all three languages tested.
- **The numbers.** Constants are baked into a build; they read back
  verbatim: 85.0 (hourly rate), 0.10, 1.5, the threshold 3. If your
  program's rules live in constants — prices, limits, timings — they
  are recoverable.
- **The words.** Strings the program shows users survive word-for-word
  ("Quote total: $" in the proof), along with file paths, URLs, and
  format strings embedded in the build.
- **The shape.** Classes and functions keep their boundaries; named
  constants declared in the source (Java/.NET) can keep their names —
  both Java decompilers in the proof returned `LABOR_RATE_PER_HOUR`,
  `LOYALTY_DISCOUNT`, and `RUSH_MULTIPLIER` by name.

## What does not come back

- **Variable and parameter names** (in native and WebAssembly builds, and
  for locals everywhere). `laborHours` returns as `b`, `var3`, `param_2`.
  The *values and uses* are all there; the labels are gone. That's why the
  workflow prompt has the AI propose names tagged [INFERRED] instead of
  pretending.
- **Comments.** Compilers erase them entirely. Nothing recovers a comment.
- **Your file organization and formatting.** A decompiler emits its own
  layout. Structure (functions, classes) survives; presentation doesn't.
- **Certainty.** Recovered code is a faithful reading of what the build
  *does*, reconstructed by a tool that can occasionally misread exotic
  constructs. Treat it as a very good map, not the territory: test any
  rebuild against the original build's behavior.

## The graded proof, in one breath

Same small program, four routes — **CFR (MIT)** and **Vineflower
(Apache-2.0)** on the Java build: near-total recovery, constants named,
logic identical, comments and local names gone. **Ghidra (Apache-2.0)**
headless on the stripped native build: functions, logic, constants, and
strings recovered from a binary with no symbol names at all. **WABT
(Apache-2.0)** on the WebAssembly build: the whole rule readable in six
lines; names reduced to single letters. Full commands and outputs:
proof.md.