01How Computers Work (online)
Practice library (online) / Eight-bit addition

Fully solved problem book

Eight-bit addition

Set 5 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 0129

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

Final answer: 11101000

Bitwise arithmetic · Problem 0130

Add 01001110₂ 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=01001110, B=00100011.
  2. Ordinary decimal arithmetic gives 78+35=113.
  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): 0+0+incoming carry 1=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): 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 01110001, which is 113 unsigned.
  14. Check modular arithmetic: 113 modulo 256 = 113.
  15. Signed readings of the inputs are 78 and 35; 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 0131

Add 01010001₂ 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=01010001, B=01110010.
  2. Ordinary decimal arithmetic gives 81+114=195.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+0+incoming carry 0=1; write 1, pass carry 0.
  5. Bit 1 (weight 2): 0+1+incoming carry 0=1; write 1, pass carry 0.
  6. Bit 2 (weight 4): 0+0+incoming carry 0=0; write 0, pass carry 0.
  7. Bit 3 (weight 8): 0+0+incoming carry 0=0; write 0, pass carry 0.
  8. Bit 4 (weight 16): 1+1+incoming carry 0=2; write 0, pass carry 1.
  9. Bit 5 (weight 32): 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): 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 11000011, which is 195 unsigned.
  14. Check modular arithmetic: 195 modulo 256 = 195.
  15. Signed readings of the inputs are 81 and 114; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 11000011

Bitwise arithmetic · Problem 0132

Add 01010001₂ and 01111110₂; 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=01010001, B=01111110.
  2. Ordinary decimal arithmetic gives 81+126=207.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+0+incoming carry 0=1; write 1, pass carry 0.
  5. Bit 1 (weight 2): 0+1+incoming carry 0=1; write 1, pass carry 0.
  6. Bit 2 (weight 4): 0+1+incoming carry 0=1; write 1, pass carry 0.
  7. Bit 3 (weight 8): 0+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): 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 11001111, which is 207 unsigned.
  14. Check modular arithmetic: 207 modulo 256 = 207.
  15. Signed readings of the inputs are 81 and 126; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 11001111

Bitwise arithmetic · Problem 0133

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

Final answer: 00011001

Bitwise arithmetic · Problem 0134

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

Final answer: 01011010

Bitwise arithmetic · Problem 0135

Add 01010010₂ and 10011000₂; 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=01010010, B=10011000.
  2. Ordinary decimal arithmetic gives 82+152=234.
  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): 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): 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 11101010, which is 234 unsigned.
  14. Check modular arithmetic: 234 modulo 256 = 234.
  15. Signed readings of the inputs are 82 and -104; 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 0136

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

Final answer: 00011000

Bitwise arithmetic · Problem 0137

Add 01010011₂ 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=01010011, B=00010011.
  2. Ordinary decimal arithmetic gives 83+19=102.
  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): 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): 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 01100110, which is 102 unsigned.
  14. Check modular arithmetic: 102 modulo 256 = 102.
  15. Signed readings of the inputs are 83 and 19; 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 0138

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

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

Reveal detailed solution →
  1. Use exactly eight bits: A=01010100, B=00000110.
  2. Ordinary decimal arithmetic gives 84+6=90.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 0+0+incoming carry 0=0; write 0, pass carry 0.
  5. Bit 1 (weight 2): 0+1+incoming carry 0=1; write 1, pass carry 0.
  6. Bit 2 (weight 4): 1+1+incoming carry 0=2; write 0, pass carry 1.
  7. Bit 3 (weight 8): 0+0+incoming carry 1=1; write 1, pass carry 0.
  8. Bit 4 (weight 16): 1+0+incoming carry 0=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 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): 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 01011010, which is 90 unsigned.
  14. Check modular arithmetic: 90 modulo 256 = 90.
  15. Signed readings of the inputs are 84 and 6; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01011010

Bitwise arithmetic · Problem 0139

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

Final answer: 10111100

Bitwise arithmetic · Problem 0140

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

Final answer: 10111111

Bitwise arithmetic · Problem 0141

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

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

Reveal detailed solution →
  1. Use exactly eight bits: A=01010101, B=11100110.
  2. Ordinary decimal arithmetic gives 85+230=315.
  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+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): 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 00111011, which is 59 unsigned.
  14. Check modular arithmetic: 315 modulo 256 = 59.
  15. Signed readings of the inputs are 85 and -26; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00111011

Bitwise arithmetic · Problem 0142

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

Final answer: 10001001

Bitwise arithmetic · Problem 0143

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

Final answer: 11000000

Bitwise arithmetic · Problem 0144

Add 01011000₂ and 01101110₂; 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=01011000, B=01101110.
  2. Ordinary decimal arithmetic gives 88+110=198.
  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+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): 1+1+incoming carry 1=3; write 1, 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 11000110, which is 198 unsigned.
  14. Check modular arithmetic: 198 modulo 256 = 198.
  15. Signed readings of the inputs are 88 and 110; 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 0145

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

Final answer: 00110110

Bitwise arithmetic · Problem 0146

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

Final answer: 01111011

Bitwise arithmetic · Problem 0147

Add 01011010₂ 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=01011010, B=01101111.
  2. Ordinary decimal arithmetic gives 90+111=201.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 0+1+incoming carry 0=1; write 1, pass carry 0.
  5. Bit 1 (weight 2): 1+1+incoming carry 0=2; write 0, pass carry 1.
  6. Bit 2 (weight 4): 0+1+incoming carry 1=2; write 0, pass carry 1.
  7. Bit 3 (weight 8): 1+1+incoming carry 1=3; write 1, pass carry 1.
  8. Bit 4 (weight 16): 1+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): 1+1+incoming carry 1=3; write 1, 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 11001001, which is 201 unsigned.
  14. Check modular arithmetic: 201 modulo 256 = 201.
  15. Signed readings of the inputs are 90 and 111; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 11001001

Bitwise arithmetic · Problem 0148

Add 01011010₂ and 10011000₂; 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=01011010, B=10011000.
  2. Ordinary decimal arithmetic gives 90+152=242.
  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+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+0+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 11110010, which is 242 unsigned.
  14. Check modular arithmetic: 242 modulo 256 = 242.
  15. Signed readings of the inputs are 90 and -104; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 11110010

Bitwise arithmetic · Problem 0149

Add 01011010₂ and 11000100₂; 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=01011010, B=11000100.
  2. Ordinary decimal arithmetic gives 90+196=286.
  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): 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): 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 00011110, which is 30 unsigned.
  14. Check modular arithmetic: 286 modulo 256 = 30.
  15. Signed readings of the inputs are 90 and -60; 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 0150

Add 01011010₂ and 11110111₂; 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=01011010, B=11110111.
  2. Ordinary decimal arithmetic gives 90+247=337.
  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+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): 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 01010001, which is 81 unsigned.
  14. Check modular arithmetic: 337 modulo 256 = 81.
  15. Signed readings of the inputs are 90 and -9; 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 0151

Add 01011011₂ and 11001000₂; 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=01011011, B=11001000.
  2. Ordinary decimal arithmetic gives 91+200=291.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+0+incoming carry 0=1; write 1, pass carry 0.
  5. Bit 1 (weight 2): 1+0+incoming carry 0=1; write 1, pass carry 0.
  6. Bit 2 (weight 4): 0+0+incoming carry 0=0; write 0, pass carry 0.
  7. Bit 3 (weight 8): 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+1+incoming carry 0=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 00100011, which is 35 unsigned.
  14. Check modular arithmetic: 291 modulo 256 = 35.
  15. Signed readings of the inputs are 91 and -56; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00100011

Bitwise arithmetic · Problem 0152

Add 01011100₂ and 10111110₂; 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=01011100, B=10111110.
  2. Ordinary decimal arithmetic gives 92+190=282.
  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+1+incoming carry 1=3; write 1, pass carry 1.
  8. Bit 4 (weight 16): 1+1+incoming carry 1=3; write 1, pass carry 1.
  9. Bit 5 (weight 32): 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): 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 00011010, which is 26 unsigned.
  14. Check modular arithmetic: 282 modulo 256 = 26.
  15. Signed readings of the inputs are 92 and -66; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00011010

Bitwise arithmetic · Problem 0153

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

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

Reveal detailed solution →
  1. Use exactly eight bits: A=01011100, B=11001010.
  2. Ordinary decimal arithmetic gives 92+202=294.
  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): 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+1+incoming carry 0=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 00100110, which is 38 unsigned.
  14. Check modular arithmetic: 294 modulo 256 = 38.
  15. Signed readings of the inputs are 92 and -54; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00100110

Bitwise arithmetic · Problem 0154

Add 01011100₂ 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=01011100, B=11100100.
  2. Ordinary decimal arithmetic gives 92+228=320.
  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): 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): 1+1+incoming carry 1=3; write 1, 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 01000000, which is 64 unsigned.
  14. Check modular arithmetic: 320 modulo 256 = 64.
  15. Signed readings of the inputs are 92 and -28; 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 0155

Add 01011101₂ 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=01011101, B=00001001.
  2. Ordinary decimal arithmetic gives 93+9=102.
  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): 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 01100110, which is 102 unsigned.
  14. Check modular arithmetic: 102 modulo 256 = 102.
  15. Signed readings of the inputs are 93 and 9; 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 0156

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

Final answer: 10111000

Bitwise arithmetic · Problem 0157

Add 01011110₂ and 00111011₂; 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=01011110, B=00111011.
  2. Ordinary decimal arithmetic gives 94+59=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): 1+0+incoming carry 1=2; write 0, pass carry 1.
  7. Bit 3 (weight 8): 1+1+incoming carry 1=3; write 1, pass carry 1.
  8. Bit 4 (weight 16): 1+1+incoming carry 1=3; write 1, pass carry 1.
  9. Bit 5 (weight 32): 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): 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 10011001, which is 153 unsigned.
  14. Check modular arithmetic: 153 modulo 256 = 153.
  15. Signed readings of the inputs are 94 and 59; 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 0158

Add 01100001₂ and 11101101₂; 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=01100001, B=11101101.
  2. Ordinary decimal arithmetic gives 97+237=334.
  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): 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+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): 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 01001110, which is 78 unsigned.
  14. Check modular arithmetic: 334 modulo 256 = 78.
  15. Signed readings of the inputs are 97 and -19; 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 0159

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

Final answer: 01110100

Bitwise arithmetic · Problem 0160

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

Final answer: 01110101