Skip to content
TheChatArchiveThe Chat Archive
Kimikimi-k2-0711-preview· Moonshot AIHugging Face LMArena Human Preference 140K

68000 function to multiply two 32-bit signed registers together and form a result in two…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Claudeclaude-sonnet-4-20250514-thinking-32k’s answer.
  1. User

    68000 function to multiply two 32-bit signed registers together and form a result in two registers. Do not use the shift and add method under any circumstances. When generating the two middle terms add them together first before calculating the whole result.

  2. Kimi Assistant

    Here is a 68000 routine that multiplies two 32-bit signed values in D0 and D1 and returns the 64-bit product in D2 (high 32 bits) and D3 (low 32 bits).
    It uses the classic “four partial products” decomposition, but the two middle terms are added together before they are merged with the high and low parts.

    ;----------------------------------------------------------
    ; 64-bit signed multiply  D0 * D1  →  D2:D3
    ;   D0, D1 are destroyed
    ;   D2 = high 32 bits of product
    ;   D3 = low  32 bits of product
    ;   D4-D7 are scratch
    ;----------------------------------------------------------
    
            ; Split operands into 16-bit halves
            move.l  d0,d4           ; a = aH:aL
            swap    d4              ; d4 = aH
            move.w  d0,d5           ; d5 = aL
    
            move.l  d1,d6           ; b = bH:bL
            swap    d6              ; d6 = bH
            move.w  d1,d7           ; d7 = bL
    
            ;--------------------------------------------------
            ; 1.  low  partial product   aL * bL   (unsigned)
            ;--------------------------------------------------
            mulu.w  d7,d5           ; d5 = aL * bL   (32-bit result)
    
            ;--------------------------------------------------
            ; 2.  high partial product   aH * bH   (signed)
            ;--------------------------------------------------
            muls.w  d6,d4           ; d4 = aH * bH   (32-bit result)
    
            ;--------------------------------------------------
            ; 3.  middle terms  aL*bH  and  aH*bL
            ;     add them together FIRST
            ;--------------------------------------------------
            move.w  d1,d3           ; d3 = bL
            swap    d3              ; d3 = bH
            muls.w  d3,d0           ; d0 = aL * bH   (signed)
    
            move.w  d6,d1           ; d1 = bH
            swap    d1              ; d1 = bL
            muls.w  d1,d2           ; d2 = aH * bL   (signed)
    
            add.l   d0,d2           ; d2 = (aL*bH + aH*bL)  <<-- combined middle
    
            ;--------------------------------------------------
            ; 4.  assemble the 64-bit result
            ;--------------------------------------------------
            ; d5 = low  partial product (aL*bL)
            ; d4 = high partial product (aH*bH)
            ; d2 = combined middle term (aL*bH + aH*bL)
    
            ; propagate carry from low product into middle
            add.l   d5,d2           ; middle += low  (low 16 bits of middle)
            swap    d5              ; d5 = high 16 bits of low product
            clr.w   d5              ; zero-extend
            addx.l  d5,d4           ; propagate carry into high product
    
            ; final registers
            move.l  d4,d2           ; high 32 bits
            move.l  d5,d3           ; low  32 bits   (already in d5)
    

    Explanation of the algorithm

    1. Split each 32-bit operand into 16-bit halves:
      a = aH·2¹⁶ + aL, b = bH·2¹⁶ + bL
    2. Compute the four 16×16 partial products:
      P₀ = aL·bL (unsigned)
      P₁ = aL·bH (signed)
      P₂ = aH·bL (signed)
      P₃ = aH·bH (signed)
    3. Add the two middle terms first:
      M = P₁ + P₂
    4. Combine the parts with proper alignment and carry propagation to obtain the 64-bit signed product.
  3. User

    rewrite to only multiply unsigned numbers instead

  4. Kimi Assistant

    ;---------------------------------------------------------- ; 64-bit UNSIGNED multiply D0 * D1 → D2:D3 ; D0, D1 are destroyed ; D2 = high 32 bits of product ; D3 = low 32 bits of product ; D4-D7 are scratch ; Uses only MULU.W, no shift-and-add ;----------------------------------------------------------

        ; Split operands into 16-bit halves
        move.l  d0,d4           ; a = aH:aL
        swap    d4              ; d4 = aH
        move.w  d0,d5           ; d5 = aL
    
        move.l  d1,d6           ; b = bH:bL
        swap    d6              ; d6 = bH
        move.w  d1,d7           ; d7 = bL
    
        ;--------------------------------------------------
        ; 1.  low  partial product   aL * bL   (unsigned)
        ;--------------------------------------------------
        mulu.w  d7,d5           ; d5 = aL * bL   (32-bit result)
    
        ;--------------------------------------------------
        ; 2.  high partial product   aH * bH   (unsigned)
        ;--------------------------------------------------
        mulu.w  d6,d4           ; d4 = aH * bH   (32-bit result)
    
        ;--------------------------------------------------
        ; 3.  middle terms  aL*bH  and  aH*bL
        ;     add them together FIRST
        ;--------------------------------------------------
        move.w  d1,d3           ; d3 = bL
        swap    d3              ; d3 = bH
        mulu.w  d3,d0           ; d0 = aL * bH   (unsigned)
    
        move.w  d6,d1           ; d1 = bH
        swap    d1              ; d1 = bL
        mulu.w  d1,d2           ; d2 = aH * bL   (unsigned)
    
        add.l   d0,d2           ; d2 = (aL*bH + aH*bL)  <<-- combined middle
    
        ;--------------------------------------------------
        ; 4.  assemble the 64-bit result
        ;--------------------------------------------------
        ; d5 = low  partial product (aL*bL)
        ; d4 = high partial product (aH*bH)
        ; d2 = combined middle term (aL*bH + aH*bL)
    
        ; propagate carry from low product into middle
        add.l   d5,d2           ; middle += low  (low 16 bits of middle)
        swap    d5              ; d5 = high 16 bits of low product
        clr.w   d5              ; zero-extend
        addx.l  d5,d4           ; propagate carry into high product
    
        ; final registers
        move.l  d4,d2           ; high 32 bits
        move.l  d5,d3           ; low  32 bits
    

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.