Eight-bit subtraction

1. Start with A=01011110 and B=01010001.
2. The unsigned values are A=94 and B=81.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 01010001 → 10101110.
5. Add one to the inverted byte: 10101110 + 1 → 10101111.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01011110 + 10101111.
8. Keep only the lowest eight bits: 00001101.
9. Normal integers give 94−81=13.
10. After modulo 256, the result is 13.
11. The signed interpretation of the output byte is 13.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 00001101 (13 unsigned)

1. Start with A=01011110 and B=01101001.
2. The unsigned values are A=94 and B=105.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 01101001 → 10010110.
5. Add one to the inverted byte: 10010110 + 1 → 10010111.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01011110 + 10010111.
8. Keep only the lowest eight bits: 11110101.
9. Normal integers give 94−105=-11.
10. After modulo 256, the result is 245.
11. The signed interpretation of the output byte is -11.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 11110101 (245 unsigned)

1. Start with A=01011110 and B=11100000.
2. The unsigned values are A=94 and B=224.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 11100000 → 00011111.
5. Add one to the inverted byte: 00011111 + 1 → 00100000.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01011110 + 00100000.
8. Keep only the lowest eight bits: 01111110.
9. Normal integers give 94−224=-130.
10. After modulo 256, the result is 126.
11. The signed interpretation of the output byte is 126.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 01111110 (126 unsigned)

1. Start with A=01011111 and B=10111111.
2. The unsigned values are A=95 and B=191.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 10111111 → 01000000.
5. Add one to the inverted byte: 01000000 + 1 → 01000001.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01011111 + 01000001.
8. Keep only the lowest eight bits: 10100000.
9. Normal integers give 95−191=-96.
10. After modulo 256, the result is 160.
11. The signed interpretation of the output byte is -96.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 10100000 (160 unsigned)

1. Start with A=01011111 and B=11100111.
2. The unsigned values are A=95 and B=231.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 11100111 → 00011000.
5. Add one to the inverted byte: 00011000 + 1 → 00011001.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01011111 + 00011001.
8. Keep only the lowest eight bits: 01111000.
9. Normal integers give 95−231=-136.
10. After modulo 256, the result is 120.
11. The signed interpretation of the output byte is 120.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 01111000 (120 unsigned)

1. Start with A=01100001 and B=10010011.
2. The unsigned values are A=97 and B=147.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 10010011 → 01101100.
5. Add one to the inverted byte: 01101100 + 1 → 01101101.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01100001 + 01101101.
8. Keep only the lowest eight bits: 11001110.
9. Normal integers give 97−147=-50.
10. After modulo 256, the result is 206.
11. The signed interpretation of the output byte is -50.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 11001110 (206 unsigned)

1. Start with A=01100001 and B=10101110.
2. The unsigned values are A=97 and B=174.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 10101110 → 01010001.
5. Add one to the inverted byte: 01010001 + 1 → 01010010.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01100001 + 01010010.
8. Keep only the lowest eight bits: 10110011.
9. Normal integers give 97−174=-77.
10. After modulo 256, the result is 179.
11. The signed interpretation of the output byte is -77.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 10110011 (179 unsigned)

1. Start with A=01100010 and B=01111111.
2. The unsigned values are A=98 and B=127.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 01111111 → 10000000.
5. Add one to the inverted byte: 10000000 + 1 → 10000001.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01100010 + 10000001.
8. Keep only the lowest eight bits: 11100011.
9. Normal integers give 98−127=-29.
10. After modulo 256, the result is 227.
11. The signed interpretation of the output byte is -29.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 11100011 (227 unsigned)

1. Start with A=01100010 and B=10100101.
2. The unsigned values are A=98 and B=165.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 10100101 → 01011010.
5. Add one to the inverted byte: 01011010 + 1 → 01011011.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01100010 + 01011011.
8. Keep only the lowest eight bits: 10111101.
9. Normal integers give 98−165=-67.
10. After modulo 256, the result is 189.
11. The signed interpretation of the output byte is -67.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 10111101 (189 unsigned)

1. Start with A=01100100 and B=00101011.
2. The unsigned values are A=100 and B=43.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 00101011 → 11010100.
5. Add one to the inverted byte: 11010100 + 1 → 11010101.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01100100 + 11010101.
8. Keep only the lowest eight bits: 00111001.
9. Normal integers give 100−43=57.
10. After modulo 256, the result is 57.
11. The signed interpretation of the output byte is 57.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 00111001 (57 unsigned)

1. Start with A=01100100 and B=10001110.
2. The unsigned values are A=100 and B=142.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 10001110 → 01110001.
5. Add one to the inverted byte: 01110001 + 1 → 01110010.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01100100 + 01110010.
8. Keep only the lowest eight bits: 11010110.
9. Normal integers give 100−142=-42.
10. After modulo 256, the result is 214.
11. The signed interpretation of the output byte is -42.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 11010110 (214 unsigned)

1. Start with A=01100101 and B=00000110.
2. The unsigned values are A=101 and B=6.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 00000110 → 11111001.
5. Add one to the inverted byte: 11111001 + 1 → 11111010.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01100101 + 11111010.
8. Keep only the lowest eight bits: 01011111.
9. Normal integers give 101−6=95.
10. After modulo 256, the result is 95.
11. The signed interpretation of the output byte is 95.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 01011111 (95 unsigned)

1. Start with A=01100101 and B=01001111.
2. The unsigned values are A=101 and B=79.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 01001111 → 10110000.
5. Add one to the inverted byte: 10110000 + 1 → 10110001.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01100101 + 10110001.
8. Keep only the lowest eight bits: 00010110.
9. Normal integers give 101−79=22.
10. After modulo 256, the result is 22.
11. The signed interpretation of the output byte is 22.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 00010110 (22 unsigned)

1. Start with A=01100110 and B=00010000.
2. The unsigned values are A=102 and B=16.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 00010000 → 11101111.
5. Add one to the inverted byte: 11101111 + 1 → 11110000.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01100110 + 11110000.
8. Keep only the lowest eight bits: 01010110.
9. Normal integers give 102−16=86.
10. After modulo 256, the result is 86.
11. The signed interpretation of the output byte is 86.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 01010110 (86 unsigned)

1. Start with A=01100111 and B=00100110.
2. The unsigned values are A=103 and B=38.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 00100110 → 11011001.
5. Add one to the inverted byte: 11011001 + 1 → 11011010.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01100111 + 11011010.
8. Keep only the lowest eight bits: 01000001.
9. Normal integers give 103−38=65.
10. After modulo 256, the result is 65.
11. The signed interpretation of the output byte is 65.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 01000001 (65 unsigned)

1. Start with A=01101000 and B=01101101.
2. The unsigned values are A=104 and B=109.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 01101101 → 10010010.
5. Add one to the inverted byte: 10010010 + 1 → 10010011.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01101000 + 10010011.
8. Keep only the lowest eight bits: 11111011.
9. Normal integers give 104−109=-5.
10. After modulo 256, the result is 251.
11. The signed interpretation of the output byte is -5.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 11111011 (251 unsigned)

1. Start with A=01101001 and B=11010001.
2. The unsigned values are A=105 and B=209.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 11010001 → 00101110.
5. Add one to the inverted byte: 00101110 + 1 → 00101111.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01101001 + 00101111.
8. Keep only the lowest eight bits: 10011000.
9. Normal integers give 105−209=-104.
10. After modulo 256, the result is 152.
11. The signed interpretation of the output byte is -104.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 10011000 (152 unsigned)

1. Start with A=01101010 and B=01010011.
2. The unsigned values are A=106 and B=83.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 01010011 → 10101100.
5. Add one to the inverted byte: 10101100 + 1 → 10101101.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01101010 + 10101101.
8. Keep only the lowest eight bits: 00010111.
9. Normal integers give 106−83=23.
10. After modulo 256, the result is 23.
11. The signed interpretation of the output byte is 23.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 00010111 (23 unsigned)

1. Start with A=01101100 and B=01100001.
2. The unsigned values are A=108 and B=97.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 01100001 → 10011110.
5. Add one to the inverted byte: 10011110 + 1 → 10011111.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01101100 + 10011111.
8. Keep only the lowest eight bits: 00001011.
9. Normal integers give 108−97=11.
10. After modulo 256, the result is 11.
11. The signed interpretation of the output byte is 11.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 00001011 (11 unsigned)

1. Start with A=01101100 and B=10011101.
2. The unsigned values are A=108 and B=157.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 10011101 → 01100010.
5. Add one to the inverted byte: 01100010 + 1 → 01100011.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01101100 + 01100011.
8. Keep only the lowest eight bits: 11001111.
9. Normal integers give 108−157=-49.
10. After modulo 256, the result is 207.
11. The signed interpretation of the output byte is -49.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 11001111 (207 unsigned)

1. Start with A=01101101 and B=11101000.
2. The unsigned values are A=109 and B=232.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 11101000 → 00010111.
5. Add one to the inverted byte: 00010111 + 1 → 00011000.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01101101 + 00011000.
8. Keep only the lowest eight bits: 10000101.
9. Normal integers give 109−232=-123.
10. After modulo 256, the result is 133.
11. The signed interpretation of the output byte is -123.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 10000101 (133 unsigned)

1. Start with A=01101101 and B=11111101.
2. The unsigned values are A=109 and B=253.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 11111101 → 00000010.
5. Add one to the inverted byte: 00000010 + 1 → 00000011.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01101101 + 00000011.
8. Keep only the lowest eight bits: 01110000.
9. Normal integers give 109−253=-144.
10. After modulo 256, the result is 112.
11. The signed interpretation of the output byte is 112.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 01110000 (112 unsigned)

1. Start with A=01101110 and B=10110111.
2. The unsigned values are A=110 and B=183.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 10110111 → 01001000.
5. Add one to the inverted byte: 01001000 + 1 → 01001001.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01101110 + 01001001.
8. Keep only the lowest eight bits: 10110111.
9. Normal integers give 110−183=-73.
10. After modulo 256, the result is 183.
11. The signed interpretation of the output byte is -73.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 10110111 (183 unsigned)

1. Start with A=01101111 and B=01000010.
2. The unsigned values are A=111 and B=66.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 01000010 → 10111101.
5. Add one to the inverted byte: 10111101 + 1 → 10111110.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01101111 + 10111110.
8. Keep only the lowest eight bits: 00101101.
9. Normal integers give 111−66=45.
10. After modulo 256, the result is 45.
11. The signed interpretation of the output byte is 45.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 00101101 (45 unsigned)

1. Start with A=01101111 and B=01100011.
2. The unsigned values are A=111 and B=99.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 01100011 → 10011100.
5. Add one to the inverted byte: 10011100 + 1 → 10011101.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01101111 + 10011101.
8. Keep only the lowest eight bits: 00001100.
9. Normal integers give 111−99=12.
10. After modulo 256, the result is 12.
11. The signed interpretation of the output byte is 12.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 00001100 (12 unsigned)

1. Start with A=01101111 and B=10000000.
2. The unsigned values are A=111 and B=128.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 10000000 → 01111111.
5. Add one to the inverted byte: 01111111 + 1 → 10000000.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01101111 + 10000000.
8. Keep only the lowest eight bits: 11101111.
9. Normal integers give 111−128=-17.
10. After modulo 256, the result is 239.
11. The signed interpretation of the output byte is -17.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 11101111 (239 unsigned)

1. Start with A=01101111 and B=10001101.
2. The unsigned values are A=111 and B=141.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 10001101 → 01110010.
5. Add one to the inverted byte: 01110010 + 1 → 01110011.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01101111 + 01110011.
8. Keep only the lowest eight bits: 11100010.
9. Normal integers give 111−141=-30.
10. After modulo 256, the result is 226.
11. The signed interpretation of the output byte is -30.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 11100010 (226 unsigned)

1. Start with A=01101111 and B=11111001.
2. The unsigned values are A=111 and B=249.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 11111001 → 00000110.
5. Add one to the inverted byte: 00000110 + 1 → 00000111.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01101111 + 00000111.
8. Keep only the lowest eight bits: 01110110.
9. Normal integers give 111−249=-138.
10. After modulo 256, the result is 118.
11. The signed interpretation of the output byte is 118.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 01110110 (118 unsigned)

1. Start with A=01110000 and B=00111011.
2. The unsigned values are A=112 and B=59.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 00111011 → 11000100.
5. Add one to the inverted byte: 11000100 + 1 → 11000101.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01110000 + 11000101.
8. Keep only the lowest eight bits: 00110101.
9. Normal integers give 112−59=53.
10. After modulo 256, the result is 53.
11. The signed interpretation of the output byte is 53.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 00110101 (53 unsigned)

1. Start with A=01110001 and B=10011000.
2. The unsigned values are A=113 and B=152.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 10011000 → 01100111.
5. Add one to the inverted byte: 01100111 + 1 → 01101000.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01110001 + 01101000.
8. Keep only the lowest eight bits: 11011001.
9. Normal integers give 113−152=-39.
10. After modulo 256, the result is 217.
11. The signed interpretation of the output byte is -39.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 11011001 (217 unsigned)

1. Start with A=01110101 and B=00000000.
2. The unsigned values are A=117 and B=0.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 00000000 → 11111111.
5. Add one to the inverted byte: 11111111 + 1 → 00000000.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01110101 + 00000000.
8. Keep only the lowest eight bits: 01110101.
9. Normal integers give 117−0=117.
10. After modulo 256, the result is 117.
11. The signed interpretation of the output byte is 117.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 01110101 (117 unsigned)

1. Start with A=01110101 and B=00110101.
2. The unsigned values are A=117 and B=53.
3. Rewrite subtraction as A + (NOT B) + 1.
4. Invert every bit of B: 00110101 → 11001010.
5. Add one to the inverted byte: 11001010 + 1 → 11001011.
6. This new byte represents the modular additive inverse of B.
7. Add A and modular −B: 01110101 + 11001011.
8. Keep only the lowest eight bits: 01000000.
9. Normal integers give 117−53=64.
10. After modulo 256, the result is 64.
11. The signed interpretation of the output byte is 64.
12. Discarding the ninth carry is valid for the fixed-width modular result; signed overflow is a separate question.

Final answer: 01000000 (64 unsigned)