model small
.stack 100h
.data
        ar db 30,90,87,50,31,77,27,120
        len db $ - ar
.code
start:
        assume cs:@code, ds:@data
        mov ax, @data
        mov ds, ax
        mov es, ax

        xor ax, ax
        mov al, len
        dec ax

        mov dx, 0

        push dx
        push ax

        call qsort

        xor ax, ax
        mov al, len
        push ax
        call big_prnt
        pop ax

        mov ax, 4c00h
        int 21h

big_prnt proc far
        mov bp, sp
        mov cx, [bp + 4]

lp:
        xor ax, ax
        mov al, len
        sub ax, cx

        mov si, ax
        push cx
        xor bx, bx
        mov bl, ar[si]
        push bx
        call prnt
        pop cx
        pop cx

        xor dx, dx
        mov dl, ' '
        xor ax, ax
        mov ah, 02h
        int 21h

        loop lp

        ret

big_prnt endp

prnt proc far
        mov bp, sp
        mov ax, [bp + 4]

        xor dx, dx

        mov bx, 10
        div bx
        add dx, 30h
        push dx

        mov cx, ax

        cmp cx, 0
        jg rpt

rt1:
        pop dx
        mov ah, 02h
        int 21h

        ret

rpt:
        push cx
        call prnt
        pop cx
        jmp rt1
prnt endp

qsort proc far
        mov bp, sp

        mov ax, [bp + 6] ; left
        mov dx, [bp + 4] ; right

        add ax, dx ; left + right
        mov dl, 2 ; divisor
        div dl ; dividing

        mov ah, 0 ; убираем остаток

        xor bx, bx
        mov si, ax
        mov bl, ar[si] ; element m

        mov ax, [bp + 6] ; left
        mov dx, [bp + 4] ; right

p1:
        dec ax
w1:
        inc ax
        mov si, ax
        cmp ar[si], bl
        jl w1

        inc dx
w2:
        dec dx
        mov si, dx
        cmp ar[si], bl
        jg w2

        cmp ax, dx
        jle c1

        cmp [bp + 6], dx
        jl lrec

w3:
        mov bp, sp
        cmp ax, [bp + 4]
        jl rrec

w4:
        ret 4


c1:
        mov si, ax ; si - ax
        mov di, dx ; di - dx
        mov cl, ar[si]
        mov ch, ar[di]
        mov ar[si], ch
        mov ar[di], cl
        inc ax
        dec dx
        jmp p1

lrec:
        push ax dx
        push [bp + 6]
        push dx
        call qsort
        pop dx ax
        jmp w3

rrec:
        push ax
        push [bp + 4]
        call qsort
        jmp w4
qsort endp


end start