01How Computers Work
Practice library / Eight-bit addition

Fully solved problem book

Eight-bit addition

Set 10 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 0289

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

Final answer: 11111101

Bitwise arithmetic · Problem 0290

Add 10101111₂ and 01110110₂; 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=10101111, B=01110110.
  2. Ordinary decimal arithmetic gives 175+118=293.
  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): 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+1+incoming carry 1=3; write 1, pass carry 1.
  10. Bit 6 (weight 64): 0+1+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 00100101, which is 37 unsigned.
  14. Check modular arithmetic: 293 modulo 256 = 37.
  15. Signed readings of the inputs are -81 and 118; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00100101

Bitwise arithmetic · Problem 0291

Add 10101111₂ and 11000111₂; 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=10101111, B=11000111.
  2. Ordinary decimal arithmetic gives 175+199=374.
  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): 1+1+incoming carry 1=3; write 1, 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): 0+1+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 -81 and -57; 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 0292

Add 10110001₂ and 00001000₂; 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=10110001, B=00001000.
  2. Ordinary decimal arithmetic gives 177+8=185.
  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): 0+0+incoming carry 0=0; write 0, 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): 0+0+incoming carry 0=0; write 0, 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 10111001, which is 185 unsigned.
  14. Check modular arithmetic: 185 modulo 256 = 185.
  15. Signed readings of the inputs are -79 and 8; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 10111001

Bitwise arithmetic · Problem 0293

Add 10110010₂ and 10011010₂; 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=10110010, B=10011010.
  2. Ordinary decimal arithmetic gives 178+154=332.
  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+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): 0+0+incoming carry 1=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 01001100, which is 76 unsigned.
  14. Check modular arithmetic: 332 modulo 256 = 76.
  15. Signed readings of the inputs are -78 and -102; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01001100

Bitwise arithmetic · Problem 0294

Add 10110010₂ and 11010110₂; 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=10110010, B=11010110.
  2. Ordinary decimal arithmetic gives 178+214=392.
  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+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): 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): 0+1+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 10001000, which is 136 unsigned.
  14. Check modular arithmetic: 392 modulo 256 = 136.
  15. Signed readings of the inputs are -78 and -42; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 10001000

Bitwise arithmetic · Problem 0295

Add 10110011₂ and 00010011₂; 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=10110011, B=00010011.
  2. Ordinary decimal arithmetic gives 179+19=198.
  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+0+incoming carry 1=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+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): 0+0+incoming carry 1=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 11000110, which is 198 unsigned.
  14. Check modular arithmetic: 198 modulo 256 = 198.
  15. Signed readings of the inputs are -77 and 19; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 11000110

Bitwise arithmetic · Problem 0296

Add 10110011₂ and 00011011₂; 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=10110011, B=00011011.
  2. Ordinary decimal arithmetic gives 179+27=206.
  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+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+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): 0+0+incoming carry 1=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 11001110, which is 206 unsigned.
  14. Check modular arithmetic: 206 modulo 256 = 206.
  15. Signed readings of the inputs are -77 and 27; 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 0297

Add 10110011₂ and 01101011₂; 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=10110011, B=01101011.
  2. Ordinary decimal arithmetic gives 179+107=286.
  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+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+1+incoming carry 0=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 0+1+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 00011110, which is 30 unsigned.
  14. Check modular arithmetic: 286 modulo 256 = 30.
  15. Signed readings of the inputs are -77 and 107; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00011110

Bitwise arithmetic · Problem 0298

Add 10110101₂ and 00001001₂; 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=10110101, B=00001001.
  2. Ordinary decimal arithmetic gives 181+9=190.
  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): 1+0+incoming carry 0=1; write 1, pass carry 0.
  10. Bit 6 (weight 64): 0+0+incoming carry 0=0; write 0, 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 10111110, which is 190 unsigned.
  14. Check modular arithmetic: 190 modulo 256 = 190.
  15. Signed readings of the inputs are -75 and 9; 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 0299

Add 10110101₂ and 00010110₂; 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=10110101, B=00010110.
  2. Ordinary decimal arithmetic gives 181+22=203.
  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): 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): 0+0+incoming carry 1=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 11001011, which is 203 unsigned.
  14. Check modular arithmetic: 203 modulo 256 = 203.
  15. Signed readings of the inputs are -75 and 22; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 11001011

Bitwise arithmetic · Problem 0300

Add 10110111₂ 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=10110111, B=00100000.
  2. Ordinary decimal arithmetic gives 183+32=215.
  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+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): 0+0+incoming carry 1=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 11010111, which is 215 unsigned.
  14. Check modular arithmetic: 215 modulo 256 = 215.
  15. Signed readings of the inputs are -73 and 32; 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 0301

Add 10110111₂ 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=10110111, B=00111110.
  2. Ordinary decimal arithmetic gives 183+62=245.
  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+1+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+1+incoming carry 1=3; write 1, pass carry 1.
  10. Bit 6 (weight 64): 0+0+incoming carry 1=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 11110101, which is 245 unsigned.
  14. Check modular arithmetic: 245 modulo 256 = 245.
  15. Signed readings of the inputs are -73 and 62; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 11110101

Bitwise arithmetic · Problem 0302

Add 10110111₂ and 01000010₂; 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=10110111, B=01000010.
  2. Ordinary decimal arithmetic gives 183+66=249.
  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): 1+0+incoming carry 0=1; write 1, pass carry 0.
  10. Bit 6 (weight 64): 0+1+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 -73 and 66; 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 0303

Add 10110111₂ and 01001011₂; 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=10110111, B=01001011.
  2. Ordinary decimal arithmetic gives 183+75=258.
  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): 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): 1+0+incoming carry 1=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 0+1+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 00000010, which is 2 unsigned.
  14. Check modular arithmetic: 258 modulo 256 = 2.
  15. Signed readings of the inputs are -73 and 75; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00000010

Bitwise arithmetic · Problem 0304

Add 10111000₂ and 10010110₂; 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=10111000, B=10010110.
  2. Ordinary decimal arithmetic gives 184+150=334.
  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+0+incoming carry 1=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 0+0+incoming carry 1=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 01001110, which is 78 unsigned.
  14. Check modular arithmetic: 334 modulo 256 = 78.
  15. Signed readings of the inputs are -72 and -106; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01001110

Bitwise arithmetic · Problem 0305

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

Final answer: 10110111

Bitwise arithmetic · Problem 0306

Add 10111001₂ and 00111010₂; 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=10111001, B=00111010.
  2. Ordinary decimal arithmetic gives 185+58=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): 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+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): 0+0+incoming carry 1=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 -71 and 58; 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 0307

Add 10111001₂ and 01110000₂; 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=10111001, B=01110000.
  2. Ordinary decimal arithmetic gives 185+112=297.
  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): 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): 1+1+incoming carry 1=3; write 1, pass carry 1.
  10. Bit 6 (weight 64): 0+1+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 -71 and 112; 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 0308

Add 10111001₂ and 10111100₂; 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=10111001, B=10111100.
  2. Ordinary decimal arithmetic gives 185+188=373.
  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): 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): 1+1+incoming carry 1=3; write 1, pass carry 1.
  10. Bit 6 (weight 64): 0+0+incoming carry 1=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 01110101, which is 117 unsigned.
  14. Check modular arithmetic: 373 modulo 256 = 117.
  15. Signed readings of the inputs are -71 and -68; 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 0309

Add 10111001₂ and 11100000₂; 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=10111001, B=11100000.
  2. Ordinary decimal arithmetic gives 185+224=409.
  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): 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+1+incoming carry 0=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 0+1+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 10011001, which is 153 unsigned.
  14. Check modular arithmetic: 409 modulo 256 = 153.
  15. Signed readings of the inputs are -71 and -32; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 10011001

Bitwise arithmetic · Problem 0310

Add 10111010₂ and 10101010₂; 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=10111010, B=10101010.
  2. Ordinary decimal arithmetic gives 186+170=356.
  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+0+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): 0+0+incoming carry 1=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 01100100, which is 100 unsigned.
  14. Check modular arithmetic: 356 modulo 256 = 100.
  15. Signed readings of the inputs are -70 and -86; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01100100

Bitwise arithmetic · Problem 0311

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

Final answer: 11110101

Bitwise arithmetic · Problem 0312

Add 10111101₂ and 11011001₂; 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=10111101, B=11011001.
  2. Ordinary decimal arithmetic gives 189+217=406.
  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+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): 0+1+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 10010110, which is 150 unsigned.
  14. Check modular arithmetic: 406 modulo 256 = 150.
  15. Signed readings of the inputs are -67 and -39; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 10010110

Bitwise arithmetic · Problem 0313

Add 10111110₂ and 00010000₂; 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=10111110, B=00010000.
  2. Ordinary decimal arithmetic gives 190+16=206.
  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): 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+0+incoming carry 1=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 0+0+incoming carry 1=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 11001110, which is 206 unsigned.
  14. Check modular arithmetic: 206 modulo 256 = 206.
  15. Signed readings of the inputs are -66 and 16; 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 0314

Add 10111110₂ 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=10111110, B=11110101.
  2. Ordinary decimal arithmetic gives 190+245=435.
  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+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+1+incoming carry 1=3; write 1, pass carry 1.
  10. Bit 6 (weight 64): 0+1+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 10110011, which is 179 unsigned.
  14. Check modular arithmetic: 435 modulo 256 = 179.
  15. Signed readings of the inputs are -66 and -11; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 10110011

Bitwise arithmetic · Problem 0315

Add 10111111₂ and 00000101₂; 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=10111111, B=00000101.
  2. Ordinary decimal arithmetic gives 191+5=196.
  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+0+incoming carry 1=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): 1+0+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): 1+0+incoming carry 1=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 0+0+incoming carry 1=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 11000100, which is 196 unsigned.
  14. Check modular arithmetic: 196 modulo 256 = 196.
  15. Signed readings of the inputs are -65 and 5; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 11000100

Bitwise arithmetic · Problem 0316

Add 10111111₂ 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=10111111, B=00101000.
  2. Ordinary decimal arithmetic gives 191+40=231.
  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): 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): 1+1+incoming carry 1=3; write 1, pass carry 1.
  10. Bit 6 (weight 64): 0+0+incoming carry 1=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 11100111, which is 231 unsigned.
  14. Check modular arithmetic: 231 modulo 256 = 231.
  15. Signed readings of the inputs are -65 and 40; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 11100111

Bitwise arithmetic · Problem 0317

Add 10111111₂ and 01110001₂; 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=10111111, B=01110001.
  2. Ordinary decimal arithmetic gives 191+113=304.
  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+0+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): 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+1+incoming carry 1=3; write 1, pass carry 1.
  10. Bit 6 (weight 64): 0+1+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 00110000, which is 48 unsigned.
  14. Check modular arithmetic: 304 modulo 256 = 48.
  15. Signed readings of the inputs are -65 and 113; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00110000

Bitwise arithmetic · Problem 0318

Add 11000000₂ and 00000100₂; 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=11000000, B=00000100.
  2. Ordinary decimal arithmetic gives 192+4=196.
  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): 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): 0+0+incoming carry 0=0; write 0, 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+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 11000100, which is 196 unsigned.
  14. Check modular arithmetic: 196 modulo 256 = 196.
  15. Signed readings of the inputs are -64 and 4; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 11000100

Bitwise arithmetic · Problem 0319

Add 11000000₂ and 00001000₂; 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=11000000, B=00001000.
  2. Ordinary decimal arithmetic gives 192+8=200.
  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): 0+0+incoming carry 0=0; write 0, 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+0+incoming carry 0=0; write 0, 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+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 11001000, which is 200 unsigned.
  14. Check modular arithmetic: 200 modulo 256 = 200.
  15. Signed readings of the inputs are -64 and 8; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 11001000

Bitwise arithmetic · Problem 0320

Add 11000000₂ and 11010000₂; 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=11000000, B=11010000.
  2. Ordinary decimal arithmetic gives 192+208=400.
  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): 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): 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 10010000, which is 144 unsigned.
  14. Check modular arithmetic: 400 modulo 256 = 144.
  15. Signed readings of the inputs are -64 and -48; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 10010000