01How Computers Work
Practice library / Eight-bit addition

Fully solved problem book

Eight-bit addition

Set 3 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 0065

Add 00101000₂ and 00101001₂; keep the low eight result bits.

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

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

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

Final answer: 01111110

Bitwise arithmetic · Problem 0067

Add 00101000₂ and 10001101₂; keep the low eight result bits.

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

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

Final answer: 10110101

Bitwise arithmetic · Problem 0068

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

Final answer: 11010100

Bitwise arithmetic · Problem 0069

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

Final answer: 00000000

Bitwise arithmetic · Problem 0070

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

Final answer: 00010101

Bitwise arithmetic · Problem 0071

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

Final answer: 10000101

Bitwise arithmetic · Problem 0072

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

Final answer: 00011101

Bitwise arithmetic · Problem 0073

Add 00101011₂ and 11111111₂; keep the low eight result bits.

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

Reveal detailed solution →
  1. Use exactly eight bits: A=00101011, B=11111111.
  2. Ordinary decimal arithmetic gives 43+255=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): 1+1+incoming carry 1=3; write 1, 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): 0+1+incoming carry 1=2; write 0, pass carry 1.
  9. Bit 5 (weight 32): 1+1+incoming carry 1=3; write 1, pass carry 1.
  10. Bit 6 (weight 64): 0+1+incoming carry 1=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 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 43 and -1; 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 0074

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

Final answer: 10010100

Bitwise arithmetic · Problem 0075

Add 00101100₂ and 11100001₂; 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=00101100, B=11100001.
  2. Ordinary decimal arithmetic gives 44+225=269.
  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+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): 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 00001101, which is 13 unsigned.
  14. Check modular arithmetic: 269 modulo 256 = 13.
  15. Signed readings of the inputs are 44 and -31; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00001101

Bitwise arithmetic · Problem 0076

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

Final answer: 00101110

Bitwise arithmetic · Problem 0077

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

Final answer: 10000010

Bitwise arithmetic · Problem 0078

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

Final answer: 10000000

Bitwise arithmetic · Problem 0079

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

Final answer: 10010011

Bitwise arithmetic · Problem 0080

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

Final answer: 10110100

Bitwise arithmetic · Problem 0081

Add 00101111₂ 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=00101111, B=11011011.
  2. Ordinary decimal arithmetic gives 47+219=266.
  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): 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+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): 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 00001010, which is 10 unsigned.
  14. Check modular arithmetic: 266 modulo 256 = 10.
  15. Signed readings of the inputs are 47 and -37; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 00001010

Bitwise arithmetic · Problem 0082

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

Final answer: 10100011

Bitwise arithmetic · Problem 0083

Add 00110001₂ and 01000010₂; keep the low eight result bits.

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

Reveal detailed solution →
  1. Use exactly eight bits: A=00110001, B=01000010.
  2. Ordinary decimal arithmetic gives 49+66=115.
  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+0+incoming carry 0=1; write 1, pass carry 0.
  9. Bit 5 (weight 32): 1+0+incoming carry 0=1; write 1, pass carry 0.
  10. Bit 6 (weight 64): 0+1+incoming carry 0=1; write 1, pass carry 0.
  11. Bit 7 (weight 128): 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 01110011, which is 115 unsigned.
  14. Check modular arithmetic: 115 modulo 256 = 115.
  15. Signed readings of the inputs are 49 and 66; 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 0084

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

Add 00110010₂ 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=00110010, B=11011010.
  2. Ordinary decimal arithmetic gives 50+218=268.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 0+0+incoming carry 0=0; write 0, pass carry 0.
  5. Bit 1 (weight 2): 1+1+incoming carry 0=2; write 0, pass carry 1.
  6. Bit 2 (weight 4): 0+0+incoming carry 1=1; write 1, pass carry 0.
  7. Bit 3 (weight 8): 0+1+incoming carry 0=1; write 1, pass carry 0.
  8. Bit 4 (weight 16): 1+1+incoming carry 0=2; write 0, pass carry 1.
  9. Bit 5 (weight 32): 1+0+incoming carry 1=2; write 0, pass carry 1.
  10. Bit 6 (weight 64): 0+1+incoming carry 1=2; write 0, pass carry 1.
  11. Bit 7 (weight 128): 0+1+incoming carry 1=2; write 0, pass carry 1.
  12. The final carry-out is 1; it is outside the eight-bit result.
  13. The stored sum is 00001100, which is 12 unsigned.
  14. Check modular arithmetic: 268 modulo 256 = 12.
  15. Signed readings of the inputs are 50 and -38; 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 0086

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

Final answer: 00111001

Bitwise arithmetic · Problem 0087

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

Final answer: 11110111

Bitwise arithmetic · Problem 0088

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

Final answer: 00001010

Bitwise arithmetic · Problem 0089

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

Final answer: 00011101

Bitwise arithmetic · Problem 0090

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

Final answer: 10001010

Bitwise arithmetic · Problem 0091

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

Final answer: 11001000

Bitwise arithmetic · Problem 0092

Add 00110110₂ and 00111101₂; keep the low eight result bits.

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

Reveal detailed solution →
  1. Use exactly eight bits: A=00110110, B=00111101.
  2. Ordinary decimal arithmetic gives 54+61=115.
  3. We process bits from the rightmost column (bit zero) to the leftmost (bit seven).
  4. Bit 0 (weight 1): 0+1+incoming carry 0=1; write 1, pass carry 0.
  5. Bit 1 (weight 2): 1+0+incoming carry 0=1; write 1, pass carry 0.
  6. Bit 2 (weight 4): 1+1+incoming carry 0=2; write 0, pass carry 1.
  7. Bit 3 (weight 8): 0+1+incoming carry 1=2; write 0, pass carry 1.
  8. Bit 4 (weight 16): 1+1+incoming carry 1=3; write 1, pass carry 1.
  9. Bit 5 (weight 32): 1+1+incoming carry 1=3; write 1, pass carry 1.
  10. Bit 6 (weight 64): 0+0+incoming carry 1=1; write 1, pass carry 0.
  11. Bit 7 (weight 128): 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 01110011, which is 115 unsigned.
  14. Check modular arithmetic: 115 modulo 256 = 115.
  15. Signed readings of the inputs are 54 and 61; 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 0093

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

Final answer: 11100001

Bitwise arithmetic · Problem 0094

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

Final answer: 01100001

Bitwise arithmetic · Problem 0095

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

Final answer: 11110100

Bitwise arithmetic · Problem 0096

Add 00111000₂ 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=00111000, B=00101110.
  2. Ordinary decimal arithmetic gives 56+46=102.
  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): 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): 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 56 and 46; signed overflow should be evaluated separately.
  16. An ALU may expose carry-out and signed overflow as different flags.

Final answer: 01100110