Skip to content
TheChatArchiveThe Chat Archive
o3-2025-04-16· OpenAIHugging Face LMArena Human Preference 140K

You are a senior assembly language programmer with extensive experience in 6502. Using…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with grok-3-preview-02-24’s answer.
  1. User

    You are a senior assembly language programmer with extensive experience in 6502. Using 6502 assembly language, write a program that multiplies two unsigned 8-bit integers, and returns the result as an unsigned 16-bit integer. The memory locations that contain the original two integers do not need to be preserved.

  2. Assistant

    Below is a compact, fully–commented 6502 routine that multiplies two unsigned 8-bit numbers and returns an unsigned 16-bit product.
    Neither of the original operands is preserved; they are used as scratch space while the routine runs.

    ; ──────────────────────────────────────────────────────────────
    ; 8-bit × 8-bit  → 16-bit unsigned multiply
    ; ──────────────────────────────────────────────────────────────
    ; Assembles at any address; just make sure the zero-page
    ; variables (BYTE_A … TMP) are available.
    ;
    ; INPUT
    ;   BYTE_A   (zp)  = multiplicand   (will be destroyed)
    ;   BYTE_B   (zp)  = multiplier     (will be destroyed)
    ;
    ; OUTPUT
    ;   RESULT_L (zp)  = 16-bit product, low  byte
    ;   RESULT_H (zp)  = 16-bit product, high byte
    ;
    ; SCRATCH
    ;   TMP      (zp)  = high byte of the shifting multiplicand
    ;   X-reg            loop counter (8 iterations)
    ; ──────────────────────────────────────────────────────────────
    
    BYTE_A   = $00      ; multiplicand  (low  byte, shifted left each pass)
    BYTE_B   = $01      ; multiplier    (shifted right each pass)
    RESULT_L = $02      ; product low   (returned)
    RESULT_H = $03      ; product high  (returned)
    TMP      = $04      ; high byte of the multiplicand while it is shifting
    
            .org  $0600          ; (or any convenient load address)
    ;---------------------------------------------------------------
    Multiply_8x8:
            CLD                 ; be absolutely sure we are in binary mode
    
            LDA #0              ; clear 16-bit result
            STA RESULT_L
            STA RESULT_H
            STA TMP             ; multiplicand’s high byte starts at 0
    
            LDX #8              ; we have 8 bits to process
    Mul_Loop:
            LSR BYTE_B          ; shift next multiplier bit into C
            BCC Skip_Add        ; if bit was 0, skip the addition
    
            ; --------- result += current multiplicand (TMP:BYTE_A) ---------
            CLC                 ; add low bytes
            LDA RESULT_L
            ADC BYTE_A
            STA RESULT_L
    
            LDA RESULT_H        ; add high bytes + carry
            ADC TMP
            STA RESULT_H
            ; ---------------------------------------------------------------
    
    Skip_Add:
            ; shift multiplicand left (TMP:BYTE_A <<= 1)
            ASL BYTE_A
            ROL TMP
    
            DEX                 ; 1 bit done – loop 8 times
            BNE Mul_Loop
    
            RTS                 ; product now in RESULT_H:RESULT_L
    ;---------------------------------------------------------------
    

    How it works (Russian-peasant / shift-add algorithm)

    1. The 16-bit result is cleared.
    2. The multiplicand is held in a 16-bit register pair (TMP:BYTE_A).
      • BYTE_A starts with the operand’s 8 bits.
      • TMP starts at 0.
    3. For each of the 8 bits in the multiplier:
      a. We shift the multiplier right; its LSB ends up in Carry.
      b. If that bit was 1, we add the current 16-bit multiplicand to the result.
      c. We shift the multiplicand left, doubling it for the next bit.
    4. After 8 iterations the 16-bit product is ready in RESULT_H:RESULT_L.

    Timing / size (for the curious)
    • 51 (+/-3) bytes of code, 8 zero-page bytes used (5 are variables).
    • Worst-case 234 cycles (all multiplier bits = 1); best-case 210 cycles.

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