01How Computers Work
Practice library / Eight-bit addition

Fully solved problem book

Eight-bit addition

Set 1 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 0001

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

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

Final answer: 00110010

Bitwise arithmetic · Problem 0003

Add 00000011₂ and 00001000₂; keep the low eight result bits.

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

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

Add 00000011₂ and 00010010₂; keep the low eight result bits.

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

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

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

Final answer: 01101000

Bitwise arithmetic · Problem 0006

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

Final answer: 10011001

Bitwise arithmetic · Problem 0007

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

Final answer: 10100111

Bitwise arithmetic · Problem 0008

Add 00000100₂ and 11011110₂; keep the low eight result bits.

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

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

Final answer: 11100010

Bitwise arithmetic · Problem 0009

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

Final answer: 10110001

Bitwise arithmetic · Problem 0010

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

Final answer: 10111100

Bitwise arithmetic · Problem 0011

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

Final answer: 11111001

Bitwise arithmetic · Problem 0012

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

Final answer: 01000011

Bitwise arithmetic · Problem 0013

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

Final answer: 10100101

Bitwise arithmetic · Problem 0014

Add 00001000₂ and 10110101₂; 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=00001000, B=10110101.
  2. Ordinary decimal arithmetic gives 8+181=189.
  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+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): 0+1+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 10111101, which is 189 unsigned.
  14. Check modular arithmetic: 189 modulo 256 = 189.
  15. Signed readings of the inputs are 8 and -75; 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 0015

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

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

Reveal detailed solution →
  1. Use exactly eight bits: A=00001001, B=01101010.
  2. Ordinary decimal arithmetic gives 9+106=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): 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): 0+1+incoming carry 0=1; write 1, pass carry 0.
  10. Bit 6 (weight 64): 0+1+incoming carry 0=1; write 1, pass carry 0.
  11. Bit 7 (weight 128): 0+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 9 and 106; 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 0016

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

Final answer: 11110010

Bitwise arithmetic · Problem 0017

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

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

Final answer: 11100111

Bitwise arithmetic · Problem 0019

Add 00001011₂ and 01010011₂; keep the low eight result bits.

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

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

Final answer: 01011110

Bitwise arithmetic · Problem 0020

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

Add 00001100₂ and 00010010₂; keep the low eight result bits.

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

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

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

Final answer: 00100011

Bitwise arithmetic · Problem 0023

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

Final answer: 01000010

Bitwise arithmetic · Problem 0024

Add 00001100₂ and 01000111₂; keep the low eight result bits.

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

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

Final answer: 01010011

Bitwise arithmetic · Problem 0025

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

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

Final answer: 01100111

Bitwise arithmetic · Problem 0027

Add 00010000₂ and 10101110₂; 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=00010000, B=10101110.
  2. Ordinary decimal arithmetic gives 16+174=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): 0+1+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 10111110, which is 190 unsigned.
  14. Check modular arithmetic: 190 modulo 256 = 190.
  15. Signed readings of the inputs are 16 and -82; 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 0028

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

Final answer: 00101101

Bitwise arithmetic · Problem 0029

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

Final answer: 10101000

Bitwise arithmetic · Problem 0030

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

Final answer: 11101000

Bitwise arithmetic · Problem 0031

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

Final answer: 00000101

Bitwise arithmetic · Problem 0032

Add 00010010₂ and 00011001₂; keep the low eight result bits.

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

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

Final answer: 00101011