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

Fully solved problem book

Eight-bit addition

Set 9 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 0257

Add 10011110₂ and 00111100₂; 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=10011110, B=00111100.
  2. Ordinary decimal arithmetic gives 158+60=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): 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): 0+0+incoming carry 1=1; write 1, pass carry 0.
  11. Bit 7 (weight 128): 1+0+incoming carry 0=1; write 1, pass carry 0.
  12. The final carry-out is 0; it is outside the eight-bit result.
  13. The stored sum is 11011010, which is 218 unsigned.
  14. Check modular arithmetic: 218 modulo 256 = 218.
  15. Signed readings of the inputs are -98 and 60; 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 0258

Add 10011111₂ and 10001001₂; keep the low eight result bits.

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

Reveal detailed solution →
  1. Use exactly eight bits: A=10011111, B=10001001.
  2. Ordinary decimal arithmetic gives 159+137=296.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+1+incoming carry 0=2; write 0, pass carry 1.
  5. Bit 1 (weight 2): 1+0+incoming carry 1=2; write 0, pass carry 1.
  6. Bit 2 (weight 4): 1+0+incoming carry 1=2; write 0, pass carry 1.
  7. Bit 3 (weight 8): 1+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+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): 1+1+incoming carry 0=2; write 0, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 00101000, which is 40 unsigned.
  14. Check modular arithmetic: 296 modulo 256 = 40.
  15. Signed readings of the inputs are -97 and -119; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00101000

Bitwise arithmetic · Problem 0259

Add 10011111₂ and 10010110₂; keep the low eight result bits.

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

Reveal detailed solution →
  1. Use exactly eight bits: A=10011111, B=10010110.
  2. Ordinary decimal arithmetic gives 159+150=309.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+0+incoming carry 0=1; write 1, pass carry 0.
  5. Bit 1 (weight 2): 1+1+incoming carry 0=2; write 0, pass carry 1.
  6. Bit 2 (weight 4): 1+1+incoming carry 1=3; write 1, pass carry 1.
  7. Bit 3 (weight 8): 1+0+incoming carry 1=2; write 0, pass carry 1.
  8. Bit 4 (weight 16): 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): 1+1+incoming carry 0=2; write 0, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 00110101, which is 53 unsigned.
  14. Check modular arithmetic: 309 modulo 256 = 53.
  15. Signed readings of the inputs are -97 and -106; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00110101

Bitwise arithmetic · Problem 0260

Add 10011111₂ and 10110000₂; 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=10011111, B=10110000.
  2. Ordinary decimal arithmetic gives 159+176=335.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+0+incoming carry 0=1; write 1, pass carry 0.
  5. Bit 1 (weight 2): 1+0+incoming carry 0=1; write 1, pass carry 0.
  6. Bit 2 (weight 4): 1+0+incoming carry 0=1; write 1, pass carry 0.
  7. Bit 3 (weight 8): 1+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+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): 1+1+incoming carry 0=2; write 0, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 01001111, which is 79 unsigned.
  14. Check modular arithmetic: 335 modulo 256 = 79.
  15. Signed readings of the inputs are -97 and -80; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01001111

Bitwise arithmetic · Problem 0261

Add 10011111₂ and 11101001₂; 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=10011111, B=11101001.
  2. Ordinary decimal arithmetic gives 159+233=392.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+1+incoming carry 0=2; write 0, pass carry 1.
  5. Bit 1 (weight 2): 1+0+incoming carry 1=2; write 0, pass carry 1.
  6. Bit 2 (weight 4): 1+0+incoming carry 1=2; write 0, pass carry 1.
  7. Bit 3 (weight 8): 1+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): 0+1+incoming carry 1=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 1+1+incoming carry 1=3; write 1, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 10001000, which is 136 unsigned.
  14. Check modular arithmetic: 392 modulo 256 = 136.
  15. Signed readings of the inputs are -97 and -23; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 10001000

Bitwise arithmetic · Problem 0262

Add 10100000₂ and 00010000₂; keep the low eight result bits.

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

Reveal detailed solution →
  1. Use exactly eight bits: A=10100000, B=00010000.
  2. Ordinary decimal arithmetic gives 160+16=176.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 0+0+incoming carry 0=0; write 0, pass carry 0.
  5. Bit 1 (weight 2): 0+0+incoming carry 0=0; write 0, pass carry 0.
  6. Bit 2 (weight 4): 0+0+incoming carry 0=0; write 0, pass carry 0.
  7. Bit 3 (weight 8): 0+0+incoming carry 0=0; write 0, pass carry 0.
  8. Bit 4 (weight 16): 0+1+incoming carry 0=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+0+incoming carry 0=1; write 1, pass carry 0.
  10. Bit 6 (weight 64): 0+0+incoming carry 0=0; write 0, pass carry 0.
  11. Bit 7 (weight 128): 1+0+incoming carry 0=1; write 1, pass carry 0.
  12. The final carry-out is 0; it is outside the eight-bit result.
  13. The stored sum is 10110000, which is 176 unsigned.
  14. Check modular arithmetic: 176 modulo 256 = 176.
  15. Signed readings of the inputs are -96 and 16; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 10110000

Bitwise arithmetic · Problem 0263

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

Final answer: 11111110

Bitwise arithmetic · Problem 0264

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

Final answer: 11011100

Bitwise arithmetic · Problem 0265

Add 10100001₂ 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=10100001, B=11011010.
  2. Ordinary decimal arithmetic gives 161+218=379.
  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): 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): 1+1+incoming carry 0=2; write 0, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 01111011, which is 123 unsigned.
  14. Check modular arithmetic: 379 modulo 256 = 123.
  15. Signed readings of the inputs are -95 and -38; 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 0266

Add 10100001₂ and 11111001₂; 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=10100001, B=11111001.
  2. Ordinary decimal arithmetic gives 161+249=410.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+1+incoming carry 0=2; write 0, pass carry 1.
  5. Bit 1 (weight 2): 0+0+incoming carry 1=1; write 1, pass carry 0.
  6. Bit 2 (weight 4): 0+0+incoming carry 0=0; write 0, pass carry 0.
  7. Bit 3 (weight 8): 0+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): 0+1+incoming carry 1=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 1+1+incoming carry 1=3; write 1, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 10011010, which is 154 unsigned.
  14. Check modular arithmetic: 410 modulo 256 = 154.
  15. Signed readings of the inputs are -95 and -7; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 10011010

Bitwise arithmetic · Problem 0267

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

Final answer: 11011110

Bitwise arithmetic · Problem 0268

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

Final answer: 01110011

Bitwise arithmetic · Problem 0269

Add 10100100₂ and 11010001₂; keep the low eight result bits.

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

Reveal detailed solution →
  1. Use exactly eight bits: A=10100100, B=11010001.
  2. Ordinary decimal arithmetic gives 164+209=373.
  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+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+0+incoming carry 0=1; write 1, pass carry 0.
  10. Bit 6 (weight 64): 0+1+incoming carry 0=1; write 1, pass carry 0.
  11. Bit 7 (weight 128): 1+1+incoming carry 0=2; write 0, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 01110101, which is 117 unsigned.
  14. Check modular arithmetic: 373 modulo 256 = 117.
  15. Signed readings of the inputs are -92 and -47; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01110101

Bitwise arithmetic · Problem 0270

Add 10100101₂ and 01100100₂; keep the low eight result bits.

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

Reveal detailed solution →
  1. Use exactly eight bits: A=10100101, B=01100100.
  2. Ordinary decimal arithmetic gives 165+100=265.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+0+incoming carry 0=1; write 1, pass carry 0.
  5. Bit 1 (weight 2): 0+0+incoming carry 0=0; write 0, pass carry 0.
  6. Bit 2 (weight 4): 1+1+incoming carry 0=2; write 0, pass carry 1.
  7. Bit 3 (weight 8): 0+0+incoming carry 1=1; write 1, pass carry 0.
  8. Bit 4 (weight 16): 0+0+incoming carry 0=0; write 0, pass carry 0.
  9. Bit 5 (weight 32): 1+1+incoming carry 0=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 0+1+incoming carry 1=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 1+0+incoming carry 1=2; write 0, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 00001001, which is 9 unsigned.
  14. Check modular arithmetic: 265 modulo 256 = 9.
  15. Signed readings of the inputs are -91 and 100; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00001001

Bitwise arithmetic · Problem 0271

Add 10100110₂ and 10101111₂; keep the low eight result bits.

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

Reveal detailed solution →
  1. Use exactly eight bits: A=10100110, B=10101111.
  2. Ordinary decimal arithmetic gives 166+175=341.
  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+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): 1+1+incoming carry 0=2; write 0, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 01010101, which is 85 unsigned.
  14. Check modular arithmetic: 341 modulo 256 = 85.
  15. Signed readings of the inputs are -90 and -81; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01010101

Bitwise arithmetic · Problem 0272

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

Final answer: 10110110

Bitwise arithmetic · Problem 0273

Add 10100111₂ 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=10100111, B=11001011.
  2. Ordinary decimal arithmetic gives 167+203=370.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+1+incoming carry 0=2; write 0, pass carry 1.
  5. Bit 1 (weight 2): 1+1+incoming carry 1=3; write 1, pass carry 1.
  6. Bit 2 (weight 4): 1+0+incoming carry 1=2; write 0, pass carry 1.
  7. Bit 3 (weight 8): 0+1+incoming carry 1=2; write 0, pass carry 1.
  8. Bit 4 (weight 16): 0+0+incoming carry 1=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+0+incoming carry 0=1; write 1, pass carry 0.
  10. Bit 6 (weight 64): 0+1+incoming carry 0=1; write 1, pass carry 0.
  11. Bit 7 (weight 128): 1+1+incoming carry 0=2; write 0, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 01110010, which is 114 unsigned.
  14. Check modular arithmetic: 370 modulo 256 = 114.
  15. Signed readings of the inputs are -89 and -53; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01110010

Bitwise arithmetic · Problem 0274

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

Final answer: 11110000

Bitwise arithmetic · Problem 0275

Add 10101000₂ and 01001011₂; keep the low eight result bits.

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

Reveal detailed solution →
  1. Use exactly eight bits: A=10101000, B=01001011.
  2. Ordinary decimal arithmetic gives 168+75=243.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 0+1+incoming carry 0=1; write 1, pass carry 0.
  5. Bit 1 (weight 2): 0+1+incoming carry 0=1; write 1, pass carry 0.
  6. Bit 2 (weight 4): 0+0+incoming carry 0=0; write 0, pass carry 0.
  7. Bit 3 (weight 8): 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): 0+1+incoming carry 0=1; write 1, pass carry 0.
  11. Bit 7 (weight 128): 1+0+incoming carry 0=1; write 1, pass carry 0.
  12. The final carry-out is 0; it is outside the eight-bit result.
  13. The stored sum is 11110011, which is 243 unsigned.
  14. Check modular arithmetic: 243 modulo 256 = 243.
  15. Signed readings of the inputs are -88 and 75; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 11110011

Bitwise arithmetic · Problem 0276

Add 10101000₂ 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=10101000, B=01100011.
  2. Ordinary decimal arithmetic gives 168+99=267.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 0+1+incoming carry 0=1; write 1, pass carry 0.
  5. Bit 1 (weight 2): 0+1+incoming carry 0=1; write 1, pass carry 0.
  6. Bit 2 (weight 4): 0+0+incoming carry 0=0; write 0, pass carry 0.
  7. Bit 3 (weight 8): 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): 0+1+incoming carry 1=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 1+0+incoming carry 1=2; write 0, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 00001011, which is 11 unsigned.
  14. Check modular arithmetic: 267 modulo 256 = 11.
  15. Signed readings of the inputs are -88 and 99; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00001011

Bitwise arithmetic · Problem 0277

Add 10101001₂ and 01000001₂; 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=10101001, B=01000001.
  2. Ordinary decimal arithmetic gives 169+65=234.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+1+incoming carry 0=2; write 0, pass carry 1.
  5. Bit 1 (weight 2): 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): 0+1+incoming carry 0=1; write 1, pass carry 0.
  11. Bit 7 (weight 128): 1+0+incoming carry 0=1; write 1, pass carry 0.
  12. The final carry-out is 0; it is outside the eight-bit result.
  13. The stored sum is 11101010, which is 234 unsigned.
  14. Check modular arithmetic: 234 modulo 256 = 234.
  15. Signed readings of the inputs are -87 and 65; 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 0278

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

Final answer: 00000100

Bitwise arithmetic · Problem 0279

Add 10101010₂ and 11011100₂; 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=10101010, B=11011100.
  2. Ordinary decimal arithmetic gives 170+220=390.
  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+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): 0+1+incoming carry 1=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 1+1+incoming carry 1=3; write 1, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 10000110, which is 134 unsigned.
  14. Check modular arithmetic: 390 modulo 256 = 134.
  15. Signed readings of the inputs are -86 and -36; 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 0280

Add 10101011₂ 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=10101011, B=00010011.
  2. Ordinary decimal arithmetic gives 171+19=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): 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): 0+0+incoming carry 0=0; write 0, pass carry 0.
  11. Bit 7 (weight 128): 1+0+incoming carry 0=1; write 1, pass carry 0.
  12. The final carry-out is 0; it is outside the eight-bit result.
  13. The stored sum is 10111110, which is 190 unsigned.
  14. Check modular arithmetic: 190 modulo 256 = 190.
  15. Signed readings of the inputs are -85 and 19; 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 0281

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

Final answer: 11011101

Bitwise arithmetic · Problem 0282

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

Final answer: 01000101

Bitwise arithmetic · Problem 0283

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

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

Final answer: 11011000

Bitwise arithmetic · Problem 0285

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

Final answer: 11111011

Bitwise arithmetic · Problem 0286

Add 10101101₂ and 01110001₂; keep the low eight result bits.

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

Reveal detailed solution →
  1. Use exactly eight bits: A=10101101, B=01110001.
  2. Ordinary decimal arithmetic gives 173+113=286.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 1+1+incoming carry 0=2; write 0, pass carry 1.
  5. Bit 1 (weight 2): 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+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): 0+1+incoming carry 1=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 1+0+incoming carry 1=2; write 0, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 00011110, which is 30 unsigned.
  14. Check modular arithmetic: 286 modulo 256 = 30.
  15. Signed readings of the inputs are -83 and 113; 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 0287

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

Final answer: 01101010

Bitwise arithmetic · Problem 0288

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

Final answer: 01101110