; si * di = si
mul64:
    push ax
    push bx
    push cx

    ; bp -> nasz mnożnik
    sub sp, 8
    mov bp, sp

    mov cx, 64

    ; Kopiuj dane z si do bp
    mov ax, word ptr [si]
    mov word ptr [bp], ax

    mov ax, word ptr [si+2]
    mov word ptr [bp+2], ax

    mov ax, word ptr [si+4]
    mov word ptr [bp+4], ax

    mov ax, word ptr [si+6]
    mov word ptr [bp+6], ax

    ; Czyscimy si
    mov word ptr [si], 0
    mov word ptr [si+2], 0
    mov word ptr [si+4], 0
    mov word ptr [si+6], 0

    ; Sprawdźmy czy mnozymy przez 0 :)
    cmp word ptr [di], 0
    jne mul64_calc

    cmp word ptr [di+2], 0
    jne mul64_calc

    cmp word ptr [di+4], 0
    jne mul64_calc

    cmp word ptr [di+6], 0
    jne mul64_calc

    jmp mul64_zero

mul64_calc:
    ; First 16
    mov ax, word ptr [di]

    shr word ptr [di+6], 1
    rcr word ptr [di+4], 1
    rcr word ptr [di+2], 1
    rcr word ptr [di], 1

    and ax, 1
    cmp ax, 1

    je mul64_bit_one

mul64_bit_zero:
    ; Przesun całe 64 bity o jeden w lewo
    shl word ptr [bp], 1
    rcl word ptr [bp+2], 1
    rcl word ptr [bp+4], 1
    rcl word ptr [bp+6], 1

    loop mul64_calc
    jmp mul64_res

mul64_bit_one:
    mov ax, word ptr [bp]
    add word ptr [si], ax

    mov ax, word ptr [bp+2]
    adc word ptr [si+2], ax

    mov ax, word ptr [bp+4]
    adc word ptr [si+4], ax

    mov ax, word ptr [bp+6]
    adc word ptr [si+6], ax

    ; Przesun całe 64 bity o jeden w lewo
    shl word ptr [bp], 1
    rcl word ptr [bp+2], 1
    rcl word ptr [bp+4], 1
    rcl word ptr [bp+6], 1

    loop mul64_calc
    jmp mul64_res

mul64_zero:
    mov word ptr [si], 0
    mov word ptr [si+2], 0
    mov word ptr [si+4], 0
    mov word ptr [si+6], 0

mul64_res:
    add sp, 8

    pop cx
    pop bx
    pop ax
    ret