01How Computers Work
Practice library / Eight-bit addition

Fully solved problem book

Eight-bit addition

Set 2 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 0033

Add 00010010₂ and 10000111₂; 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=00010010, B=10000111.
  2. Ordinary decimal arithmetic gives 18+135=153.
  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): 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+0+incoming carry 0=0; write 0, pass carry 0.
  10. Bit 6 (weight 64): 0+0+incoming carry 0=0; write 0, pass carry 0.
  11. Bit 7 (weight 128): 0+1+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 10011001, which is 153 unsigned.
  14. Check modular arithmetic: 153 modulo 256 = 153.
  15. Signed readings of the inputs are 18 and -121; 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 0034

Add 00010010₂ 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=00010010, B=10111100.
  2. Ordinary decimal arithmetic gives 18+188=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): 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+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): 0+0+incoming carry 1=1; write 1, pass carry 0.
  11. Bit 7 (weight 128): 0+1+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 18 and -68; 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 0035

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

Final answer: 11110110

Bitwise arithmetic · Problem 0036

Add 00010011₂ and 00001101₂; 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=00010011, B=00001101.
  2. Ordinary decimal arithmetic gives 19+13=32.
  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): 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): 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): 0+0+incoming carry 0=0; write 0, pass carry 0.
  11. Bit 7 (weight 128): 0+0+incoming carry 0=0; write 0, pass carry 0.
  12. The final carry-out is 0; it is outside the eight-bit result.
  13. The stored sum is 00100000, which is 32 unsigned.
  14. Check modular arithmetic: 32 modulo 256 = 32.
  15. Signed readings of the inputs are 19 and 13; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00100000

Bitwise arithmetic · Problem 0037

Add 00010011₂ and 10001101₂; 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=00010011, B=10001101.
  2. Ordinary decimal arithmetic gives 19+141=160.
  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): 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): 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): 0+0+incoming carry 0=0; write 0, pass carry 0.
  11. Bit 7 (weight 128): 0+1+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 10100000, which is 160 unsigned.
  14. Check modular arithmetic: 160 modulo 256 = 160.
  15. Signed readings of the inputs are 19 and -115; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 10100000

Bitwise arithmetic · Problem 0038

Add 00010100₂ 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=00010100, B=00111101.
  2. Ordinary decimal arithmetic gives 20+61=81.
  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): 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): 0+1+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): 0+0+incoming carry 0=0; write 0, pass carry 0.
  12. The final carry-out is 0; it is outside the eight-bit result.
  13. The stored sum is 01010001, which is 81 unsigned.
  14. Check modular arithmetic: 81 modulo 256 = 81.
  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: 01010001

Bitwise arithmetic · Problem 0039

Add 00010100₂ and 11111011₂; 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=00010100, B=11111011.
  2. Ordinary decimal arithmetic gives 20+251=271.
  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): 0+1+incoming carry 1=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 0+1+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 00001111, which is 15 unsigned.
  14. Check modular arithmetic: 271 modulo 256 = 15.
  15. Signed readings of the inputs are 20 and -5; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00001111

Bitwise arithmetic · Problem 0040

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

Final answer: 11100101

Bitwise arithmetic · Problem 0041

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

Final answer: 11101011

Bitwise arithmetic · Problem 0042

Add 00010110₂ and 00110100₂; 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=00010110, B=00110100.
  2. Ordinary decimal arithmetic gives 22+52=74.
  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): 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+1+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): 0+0+incoming carry 0=0; write 0, pass carry 0.
  12. The final carry-out is 0; it is outside the eight-bit result.
  13. The stored sum is 01001010, which is 74 unsigned.
  14. Check modular arithmetic: 74 modulo 256 = 74.
  15. Signed readings of the inputs are 22 and 52; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01001010

Bitwise arithmetic · Problem 0043

Add 00010110₂ and 01000000₂; 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=00010110, B=01000000.
  2. Ordinary decimal arithmetic gives 22+64=86.
  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): 0+0+incoming carry 0=0; write 0, pass carry 0.
  10. Bit 6 (weight 64): 0+1+incoming carry 0=1; write 1, pass carry 0.
  11. Bit 7 (weight 128): 0+0+incoming carry 0=0; write 0, pass carry 0.
  12. The final carry-out is 0; it is outside the eight-bit result.
  13. The stored sum is 01010110, which is 86 unsigned.
  14. Check modular arithmetic: 86 modulo 256 = 86.
  15. Signed readings of the inputs are 22 and 64; 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 0044

Add 00010111₂ 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=00010111, B=00001001.
  2. Ordinary decimal arithmetic gives 23+9=32.
  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): 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): 0+0+incoming carry 0=0; write 0, pass carry 0.
  11. Bit 7 (weight 128): 0+0+incoming carry 0=0; write 0, pass carry 0.
  12. The final carry-out is 0; it is outside the eight-bit result.
  13. The stored sum is 00100000, which is 32 unsigned.
  14. Check modular arithmetic: 32 modulo 256 = 32.
  15. Signed readings of the inputs are 23 and 9; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00100000

Bitwise arithmetic · Problem 0045

Add 00010111₂ and 01010111₂; 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=00010111, B=01010111.
  2. Ordinary decimal arithmetic gives 23+87=110.
  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): 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): 0+1+incoming carry 0=1; write 1, pass carry 0.
  11. Bit 7 (weight 128): 0+0+incoming carry 0=0; write 0, pass carry 0.
  12. The final carry-out is 0; it is outside the eight-bit result.
  13. The stored sum is 01101110, which is 110 unsigned.
  14. Check modular arithmetic: 110 modulo 256 = 110.
  15. Signed readings of the inputs are 23 and 87; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01101110

Bitwise arithmetic · Problem 0046

Add 00010111₂ and 11010111₂; 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=00010111, B=11010111.
  2. Ordinary decimal arithmetic gives 23+215=238.
  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): 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): 0+1+incoming carry 0=1; write 1, pass carry 0.
  11. Bit 7 (weight 128): 0+1+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 11101110, which is 238 unsigned.
  14. Check modular arithmetic: 238 modulo 256 = 238.
  15. Signed readings of the inputs are 23 and -41; 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 0047

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

Final answer: 11011010

Bitwise arithmetic · Problem 0048

Add 00011011₂ and 00011001₂; 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=00011011, B=00011001.
  2. Ordinary decimal arithmetic gives 27+25=52.
  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): 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): 0+0+incoming carry 1=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): 0+0+incoming carry 0=0; write 0, pass carry 0.
  12. The final carry-out is 0; it is outside the eight-bit result.
  13. The stored sum is 00110100, which is 52 unsigned.
  14. Check modular arithmetic: 52 modulo 256 = 52.
  15. Signed readings of the inputs are 27 and 25; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00110100

Bitwise arithmetic · Problem 0049

Add 00011011₂ 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=00011011, B=01010011.
  2. Ordinary decimal arithmetic gives 27+83=110.
  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): 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): 0+1+incoming carry 0=1; write 1, pass carry 0.
  11. Bit 7 (weight 128): 0+0+incoming carry 0=0; write 0, pass carry 0.
  12. The final carry-out is 0; it is outside the eight-bit result.
  13. The stored sum is 01101110, which is 110 unsigned.
  14. Check modular arithmetic: 110 modulo 256 = 110.
  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: 01101110

Bitwise arithmetic · Problem 0050

Add 00011100₂ 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=00011100, B=00100110.
  2. Ordinary decimal arithmetic gives 28+38=66.
  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): 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): 0+1+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): 0+0+incoming carry 0=0; write 0, pass carry 0.
  12. The final carry-out is 0; it is outside the eight-bit result.
  13. The stored sum is 01000010, which is 66 unsigned.
  14. Check modular arithmetic: 66 modulo 256 = 66.
  15. Signed readings of the inputs are 28 and 38; 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 0051

Add 00011101₂ and 00010100₂; 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=00011101, B=00010100.
  2. Ordinary decimal arithmetic gives 29+20=49.
  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): 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): 0+0+incoming carry 0=0; write 0, pass carry 0.
  11. Bit 7 (weight 128): 0+0+incoming carry 0=0; write 0, pass carry 0.
  12. The final carry-out is 0; it is outside the eight-bit result.
  13. The stored sum is 00110001, which is 49 unsigned.
  14. Check modular arithmetic: 49 modulo 256 = 49.
  15. Signed readings of the inputs are 29 and 20; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00110001

Bitwise arithmetic · Problem 0052

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

Final answer: 10000110

Bitwise arithmetic · Problem 0053

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

Final answer: 10000001

Bitwise arithmetic · Problem 0054

Add 00011111₂ and 01000100₂; 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=00011111, B=01000100.
  2. Ordinary decimal arithmetic gives 31+68=99.
  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+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+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): 0+1+incoming carry 0=1; write 1, pass carry 0.
  11. Bit 7 (weight 128): 0+0+incoming carry 0=0; write 0, pass carry 0.
  12. The final carry-out is 0; it is outside the eight-bit result.
  13. The stored sum is 01100011, which is 99 unsigned.
  14. Check modular arithmetic: 99 modulo 256 = 99.
  15. Signed readings of the inputs are 31 and 68; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01100011

Bitwise arithmetic · Problem 0055

Add 00011111₂ and 10000100₂; 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=00011111, B=10000100.
  2. Ordinary decimal arithmetic gives 31+132=163.
  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+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+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): 0+0+incoming carry 0=0; write 0, pass carry 0.
  11. Bit 7 (weight 128): 0+1+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 10100011, which is 163 unsigned.
  14. Check modular arithmetic: 163 modulo 256 = 163.
  15. Signed readings of the inputs are 31 and -124; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 10100011

Bitwise arithmetic · Problem 0056

Add 00100000₂ and 01000111₂; 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=00100000, B=01000111.
  2. Ordinary decimal arithmetic gives 32+71=103.
  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): 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+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): 0+0+incoming carry 0=0; write 0, pass carry 0.
  12. The final carry-out is 0; it is outside the eight-bit result.
  13. The stored sum is 01100111, which is 103 unsigned.
  14. Check modular arithmetic: 103 modulo 256 = 103.
  15. Signed readings of the inputs are 32 and 71; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01100111

Bitwise arithmetic · Problem 0057

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

Final answer: 10101000

Bitwise arithmetic · Problem 0058

Add 00100001₂ 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=00100001, B=00011111.
  2. Ordinary decimal arithmetic gives 33+31=64.
  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): 0+1+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): 0+0+incoming carry 1=1; write 1, pass carry 0.
  11. Bit 7 (weight 128): 0+0+incoming carry 0=0; write 0, pass carry 0.
  12. The final carry-out is 0; it is outside the eight-bit result.
  13. The stored sum is 01000000, which is 64 unsigned.
  14. Check modular arithmetic: 64 modulo 256 = 64.
  15. Signed readings of the inputs are 33 and 31; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01000000

Bitwise arithmetic · Problem 0059

Add 00100010₂ 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=00100010, B=11011000.
  2. Ordinary decimal arithmetic gives 34+216=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): 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+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): 0+1+incoming carry 0=1; write 1, pass carry 0.
  11. Bit 7 (weight 128): 0+1+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 34 and -40; 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 0060

Add 00100100₂ and 01000011₂; 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=00100100, B=01000011.
  2. Ordinary decimal arithmetic gives 36+67=103.
  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+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+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): 0+0+incoming carry 0=0; write 0, pass carry 0.
  12. The final carry-out is 0; it is outside the eight-bit result.
  13. The stored sum is 01100111, which is 103 unsigned.
  14. Check modular arithmetic: 103 modulo 256 = 103.
  15. Signed readings of the inputs are 36 and 67; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01100111

Bitwise arithmetic · Problem 0061

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

Final answer: 10101101

Bitwise arithmetic · Problem 0062

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

Final answer: 11101100

Bitwise arithmetic · Problem 0063

Add 00100111₂ and 00101001₂; 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=00100111, B=00101001.
  2. Ordinary decimal arithmetic gives 39+41=80.
  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): 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): 0+0+incoming carry 1=1; write 1, pass carry 0.
  11. Bit 7 (weight 128): 0+0+incoming carry 0=0; write 0, pass carry 0.
  12. The final carry-out is 0; it is outside the eight-bit result.
  13. The stored sum is 01010000, which is 80 unsigned.
  14. Check modular arithmetic: 80 modulo 256 = 80.
  15. Signed readings of the inputs are 39 and 41; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01010000

Bitwise arithmetic · Problem 0064

Add 00100111₂ 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=00100111, B=01010010.
  2. Ordinary decimal arithmetic gives 39+82=121.
  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): 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): 0+1+incoming carry 0=1; write 1, pass carry 0.
  11. Bit 7 (weight 128): 0+0+incoming carry 0=0; write 0, pass carry 0.
  12. The final carry-out is 0; it is outside the eight-bit result.
  13. The stored sum is 01111001, which is 121 unsigned.
  14. Check modular arithmetic: 121 modulo 256 = 121.
  15. Signed readings of the inputs are 39 and 82; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01111001