01How Computers Work
Practice library / Eight-bit addition

Fully solved problem book

Eight-bit addition

Set 13 of 14 · 32 worked questions. Predict your result before expanding the solution.

These worked traces are meant to build fluency through controlled variation. If several answers feel identical, try the next difficult value and look for the point where a carry, sign, branch, or selected memory address changes the outcome.

Bitwise arithmetic · Problem 0385

Add 11101001₂ and 00000001₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11101001, B=00000001.
  2. Ordinary decimal arithmetic gives 233+1=234.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+1+incoming carry 0=2; write 0, pass carry 1.
  5. Bit 1 (weight 2): 0+0+incoming carry 1=1; write 1, pass carry 0.
  6. Bit 2 (weight 4): 0+0+incoming carry 0=0; write 0, pass carry 0.
  7. Bit 3 (weight 8): 1+0+incoming carry 0=1; write 1, pass carry 0.
  8. Bit 4 (weight 16): 0+0+incoming carry 0=0; write 0, pass carry 0.
  9. Bit 5 (weight 32): 1+0+incoming carry 0=1; write 1, pass carry 0.
  10. Bit 6 (weight 64): 1+0+incoming carry 0=1; write 1, pass carry 0.
  11. Bit 7 (weight 128): 1+0+incoming carry 0=1; write 1, pass carry 0.
  12. The final carry-out is 0; it is outside the eight-bit result.
  13. The stored sum is 11101010, which is 234 unsigned.
  14. Check modular arithmetic: 234 modulo 256 = 234.
  15. Signed readings of the inputs are -23 and 1; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 11101010

Bitwise arithmetic · Problem 0386

Add 11101001₂ and 10100110₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11101001, B=10100110.
  2. Ordinary decimal arithmetic gives 233+166=399.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+0+incoming carry 0=1; write 1, pass carry 0.
  5. Bit 1 (weight 2): 0+1+incoming carry 0=1; write 1, pass carry 0.
  6. Bit 2 (weight 4): 0+1+incoming carry 0=1; write 1, pass carry 0.
  7. Bit 3 (weight 8): 1+0+incoming carry 0=1; write 1, pass carry 0.
  8. Bit 4 (weight 16): 0+0+incoming carry 0=0; write 0, pass carry 0.
  9. Bit 5 (weight 32): 1+1+incoming carry 0=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 1+0+incoming carry 1=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 1+1+incoming carry 1=3; write 1, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 10001111, which is 143 unsigned.
  14. Check modular arithmetic: 399 modulo 256 = 143.
  15. Signed readings of the inputs are -23 and -90; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 10001111

Bitwise arithmetic · Problem 0387

Add 11101010₂ and 10010101₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11101010, B=10010101.
  2. Ordinary decimal arithmetic gives 234+149=383.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 0+1+incoming carry 0=1; write 1, pass carry 0.
  5. Bit 1 (weight 2): 1+0+incoming carry 0=1; write 1, pass carry 0.
  6. Bit 2 (weight 4): 0+1+incoming carry 0=1; write 1, pass carry 0.
  7. Bit 3 (weight 8): 1+0+incoming carry 0=1; write 1, pass carry 0.
  8. Bit 4 (weight 16): 0+1+incoming carry 0=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+0+incoming carry 0=1; write 1, pass carry 0.
  10. Bit 6 (weight 64): 1+0+incoming carry 0=1; write 1, pass carry 0.
  11. Bit 7 (weight 128): 1+1+incoming carry 0=2; write 0, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 01111111, which is 127 unsigned.
  14. Check modular arithmetic: 383 modulo 256 = 127.
  15. Signed readings of the inputs are -22 and -107; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01111111

Bitwise arithmetic · Problem 0388

Add 11101010₂ and 11001010₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11101010, B=11001010.
  2. Ordinary decimal arithmetic gives 234+202=436.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 0+0+incoming carry 0=0; write 0, pass carry 0.
  5. Bit 1 (weight 2): 1+1+incoming carry 0=2; write 0, pass carry 1.
  6. Bit 2 (weight 4): 0+0+incoming carry 1=1; write 1, pass carry 0.
  7. Bit 3 (weight 8): 1+1+incoming carry 0=2; write 0, pass carry 1.
  8. Bit 4 (weight 16): 0+0+incoming carry 1=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+0+incoming carry 0=1; write 1, pass carry 0.
  10. Bit 6 (weight 64): 1+1+incoming carry 0=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 1+1+incoming carry 1=3; write 1, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 10110100, which is 180 unsigned.
  14. Check modular arithmetic: 436 modulo 256 = 180.
  15. Signed readings of the inputs are -22 and -54; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 10110100

Bitwise arithmetic · Problem 0389

Add 11101011₂ and 00001111₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11101011, B=00001111.
  2. Ordinary decimal arithmetic gives 235+15=250.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+1+incoming carry 0=2; write 0, pass carry 1.
  5. Bit 1 (weight 2): 1+1+incoming carry 1=3; write 1, pass carry 1.
  6. Bit 2 (weight 4): 0+1+incoming carry 1=2; write 0, pass carry 1.
  7. Bit 3 (weight 8): 1+1+incoming carry 1=3; write 1, pass carry 1.
  8. Bit 4 (weight 16): 0+0+incoming carry 1=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+0+incoming carry 0=1; write 1, pass carry 0.
  10. Bit 6 (weight 64): 1+0+incoming carry 0=1; write 1, pass carry 0.
  11. Bit 7 (weight 128): 1+0+incoming carry 0=1; write 1, pass carry 0.
  12. The final carry-out is 0; it is outside the eight-bit result.
  13. The stored sum is 11111010, which is 250 unsigned.
  14. Check modular arithmetic: 250 modulo 256 = 250.
  15. Signed readings of the inputs are -21 and 15; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 11111010

Bitwise arithmetic · Problem 0390

Add 11101011₂ and 01101111₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11101011, B=01101111.
  2. Ordinary decimal arithmetic gives 235+111=346.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+1+incoming carry 0=2; write 0, pass carry 1.
  5. Bit 1 (weight 2): 1+1+incoming carry 1=3; write 1, pass carry 1.
  6. Bit 2 (weight 4): 0+1+incoming carry 1=2; write 0, pass carry 1.
  7. Bit 3 (weight 8): 1+1+incoming carry 1=3; write 1, pass carry 1.
  8. Bit 4 (weight 16): 0+0+incoming carry 1=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+1+incoming carry 0=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 1+1+incoming carry 1=3; write 1, pass carry 1.
  11. Bit 7 (weight 128): 1+0+incoming carry 1=2; write 0, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 01011010, which is 90 unsigned.
  14. Check modular arithmetic: 346 modulo 256 = 90.
  15. Signed readings of the inputs are -21 and 111; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01011010

Bitwise arithmetic · Problem 0391

Add 11101011₂ and 10010111₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11101011, B=10010111.
  2. Ordinary decimal arithmetic gives 235+151=386.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+1+incoming carry 0=2; write 0, pass carry 1.
  5. Bit 1 (weight 2): 1+1+incoming carry 1=3; write 1, pass carry 1.
  6. Bit 2 (weight 4): 0+1+incoming carry 1=2; write 0, pass carry 1.
  7. Bit 3 (weight 8): 1+0+incoming carry 1=2; write 0, pass carry 1.
  8. Bit 4 (weight 16): 0+1+incoming carry 1=2; write 0, pass carry 1.
  9. Bit 5 (weight 32): 1+0+incoming carry 1=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 1+0+incoming carry 1=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 1+1+incoming carry 1=3; write 1, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 10000010, which is 130 unsigned.
  14. Check modular arithmetic: 386 modulo 256 = 130.
  15. Signed readings of the inputs are -21 and -105; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 10000010

Bitwise arithmetic · Problem 0392

Add 11101100₂ and 00111101₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11101100, B=00111101.
  2. Ordinary decimal arithmetic gives 236+61=297.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 0+1+incoming carry 0=1; write 1, pass carry 0.
  5. Bit 1 (weight 2): 0+0+incoming carry 0=0; write 0, pass carry 0.
  6. Bit 2 (weight 4): 1+1+incoming carry 0=2; write 0, pass carry 1.
  7. Bit 3 (weight 8): 1+1+incoming carry 1=3; write 1, pass carry 1.
  8. Bit 4 (weight 16): 0+1+incoming carry 1=2; write 0, pass carry 1.
  9. Bit 5 (weight 32): 1+1+incoming carry 1=3; write 1, pass carry 1.
  10. Bit 6 (weight 64): 1+0+incoming carry 1=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 1+0+incoming carry 1=2; write 0, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 00101001, which is 41 unsigned.
  14. Check modular arithmetic: 297 modulo 256 = 41.
  15. Signed readings of the inputs are -20 and 61; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00101001

Bitwise arithmetic · Problem 0393

Add 11101101₂ and 00111110₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11101101, B=00111110.
  2. Ordinary decimal arithmetic gives 237+62=299.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+0+incoming carry 0=1; write 1, pass carry 0.
  5. Bit 1 (weight 2): 0+1+incoming carry 0=1; write 1, pass carry 0.
  6. Bit 2 (weight 4): 1+1+incoming carry 0=2; write 0, pass carry 1.
  7. Bit 3 (weight 8): 1+1+incoming carry 1=3; write 1, pass carry 1.
  8. Bit 4 (weight 16): 0+1+incoming carry 1=2; write 0, pass carry 1.
  9. Bit 5 (weight 32): 1+1+incoming carry 1=3; write 1, pass carry 1.
  10. Bit 6 (weight 64): 1+0+incoming carry 1=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 1+0+incoming carry 1=2; write 0, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 00101011, which is 43 unsigned.
  14. Check modular arithmetic: 299 modulo 256 = 43.
  15. Signed readings of the inputs are -19 and 62; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00101011

Bitwise arithmetic · Problem 0394

Add 11101110₂ and 01100100₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11101110, B=01100100.
  2. Ordinary decimal arithmetic gives 238+100=338.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 0+0+incoming carry 0=0; write 0, pass carry 0.
  5. Bit 1 (weight 2): 1+0+incoming carry 0=1; write 1, pass carry 0.
  6. Bit 2 (weight 4): 1+1+incoming carry 0=2; write 0, pass carry 1.
  7. Bit 3 (weight 8): 1+0+incoming carry 1=2; write 0, pass carry 1.
  8. Bit 4 (weight 16): 0+0+incoming carry 1=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+1+incoming carry 0=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 1+1+incoming carry 1=3; write 1, pass carry 1.
  11. Bit 7 (weight 128): 1+0+incoming carry 1=2; write 0, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 01010010, which is 82 unsigned.
  14. Check modular arithmetic: 338 modulo 256 = 82.
  15. Signed readings of the inputs are -18 and 100; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01010010

Bitwise arithmetic · Problem 0395

Add 11101111₂ and 00000010₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11101111, B=00000010.
  2. Ordinary decimal arithmetic gives 239+2=241.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+0+incoming carry 0=1; write 1, pass carry 0.
  5. Bit 1 (weight 2): 1+1+incoming carry 0=2; write 0, pass carry 1.
  6. Bit 2 (weight 4): 1+0+incoming carry 1=2; write 0, pass carry 1.
  7. Bit 3 (weight 8): 1+0+incoming carry 1=2; write 0, pass carry 1.
  8. Bit 4 (weight 16): 0+0+incoming carry 1=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+0+incoming carry 0=1; write 1, pass carry 0.
  10. Bit 6 (weight 64): 1+0+incoming carry 0=1; write 1, pass carry 0.
  11. Bit 7 (weight 128): 1+0+incoming carry 0=1; write 1, pass carry 0.
  12. The final carry-out is 0; it is outside the eight-bit result.
  13. The stored sum is 11110001, which is 241 unsigned.
  14. Check modular arithmetic: 241 modulo 256 = 241.
  15. Signed readings of the inputs are -17 and 2; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 11110001

Bitwise arithmetic · Problem 0396

Add 11110000₂ and 00101101₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11110000, B=00101101.
  2. Ordinary decimal arithmetic gives 240+45=285.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 0+1+incoming carry 0=1; write 1, pass carry 0.
  5. Bit 1 (weight 2): 0+0+incoming carry 0=0; write 0, pass carry 0.
  6. Bit 2 (weight 4): 0+1+incoming carry 0=1; write 1, pass carry 0.
  7. Bit 3 (weight 8): 0+1+incoming carry 0=1; write 1, pass carry 0.
  8. Bit 4 (weight 16): 1+0+incoming carry 0=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+1+incoming carry 0=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 1+0+incoming carry 1=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 1+0+incoming carry 1=2; write 0, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 00011101, which is 29 unsigned.
  14. Check modular arithmetic: 285 modulo 256 = 29.
  15. Signed readings of the inputs are -16 and 45; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00011101

Bitwise arithmetic · Problem 0397

Add 11110001₂ and 01010010₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11110001, B=01010010.
  2. Ordinary decimal arithmetic gives 241+82=323.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+0+incoming carry 0=1; write 1, pass carry 0.
  5. Bit 1 (weight 2): 0+1+incoming carry 0=1; write 1, pass carry 0.
  6. Bit 2 (weight 4): 0+0+incoming carry 0=0; write 0, pass carry 0.
  7. Bit 3 (weight 8): 0+0+incoming carry 0=0; write 0, pass carry 0.
  8. Bit 4 (weight 16): 1+1+incoming carry 0=2; write 0, pass carry 1.
  9. Bit 5 (weight 32): 1+0+incoming carry 1=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 1+1+incoming carry 1=3; write 1, pass carry 1.
  11. Bit 7 (weight 128): 1+0+incoming carry 1=2; write 0, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 01000011, which is 67 unsigned.
  14. Check modular arithmetic: 323 modulo 256 = 67.
  15. Signed readings of the inputs are -15 and 82; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01000011

Bitwise arithmetic · Problem 0398

Add 11110001₂ and 11100110₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11110001, B=11100110.
  2. Ordinary decimal arithmetic gives 241+230=471.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+0+incoming carry 0=1; write 1, pass carry 0.
  5. Bit 1 (weight 2): 0+1+incoming carry 0=1; write 1, pass carry 0.
  6. Bit 2 (weight 4): 0+1+incoming carry 0=1; write 1, pass carry 0.
  7. Bit 3 (weight 8): 0+0+incoming carry 0=0; write 0, pass carry 0.
  8. Bit 4 (weight 16): 1+0+incoming carry 0=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+1+incoming carry 0=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 1+1+incoming carry 1=3; write 1, pass carry 1.
  11. Bit 7 (weight 128): 1+1+incoming carry 1=3; write 1, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 11010111, which is 215 unsigned.
  14. Check modular arithmetic: 471 modulo 256 = 215.
  15. Signed readings of the inputs are -15 and -26; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 11010111

Bitwise arithmetic · Problem 0399

Add 11110010₂ and 01001010₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11110010, B=01001010.
  2. Ordinary decimal arithmetic gives 242+74=316.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 0+0+incoming carry 0=0; write 0, pass carry 0.
  5. Bit 1 (weight 2): 1+1+incoming carry 0=2; write 0, pass carry 1.
  6. Bit 2 (weight 4): 0+0+incoming carry 1=1; write 1, pass carry 0.
  7. Bit 3 (weight 8): 0+1+incoming carry 0=1; write 1, pass carry 0.
  8. Bit 4 (weight 16): 1+0+incoming carry 0=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+0+incoming carry 0=1; write 1, pass carry 0.
  10. Bit 6 (weight 64): 1+1+incoming carry 0=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 1+0+incoming carry 1=2; write 0, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 00111100, which is 60 unsigned.
  14. Check modular arithmetic: 316 modulo 256 = 60.
  15. Signed readings of the inputs are -14 and 74; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00111100

Bitwise arithmetic · Problem 0400

Add 11110011₂ and 00000000₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11110011, B=00000000.
  2. Ordinary decimal arithmetic gives 243+0=243.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+0+incoming carry 0=1; write 1, pass carry 0.
  5. Bit 1 (weight 2): 1+0+incoming carry 0=1; write 1, pass carry 0.
  6. Bit 2 (weight 4): 0+0+incoming carry 0=0; write 0, pass carry 0.
  7. Bit 3 (weight 8): 0+0+incoming carry 0=0; write 0, pass carry 0.
  8. Bit 4 (weight 16): 1+0+incoming carry 0=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+0+incoming carry 0=1; write 1, pass carry 0.
  10. Bit 6 (weight 64): 1+0+incoming carry 0=1; write 1, pass carry 0.
  11. Bit 7 (weight 128): 1+0+incoming carry 0=1; write 1, pass carry 0.
  12. The final carry-out is 0; it is outside the eight-bit result.
  13. The stored sum is 11110011, which is 243 unsigned.
  14. Check modular arithmetic: 243 modulo 256 = 243.
  15. Signed readings of the inputs are -13 and 0; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 11110011

Bitwise arithmetic · Problem 0401

Add 11110100₂ and 00000110₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11110100, B=00000110.
  2. Ordinary decimal arithmetic gives 244+6=250.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 0+0+incoming carry 0=0; write 0, pass carry 0.
  5. Bit 1 (weight 2): 0+1+incoming carry 0=1; write 1, pass carry 0.
  6. Bit 2 (weight 4): 1+1+incoming carry 0=2; write 0, pass carry 1.
  7. Bit 3 (weight 8): 0+0+incoming carry 1=1; write 1, pass carry 0.
  8. Bit 4 (weight 16): 1+0+incoming carry 0=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+0+incoming carry 0=1; write 1, pass carry 0.
  10. Bit 6 (weight 64): 1+0+incoming carry 0=1; write 1, pass carry 0.
  11. Bit 7 (weight 128): 1+0+incoming carry 0=1; write 1, pass carry 0.
  12. The final carry-out is 0; it is outside the eight-bit result.
  13. The stored sum is 11111010, which is 250 unsigned.
  14. Check modular arithmetic: 250 modulo 256 = 250.
  15. Signed readings of the inputs are -12 and 6; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 11111010

Bitwise arithmetic · Problem 0402

Add 11110100₂ and 10000010₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11110100, B=10000010.
  2. Ordinary decimal arithmetic gives 244+130=374.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 0+0+incoming carry 0=0; write 0, pass carry 0.
  5. Bit 1 (weight 2): 0+1+incoming carry 0=1; write 1, pass carry 0.
  6. Bit 2 (weight 4): 1+0+incoming carry 0=1; write 1, pass carry 0.
  7. Bit 3 (weight 8): 0+0+incoming carry 0=0; write 0, pass carry 0.
  8. Bit 4 (weight 16): 1+0+incoming carry 0=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+0+incoming carry 0=1; write 1, pass carry 0.
  10. Bit 6 (weight 64): 1+0+incoming carry 0=1; write 1, pass carry 0.
  11. Bit 7 (weight 128): 1+1+incoming carry 0=2; write 0, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 01110110, which is 118 unsigned.
  14. Check modular arithmetic: 374 modulo 256 = 118.
  15. Signed readings of the inputs are -12 and -126; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01110110

Bitwise arithmetic · Problem 0403

Add 11110101₂ and 00110101₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11110101, B=00110101.
  2. Ordinary decimal arithmetic gives 245+53=298.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+1+incoming carry 0=2; write 0, pass carry 1.
  5. Bit 1 (weight 2): 0+0+incoming carry 1=1; write 1, pass carry 0.
  6. Bit 2 (weight 4): 1+1+incoming carry 0=2; write 0, pass carry 1.
  7. Bit 3 (weight 8): 0+0+incoming carry 1=1; write 1, pass carry 0.
  8. Bit 4 (weight 16): 1+1+incoming carry 0=2; write 0, pass carry 1.
  9. Bit 5 (weight 32): 1+1+incoming carry 1=3; write 1, pass carry 1.
  10. Bit 6 (weight 64): 1+0+incoming carry 1=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 1+0+incoming carry 1=2; write 0, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 00101010, which is 42 unsigned.
  14. Check modular arithmetic: 298 modulo 256 = 42.
  15. Signed readings of the inputs are -11 and 53; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00101010

Bitwise arithmetic · Problem 0404

Add 11110101₂ and 10001000₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11110101, B=10001000.
  2. Ordinary decimal arithmetic gives 245+136=381.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+0+incoming carry 0=1; write 1, pass carry 0.
  5. Bit 1 (weight 2): 0+0+incoming carry 0=0; write 0, pass carry 0.
  6. Bit 2 (weight 4): 1+0+incoming carry 0=1; write 1, pass carry 0.
  7. Bit 3 (weight 8): 0+1+incoming carry 0=1; write 1, pass carry 0.
  8. Bit 4 (weight 16): 1+0+incoming carry 0=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+0+incoming carry 0=1; write 1, pass carry 0.
  10. Bit 6 (weight 64): 1+0+incoming carry 0=1; write 1, pass carry 0.
  11. Bit 7 (weight 128): 1+1+incoming carry 0=2; write 0, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 01111101, which is 125 unsigned.
  14. Check modular arithmetic: 381 modulo 256 = 125.
  15. Signed readings of the inputs are -11 and -120; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01111101

Bitwise arithmetic · Problem 0405

Add 11110110₂ and 01100000₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11110110, B=01100000.
  2. Ordinary decimal arithmetic gives 246+96=342.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 0+0+incoming carry 0=0; write 0, pass carry 0.
  5. Bit 1 (weight 2): 1+0+incoming carry 0=1; write 1, pass carry 0.
  6. Bit 2 (weight 4): 1+0+incoming carry 0=1; write 1, pass carry 0.
  7. Bit 3 (weight 8): 0+0+incoming carry 0=0; write 0, pass carry 0.
  8. Bit 4 (weight 16): 1+0+incoming carry 0=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+1+incoming carry 0=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 1+1+incoming carry 1=3; write 1, pass carry 1.
  11. Bit 7 (weight 128): 1+0+incoming carry 1=2; write 0, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 01010110, which is 86 unsigned.
  14. Check modular arithmetic: 342 modulo 256 = 86.
  15. Signed readings of the inputs are -10 and 96; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01010110

Bitwise arithmetic · Problem 0406

Add 11110111₂ and 00101000₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11110111, B=00101000.
  2. Ordinary decimal arithmetic gives 247+40=287.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+0+incoming carry 0=1; write 1, pass carry 0.
  5. Bit 1 (weight 2): 1+0+incoming carry 0=1; write 1, pass carry 0.
  6. Bit 2 (weight 4): 1+0+incoming carry 0=1; write 1, pass carry 0.
  7. Bit 3 (weight 8): 0+1+incoming carry 0=1; write 1, pass carry 0.
  8. Bit 4 (weight 16): 1+0+incoming carry 0=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+1+incoming carry 0=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 1+0+incoming carry 1=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 1+0+incoming carry 1=2; write 0, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 00011111, which is 31 unsigned.
  14. Check modular arithmetic: 287 modulo 256 = 31.
  15. Signed readings of the inputs are -9 and 40; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00011111

Bitwise arithmetic · Problem 0407

Add 11111000₂ and 00000001₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11111000, B=00000001.
  2. Ordinary decimal arithmetic gives 248+1=249.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 0+1+incoming carry 0=1; write 1, pass carry 0.
  5. Bit 1 (weight 2): 0+0+incoming carry 0=0; write 0, pass carry 0.
  6. Bit 2 (weight 4): 0+0+incoming carry 0=0; write 0, pass carry 0.
  7. Bit 3 (weight 8): 1+0+incoming carry 0=1; write 1, pass carry 0.
  8. Bit 4 (weight 16): 1+0+incoming carry 0=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+0+incoming carry 0=1; write 1, pass carry 0.
  10. Bit 6 (weight 64): 1+0+incoming carry 0=1; write 1, pass carry 0.
  11. Bit 7 (weight 128): 1+0+incoming carry 0=1; write 1, pass carry 0.
  12. The final carry-out is 0; it is outside the eight-bit result.
  13. The stored sum is 11111001, which is 249 unsigned.
  14. Check modular arithmetic: 249 modulo 256 = 249.
  15. Signed readings of the inputs are -8 and 1; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 11111001

Bitwise arithmetic · Problem 0408

Add 11111000₂ and 11110101₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11111000, B=11110101.
  2. Ordinary decimal arithmetic gives 248+245=493.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 0+1+incoming carry 0=1; write 1, pass carry 0.
  5. Bit 1 (weight 2): 0+0+incoming carry 0=0; write 0, pass carry 0.
  6. Bit 2 (weight 4): 0+1+incoming carry 0=1; write 1, pass carry 0.
  7. Bit 3 (weight 8): 1+0+incoming carry 0=1; write 1, pass carry 0.
  8. Bit 4 (weight 16): 1+1+incoming carry 0=2; write 0, pass carry 1.
  9. Bit 5 (weight 32): 1+1+incoming carry 1=3; write 1, pass carry 1.
  10. Bit 6 (weight 64): 1+1+incoming carry 1=3; write 1, pass carry 1.
  11. Bit 7 (weight 128): 1+1+incoming carry 1=3; write 1, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 11101101, which is 237 unsigned.
  14. Check modular arithmetic: 493 modulo 256 = 237.
  15. Signed readings of the inputs are -8 and -11; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 11101101

Bitwise arithmetic · Problem 0409

Add 11111000₂ and 11110110₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11111000, B=11110110.
  2. Ordinary decimal arithmetic gives 248+246=494.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 0+0+incoming carry 0=0; write 0, pass carry 0.
  5. Bit 1 (weight 2): 0+1+incoming carry 0=1; write 1, pass carry 0.
  6. Bit 2 (weight 4): 0+1+incoming carry 0=1; write 1, pass carry 0.
  7. Bit 3 (weight 8): 1+0+incoming carry 0=1; write 1, pass carry 0.
  8. Bit 4 (weight 16): 1+1+incoming carry 0=2; write 0, pass carry 1.
  9. Bit 5 (weight 32): 1+1+incoming carry 1=3; write 1, pass carry 1.
  10. Bit 6 (weight 64): 1+1+incoming carry 1=3; write 1, pass carry 1.
  11. Bit 7 (weight 128): 1+1+incoming carry 1=3; write 1, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 11101110, which is 238 unsigned.
  14. Check modular arithmetic: 494 modulo 256 = 238.
  15. Signed readings of the inputs are -8 and -10; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 11101110

Bitwise arithmetic · Problem 0410

Add 11111001₂ and 00010111₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11111001, B=00010111.
  2. Ordinary decimal arithmetic gives 249+23=272.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+1+incoming carry 0=2; write 0, pass carry 1.
  5. Bit 1 (weight 2): 0+1+incoming carry 1=2; write 0, pass carry 1.
  6. Bit 2 (weight 4): 0+1+incoming carry 1=2; write 0, pass carry 1.
  7. Bit 3 (weight 8): 1+0+incoming carry 1=2; write 0, pass carry 1.
  8. Bit 4 (weight 16): 1+1+incoming carry 1=3; write 1, pass carry 1.
  9. Bit 5 (weight 32): 1+0+incoming carry 1=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 1+0+incoming carry 1=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 1+0+incoming carry 1=2; write 0, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 00010000, which is 16 unsigned.
  14. Check modular arithmetic: 272 modulo 256 = 16.
  15. Signed readings of the inputs are -7 and 23; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00010000

Bitwise arithmetic · Problem 0411

Add 11111001₂ and 10111011₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11111001, B=10111011.
  2. Ordinary decimal arithmetic gives 249+187=436.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+1+incoming carry 0=2; write 0, pass carry 1.
  5. Bit 1 (weight 2): 0+1+incoming carry 1=2; write 0, pass carry 1.
  6. Bit 2 (weight 4): 0+0+incoming carry 1=1; write 1, pass carry 0.
  7. Bit 3 (weight 8): 1+1+incoming carry 0=2; write 0, pass carry 1.
  8. Bit 4 (weight 16): 1+1+incoming carry 1=3; write 1, pass carry 1.
  9. Bit 5 (weight 32): 1+1+incoming carry 1=3; write 1, pass carry 1.
  10. Bit 6 (weight 64): 1+0+incoming carry 1=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 1+1+incoming carry 1=3; write 1, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 10110100, which is 180 unsigned.
  14. Check modular arithmetic: 436 modulo 256 = 180.
  15. Signed readings of the inputs are -7 and -69; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 10110100

Bitwise arithmetic · Problem 0412

Add 11111010₂ and 00011111₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11111010, B=00011111.
  2. Ordinary decimal arithmetic gives 250+31=281.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 0+1+incoming carry 0=1; write 1, pass carry 0.
  5. Bit 1 (weight 2): 1+1+incoming carry 0=2; write 0, pass carry 1.
  6. Bit 2 (weight 4): 0+1+incoming carry 1=2; write 0, pass carry 1.
  7. Bit 3 (weight 8): 1+1+incoming carry 1=3; write 1, pass carry 1.
  8. Bit 4 (weight 16): 1+1+incoming carry 1=3; write 1, pass carry 1.
  9. Bit 5 (weight 32): 1+0+incoming carry 1=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 1+0+incoming carry 1=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 1+0+incoming carry 1=2; write 0, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 00011001, which is 25 unsigned.
  14. Check modular arithmetic: 281 modulo 256 = 25.
  15. Signed readings of the inputs are -6 and 31; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00011001

Bitwise arithmetic · Problem 0413

Add 11111010₂ and 10111010₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11111010, B=10111010.
  2. Ordinary decimal arithmetic gives 250+186=436.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 0+0+incoming carry 0=0; write 0, pass carry 0.
  5. Bit 1 (weight 2): 1+1+incoming carry 0=2; write 0, pass carry 1.
  6. Bit 2 (weight 4): 0+0+incoming carry 1=1; write 1, pass carry 0.
  7. Bit 3 (weight 8): 1+1+incoming carry 0=2; write 0, pass carry 1.
  8. Bit 4 (weight 16): 1+1+incoming carry 1=3; write 1, pass carry 1.
  9. Bit 5 (weight 32): 1+1+incoming carry 1=3; write 1, pass carry 1.
  10. Bit 6 (weight 64): 1+0+incoming carry 1=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 1+1+incoming carry 1=3; write 1, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 10110100, which is 180 unsigned.
  14. Check modular arithmetic: 436 modulo 256 = 180.
  15. Signed readings of the inputs are -6 and -70; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 10110100

Bitwise arithmetic · Problem 0414

Add 11111011₂ and 00011111₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11111011, B=00011111.
  2. Ordinary decimal arithmetic gives 251+31=282.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+1+incoming carry 0=2; write 0, pass carry 1.
  5. Bit 1 (weight 2): 1+1+incoming carry 1=3; write 1, pass carry 1.
  6. Bit 2 (weight 4): 0+1+incoming carry 1=2; write 0, pass carry 1.
  7. Bit 3 (weight 8): 1+1+incoming carry 1=3; write 1, pass carry 1.
  8. Bit 4 (weight 16): 1+1+incoming carry 1=3; write 1, pass carry 1.
  9. Bit 5 (weight 32): 1+0+incoming carry 1=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 1+0+incoming carry 1=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 1+0+incoming carry 1=2; write 0, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 00011010, which is 26 unsigned.
  14. Check modular arithmetic: 282 modulo 256 = 26.
  15. Signed readings of the inputs are -5 and 31; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00011010

Bitwise arithmetic · Problem 0415

Add 11111100₂ and 01111001₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11111100, B=01111001.
  2. Ordinary decimal arithmetic gives 252+121=373.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 0+1+incoming carry 0=1; write 1, pass carry 0.
  5. Bit 1 (weight 2): 0+0+incoming carry 0=0; write 0, pass carry 0.
  6. Bit 2 (weight 4): 1+0+incoming carry 0=1; write 1, pass carry 0.
  7. Bit 3 (weight 8): 1+1+incoming carry 0=2; write 0, pass carry 1.
  8. Bit 4 (weight 16): 1+1+incoming carry 1=3; write 1, pass carry 1.
  9. Bit 5 (weight 32): 1+1+incoming carry 1=3; write 1, pass carry 1.
  10. Bit 6 (weight 64): 1+1+incoming carry 1=3; write 1, pass carry 1.
  11. Bit 7 (weight 128): 1+0+incoming carry 1=2; write 0, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 01110101, which is 117 unsigned.
  14. Check modular arithmetic: 373 modulo 256 = 117.
  15. Signed readings of the inputs are -4 and 121; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01110101

Bitwise arithmetic · Problem 0416

Add 11111100₂ and 10010111₂; keep the low eight result bits.

Try it on paper first. The worked answer is hidden below.

Reveal detailed solution →
  1. Use exactly eight bits: A=11111100, B=10010111.
  2. Ordinary decimal arithmetic gives 252+151=403.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 0+1+incoming carry 0=1; write 1, pass carry 0.
  5. Bit 1 (weight 2): 0+1+incoming carry 0=1; write 1, pass carry 0.
  6. Bit 2 (weight 4): 1+1+incoming carry 0=2; write 0, pass carry 1.
  7. Bit 3 (weight 8): 1+0+incoming carry 1=2; write 0, pass carry 1.
  8. Bit 4 (weight 16): 1+1+incoming carry 1=3; write 1, pass carry 1.
  9. Bit 5 (weight 32): 1+0+incoming carry 1=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 1+0+incoming carry 1=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 1+1+incoming carry 1=3; write 1, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 10010011, which is 147 unsigned.
  14. Check modular arithmetic: 403 modulo 256 = 147.
  15. Signed readings of the inputs are -4 and -105; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 10010011