.model  small
    .stack  1000h
    .386

    .data


stq db  'esly,  ...    ..... ..   .    pomogete$'

l   dw  $-stq

    .code
start:
    mov ax, @data
    mov ds, ax
    xor ax, ax
    mov cx, l
    xor si, si
    mov dx, 2eh

steck:
    cmp bx, 16
    je  row

    mov al, byte ptr stq[bx][di]
    push    ax
    xor ax, ax
    inc bx
    jmp tre
row:
    add di, 16
    xor bx, bx
    jmp steck
tre:
    loop    steck

    xor bx, bx
    xor di, di
    xor cx, cx
    xor dx, dx
    xor ax, ax



    xor ax, ax
    mov cx, l
    xor si, si
    mov dx, 2eh

steck1:
    cmp bx, 16
    je  row1
    pop ax
    mov byte ptr stq[bx][di], al
    xor ax, ax
    inc bx
    jmp tre1
row1:
    add di, 16
    xor bx, bx
    jmp steck1
tre1:
    loop    steck1

    xor bx, bx
    xor di, di
    xor cx, cx
    xor dx, dx
    xor ax, ax

    mov cx, l
    xor si, si
    mov dx, 2eh


steck2:
    cmp bx, 16
    je  row2

    mov al, byte ptr stq[bx][di]
    push    ax
    xor ax, ax
    inc bx
    jmp tre2
row2:
    add di, 16
    xor bx, bx
    jmp steck2
tre2:
    loop    steck2

    xor bx, bx
    xor di, di
    xor cx, cx
    xor dx, dx
    xor ax, ax
    mov cx, l
    xor si, si
    mov dx, 2eh

sort:
    cmp bx, 16
    je  rot

    pop ax

    cmp ax, 20h
    je  space
ttt:
    cmp ax, 2eh
    je  dote1

    mov byte ptr stq[bx][di], al

    inc bx
;   cmp ax, 24h
;   je  finish1
    xor ax, ax
    jmp finish

space:
    mov byte ptr stq[bx][di], al
    mov dx, ax
    inc bx
    xor ax, ax
    jmp space2
space1:

    dec cx
space2:
    xor ax, ax

    pop ax
    cmp ax, 20h
    je  space1
    jne ttt
dote1:
    mov bp, ax
    xor ax, ax
    pop ax

    cmp ax, 2eh
    je  dote2

    jne nodote1

dote2:
    xor ax, ax
    pop ax
    xor bp, bp
    mov bp, ax
    cmp ax, 2eh
    je  dadote3
    jne nodote2

nodote1:
    mov byte ptr stq[bx][di], 2ah
    inc bx
    cmp bx, 16
    jne rrr
    add di, 16
    xor bx, bx
rrr:

    cmp al, 20h
    je  space4
    mov byte ptr stq[bx][di], al
    inc bx
    dec cx
    jmp finish
finish:
    loop    sort
    jmp finish1

nodote2:
    mov byte ptr stq[bx][di], 2ah
    inc bx

    cmp bx, 16
    jne rr2

    add di, 16
    xor bx, bx
rr2:
    mov byte ptr stq[bx][di], 2ah
    inc bx
    cmp bx, 16
    jne rr22
    add di, 16
    xor bx, bx
rr22:

    cmp ax, 20h
    je  space5
    mov byte ptr stq[bx][di], al
    inc bx
    dec cx
    dec cx
    jmp finish

dadote3:
    mov byte ptr stq[bx][di], 2dh
    inc bx
    dec cx
    dec cx
    dec cx
    jmp finish
space5:
    dec cx
space4:
    dec cx
    jmp space
;;  cmp bx, 16
;;  jne rot
;
;
;   add di, 16
;   xor bx, bx
;d3:
;   mov byte ptr stq[bx][di], 2ah
;   inc bx
;
;   cmp bx, 16
;   jne de3
;
;   add di, 16
;   xor bx, bx
;de3:
;   mov byte ptr stq[bx][di], 2ah
;   inc bx
;   cmp bx, 16
;   jne dd3
;
;   add di, 16
;   xor bx, bx
;dd3:
;
;   xor ax, ax
;   pop ax
;   mov byte ptr stq[bx][di], al
;   inc bx
;   dec cx
;   dec cx
;   dec cx
;   jmp sort

rot:
    add di, 16
    xor bx, bx
    jmp sort


finish1:





    mov ax, 4c00h
    int 21h
    end start