.model tiny
.stack 100h
.data
buf db 256 dup(0)
size = $ - buf
buf2 db 256 dup(0)
res db 256 dup(0)
newline db 10,13,'$'
max db ?

.code

start proc
  mov al, size-2
  lea bx, buf
  call INPUT; âõîäíîé ìàññèâ ñ ðàçìåðîì â MaxSize â al è ptr â bx
  call OUTPUT

  lea bx, buf2
  mov al, size-2
  call INPUT
  call OUTPUT

  xor cx, cx

  call sumArrays

  mov al, [buf+1] ; êëàäåì ìàêñ äëèíó ìàññèâà â max
  mov ah, [buf2+1]
  cmp al, ah
  jg gt ;ïåðåõîä åñëè áîëüøå
  mov max, ah
  jmp skip1
gt:
  mov max, al

skip1:
  or dx, dx ;ïðîâåðêà áèòà íà ïåðåïîëíåíèå
  jz no_overflow   ; flag ZF = 1
  xor ax, ax
  cmp dl, 10
  jl decremHigh
  sub dl, 10
  add dl, 'A'
  xor ax, ax
  mov ah, 02h
  int 21h
  jmp no_overflow

decremHigh:
  add dl, '0'
  xor ax, ax
  mov ah, 02h
  int 21h

no_overflow: ;ïîêà íå ïåðåïîëíèëîñü
  xor ax, ax
  xor dx, dx
  xor cx, cx
  xor bx, bx
  mov ax, @data
  mov ds, ax
  lea si, res
  mov cl, max
   ; âûâîä ìàññèâà ñ ðàçìåðîì â cl  è ïåðâîãî ýëåìåíòà ptr â ds[si]
  push ax
    push bx
    push cx
    push dx

    xor dx, dx
    xor ax, ax
l:  mov dl, ds[si]
    mov ah, 02h
    int 21h
    inc si
    loop l

    pop dx
    pop cx
    pop bx
    pop ax
    ret
  ret
start endp


INPUT proc
    push ax
    push bx
    push cx
    push dx

    mov cx, ax
    mov ah, 0Ah
    mov [bx], al
    mov [bx+1], 0
    mov dx, bx
    int 21h
    mov al, [bx+1]
    add dx, 2
    mov ah, ch

    pop dx
    pop cx
    pop bx
    pop ax
    ret
INPUT endp

OUTPUT proc
    push    ax
    push    bx
    push    cx
    push    dx
    mov ax, @data
    mov ds, ax
    lea dx, newline
    mov ah, 9
    int 21h
    pop dx
    pop cx
    pop bx
    pop ax
    ret
OUTPUT endp

sumArrays proc
    push 0       ;äîáàâëåíèå 0 åñëè ó ìàññèâîâ íå îäèíàêîâàÿ äëèíà
    mov al, [buf+1]
    mov ah, [buf2+1]
    cmp al, ah ;ñðàâíåíèå äëèí äâóõ ìàññèâîâ
    jg small ; åñëè áîëüøå
    jl big
    mov cl, ah
    jmp Addition

small: ;>> äëèíà ìàëåíüêîãî ìàññèâà
    mov cl, ah
lenSmall:
    mov dx, @data
    mov ds, dx
    lea bx, buf2
    add bx, cx
    inc bx  ;+1
    mov dl, ds[bx]
    add bl, al
    sub bl, ah
    mov ds[bx], dl
    loop lenSmall
    mov cl, al
    sub cl, ah

zeroSmall:
    mov dx, @data
    mov ds, dx
    lea bx, buf2
    add bx, cx
    inc bx
    mov ds[bx], '0'
    loop zeroSmall
    mov cl, al
    jmp Addition

big:
    mov cl, al
lenBig:
    mov dx, @data
    mov ds, dx
    lea bx, buf
    add bx, cx
    inc bx
    mov dl, ds[bx]
    add bl, ah
    sub bl, al
    mov ds[bx], dl
    loop lenBig
    mov cl, ah
    sub cl, al

zeroBig:
    mov dx, @data
    mov ds, dx
    lea bx, buf
    add bx, cx
    inc bx
    mov ds[bx], '0'
    loop zeroBig
    mov cl, ah
    jmp Addition


Addition:
    xor ax, ax
    lea bx, buf
    mov dx, @data
    mov ds, dx
    xor dx, dx
    add bx, cx
    inc bx
    pop dx
    mov al, ds[bx]
    cmp al, 'A'
    jl decrem1  ;åñëè ìåíüøå
    sub al, 'A'
    add al, 10
    jmp hex1
decrem1:
    sub al, '0'
hex1:
    add dl, al
    lea bx, buf2
    add bx, cx
    inc bx
    mov al, ds[bx]
    cmp al, 'A'
    jl decrem2
    sub al, 'A'
    add al, 10
    jmp hex2
decrem2:
    sub al, '0'
hex2:

    add dl, al
    cmp dl, 16
    jl else ;åñëè íå ïåðåïîëíèëñÿ
    push 1
    sub dl, 16
    cmp dl, 10
    jl decrem3
    sub dl, 10
    add dl, 'A'
    jmp hex3

decrem3:
    add dl, '0'
hex3:
    jmp skip

else:
    push 0
    cmp dl, 10
    jl decrem4
    sub dl, 10
    add dl, 'A'
    jmp hex4

decrem4:
    add dl, '0'
hex4:

skip:
    lea bx, res  ;çàãðóæàåì â bx res ñëîæåíèÿ
    add bx, cx
    dec bx
    mov ds[bx], dl
    loop Addition
    pop dx; îñòàâëÿåì ñàìûé áîëüøîé áèò â dx
    ret
sumArrays endp
end