Integer Concept - Simple Typo

acornelectronics · December 30, 2025, 10:29am

Hello:

In the section that discusses zero extention (Heading: Handling Overflow), there is a typo at the end of the code block.

mul ecx ; now eax correctly holds 200 * 100
The 100 at the end ought to be 1000.

Blessings,
Acorn

BNAndras · December 30, 2025, 4:19pm

The three affected locations

github.com

exercism/x86-64-assembly/blob/4302f192fb2dbecccaca582acfeccf62daaddb10/concepts/integers/introduction.md?plain=1#L153


      
          
          ```x86asm
          mov ax, 1000 ; lower 16 bits of eax are 1000, upper bits are undefined
          mov cx, 200 ; lower 16 bits of ecx are 200, upper bits are undefined
          
          ; 200 * 1000 does not fit in 16 bits, so a 32 bits multiplication is necessary
          ; however, multiplying eax by ecx may produce an incorrect result due to undefined bits
          
          movzx eax, ax ; lower 16 bits of eax remain 1000, upper bits are cleared
          movzx ecx, cx ; lower 16 bits of ecx remain 200, upper bits are cleared
          mul ecx ; now eax correctly holds 200 * 100
          ```
          
          A 32-bit source operand is always zero-extended to all 64 bits of the destination operand with a simple `mov`.
          
          #### Using imul with unsigned numbers
          
          It is possible to use `imul` to multiply unsigned numbers.
          However, this may give an incorrect result if one of the numbers may be interpreted as negative.
          
          Since the sign bit in a signed integer corresponds to the most significant bit in an unsigned integer, in practice, this difference becomes relevant when more than the truncated result is needed, i.e., when the full range of `rdx:rax` is used.

github.com

exercism/x86-64-assembly/blob/4302f192fb2dbecccaca582acfeccf62daaddb10/concepts/integers/about.md?plain=1#L285


      
          
          ```x86asm
          mov ax, 1000 ; lower 16 bits of eax are 1000, upper bits are undefined
          mov cx, 200 ; lower 16 bits of ecx are 200, upper bits are undefined
          
          ; 200 * 1000 does not fit in 16 bits, so a 32 bits multiplication is necessary
          ; however, multiplying eax by ecx may produce an incorrect result due to undefined bits
          
          movzx eax, ax ; lower 16 bits of eax remain 1000, upper bits are cleared
          movzx ecx, cx ; lower 16 bits of ecx remain 200, upper bits are cleared
          mul ecx ; now eax correctly holds 200 * 100
          ```
          
          A 32-bit source operand is always zero-extended to all 64 bits of the destination operand with a simple `mov`.
          
          #### Using imul with unsigned numbers
          
          It is possible to use `imul` to multiply unsigned numbers.
          However, this may give an incorrect result if one of the numbers may be interpreted as negative.
          
          Since the sign bit in a signed integer corresponds to the most significant bit in an unsigned integer, in practice, this difference becomes relevant when more than the truncated result is needed, i.e., when the full range of `rdx:rax` is used.

github.com

exercism/x86-64-assembly/blob/4302f192fb2dbecccaca582acfeccf62daaddb10/exercises/concept/inventory-management/.docs/introduction.md?plain=1#L153


      
          
          ```x86asm
          mov ax, 1000 ; lower 16 bits of eax are 1000, upper bits are undefined
          mov cx, 200 ; lower 16 bits of ecx are 200, upper bits are undefined
          
          ; 200 * 1000 does not fit in 16 bits, so a 32 bits multiplication is necessary
          ; however, multiplying eax by ecx may produce an incorrect result due to undefined bits
          
          movzx eax, ax ; lower 16 bits of eax remain 1000, upper bits are cleared
          movzx ecx, cx ; lower 16 bits of ecx remain 200, upper bits are cleared
          mul ecx ; now eax correctly holds 200 * 100
          ```
          
          A 32-bit source operand is always zero-extended to all 64 bits of the destination operand with a simple `mov`.
          
          #### Using imul with unsigned numbers
          
          It is possible to use `imul` to multiply unsigned numbers.
          However, this may give an incorrect result if one of the numbers may be interpreted as negative.
          
          Since the sign bit in a signed integer corresponds to the most significant bit in an unsigned integer, in practice, this difference becomes relevant when more than the truncated result is needed, i.e., when the full range of `rdx:rax` is used.

keiraville · December 31, 2025, 10:18am

Thank you both, now fixed.