; multi-segment executable file template.

data segment
    ; add your data here!
    niza1 dw 128 dup(?)
    niza2 dw 128 dup(?)
    broj1 dw 0d
    broj2 dw 0d
    i dw 0d
    j dw 0d
    b1 dw 0d
    b2 dw 0d
    m dw 0d
    n dw 0d
    flag dw 1d
ends

stack segment
    dw   128  dup(0)
ends

code segment
start:
; set segment registers:
    mov ax, data
    mov ds, ax
    mov es, ax

    ; add your code here

    mov cx, 0d

    while1:
    mov ah, 01h
    int 21h
    cmp al, '.'
    je compare_number1
    mov cl, al
    mov ah, 0d
    sub cl, 48d
    mov al, 10d
    mov dx, broj1
    mul dx
    add ax, cx
    mov broj1, ax
    cmp broj1, 100d
    jae add_to_array1
    jmp while1

    compare_number1:
    cmp broj1, 0d
    je end_add_in_array1
    jmp add_to_array1

    add_to_array1:
    mov ax, broj1
    mov bx, i
    mov niza1[bx], ax
    add i, 2d
    add b1, 1d
    mov broj1, 0d
    jmp while1

    end_add_in_array1:

    mov cx, 0d

    while2:
    mov ah, 01h
    int 21h
    cmp al, '.'
    je compare_number2
    mov cl, al
    mov ah, 0d
    sub cl, 48d
    mov al, 10d
    mov dx, broj2
    mul dx
    add ax, cx
    mov broj2, ax
    cmp broj2, 100d
    jae add_to_array2
    jmp while2

    compare_number2:
    cmp broj2, 0d
    je end_add_in_array2
    jmp add_to_array2

    add_to_array2:
    mov ax, broj2
    mov bx, j
    mov niza2[bx], ax
    add j, 2d
    add b2, 1d
    mov broj2, 0d
    jmp while2

    end_add_in_array2:
    mov bx, i
    mov b1, bx
    mov bx, j
    mov b2, bx

    for1:
    mov m, 0d
    mov flag, 1d
    mov bx, n
    cmp bx, b1
    je kraj
    mov cx, niza1[bx]
    add n, 2d
    for2:
    mov bx, m
    cmp bx, b2
    je proveri_flag
    mov dx, niza2[bx]
    add m, 2d
    cmp cx, dx
    je go_ima
    jmp for2

    proveri_flag:
    mov bx, 1d
    cmp flag, bx
    je dodadi
    jmp for1

    go_ima:
    mov flag, 0d
    jmp for1

    dodadi:
    mov bx, j
    mov niza2[bx], cx
    add j, 2d
    jmp for1

    kraj:

    mov ax, 4c00h ; exit to operating system.
    int 21h
ends

end start ; set entry point and stop the assembler.