01How Computers Work
Practice library / Eight-bit addition

Fully solved problem book

Eight-bit addition

Set 12 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 0353

Add 11010100₂ and 01010100₂; 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=11010100, B=01010100.
  2. Ordinary decimal arithmetic gives 212+84=296.
  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+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): 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): 0+0+incoming carry 1=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 00101000, which is 40 unsigned.
  14. Check modular arithmetic: 296 modulo 256 = 40.
  15. Signed readings of the inputs are -44 and 84; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00101000

Bitwise arithmetic · Problem 0354

Add 11010100₂ 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=11010100, B=10111011.
  2. Ordinary decimal arithmetic gives 212+187=399.
  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+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+1+incoming carry 0=2; write 0, pass carry 1.
  9. Bit 5 (weight 32): 0+1+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 10001111, which is 143 unsigned.
  14. Check modular arithmetic: 399 modulo 256 = 143.
  15. Signed readings of the inputs are -44 and -69; 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 0355

Add 11010100₂ and 11111010₂; 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=11010100, B=11111010.
  2. Ordinary decimal arithmetic gives 212+250=462.
  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+1+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): 0+1+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+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 11001110, which is 206 unsigned.
  14. Check modular arithmetic: 462 modulo 256 = 206.
  15. Signed readings of the inputs are -44 and -6; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 11001110

Bitwise arithmetic · Problem 0356

Add 11010101₂ and 11001001₂; 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=11010101, B=11001001.
  2. Ordinary decimal arithmetic gives 213+201=414.
  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+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): 0+0+incoming carry 0=0; write 0, 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 10011110, which is 158 unsigned.
  14. Check modular arithmetic: 414 modulo 256 = 158.
  15. Signed readings of the inputs are -43 and -55; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 10011110

Bitwise arithmetic · Problem 0357

Add 11010111₂ and 00001010₂; 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=11010111, B=00001010.
  2. Ordinary decimal arithmetic gives 215+10=225.
  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): 0+1+incoming carry 1=2; write 0, pass carry 1.
  8. Bit 4 (weight 16): 1+0+incoming carry 1=2; write 0, pass carry 1.
  9. Bit 5 (weight 32): 0+0+incoming carry 1=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 11100001, which is 225 unsigned.
  14. Check modular arithmetic: 225 modulo 256 = 225.
  15. Signed readings of the inputs are -41 and 10; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 11100001

Bitwise arithmetic · Problem 0358

Add 11010111₂ and 01100110₂; 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=11010111, B=01100110.
  2. Ordinary decimal arithmetic gives 215+102=317.
  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+1+incoming carry 1=3; write 1, 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): 0+1+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 00111101, which is 61 unsigned.
  14. Check modular arithmetic: 317 modulo 256 = 61.
  15. Signed readings of the inputs are -41 and 102; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00111101

Bitwise arithmetic · Problem 0359

Add 11010111₂ and 10100010₂; 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=11010111, B=10100010.
  2. Ordinary decimal arithmetic gives 215+162=377.
  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): 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): 0+1+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 01111001, which is 121 unsigned.
  14. Check modular arithmetic: 377 modulo 256 = 121.
  15. Signed readings of the inputs are -41 and -94; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01111001

Bitwise arithmetic · Problem 0360

Add 11011000₂ and 11000010₂; 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=11011000, B=11000010.
  2. Ordinary decimal arithmetic gives 216+194=410.
  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+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): 0+0+incoming carry 0=0; write 0, 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 10011010, which is 154 unsigned.
  14. Check modular arithmetic: 410 modulo 256 = 154.
  15. Signed readings of the inputs are -40 and -62; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 10011010

Bitwise arithmetic · Problem 0361

Add 11011001₂ and 01111101₂; 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=11011001, B=01111101.
  2. Ordinary decimal arithmetic gives 217+125=342.
  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+1+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): 0+1+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 01010110, which is 86 unsigned.
  14. Check modular arithmetic: 342 modulo 256 = 86.
  15. Signed readings of the inputs are -39 and 125; 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 0362

Add 11011001₂ and 11010001₂; 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=11011001, B=11010001.
  2. Ordinary decimal arithmetic gives 217+209=426.
  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): 1+1+incoming carry 0=2; write 0, pass carry 1.
  9. Bit 5 (weight 32): 0+0+incoming carry 1=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 10101010, which is 170 unsigned.
  14. Check modular arithmetic: 426 modulo 256 = 170.
  15. Signed readings of the inputs are -39 and -47; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 10101010

Bitwise arithmetic · Problem 0363

Add 11011010₂ and 01011101₂; 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=11011010, B=01011101.
  2. Ordinary decimal arithmetic gives 218+93=311.
  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+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): 0+0+incoming carry 1=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 00110111, which is 55 unsigned.
  14. Check modular arithmetic: 311 modulo 256 = 55.
  15. Signed readings of the inputs are -38 and 93; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00110111

Bitwise arithmetic · Problem 0364

Add 11011010₂ 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=11011010, B=10010111.
  2. Ordinary decimal arithmetic gives 218+151=369.
  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+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): 0+0+incoming carry 1=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 01110001, which is 113 unsigned.
  14. Check modular arithmetic: 369 modulo 256 = 113.
  15. Signed readings of the inputs are -38 and -105; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01110001

Bitwise arithmetic · Problem 0365

Add 11011010₂ and 10100010₂; 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=11011010, B=10100010.
  2. Ordinary decimal arithmetic gives 218+162=380.
  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+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): 0+1+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 01111100, which is 124 unsigned.
  14. Check modular arithmetic: 380 modulo 256 = 124.
  15. Signed readings of the inputs are -38 and -94; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01111100

Bitwise arithmetic · Problem 0366

Add 11011011₂ 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=11011011, B=01100100.
  2. Ordinary decimal arithmetic gives 219+100=319.
  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+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+0+incoming carry 0=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 0+1+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 00111111, which is 63 unsigned.
  14. Check modular arithmetic: 319 modulo 256 = 63.
  15. Signed readings of the inputs are -37 and 100; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00111111

Bitwise arithmetic · Problem 0367

Add 11011100₂ and 00100000₂; 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=11011100, B=00100000.
  2. Ordinary decimal arithmetic gives 220+32=252.
  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+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+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): 0+1+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 11111100, which is 252 unsigned.
  14. Check modular arithmetic: 252 modulo 256 = 252.
  15. Signed readings of the inputs are -36 and 32; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 11111100

Bitwise arithmetic · Problem 0368

Add 11011100₂ and 10110111₂; 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=11011100, B=10110111.
  2. Ordinary decimal arithmetic gives 220+183=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): 0+1+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 -36 and -73; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 10010011

Bitwise arithmetic · Problem 0369

Add 11011101₂ and 10001001₂; 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=11011101, B=10001001.
  2. Ordinary decimal arithmetic gives 221+137=358.
  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+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+0+incoming carry 1=2; write 0, pass carry 1.
  9. Bit 5 (weight 32): 0+0+incoming carry 1=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 01100110, which is 102 unsigned.
  14. Check modular arithmetic: 358 modulo 256 = 102.
  15. Signed readings of the inputs are -35 and -119; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01100110

Bitwise arithmetic · Problem 0370

Add 11011110₂ and 10010001₂; 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=11011110, B=10010001.
  2. Ordinary decimal arithmetic gives 222+145=367.
  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): 1+0+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): 0+0+incoming carry 1=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 01101111, which is 111 unsigned.
  14. Check modular arithmetic: 367 modulo 256 = 111.
  15. Signed readings of the inputs are -34 and -111; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01101111

Bitwise arithmetic · Problem 0371

Add 11100000₂ and 00100011₂; 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=11100000, B=00100011.
  2. Ordinary decimal arithmetic gives 224+35=259.
  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): 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): 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+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 00000011, which is 3 unsigned.
  14. Check modular arithmetic: 259 modulo 256 = 3.
  15. Signed readings of the inputs are -32 and 35; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00000011

Bitwise arithmetic · Problem 0372

Add 11100000₂ and 01110010₂; 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=11100000, B=01110010.
  2. Ordinary decimal arithmetic gives 224+114=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): 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): 0+1+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 01010010, which is 82 unsigned.
  14. Check modular arithmetic: 338 modulo 256 = 82.
  15. Signed readings of the inputs are -32 and 114; 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 0373

Add 11100001₂ and 01100001₂; 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=11100001, B=01100001.
  2. Ordinary decimal arithmetic gives 225+97=322.
  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): 0+0+incoming carry 0=0; write 0, 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+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 01000010, which is 66 unsigned.
  14. Check modular arithmetic: 322 modulo 256 = 66.
  15. Signed readings of the inputs are -31 and 97; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01000010

Bitwise arithmetic · Problem 0374

Add 11100011₂ and 00000111₂; 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=11100011, B=00000111.
  2. Ordinary decimal arithmetic gives 227+7=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): 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): 0+0+incoming carry 1=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 -29 and 7; 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 0375

Add 11100011₂ and 00101111₂; 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=11100011, B=00101111.
  2. Ordinary decimal arithmetic gives 227+47=274.
  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): 0+1+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+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 00010010, which is 18 unsigned.
  14. Check modular arithmetic: 274 modulo 256 = 18.
  15. Signed readings of the inputs are -29 and 47; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00010010

Bitwise arithmetic · Problem 0376

Add 11100011₂ and 10101111₂; 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=11100011, B=10101111.
  2. Ordinary decimal arithmetic gives 227+175=402.
  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): 0+1+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+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 10010010, which is 146 unsigned.
  14. Check modular arithmetic: 402 modulo 256 = 146.
  15. Signed readings of the inputs are -29 and -81; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 10010010

Bitwise arithmetic · Problem 0377

Add 11100100₂ and 01011000₂; 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=11100100, B=01011000.
  2. Ordinary decimal arithmetic gives 228+88=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): 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): 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+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 -28 and 88; 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 0378

Add 11100101₂ and 00011010₂; 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=11100101, B=00011010.
  2. Ordinary decimal arithmetic gives 229+26=255.
  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+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): 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+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 11111111, which is 255 unsigned.
  14. Check modular arithmetic: 255 modulo 256 = 255.
  15. Signed readings of the inputs are -27 and 26; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 11111111

Bitwise arithmetic · Problem 0379

Add 11100101₂ and 00100100₂; 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=11100101, B=00100100.
  2. Ordinary decimal arithmetic gives 229+36=265.
  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+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): 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+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 00001001, which is 9 unsigned.
  14. Check modular arithmetic: 265 modulo 256 = 9.
  15. Signed readings of the inputs are -27 and 36; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00001001

Bitwise arithmetic · Problem 0380

Add 11100101₂ and 01010011₂; 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=11100101, B=01010011.
  2. Ordinary decimal arithmetic gives 229+83=312.
  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): 1+0+incoming carry 1=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): 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+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 00111000, which is 56 unsigned.
  14. Check modular arithmetic: 312 modulo 256 = 56.
  15. Signed readings of the inputs are -27 and 83; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00111000

Bitwise arithmetic · Problem 0381

Add 11100101₂ and 10000110₂; 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=11100101, B=10000110.
  2. Ordinary decimal arithmetic gives 229+134=363.
  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): 0+0+incoming carry 1=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+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 01101011, which is 107 unsigned.
  14. Check modular arithmetic: 363 modulo 256 = 107.
  15. Signed readings of the inputs are -27 and -122; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01101011

Bitwise arithmetic · Problem 0382

Add 11100110₂ and 00100110₂; 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=11100110, B=00100110.
  2. Ordinary decimal arithmetic gives 230+38=268.
  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): 1+1+incoming carry 1=3; write 1, pass carry 1.
  7. Bit 3 (weight 8): 0+0+incoming carry 1=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+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 00001100, which is 12 unsigned.
  14. Check modular arithmetic: 268 modulo 256 = 12.
  15. Signed readings of the inputs are -26 and 38; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00001100

Bitwise arithmetic · Problem 0383

Add 11100110₂ and 11011000₂; 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=11100110, B=11011000.
  2. Ordinary decimal arithmetic gives 230+216=446.
  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+1+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+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 10111110, which is 190 unsigned.
  14. Check modular arithmetic: 446 modulo 256 = 190.
  15. Signed readings of the inputs are -26 and -40; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 10111110

Bitwise arithmetic · Problem 0384

Add 11101000₂ 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=11101000, B=01101111.
  2. Ordinary decimal arithmetic gives 232+111=343.
  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): 0+1+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): 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 01010111, which is 87 unsigned.
  14. Check modular arithmetic: 343 modulo 256 = 87.
  15. Signed readings of the inputs are -24 and 111; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01010111