01How Computers Work
Practice library / Eight-bit addition

Fully solved problem book

Eight-bit addition

Set 6 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 0161

Add 01100010₂ 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=01100010, B=10001000.
  2. Ordinary decimal arithmetic gives 98+136=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): 0+0+incoming carry 0=0; write 0, pass carry 0.
  9. Bit 5 (weight 32): 1+0+incoming carry 0=1; write 1, pass carry 0.
  10. Bit 6 (weight 64): 1+0+incoming carry 0=1; write 1, pass carry 0.
  11. Bit 7 (weight 128): 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 98 and -120; 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 0162

Add 01100010₂ and 11011011₂; 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=11011011.
  2. Ordinary decimal arithmetic gives 98+219=317.
  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+1+incoming carry 0=1; write 1, pass carry 0.
  8. Bit 4 (weight 16): 0+1+incoming carry 0=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+0+incoming carry 0=1; write 1, pass carry 0.
  10. Bit 6 (weight 64): 1+1+incoming carry 0=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 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 00111101, which is 61 unsigned.
  14. Check modular arithmetic: 317 modulo 256 = 61.
  15. Signed readings of the inputs are 98 and -37; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00111101

Bitwise arithmetic · Problem 0163

Add 01100011₂ 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=01100011, B=01011011.
  2. Ordinary decimal arithmetic gives 99+91=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): 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): 0+1+incoming carry 0=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+0+incoming carry 0=1; write 1, pass carry 0.
  10. Bit 6 (weight 64): 1+1+incoming carry 0=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 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 10111110, which is 190 unsigned.
  14. Check modular arithmetic: 190 modulo 256 = 190.
  15. Signed readings of the inputs are 99 and 91; 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 0164

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

Final answer: 00101011

Bitwise arithmetic · Problem 0165

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

Final answer: 01010100

Bitwise arithmetic · Problem 0166

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

Final answer: 01111010

Bitwise arithmetic · Problem 0167

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

Final answer: 00010110

Bitwise arithmetic · Problem 0168

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

Final answer: 00011111

Bitwise arithmetic · Problem 0169

Add 01100111₂ and 11010100₂; 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=01100111, B=11010100.
  2. Ordinary decimal arithmetic gives 103+212=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): 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): 0+1+incoming carry 0=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+0+incoming carry 0=1; write 1, pass carry 0.
  10. Bit 6 (weight 64): 1+1+incoming carry 0=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 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 103 and -44; 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 0170

Add 01100111₂ 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=01100111, B=11011001.
  2. Ordinary decimal arithmetic gives 103+217=320.
  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+1+incoming carry 1=2; write 0, pass carry 1.
  9. Bit 5 (weight 32): 1+0+incoming carry 1=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 1+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 103 and -39; 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 0171

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

Final answer: 00101010

Bitwise arithmetic · Problem 0172

Add 01101001₂ and 11001011₂; 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=01101001, B=11001011.
  2. Ordinary decimal arithmetic gives 105+203=308.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+1+incoming carry 0=2; write 0, pass carry 1.
  5. Bit 1 (weight 2): 0+1+incoming carry 1=2; write 0, pass carry 1.
  6. Bit 2 (weight 4): 0+0+incoming carry 1=1; write 1, pass carry 0.
  7. Bit 3 (weight 8): 1+1+incoming carry 0=2; write 0, pass carry 1.
  8. Bit 4 (weight 16): 0+0+incoming carry 1=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+0+incoming carry 0=1; write 1, pass carry 0.
  10. Bit 6 (weight 64): 1+1+incoming carry 0=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 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 00110100, which is 52 unsigned.
  14. Check modular arithmetic: 308 modulo 256 = 52.
  15. Signed readings of the inputs are 105 and -53; 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 0173

Add 01101001₂ 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=01101001, B=11101101.
  2. Ordinary decimal arithmetic gives 105+237=342.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+1+incoming carry 0=2; write 0, pass carry 1.
  5. Bit 1 (weight 2): 0+0+incoming carry 1=1; write 1, pass carry 0.
  6. Bit 2 (weight 4): 0+1+incoming carry 0=1; write 1, pass carry 0.
  7. Bit 3 (weight 8): 1+1+incoming carry 0=2; write 0, pass carry 1.
  8. Bit 4 (weight 16): 0+0+incoming carry 1=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+1+incoming carry 0=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 1+1+incoming carry 1=3; write 1, pass carry 1.
  11. Bit 7 (weight 128): 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 01010110, which is 86 unsigned.
  14. Check modular arithmetic: 342 modulo 256 = 86.
  15. Signed readings of the inputs are 105 and -19; 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 0174

Add 01101010₂ and 01100110₂; keep the low eight result bits.

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

Reveal detailed solution →
  1. Use exactly eight bits: A=01101010, B=01100110.
  2. Ordinary decimal arithmetic gives 106+102=208.
  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): 1+0+incoming carry 1=2; write 0, pass carry 1.
  8. Bit 4 (weight 16): 0+0+incoming carry 1=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+1+incoming carry 0=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 1+1+incoming carry 1=3; write 1, pass carry 1.
  11. Bit 7 (weight 128): 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 11010000, which is 208 unsigned.
  14. Check modular arithmetic: 208 modulo 256 = 208.
  15. Signed readings of the inputs are 106 and 102; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 11010000

Bitwise arithmetic · Problem 0175

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

Final answer: 10111101

Bitwise arithmetic · Problem 0176

Add 01101011₂ and 10100001₂; 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=01101011, B=10100001.
  2. Ordinary decimal arithmetic gives 107+161=268.
  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+0+incoming carry 0=1; write 1, pass carry 0.
  8. Bit 4 (weight 16): 0+0+incoming carry 0=0; write 0, pass carry 0.
  9. Bit 5 (weight 32): 1+1+incoming carry 0=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 1+0+incoming carry 1=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 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 00001100, which is 12 unsigned.
  14. Check modular arithmetic: 268 modulo 256 = 12.
  15. Signed readings of the inputs are 107 and -95; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00001100

Bitwise arithmetic · Problem 0177

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

Final answer: 00011111

Bitwise arithmetic · Problem 0178

Add 01101100₂ and 00100100₂; keep the low eight result bits.

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

Reveal detailed solution →
  1. Use exactly eight bits: A=01101100, B=00100100.
  2. Ordinary decimal arithmetic gives 108+36=144.
  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): 0+0+incoming carry 1=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+1+incoming carry 0=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 1+0+incoming carry 1=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 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 10010000, which is 144 unsigned.
  14. Check modular arithmetic: 144 modulo 256 = 144.
  15. Signed readings of the inputs are 108 and 36; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 10010000

Bitwise arithmetic · Problem 0179

Add 01101101₂ and 01011000₂; keep the low eight result bits.

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

Reveal detailed solution →
  1. Use exactly eight bits: A=01101101, B=01011000.
  2. Ordinary decimal arithmetic gives 109+88=197.
  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): 0+1+incoming carry 1=2; write 0, pass carry 1.
  9. Bit 5 (weight 32): 1+0+incoming carry 1=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 1+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 11000101, which is 197 unsigned.
  14. Check modular arithmetic: 197 modulo 256 = 197.
  15. Signed readings of the inputs are 109 and 88; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 11000101

Bitwise arithmetic · Problem 0180

Add 01101101₂ 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=01101101, B=01101001.
  2. Ordinary decimal arithmetic gives 109+105=214.
  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): 0+0+incoming carry 1=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+1+incoming carry 0=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 1+1+incoming carry 1=3; write 1, pass carry 1.
  11. Bit 7 (weight 128): 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 11010110, which is 214 unsigned.
  14. Check modular arithmetic: 214 modulo 256 = 214.
  15. Signed readings of the inputs are 109 and 105; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 11010110

Bitwise arithmetic · Problem 0181

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

Final answer: 10011100

Bitwise arithmetic · Problem 0182

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

Final answer: 11101001

Bitwise arithmetic · Problem 0183

Add 01110000₂ and 00101111₂; keep the low eight result bits.

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

Reveal detailed solution →
  1. Use exactly eight bits: A=01110000, B=00101111.
  2. Ordinary decimal arithmetic gives 112+47=159.
  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+1+incoming carry 0=1; write 1, pass carry 0.
  8. Bit 4 (weight 16): 1+0+incoming carry 0=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+1+incoming carry 0=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 1+0+incoming carry 1=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 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 10011111, which is 159 unsigned.
  14. Check modular arithmetic: 159 modulo 256 = 159.
  15. Signed readings of the inputs are 112 and 47; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 10011111

Bitwise arithmetic · Problem 0184

Add 01110000₂ and 01001110₂; 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=01110000, B=01001110.
  2. Ordinary decimal arithmetic gives 112+78=190.
  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): 0+1+incoming carry 0=1; write 1, pass carry 0.
  8. Bit 4 (weight 16): 1+0+incoming carry 0=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+0+incoming carry 0=1; write 1, pass carry 0.
  10. Bit 6 (weight 64): 1+1+incoming carry 0=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 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 10111110, which is 190 unsigned.
  14. Check modular arithmetic: 190 modulo 256 = 190.
  15. Signed readings of the inputs are 112 and 78; 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 0185

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

Final answer: 10001110

Bitwise arithmetic · Problem 0186

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

Final answer: 01001011

Bitwise arithmetic · Problem 0187

Add 01110001₂ and 11011111₂; 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=01110001, B=11011111.
  2. Ordinary decimal arithmetic gives 113+223=336.
  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): 1+1+incoming carry 1=3; write 1, pass carry 1.
  9. Bit 5 (weight 32): 1+0+incoming carry 1=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 1+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 01010000, which is 80 unsigned.
  14. Check modular arithmetic: 336 modulo 256 = 80.
  15. Signed readings of the inputs are 113 and -33; 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 0188

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

Final answer: 01011001

Bitwise arithmetic · Problem 0189

Add 01110010₂ and 00100100₂; keep the low eight result bits.

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

Reveal detailed solution →
  1. Use exactly eight bits: A=01110010, B=00100100.
  2. Ordinary decimal arithmetic gives 114+36=150.
  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): 1+1+incoming carry 0=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 1+0+incoming carry 1=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 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 10010110, which is 150 unsigned.
  14. Check modular arithmetic: 150 modulo 256 = 150.
  15. Signed readings of the inputs are 114 and 36; 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 0190

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

Final answer: 11111100

Bitwise arithmetic · Problem 0191

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

Final answer: 01001001

Bitwise arithmetic · Problem 0192

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

Final answer: 01111001