Skip to content
TheChatArchiveThe Chat Archive
DeepSeekdeepseek-v3-0324· DeepSeekHugging 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 Kimikimi-k2-0711-preview’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. DeepSeek Assistant

    6502 Assembly: 8-bit Unsigned Multiplication (16-bit Result)

    Here's an efficient 6502 assembly program that multiplies two unsigned 8-bit integers and returns a 16-bit result. The program uses the shift-and-add method, which is well-suited for the 6502's limited instruction set.

    ; Input:  Multiplicand in $00 (memory location 0x0000)
    ;         Multiplier in $01 (memory location 0x0001)
    ; Output: Product in $02 (low byte) and $03 (high byte) (16-bit result)
    ; Uses:   A, X registers
    ; Preserves: Y register
    ; Execution time: ~128-136 cycles average
    
    Multiply:
        LDA #$00        ; Initialize high byte of result to 0
        STA $03
        LDX #$08        ; We'll loop 8 times (8 bits)
        
    MultiplyLoop:
        LSR $01         ; Shift multiplier right (LSB into carry)
        BCC NoAdd       ; If carry clear, skip addition
        
        CLC             ; Add multiplicand to result
        ADC $00         ; Add to accumulator (which becomes high byte)
        
    NoAdd:
        ROR A           ; Rotate right accumulator and carry into result
        ROR $02         ; Rotate right result low byte
        
        DEX             ; Decrement counter
        BNE MultiplyLoop ; Loop until all bits processed
        
        STA $03         ; Store high byte of result
        RTS             ; Return with result in $02 (low) and $03 (high)
    

    Alternative Version (Using Indexed Addressing)

    Here's another version that uses the same algorithm but with different memory addressing:

    ; Input:  Multiplicand in M1 (user-defined memory location)
    ;         Multiplier in M2 (user-defined memory location)
    ; Output: Product in PROD (16-bit, little-endian)
    ; Uses:   A, X registers
    
    M1     = $00        ; Multiplicand address
    M2     = $01        ; Multiplier address
    PROD   = $02        ; Product address (2 bytes)
    
    Multiply:
        LDA #$00        ; Clear accumulator (will become high byte)
        LDX #$08        ; Number of bits to process
        
    MultLoop:
        LSR M2          ; Get next bit of multiplier
        BCC SkipAdd     ; If 0, skip addition
        
        CLC             ; Clear carry before add
        ADC M1          ; Add multiplicand to high byte
        
    SkipAdd:
        ROR A           ; Shift right result high byte
        ROR PROD        ; Shift right result low byte
        
        DEX             ; Decrement bit counter
        BNE MultLoop    ; Loop until all bits processed
        
        STA PROD+1      ; Store high byte of result
        RTS             ; Return with 16-bit product in PROD
    

    How It Works

    1. Initializes the high byte of the result to 0
    2. Processes each bit of the multiplier (8 bits total):
      • If the current bit is 1, adds the multiplicand to the accumulator
      • Rotates the result right to position it correctly
    3. After 8 iterations, the complete 16-bit product is formed

    The algorithm is efficient for the 6502, using about 128-136 cycles on average (depending on how many bits are set in the multiplier). This is much faster than a naive repeated addition approach.

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