.model small
.stack 100h



; МАКСРОСЫ ИЗ МЕТОДИЧКИ
;------------------------------макрос ввода значений
mReadAX MACRO buf, sz
local input, startOfConvert, endofConvert
push bx
push cx
push dx

input:
mov [buf], sz
mov dx, offset [buf]
mov ah, 0ah
int 21h

mov ah, 02h
mov dl, 0Dh
int 21h

mov ah, 02h
mov dl, 0Ah
int 21h

xor ah, ah
cmp ah, [buf][1]
jz input

xor cx, cx
mov cl, [buf][1]

xor ax, ax
xor bx, bx
xor dx, dx
mov bx, offset [buf][2]

cmp [buf][2], "-"
jne startOfConvert
inc bx
dec cl

startOfConvert:
mov dx, 10
mul dx
cmp ax, 8000h
jae input

mov dl, [bx]
sub dl, "0"

add ax, dx
cmp ax, 8000h
jae input

inc bx
loop startOfConvert

cmp [buf][2], "-"
jne endofConvert
neg ax

endofConvert:
pop dx
pop cx
pop bx

endm mReadAX



;------------------------------макрос вывода сообщений на экран
Print MACRO str
push ax
push dx

mov ah, 09h
mov dx, offset str
int 21h

pop dx
pop ax
ENDM Print

;------------------------------макрос вывода результата
mWriteAx macro
local convert, write
push ax
push bx
push cx
push dx
push di

mov cx, 10
xor di, di

or ax, ax
jns convert

push ax
mov dx, "-"
mov ah, 02h
int 21h

pop ax
neg ax

convert:
xor dx, dx
div cx
add dl, "0"
inc di
push dx
or ax, ax
jnz convert

write:
pop dx
mov ah, 02h
int 21h
dec di
jnz write

pop di
pop dx
pop cx
pop bx
pop ax

endm mWriteAx



.data

  text_in_N db "Input N: $"
  text_in_arr db "Input array elems",13,10,"$"
  text_print_sum db "Sum of negative $"

  N   dw ?

  arr dw 100 dup(?) ; массив

  len_arr dw 0 ; длинна массива

  _arr dw 100 dup(?) ; массив отрицательных
  _len_arr dw 0 ; длинна массива отрицательных

  min_neg_elem dw ? ; минимальное отрицательное число
  min_neg_elem_pos dw ? ; позиция минимального отрицательного числа

  buf db 10 dup(?) ; буфер для ввода

.code
start:
  mov ax, @data
  mov ds, ax

  ; считываем N
  Print text_in_N
  mReadAX buf, 5
  mov N, ax

  ; считываем массив
  mov bx, offset arr
  mov cx, N
  Print text_in_arr
_read_array:
  mReadAX buf, 5
  mov [bx], ax
  add bx, 2
  loop _read_array


  ; копируем отрицательные числа
  mov bx, offset arr
  mov si, offset _arr
  mov cx, N
  mov dx, 0 ; счётчик отрицательных
_copy_neg_elem:

  mov ax, [bx]
  add bx, 2

  cmp ax, 0
  jge _copy_neg ; ax >= 0
  ; ax < 0
  mov [si], ax
  add si, 2
  inc dx
  mov _len_arr, dx

_copy_neg:

  cmp dx, 5 ; если прочитано 5 или больше
  jge _end_copy_neg_elem ; уходим

  loop _copy_neg_elem
_end_copy_neg_elem:

  ; находим минимальный элемент
  mov bx, offset _arr
  mov cx, _len_arr
  mov ax, [bx]
  mov min_neg_elem_pos, bx
  ; пропускаем поиск, если нет элементов
  cmp cx, 0
  jle _end_find_min_elem
_find_min_elem:

  cmp ax, [bx]
  jle _not_min
  ; если число меньше минимума
  mov ax, [bx] ; запоминаем его
  mov min_neg_elem, ax ; запоминаем его
  mov min_neg_elem_pos, bx ; и его прозицию
_not_min:

  add bx, 2
  loop _find_min_elem
_end_find_min_elem:


  ; считаем сумму
  mov si, min_neg_elem_pos
  mov bx, offset _arr
  mov cx, _len_arr
  mov ax, 0
  ; пропускаем вывод, если нет элементов
  cmp cx, 0
  jle _end_sum_neg
_sum_neg:

  cmp bx, si
  je _skip_sum
  add ax, [bx]

_skip_sum:
  add bx, 2
  loop _sum_neg
_end_sum_neg:


  Print text_print_sum
  mWriteAx

  mov ax, 4c00h
  int 21h


end start