.model tiny
.stack 512
.code

ent db 13,10,'$'
tab dw 100 dup(?)
zmienna dw 0
poprzedni dw 0
nastepny dw 0
srodkowy dw 0
czy_zw dw 0
czy_sr dw 0
czy_zw1 dw 0

spr_czy_koniec:
mov cx,'.'
cmp [bx],cx
ret

na_koniec:
mov bx, offset tab
skocz_koniec:
add bx,2
call spr_czy_koniec
jnz skocz_koniec
sub bx,2
ret

inkrementuj:
mov cx,'9'
cmp [bx],cx
jz dziewiec
mov cx,1
add [bx],cx
jmp dalej
dziewiec:
mov cx,'0'
mov [bx],cx
sub bx,2
jmp inkrementuj
dalej:
ret

czy_zw_na_1:
mov dx,czy_zw
mov dx,1
mov czy_zw,dx
ret

czy_zw1_na_1:
mov dx,czy_zw1
mov dx,1
mov czy_zw1,dx
ret

czy_sr_na_1:
mov dx,czy_sr
mov dx,1
mov czy_sr,dx
ret


do_srodka_tab:
mov cx,ax
mov bx, offset tab
idz_do_sr:
add bx,2
loop idz_do_sr
ret

przerzuc:
mov cx,[bx]
mov bx,nastepny
mov [bx],cx
ret

nastepne:
mov cx,[bx]
mov bx,poprzedni
sub bx,2
mov poprzedni,bx
ret

do_wyswietlenia:
mov ah,02h
mov bx, offset tab
call spr_czy_koniec
jz dodaj
xor dh,dh
mov dl,'1'
int 21h
dodaj:
add bx,2
wyswietl:
call spr_czy_koniec
jz koniec_wysw
xor dh,dh
mov dx,[bx]
int 21h
add bx,2
jmp wyswietl
koniec_wysw:
ret

start: ;
mov ax, @data
mov ds,ax
mov bx, offset tab
mov cx,'.'
mov [bx],cx
add bx,2
petla:
mov ah,01h
int 21h
cmp al,0Dh
jz pomiedzy
xor ah,ah
mov [bx],ax
add bx,2
inc zmienna
jmp petla

pomiedzy:
mov ah,09h
mov dx, offset ent
int 21h
mov cx,'.'
mov [bx],cx
mov bx, offset tab
cmp [bx],cx
jz bez_zmian
mov ax,zmienna
add ax,1
mov zmienna,ax

bez_zmian:
call na_koniec
call inkrementuj

jesli_jedynka_na_poczatku:
mov bx, offset tab
call spr_czy_koniec
jz odejmij
call na_koniec
call inkrementuj
jmp do_k



odejmij:
call na_koniec
mov cx,'0'
cmp [bx],cx
jz zero_na_koncu
mov cx,[bx]
sub cx,1
mov [bx],cx
jmp i
zero_na_koncu:
mov cx,'9'
mov [bx],cx
sub bx,2
mov cx,[bx]
sub cx,1
mov [bx],cx

i:
mov ax, zmienna
mov cx,2
div cx
cmp dx,0
jnz nieparz
call do_srodka_tab
mov poprzedni,bx
add bx,2
mov nastepny,bx
aha:
mov bx,poprzedni
mov cx,[bx]
mov bx,nastepny
cmp [bx],cx
jnz do_idziemy
add bx,2
mov nastepny,bx
mov cx,'.'
cmp [bx],cx
jz jednaaa
mov bx,poprzedni
sub bx,2
mov poprzedni,bx
jmp aha
jednaaa:
call czy_zw_na_1
call do_srodka_tab
call inkrementuj
jmp do_idziemy
nieparz:
call do_srodka_tab
mov poprzedni,bx
add bx,2
mov cx,'.'
cmp [bx],cx
jz jedna
add bx,2
mov nastepny,bx
call spr_czy_koniec
jz jedna
ahaa:
mov bx,poprzedni
mov cx,[bx]
mov bx,nastepny
cmp [bx],cx
jnz do_idziemy
add bx,2
call spr_czy_koniec
jz jedna
mov bx,nastepny
add bx,2
mov nastepny,bx
mov bx,poprzedni
sub bx,2
mov poprzedni,bx
mov bx,nastepny
jmp ahaa

do_idziemy:
call na_koniec
call inkrementuj
jmp idziemy

jedna:
call czy_zw_na_1
call do_srodka_tab
add bx,2
call inkrementuj




idziemy:
mov ax, zmienna
mov cx,2
div cx
cmp dx,0
jnz do_nieparzysta
call do_srodka_tab
mov poprzedni,bx
add bx,2
mov nastepny,bx
mov cx,[bx]
mov bx,poprzedni

porownuj:
cmp [bx],cx
jb druga_wieksza
mov bx,nastepny
sub bx,2
cmp bx,poprzedni
jnz nic
mov bx,nastepny
mov cx,[bx]
mov bx,poprzedni
cmp [bx],cx
jna nic
call czy_sr_na_1
nic:
mov bx,poprzedni
call przerzuc
add bx,2
call spr_czy_koniec
jz do_k
mov nastepny,bx
call nastepne
jmp porownuj

do_nieparzysta:
jmp nieparzysta

druga_wieksza:
mov dx,czy_zw
cmp dx,0
jnz przypisz
mov bx,nastepny
sub bx,2
cmp bx,poprzedni
jnz ink
call inkrementuj
mov bx,nastepny
mov ax,'0'
mov [bx],ax
call czy_zw_na_1
jmp idziemy
ink:
mov cx,czy_zw1
cmp cx,0
jnz do_przypisz
mov cx,czy_sr
cmp cx,0
jnz do_przypisz
call inkrementuj
call czy_zw1_na_1
jmp idziemy
do_przypisz:
mov bx,poprzedni

przypisz:
call przerzuc
add bx,2
mov nastepny,bx
call spr_czy_koniec
jz do_k
call nastepne
jmp porownuj

do_k:
jmp koniec

nieparzysta:
call do_srodka_tab
mov poprzedni,bx
add bx,2
mov srodkowy,bx
add bx,2
mov nastepny,bx
call spr_czy_koniec
jz do_k
mov cx,[bx]
mov bx,poprzedni

powtarzaj:
cmp [bx],cx
jb znowu_druga
mov cx,[bx]
mov bx,nastepny
mov [bx],cx
add bx,2
call spr_czy_koniec
jz do_k
mov nastepny,bx
mov cx,[bx]
mov bx,poprzedni
sub bx,2
mov poprzedni,bx
jmp powtarzaj

startowe:
mov bx,srodkowy
sub bx,2
mov poprzedni,bx
add bx,4
mov nastepny,bx
mov cx,[bx]
mov bx,poprzedni
jmp powtarzaj

znowu_druga:
mov dx,czy_zw
cmp dx,0
jnz przypiszsz
mov bx,nastepny
sub bx,2
cmp bx,srodkowy
jnz ink2
call inkrementuj
mov bx,nastepny
mov ax,'0'
mov [bx],ax
call czy_zw_na_1
jmp startowe
ink2:
mov bx,nastepny
sub bx,2
call inkrementuj
jmp startowe
przypiszsz:
call przerzuc
add bx,2
mov nastepny,bx
call spr_czy_koniec
jz koniec
call nastepne
jmp powtarzaj

koniec:
call do_wyswietlenia
mov ah,01
int 21h
mov ah,4ch
int 21h
end start