Understand the failure.
Verify the repair.
Small, reproducible software failures. The broken implementation, the fix that didn’t work, and the one that passed—preserved together.
Explore the cases ↓How results are verified ↗WHAT THE ARCHIVE CONTAINS
100840 executable cases. 20168 are open.
Every case records the implementation that fails, the fix that did not work, and the repair that passed its checks—with recorded outputs and source hashes. This release adds 100840 cases across 20168 failure mechanisms and 254 domains.
The open tier gives you the failure and the unsuccessful fix for one case in every mechanism. The remaining 80672 cases, 5 variants per mechanism, are member-only: the verified repair, its recorded checks, and the full fixture suite are held in the member archive. Read the methodology ↗
A RECORD OF WHAT WENT WRONG
Browse the archive / 100840
Operand-size prefix treated as address-size · case 01
Immediates after a 0x66 prefix are decoded as 4 bytes.
Operand-size prefix treated as address-size · case 02
Immediates after a 0x66 prefix are decoded as 4 bytes.
Operand-size prefix treated as address-size · case 03
Immediates after a 0x66 prefix are decoded as 4 bytes.
Operand-size prefix treated as address-size · case 04
Immediates after a 0x66 prefix are decoded as 4 bytes.
Operand-size prefix treated as address-size · case 05
Immediates after a 0x66 prefix are decoded as 4 bytes.
Sign-extended imm8 form decoded with a full immediate · case 01
Opcode 0x83 swallows three extra bytes.
Sign-extended imm8 form decoded with a full immediate · case 02
Opcode 0x83 swallows three extra bytes.
Sign-extended imm8 form decoded with a full immediate · case 03
Opcode 0x83 swallows three extra bytes.
Sign-extended imm8 form decoded with a full immediate · case 04
Opcode 0x83 swallows three extra bytes.
Sign-extended imm8 form decoded with a full immediate · case 05
Opcode 0x83 swallows three extra bytes.
16-bit addressing decoded with 32-bit rules · case 01
ModRM operands under the 0x67 prefix get SIB and disp32 lengths.
16-bit addressing decoded with 32-bit rules · case 02
ModRM operands under the 0x67 prefix get SIB and disp32 lengths.
16-bit addressing decoded with 32-bit rules · case 03
ModRM operands under the 0x67 prefix get SIB and disp32 lengths.
16-bit addressing decoded with 32-bit rules · case 04
ModRM operands under the 0x67 prefix get SIB and disp32 lengths.
16-bit addressing decoded with 32-bit rules · case 05
ModRM operands under the 0x67 prefix get SIB and disp32 lengths.
Second opcode byte not consumed · case 01
Two-byte opcodes are one byte short and the second opcode byte is read as ModRM.
Second opcode byte not consumed · case 02
Two-byte opcodes are one byte short and the second opcode byte is read as ModRM.
Second opcode byte not consumed · case 03
Two-byte opcodes are one byte short and the second opcode byte is read as ModRM.
Second opcode byte not consumed · case 04
Two-byte opcodes are one byte short and the second opcode byte is read as ModRM.
Second opcode byte not consumed · case 05
Two-byte opcodes are one byte short and the second opcode byte is read as ModRM.
Auxiliary carry ignores the carry-in · case 01
A low digit sum that only exceeds 15 because of the carry-in is not adjusted.
Auxiliary carry ignores the carry-in · case 02
A low digit sum that only exceeds 15 because of the carry-in is not adjusted.
Auxiliary carry ignores the carry-in · case 03
A low digit sum that only exceeds 15 because of the carry-in is not adjusted.
Auxiliary carry ignores the carry-in · case 04
A low digit sum that only exceeds 15 because of the carry-in is not adjusted.
Auxiliary carry ignores the carry-in · case 05
A low digit sum that only exceeds 15 because of the carry-in is not adjusted.
High-digit adjust tests the already adjusted value · case 01
A low-digit adjust that pushes the byte past 0x99 triggers a spurious +0x60.
High-digit adjust tests the already adjusted value · case 02
A low-digit adjust that pushes the byte past 0x99 triggers a spurious +0x60.
High-digit adjust tests the already adjusted value · case 03
A low-digit adjust that pushes the byte past 0x99 triggers a spurious +0x60.
High-digit adjust tests the already adjusted value · case 04
A low-digit adjust that pushes the byte past 0x99 triggers a spurious +0x60.
High-digit adjust tests the already adjusted value · case 05
A low-digit adjust that pushes the byte past 0x99 triggers a spurious +0x60.
Decimal carry derived from 8-bit overflow of the adjust · case 01
A high-digit adjust that stays below 0x100 loses the decimal carry.
Decimal carry derived from 8-bit overflow of the adjust · case 02
A high-digit adjust that stays below 0x100 loses the decimal carry.
Decimal carry derived from 8-bit overflow of the adjust · case 03
A high-digit adjust that stays below 0x100 loses the decimal carry.
Decimal carry derived from 8-bit overflow of the adjust · case 04
A high-digit adjust that stays below 0x100 loses the decimal carry.
Decimal carry derived from 8-bit overflow of the adjust · case 05
A high-digit adjust that stays below 0x100 loses the decimal carry.
Low-digit adjust ignores the auxiliary carry · case 01
0x09 + 0x09 yields 0x12 instead of 0x18.
Low-digit adjust ignores the auxiliary carry · case 02
0x09 + 0x09 yields 0x12 instead of 0x18.
Low-digit adjust ignores the auxiliary carry · case 03
0x09 + 0x09 yields 0x12 instead of 0x18.
Low-digit adjust ignores the auxiliary carry · case 04
0x09 + 0x09 yields 0x12 instead of 0x18.
Low-digit adjust ignores the auxiliary carry · case 05
0x09 + 0x09 yields 0x12 instead of 0x18.
Decimal carry not propagated between bytes · case 01
Multi-byte BCD sums lose the carry from each lower byte.
Decimal carry not propagated between bytes · case 02
Multi-byte BCD sums lose the carry from each lower byte.
Decimal carry not propagated between bytes · case 03
Multi-byte BCD sums lose the carry from each lower byte.
Decimal carry not propagated between bytes · case 04
Multi-byte BCD sums lose the carry from each lower byte.
Decimal carry not propagated between bytes · case 05
Multi-byte BCD sums lose the carry from each lower byte.
INC half carry tested on the result nibble · case 01
Incrementing 0x0F leaves H clear and incrementing 0x0E sets it.
INC half carry tested on the result nibble · case 02
Incrementing 0x0F leaves H clear and incrementing 0x0E sets it.
INC half carry tested on the result nibble · case 03
Incrementing 0x0F leaves H clear and incrementing 0x0E sets it.
INC half carry tested on the result nibble · case 04
Incrementing 0x0F leaves H clear and incrementing 0x0E sets it.
INC half carry tested on the result nibble · case 05
Incrementing 0x0F leaves H clear and incrementing 0x0E sets it.
INC updates the carry flag · case 01
Incrementing 0xFF sets carry, clobbering a carry from an earlier add.
INC updates the carry flag · case 02
Incrementing 0xFF sets carry, clobbering a carry from an earlier add.
INC updates the carry flag · case 03
Incrementing 0xFF sets carry, clobbering a carry from an earlier add.
INC updates the carry flag · case 04
Incrementing 0xFF sets carry, clobbering a carry from an earlier add.
INC updates the carry flag · case 05
Incrementing 0xFF sets carry, clobbering a carry from an earlier add.
DEC half borrow uses the increment rule · case 01
Decrementing 0x10 leaves H clear.
DEC half borrow uses the increment rule · case 02
Decrementing 0x10 leaves H clear.
DEC half borrow uses the increment rule · case 03
Decrementing 0x10 leaves H clear.
DEC half borrow uses the increment rule · case 04
Decrementing 0x10 leaves H clear.
DEC half borrow uses the increment rule · case 05
Decrementing 0x10 leaves H clear.
SUB half borrow set on equal nibbles · case 01
Subtracting a value with the same low nibble sets H.
SUB half borrow set on equal nibbles · case 02
Subtracting a value with the same low nibble sets H.
SUB half borrow set on equal nibbles · case 03
Subtracting a value with the same low nibble sets H.
SUB half borrow set on equal nibbles · case 04
Subtracting a value with the same low nibble sets H.
SUB half borrow set on equal nibbles · case 05
Subtracting a value with the same low nibble sets H.
DEC overflow flagged one step late · case 01
PV is set when decrementing 0x81 to 0x80 instead of 0x80 to 0x7F.
DEC overflow flagged one step late · case 02
PV is set when decrementing 0x81 to 0x80 instead of 0x80 to 0x7F.
DEC overflow flagged one step late · case 03
PV is set when decrementing 0x81 to 0x80 instead of 0x80 to 0x7F.
DEC overflow flagged one step late · case 04
PV is set when decrementing 0x81 to 0x80 instead of 0x80 to 0x7F.
DEC overflow flagged one step late · case 05
PV is set when decrementing 0x81 to 0x80 instead of 0x80 to 0x7F.
SUB overflow computed with the ADD formula · case 01
Subtracting a negative from a positive that overflows is not flagged, and harmless subtractions are.
SUB overflow computed with the ADD formula · case 02
Subtracting a negative from a positive that overflows is not flagged, and harmless subtractions are.
SUB overflow computed with the ADD formula · case 03
Subtracting a negative from a positive that overflows is not flagged, and harmless subtractions are.
SUB overflow computed with the ADD formula · case 04
Subtracting a negative from a positive that overflows is not flagged, and harmless subtractions are.
SUB overflow computed with the ADD formula · case 05
Subtracting a negative from a positive that overflows is not flagged, and harmless subtractions are.
Page table index taken from the wrong bits · case 01
Translations use a PTE selected partly by page-offset bits.
Page table index taken from the wrong bits · case 02
Translations use a PTE selected partly by page-offset bits.
Page table index taken from the wrong bits · case 03
Translations use a PTE selected partly by page-offset bits.
Page table index taken from the wrong bits · case 04
Translations use a PTE selected partly by page-offset bits.
Page table index taken from the wrong bits · case 05
Translations use a PTE selected partly by page-offset bits.
Directory permissions ignored · case 01
A user or write access succeeds through a supervisor-only or read-only directory entry.
Directory permissions ignored · case 02
A user or write access succeeds through a supervisor-only or read-only directory entry.
Directory permissions ignored · case 03
A user or write access succeeds through a supervisor-only or read-only directory entry.
Directory permissions ignored · case 04
A user or write access succeeds through a supervisor-only or read-only directory entry.
Directory permissions ignored · case 05
A user or write access succeeds through a supervisor-only or read-only directory entry.
Protection fault reported as not-present · case 01
A permission violation on a present page has the present bit clear in its error code.
Protection fault reported as not-present · case 02
A permission violation on a present page has the present bit clear in its error code.
Protection fault reported as not-present · case 03
A permission violation on a present page has the present bit clear in its error code.
Protection fault reported as not-present · case 04
A permission violation on a present page has the present bit clear in its error code.
Protection fault reported as not-present · case 05
A permission violation on a present page has the present bit clear in its error code.
Dirty bit set on reads · case 01
Reading a page marks it dirty.
Dirty bit set on reads · case 02
Reading a page marks it dirty.
Dirty bit set on reads · case 03
Reading a page marks it dirty.
Dirty bit set on reads · case 04
Reading a page marks it dirty.
Dirty bit set on reads · case 05
Reading a page marks it dirty.
Directory accessed bit not set · case 01
After a walk the directory entry still reads as unaccessed.
Directory accessed bit not set · case 02
After a walk the directory entry still reads as unaccessed.
Directory accessed bit not set · case 03
After a walk the directory entry still reads as unaccessed.
Directory accessed bit not set · case 04
After a walk the directory entry still reads as unaccessed.
Directory accessed bit not set · case 05
After a walk the directory entry still reads as unaccessed.
INSPECTABLE BY DESIGN
Every result has a runnable source.
Runnable implementations with recorded outputs, source hashes, and explicit contracts. Related variants share a failure mechanism and belong together in evaluation splits.
Read the methodology ↗