{"abstract":"A high-digit adjust that stays below 0x100 loses the decimal carry.","category":"Instruction set emulation","checks":10,"contract":"Input [xs, ys, c]: little-endian packed-BCD byte lists and a carry-in. For each byte: s = a+b+c; AF = low-nibble sum (with carry) > 0x0F; CF = s > 0xFF; al = s & 0xFF. Decimal adjust: if (al & 0x0F) > 9 or AF then al += 6 (8-bit wrap); then if the pre-adjust al > 0x99 or CF then al += 0x60 (8-bit wrap) and carry-out = 1, else carry-out = 0. The carry-out feeds the next byte. Return [result bytes, final carry].","evaluation_group":"w2-instruction-set-emulation-bcd-add","failed_approach":"Keeping the binary carry ignores decimal overflow of the high digit.","family":"w2-instruction-set-emulation-bcd-add-decimal-carry-out","id":"FA-89631","implementations":{"attempt":{"sha256":"583221386f3da6b185a83eb821d1016c2082d047ae120a6329b4481366a2fbe0","source":"\"\"\"Failure Map reference implementation. Python standard library only.\"\"\"\nimport json\n\nN = 1\nobservations = []\ndef solve(*args):\n    xs, ys, c = args\n    out = []\n    for a, b in zip(xs, ys):\n        s = a + b + c\n        af = int((a & 0x0F) + (b & 0x0F) + c > 0x0F)\n        cf = int(s > 0xFF)\n        al = s & 0xFF\n        old_al, old_cf = al, cf\n        if (al & 0x0F) > 9 or af:\n            al = (al + 6) & 0xFF\n        if old_al > 0x99 or old_cf:\n            al = (al + 0x60) & 0xFF\n            c = old_cf\n        else:\n            c = 0\n        out.append(al)\n    return [out, c]\ndef check(label, actual, expected):\n    observations.append({\"check\": label, \"actual\": actual, \"expected\": expected, \"passed\": actual == expected})\nfixtures = [[('digits without adjust', [[18, 52], [33, 67], 0], [[51, 119], 0]), ('low digit overflow', [[24, 0], [8, 0], 0], [[38, 0], 0]), ('half carry without low digit above nine', [[9, 16], [9, 0], 0], [[24, 16], 0]), ('carry-in feeds half carry', [[24, 0], [7, 0], 1], [[38, 0], 0]), ('high digit overflow and carry out', [[144, 85], [48, 68], 0], [[32, 0], 1]), ('low adjust pushes high digit', [[149, 0], [5, 0], 0], [[0, 1], 0]), ('binary carry from high digits', [[153, 153], [153, 1], 0], [[152, 1], 1]), ('carry chains across bytes', [[153, 9, 0], [1, 0, 0], 1], [[1, 16, 0], 0]), ('non-decimal low digit', [[143, 0], [7, 2], 0], [[156, 2], 0]), ('high digit exactly A', [[80, 1], [74, 0], 0], [[0, 2], 0])], [('digits without adjust', [[18, 52], [33, 67], 0], [[51, 119], 0]), ('low digit overflow', [[25, 0], [8, 0], 0], [[39, 0], 0]), ('half carry without low digit above nine', [[9, 16], [9, 0], 0], [[24, 16], 0]), ('carry-in feeds half carry', [[40, 0], [7, 0], 1], [[54, 0], 0]), ('high digit overflow and carry out', [[144, 85], [64, 68], 0], [[48, 0], 1]), ('low adjust pushes high digit', [[149, 0], [5, 0], 0], [[0, 1], 0]), ('binary carry from high digits', [[153, 153], [153, 2], 0], [[152, 2], 1]), ('carry chains across bytes', [[153, 9, 0], [1, 0, 0], 1], [[1, 16, 0], 0]), ('non-decimal low digit', [[143, 0], [7, 3], 0], [[156, 3], 0]), ('high digit exactly A', [[80, 1], [74, 0], 0], [[0, 2], 0])], [('digits without adjust', [[18, 52], [33, 67], 0], [[51, 119], 0]), ('low digit overflow', [[24, 0], [8, 0], 0], [[38, 0], 0]), ('half carry without low digit above nine', [[9, 16], [9, 0], 0], [[24, 16], 0]), ('carry-in feeds half carry', [[8, 0], [7, 0], 1], [[22, 0], 0]), ('high digit overflow and carry out', [[144, 85], [32, 68], 0], [[16, 0], 1]), ('low adjust pushes high digit', [[149, 0], [5, 0], 0], [[0, 1], 0]), ('binary carry from high digits', [[153, 153], [153, 3], 0], [[152, 3], 1]), ('carry chains across bytes', [[153, 9, 0], [1, 0, 0], 1], [[1, 16, 0], 0]), ('non-decimal low digit', [[143, 0], [7, 4], 0], [[156, 4], 0]), ('high digit exactly A', [[80, 1], [74, 0], 0], [[0, 2], 0])], [('digits without adjust', [[18, 52], [33, 67], 0], [[51, 119], 0]), ('low digit overflow', [[25, 0], [8, 0], 0], [[39, 0], 0]), ('half carry without low digit above nine', [[9, 16], [9, 0], 0], [[24, 16], 0]), ('carry-in feeds half carry', [[24, 0], [7, 0], 1], [[38, 0], 0]), ('high digit overflow and carry out', [[144, 85], [48, 68], 0], [[32, 0], 1]), ('low adjust pushes high digit', [[149, 0], [5, 0], 0], [[0, 1], 0]), ('binary carry from high digits', [[153, 153], [153, 4], 0], [[152, 4], 1]), ('carry chains across bytes', [[153, 9, 0], [1, 0, 0], 1], [[1, 16, 0], 0]), ('non-decimal low digit', [[143, 0], [7, 5], 0], [[156, 5], 0]), ('high digit exactly A', [[80, 1], [74, 0], 0], [[0, 2], 0])], [('digits without adjust', [[18, 52], [33, 67], 0], [[51, 119], 0]), ('low digit overflow', [[24, 0], [8, 0], 0], [[38, 0], 0]), ('half carry without low digit above nine', [[9, 16], [9, 0], 0], [[24, 16], 0]), ('carry-in feeds half carry', [[40, 0], [7, 0], 1], [[54, 0], 0]), ('high digit overflow and carry out', [[144, 85], [64, 68], 0], [[48, 0], 1]), ('low adjust pushes high digit', [[149, 0], [5, 0], 0], [[0, 1], 0]), ('binary carry from high digits', [[153, 153], [153, 5], 0], [[152, 5], 1]), ('carry chains across bytes', [[153, 9, 0], [1, 0, 0], 1], [[1, 16, 0], 0]), ('non-decimal low digit', [[143, 0], [7, 6], 0], [[156, 6], 0]), ('high digit exactly A', [[80, 1], [74, 0], 0], [[0, 2], 0])]]\nfor label, args, expected in fixtures[N-1]:\n    check(label, solve(*args), expected)\nprint(json.dumps({\"observations\": observations, \"passed\": all(x[\"passed\"] for x in observations)}, ensure_ascii=False))\nraise SystemExit(0 if all(x[\"passed\"] for x in observations) else 1)\n"},"broken":{"sha256":"993df5cad507abd6e690c989e9f0405f61430c8b45b599b34ef76b9738844b99","source":"\"\"\"Failure Map reference implementation. Python standard library only.\"\"\"\nimport json\n\nN = 1\nobservations = []\ndef solve(*args):\n    xs, ys, c = args\n    out = []\n    for a, b in zip(xs, ys):\n        s = a + b + c\n        af = int((a & 0x0F) + (b & 0x0F) + c > 0x0F)\n        cf = int(s > 0xFF)\n        al = s & 0xFF\n        old_al, old_cf = al, cf\n        if (al & 0x0F) > 9 or af:\n            al = (al + 6) & 0xFF\n        if old_al > 0x99 or old_cf:\n            c = int(al + 0x60 > 0xFF)\n            al = (al + 0x60) & 0xFF\n        else:\n            c = 0\n        out.append(al)\n    return [out, c]\ndef check(label, actual, expected):\n    observations.append({\"check\": label, \"actual\": actual, \"expected\": expected, \"passed\": actual == expected})\nfixtures = [[('digits without adjust', [[18, 52], [33, 67], 0], [[51, 119], 0]), ('low digit overflow', [[24, 0], [8, 0], 0], [[38, 0], 0]), ('half carry without low digit above nine', [[9, 16], [9, 0], 0], [[24, 16], 0]), ('carry-in feeds half carry', [[24, 0], [7, 0], 1], [[38, 0], 0]), ('high digit overflow and carry out', [[144, 85], [48, 68], 0], [[32, 0], 1]), ('low adjust pushes high digit', [[149, 0], [5, 0], 0], [[0, 1], 0]), ('binary carry from high digits', [[153, 153], [153, 1], 0], [[152, 1], 1]), ('carry chains across bytes', [[153, 9, 0], [1, 0, 0], 1], [[1, 16, 0], 0]), ('non-decimal low digit', [[143, 0], [7, 2], 0], [[156, 2], 0]), ('high digit exactly A', [[80, 1], [74, 0], 0], [[0, 2], 0])], [('digits without adjust', [[18, 52], [33, 67], 0], [[51, 119], 0]), ('low digit overflow', [[25, 0], [8, 0], 0], [[39, 0], 0]), ('half carry without low digit above nine', [[9, 16], [9, 0], 0], [[24, 16], 0]), ('carry-in feeds half carry', [[40, 0], [7, 0], 1], [[54, 0], 0]), ('high digit overflow and carry out', [[144, 85], [64, 68], 0], [[48, 0], 1]), ('low adjust pushes high digit', [[149, 0], [5, 0], 0], [[0, 1], 0]), ('binary carry from high digits', [[153, 153], [153, 2], 0], [[152, 2], 1]), ('carry chains across bytes', [[153, 9, 0], [1, 0, 0], 1], [[1, 16, 0], 0]), ('non-decimal low digit', [[143, 0], [7, 3], 0], [[156, 3], 0]), ('high digit exactly A', [[80, 1], [74, 0], 0], [[0, 2], 0])], [('digits without adjust', [[18, 52], [33, 67], 0], [[51, 119], 0]), ('low digit overflow', [[24, 0], [8, 0], 0], [[38, 0], 0]), ('half carry without low digit above nine', [[9, 16], [9, 0], 0], [[24, 16], 0]), ('carry-in feeds half carry', [[8, 0], [7, 0], 1], [[22, 0], 0]), ('high digit overflow and carry out', [[144, 85], [32, 68], 0], [[16, 0], 1]), ('low adjust pushes high digit', [[149, 0], [5, 0], 0], [[0, 1], 0]), ('binary carry from high digits', [[153, 153], [153, 3], 0], [[152, 3], 1]), ('carry chains across bytes', [[153, 9, 0], [1, 0, 0], 1], [[1, 16, 0], 0]), ('non-decimal low digit', [[143, 0], [7, 4], 0], [[156, 4], 0]), ('high digit exactly A', [[80, 1], [74, 0], 0], [[0, 2], 0])], [('digits without adjust', [[18, 52], [33, 67], 0], [[51, 119], 0]), ('low digit overflow', [[25, 0], [8, 0], 0], [[39, 0], 0]), ('half carry without low digit above nine', [[9, 16], [9, 0], 0], [[24, 16], 0]), ('carry-in feeds half carry', [[24, 0], [7, 0], 1], [[38, 0], 0]), ('high digit overflow and carry out', [[144, 85], [48, 68], 0], [[32, 0], 1]), ('low adjust pushes high digit', [[149, 0], [5, 0], 0], [[0, 1], 0]), ('binary carry from high digits', [[153, 153], [153, 4], 0], [[152, 4], 1]), ('carry chains across bytes', [[153, 9, 0], [1, 0, 0], 1], [[1, 16, 0], 0]), ('non-decimal low digit', [[143, 0], [7, 5], 0], [[156, 5], 0]), ('high digit exactly A', [[80, 1], [74, 0], 0], [[0, 2], 0])], [('digits without adjust', [[18, 52], [33, 67], 0], [[51, 119], 0]), ('low digit overflow', [[24, 0], [8, 0], 0], [[38, 0], 0]), ('half carry without low digit above nine', [[9, 16], [9, 0], 0], [[24, 16], 0]), ('carry-in feeds half carry', [[40, 0], [7, 0], 1], [[54, 0], 0]), ('high digit overflow and carry out', [[144, 85], [64, 68], 0], [[48, 0], 1]), ('low adjust pushes high digit', [[149, 0], [5, 0], 0], [[0, 1], 0]), ('binary carry from high digits', [[153, 153], [153, 5], 0], [[152, 5], 1]), ('carry chains across bytes', [[153, 9, 0], [1, 0, 0], 1], [[1, 16, 0], 0]), ('non-decimal low digit', [[143, 0], [7, 6], 0], [[156, 6], 0]), ('high digit exactly A', [[80, 1], [74, 0], 0], [[0, 2], 0])]]\nfor label, args, expected in fixtures[N-1]:\n    check(label, solve(*args), expected)\nprint(json.dumps({\"observations\": observations, \"passed\": all(x[\"passed\"] for x in observations)}, ensure_ascii=False))\nraise SystemExit(0 if all(x[\"passed\"] for x in observations) else 1)\n"},"fixed":{"sha256":"f93c5508c70d57fbe14465c9a3420c9e8add4d3804d6c1352c9c6e62b8af554c","source":"\"\"\"Failure Map reference implementation. Python standard library only.\"\"\"\nimport json\n\nN = 1\nobservations = []\ndef solve(*args):\n    xs, ys, c = args\n    out = []\n    for a, b in zip(xs, ys):\n        s = a + b + c\n        af = int((a & 0x0F) + (b & 0x0F) + c > 0x0F)\n        cf = int(s > 0xFF)\n        al = s & 0xFF\n        old_al, old_cf = al, cf\n        if (al & 0x0F) > 9 or af:\n            al = (al + 6) & 0xFF\n        if old_al > 0x99 or old_cf:\n            al = (al + 0x60) & 0xFF\n            c = 1\n        else:\n            c = 0\n        out.append(al)\n    return [out, c]\ndef check(label, actual, expected):\n    observations.append({\"check\": label, \"actual\": actual, \"expected\": expected, \"passed\": actual == expected})\nfixtures = [[('digits without adjust', [[18, 52], [33, 67], 0], [[51, 119], 0]), ('low digit overflow', [[24, 0], [8, 0], 0], [[38, 0], 0]), ('half carry without low digit above nine', [[9, 16], [9, 0], 0], [[24, 16], 0]), ('carry-in feeds half carry', [[24, 0], [7, 0], 1], [[38, 0], 0]), ('high digit overflow and carry out', [[144, 85], [48, 68], 0], [[32, 0], 1]), ('low adjust pushes high digit', [[149, 0], [5, 0], 0], [[0, 1], 0]), ('binary carry from high digits', [[153, 153], [153, 1], 0], [[152, 1], 1]), ('carry chains across bytes', [[153, 9, 0], [1, 0, 0], 1], [[1, 16, 0], 0]), ('non-decimal low digit', [[143, 0], [7, 2], 0], [[156, 2], 0]), ('high digit exactly A', [[80, 1], [74, 0], 0], [[0, 2], 0])], [('digits without adjust', [[18, 52], [33, 67], 0], [[51, 119], 0]), ('low digit overflow', [[25, 0], [8, 0], 0], [[39, 0], 0]), ('half carry without low digit above nine', [[9, 16], [9, 0], 0], [[24, 16], 0]), ('carry-in feeds half carry', [[40, 0], [7, 0], 1], [[54, 0], 0]), ('high digit overflow and carry out', [[144, 85], [64, 68], 0], [[48, 0], 1]), ('low adjust pushes high digit', [[149, 0], [5, 0], 0], [[0, 1], 0]), ('binary carry from high digits', [[153, 153], [153, 2], 0], [[152, 2], 1]), ('carry chains across bytes', [[153, 9, 0], [1, 0, 0], 1], [[1, 16, 0], 0]), ('non-decimal low digit', [[143, 0], [7, 3], 0], [[156, 3], 0]), ('high digit exactly A', [[80, 1], [74, 0], 0], [[0, 2], 0])], [('digits without adjust', [[18, 52], [33, 67], 0], [[51, 119], 0]), ('low digit overflow', [[24, 0], [8, 0], 0], [[38, 0], 0]), ('half carry without low digit above nine', [[9, 16], [9, 0], 0], [[24, 16], 0]), ('carry-in feeds half carry', [[8, 0], [7, 0], 1], [[22, 0], 0]), ('high digit overflow and carry out', [[144, 85], [32, 68], 0], [[16, 0], 1]), ('low adjust pushes high digit', [[149, 0], [5, 0], 0], [[0, 1], 0]), ('binary carry from high digits', [[153, 153], [153, 3], 0], [[152, 3], 1]), ('carry chains across bytes', [[153, 9, 0], [1, 0, 0], 1], [[1, 16, 0], 0]), ('non-decimal low digit', [[143, 0], [7, 4], 0], [[156, 4], 0]), ('high digit exactly A', [[80, 1], [74, 0], 0], [[0, 2], 0])], [('digits without adjust', [[18, 52], [33, 67], 0], [[51, 119], 0]), ('low digit overflow', [[25, 0], [8, 0], 0], [[39, 0], 0]), ('half carry without low digit above nine', [[9, 16], [9, 0], 0], [[24, 16], 0]), ('carry-in feeds half carry', [[24, 0], [7, 0], 1], [[38, 0], 0]), ('high digit overflow and carry out', [[144, 85], [48, 68], 0], [[32, 0], 1]), ('low adjust pushes high digit', [[149, 0], [5, 0], 0], [[0, 1], 0]), ('binary carry from high digits', [[153, 153], [153, 4], 0], [[152, 4], 1]), ('carry chains across bytes', [[153, 9, 0], [1, 0, 0], 1], [[1, 16, 0], 0]), ('non-decimal low digit', [[143, 0], [7, 5], 0], [[156, 5], 0]), ('high digit exactly A', [[80, 1], [74, 0], 0], [[0, 2], 0])], [('digits without adjust', [[18, 52], [33, 67], 0], [[51, 119], 0]), ('low digit overflow', [[24, 0], [8, 0], 0], [[38, 0], 0]), ('half carry without low digit above nine', [[9, 16], [9, 0], 0], [[24, 16], 0]), ('carry-in feeds half carry', [[40, 0], [7, 0], 1], [[54, 0], 0]), ('high digit overflow and carry out', [[144, 85], [64, 68], 0], [[48, 0], 1]), ('low adjust pushes high digit', [[149, 0], [5, 0], 0], [[0, 1], 0]), ('binary carry from high digits', [[153, 153], [153, 5], 0], [[152, 5], 1]), ('carry chains across bytes', [[153, 9, 0], [1, 0, 0], 1], [[1, 16, 0], 0]), ('non-decimal low digit', [[143, 0], [7, 6], 0], [[156, 6], 0]), ('high digit exactly A', [[80, 1], [74, 0], 0], [[0, 2], 0])]]\nfor label, args, expected in fixtures[N-1]:\n    check(label, solve(*args), expected)\nprint(json.dumps({\"observations\": observations, \"passed\": all(x[\"passed\"] for x in observations)}, ensure_ascii=False))\nraise SystemExit(0 if all(x[\"passed\"] for x in observations) else 1)\n"}},"limitations":"A deterministic bounded teaching model of one emulator rule; the instruction semantics are a stipulated contract inspired by common ISAs and are not a claim of cycle-exact or architectural conformance. This reproducer isolates one failure mechanism. Results cover the supplied fixtures. Variants within a family share a test contract and should remain grouped when constructing evaluation splits. Related mechanisms with a shared evaluation_group must also remain together; these controlled models are not independent production incidents.","method":"Deterministic executable model with adversarial boundary fixtures.","provenance":{"created_by":"Failure Map","dependencies":"Python standard library","family":"w2-instruction-set-emulation-bcd-add-decimal-carry-out","generated_at":"2026-09-29T14:51:19.227233+00:00","license":"CC0-1.0","python":"3.12.14","seed":1,"split":"open-access"},"relevance":"Decimal-adjust instructions are among the hardest to emulate; the flag inputs and the pre-adjust comparison decide the result.","repair":"Set carry-out whenever the high-digit adjust is applied.","root_cause":"The carry-out is set only when adding 0x60 overflows the byte.","sha256":"7169ae825705c0b64eb9ddbe292dc37c07b85bd1222e01eeb890a37eadebec44","title":"Decimal carry derived from 8-bit overflow of the adjust · case 01","variant":1,"variant_policy":"Five numbered records share a model and may reuse boundary fixtures.","verification":{"attempt":{"elapsed_ms":39.97,"exit_code":1,"observations":[{"actual":[[51,119],0],"check":"digits without adjust","expected":[[51,119],0],"passed":true},{"actual":[[38,0],0],"check":"low digit overflow","expected":[[38,0],0],"passed":true},{"actual":[[24,16],0],"check":"half carry without low digit above nine","expected":[[24,16],0],"passed":true},{"actual":[[38,0],0],"check":"carry-in feeds half carry","expected":[[38,0],0],"passed":true},{"actual":[[32,153],0],"check":"high digit overflow and carry out","expected":[[32,0],1],"passed":false},{"actual":[[0,0],0],"check":"low adjust pushes high digit","expected":[[0,1],0],"passed":false},{"actual":[[152,1],0],"check":"binary carry from high digits","expected":[[152,1],1],"passed":false},{"actual":[[1,9,0],0],"check":"carry chains across bytes","expected":[[1,16,0],0],"passed":false},{"actual":[[156,2],0],"check":"non-decimal low digit","expected":[[156,2],0],"passed":true},{"actual":[[0,1],0],"check":"high digit exactly A","expected":[[0,2],0],"passed":false}],"passed":false,"stderr":"","stdout":"{\"observations\": [{\"check\": \"digits without adjust\", \"actual\": [[51, 119], 0], \"expected\": [[51, 119], 0], \"passed\": true}, {\"check\": \"low digit overflow\", \"actual\": [[38, 0], 0], \"expected\": [[38, 0], 0], \"passed\": true}, {\"check\": \"half carry without low digit above nine\", \"actual\": [[24, 16], 0], \"expected\": [[24, 16], 0], \"passed\": true}, {\"check\": \"carry-in feeds half carry\", \"actual\": [[38, 0], 0], \"expected\": [[38, 0], 0], \"passed\": true}, {\"check\": \"high digit overflow and carry out\", \"actual\": [[32, 153], 0], \"expected\": [[32, 0], 1], \"passed\": false}, {\"check\": \"low adjust pushes high digit\", \"actual\": [[0, 0], 0], \"expected\": [[0, 1], 0], \"passed\": false}, {\"check\": \"binary carry from high digits\", \"actual\": [[152, 1], 0], \"expected\": [[152, 1], 1], \"passed\": false}, {\"check\": \"carry chains across bytes\", \"actual\": [[1, 9, 0], 0], \"expected\": [[1, 16, 0], 0], \"passed\": false}, {\"check\": \"non-decimal low digit\", \"actual\": [[156, 2], 0], \"expected\": [[156, 2], 0], \"passed\": true}, {\"check\": \"high digit exactly A\", \"actual\": [[0, 1], 0], \"expected\": [[0, 2], 0], \"passed\": false}], \"passed\": false}\n"},"broken":{"elapsed_ms":40.98,"exit_code":1,"observations":[{"actual":[[51,119],0],"check":"digits without adjust","expected":[[51,119],0],"passed":true},{"actual":[[38,0],0],"check":"low digit overflow","expected":[[38,0],0],"passed":true},{"actual":[[24,16],0],"check":"half carry without low digit above nine","expected":[[24,16],0],"passed":true},{"actual":[[38,0],0],"check":"carry-in feeds half carry","expected":[[38,0],0],"passed":true},{"actual":[[32,0],1],"check":"high digit overflow and carry out","expected":[[32,0],1],"passed":true},{"actual":[[0,1],0],"check":"low adjust pushes high digit","expected":[[0,1],0],"passed":true},{"actual":[[152,0],1],"check":"binary carry from high digits","expected":[[152,1],1],"passed":false},{"actual":[[1,16,0],0],"check":"carry chains across bytes","expected":[[1,16,0],0],"passed":true},{"actual":[[156,2],0],"check":"non-decimal low digit","expected":[[156,2],0],"passed":true},{"actual":[[0,2],0],"check":"high digit exactly A","expected":[[0,2],0],"passed":true}],"passed":false,"stderr":"","stdout":"{\"observations\": [{\"check\": \"digits without adjust\", \"actual\": [[51, 119], 0], \"expected\": [[51, 119], 0], \"passed\": true}, {\"check\": \"low digit overflow\", \"actual\": [[38, 0], 0], \"expected\": [[38, 0], 0], \"passed\": true}, {\"check\": \"half carry without low digit above nine\", \"actual\": [[24, 16], 0], \"expected\": [[24, 16], 0], \"passed\": true}, {\"check\": \"carry-in feeds half carry\", \"actual\": [[38, 0], 0], \"expected\": [[38, 0], 0], \"passed\": true}, {\"check\": \"high digit overflow and carry out\", \"actual\": [[32, 0], 1], \"expected\": [[32, 0], 1], \"passed\": true}, {\"check\": \"low adjust pushes high digit\", \"actual\": [[0, 1], 0], \"expected\": [[0, 1], 0], \"passed\": true}, {\"check\": \"binary carry from high digits\", \"actual\": [[152, 0], 1], \"expected\": [[152, 1], 1], \"passed\": false}, {\"check\": \"carry chains across bytes\", \"actual\": [[1, 16, 0], 0], \"expected\": [[1, 16, 0], 0], \"passed\": true}, {\"check\": \"non-decimal low digit\", \"actual\": [[156, 2], 0], \"expected\": [[156, 2], 0], \"passed\": true}, {\"check\": \"high digit exactly A\", \"actual\": [[0, 2], 0], \"expected\": [[0, 2], 0], \"passed\": true}], \"passed\": false}\n"},"fixed":{"elapsed_ms":37.93,"exit_code":0,"observations":[{"actual":[[51,119],0],"check":"digits without adjust","expected":[[51,119],0],"passed":true},{"actual":[[38,0],0],"check":"low digit overflow","expected":[[38,0],0],"passed":true},{"actual":[[24,16],0],"check":"half carry without low digit above nine","expected":[[24,16],0],"passed":true},{"actual":[[38,0],0],"check":"carry-in feeds half carry","expected":[[38,0],0],"passed":true},{"actual":[[32,0],1],"check":"high digit overflow and carry out","expected":[[32,0],1],"passed":true},{"actual":[[0,1],0],"check":"low adjust pushes high digit","expected":[[0,1],0],"passed":true},{"actual":[[152,1],1],"check":"binary carry from high digits","expected":[[152,1],1],"passed":true},{"actual":[[1,16,0],0],"check":"carry chains across bytes","expected":[[1,16,0],0],"passed":true},{"actual":[[156,2],0],"check":"non-decimal low digit","expected":[[156,2],0],"passed":true},{"actual":[[0,2],0],"check":"high digit exactly A","expected":[[0,2],0],"passed":true}],"passed":true,"stderr":"","stdout":"{\"observations\": [{\"check\": \"digits without adjust\", \"actual\": [[51, 119], 0], \"expected\": [[51, 119], 0], \"passed\": true}, {\"check\": \"low digit overflow\", \"actual\": [[38, 0], 0], \"expected\": [[38, 0], 0], \"passed\": true}, {\"check\": \"half carry without low digit above nine\", \"actual\": [[24, 16], 0], \"expected\": [[24, 16], 0], \"passed\": true}, {\"check\": \"carry-in feeds half carry\", \"actual\": [[38, 0], 0], \"expected\": [[38, 0], 0], \"passed\": true}, {\"check\": \"high digit overflow and carry out\", \"actual\": [[32, 0], 1], \"expected\": [[32, 0], 1], \"passed\": true}, {\"check\": \"low adjust pushes high digit\", \"actual\": [[0, 1], 0], \"expected\": [[0, 1], 0], \"passed\": true}, {\"check\": \"binary carry from high digits\", \"actual\": [[152, 1], 1], \"expected\": [[152, 1], 1], \"passed\": true}, {\"check\": \"carry chains across bytes\", \"actual\": [[1, 16, 0], 0], \"expected\": [[1, 16, 0], 0], \"passed\": true}, {\"check\": \"non-decimal low digit\", \"actual\": [[156, 2], 0], \"expected\": [[156, 2], 0], \"passed\": true}, {\"check\": \"high digit exactly A\", \"actual\": [[0, 2], 0], \"expected\": [[0, 2], 0], \"passed\": true}], \"passed\": true}\n"}},"verified":true,"visibility":"public"}