Переместить все отрицательные элементы в начало массива, а положительные в конец

.model small
.stack 100h
.data 
    bb db 'aaaaaaaaaaa'
    vector1 dw 5 dup (?)
    aa db 'aaaaaaaaaaa'
    vector2 dw 4 dup (?)
    array dw 4*4*2 dup (?)
    buff    db 100, 101 Dup(?)
    nl db 13, 10, '$'
    vec1 db 13, 10, 'Vector 1: $'
    vec2 db 13, 10, 'Vector 2: $'
    text1 db 'vvevite 16 chisel cherez probel:', 13, 10, '$'
    text2 db 'Massiv:', 13, 10, '$'
    text3 db 13, 10, 'Preobrazovanniy massiv: $'
.code
start:
    mov ax, @data
    mov ds, ax
    mov es, ax
;_-----------------------------------------------------------
;вводим массив  
    mov dx, offset text1
    mov ah, 9
    int 21h
    mov si, offset array
    call inputint
;===============================================================
;выводим в виде матрицы  
    mov dx, offset text2
    mov ah, 9
    int 21h
    mov si, 0               ;смещение элемента  относительно физического адреса массива
    mov cx, 4               ;кол-во строк
@@1:
    push cx                 ;сохраним внешний счетчик
    mov cx, 4               ;кол-во столбцов
@@2:
    mov dl, ' '             ;в dl поместим пробел
    mov ax, array[si]           ;в ах очередной элемент массив
    call OutInt             ;выводим
    mov ah, 2               ;выведем пробел
    int 21h                 
    add si, 2                   ;следующий элемент
    loop @@2                    ;повторим
    mov dx, offset nl           ;переводим строку
    mov ah, 9
    int 21h
    pop cx                      ;восстановим счетчик внешних циклов
    loop @@1                    ;повторим
;======================================================================
;составляем векторы из диагоналей матрицы
    mov si, 0
    mov cx, 4
    mov bx, 0
@v1:                                ;вектор 1
    mov ax, array[si+bx]
    mov vector1[bx], ax
    add si, 8
    add bx, 2
    loop @v1
 
    mov si, 0
    mov cx, 4
    mov bx, 6
    xor di, di
@v2:                                ;вектор 2
    mov ax, array[si+bx]
    mov vector2[di], ax
    add si, 8
    sub bx, 2
    add di, 2
    loop @v2
;--------------------------------------------
;выводим векторы
    mov dx, offset vec1
    mov ah, 9
    int 21h
    mov dl, ' '
    xor bx, bx
    mov cx, 4
out_v1:
    mov ax, vector1[bx]
    call OutInt
    mov ah, 2
    int 21h
    add bx, 2
    loop out_v1
    
    mov dx, offset vec2
    mov ah, 9
    int 21h
    mov dl, ' '
    mov cx, 4
    xor bx, bx
out_v2:
    mov ax, vector2[bx]
    call OutInt
    mov ah, 2
    int 21h
    add bx, 2
    loop out_v2
;=======================================================
;преобразуем 1 массив
    xor bx, bx
    mov cx, 4
    xor dx, dx
   [MENTION=285084]TeSt[/MENTION]:
    cmp vector1[bx], 0
    jge @no_change
    push cx
    mov cx, 4
    mov si, offset vector1
    mov di, si
    add si, 6
    add di, 8
    std
    rep movsw
    mov ax, vector1[bx+2]
    xchg bx, dx
    mov vector1[bx], ax
    xchg dx, bx
    mov si, offset vector1
    add si, bx
    add si, 2
    mov di, si
    add si, 2
    pop cx
    push cx
    cld
    rep movsw
    pop cx
    add dx, 2
@no_Change:
    add bx, 2
    loop   [MENTION=285084]TeSt[/MENTION];
 
    mov ah, 9
    mov dx, offset text3
    int 21h
    mov si, offset vector1
    mov dl, ' '
    mov cx, 4
@write:
    mov ax, [si]
    Call OutInt
    mov ah, 2
    int 21h
    add si, 2
    loop @write
    
    xor ax, ax
    int 16h
    mov ax, 4C00h
    int 21h
    
    
;=====================================================================      
;вспомогательные подпрограммы
OutInt proc                 ;число для вывода должно быть в ах
    push cx             ;сохраним регистры
    push dx
    push bx
    test    ax, ax
   jns     oi1
 
; Если оно отрицательное, выведем минус и оставим его модуль.
   mov  cx, ax
   mov     ah, 02h
   mov     dl, '-'
   int     21h
   mov  ax, cx
   neg     ax
; Количество цифр будем держать в CX.
oi1:  
    xor     cx, cx
    mov     bx, 10 ; основание сс. 10 для десятеричной и т.п.
oi2:
    xor     dx,dx
    div     bx
; Делим число на основание сс. В остатке получается последняя цифра.
; Сразу выводить её нельзя, поэтому сохраним её в стэке.
    push    dx
    inc     cx
; А с частным повторяем то же самое, отделяя от него очередную
; цифру справа, пока не останется ноль, что значит, что дальше
; слева только нули.
    test    ax, ax
    jnz     oi2
; Теперь приступим к выводу.
    mov     ah, 02h
oi3:
    pop     dx
; Извлекаем очередную цифру, переводим её в символ и выводим.
;; раскоментировать если основание сс > 10, т.е. для вывода требуются буквы
;   cmp     dl,9
;   jbe     oi4
;   add     dl,7
;oi4:
    add     dl, '0'
    int     21h
; Повторим ровно столько раз, сколько цифр насчитали.
    loop    oi3
    pop bx          ;восстановим ренистры
    pop dx
    pop cx
    ret
OutInt endp
;================================================================================
InputInt proc       ;вводимые числа помещаются в массив по адресу в si
    push si         ;сохраним регистры
    push di
    push ax
    push bx
    push cx
    push dx
    push bp
;вводим числа (строку)
    mov ah,0ah
    xor bp, bp
    mov dx,offset buff ; аддрес буфера
    int 21h ; принимаем строку
    mov dl,0ah
    mov ah,02
    int 21h ; выводим перевода строки
    
; обрабатываем содержимое буфера
    mov di,offset buff+2 ; берем аддрес начала строки
@1: xor bp, bp
    cmp byte ptr [di],"-" ; если первый символ минус
    jnz ii1
    mov bp, 1  ; устанавливаем флаг
    inc di    ; и пропускаем его
ii1:
    xor ax,ax
    mov bx,10  ; основание сc
ii2:
    mov cl,[di] ; берем символ из буфера
    mov ch, 0ffh        ;установим флаг конца строки (если это не конец, то далее сбросим его)
    cmp cl,0dh  ; проверяем не последний ли он
    jz endin
    xor ch, ch          ;сбрасываем флаг конца строки
    cmp cl, ' '  ;пробел ли это?
    je probel
; если символ не последний и не пробел, то проверяем его на правильность
    cmp cl,'0'  ; если введен неверный символ <0
    jl er
    cmp cl,'9'  ; если введен неверный символ >9
    ja er
    
    sub cl,'0' ; делаем из символа число 
    mul bx     ; умножаем на 10
    add ax,cx  ; прибавляем к остальным
    inc di     ; указатель на следующий символ
    jmp ii2     ; повторяем
 
er:   ; если была ошибка, то выходим
    int 20h
probel:
    push ax     ;сохраним число
    mov al, cl      ;поместим в al код пробела
    cld             ;сбросим флаг d (автоувеличение si и di)
    repe scasb      ;пропустим все пробелы
    dec di          ;установим di на символ, следующий за всеми пробелами
    pop ax              ;восстановим число
endin:
    cmp bp,1 ; если установлен флаг, то 
    jnz ii3
    neg ax   ; делаем число отрицательным
    
ii3:                    
    mov [si], ax            ;сохраним число в буфер
    or ch, ch               ;флаг конца строки установлен?
    jne @exit               ;если да, то на выход
    add si, 2               ;следующий элемент массива
    jmp @1                  ;повторим ввод
@exit:
    pop bp              ;восстановим все регистры
    pop dx
    pop cx
    pop bx
    pop ax
    pop di
    pop si
    ret
InputInt endp
end start