dane1    segment

zera     db       "   ###   $  #   #  $ #     # $ #     # $ #     # $  #   #  $   ###   $"
jedynki  db       " ##### $   #   $   #   $   #   $ # #   $  ##   $   #   $"
blad     db       "Wprowadzono nieprawidlowe dane!", '$'
nowa_linia    db       10, 13, '$'
buffer   db       02h, 00h
         db       1 dup(?)          ; bufor
         db       00h

dane1    ends

kod1     segment

start:
; pobranie napisu
mov      ax, seg buffer
mov      ds, ax
mov      dx, offset buffer          ; ds:dx - bufor
mov      bx, dx
mov      ah, 0ah                    ; buffered input
int      21h

; przejscie do nowej linii
mov      ax, seg nowa_linia
mov      ds, ax
mov      dx, offset nowa_linia
mov      ah, 09h
int      21h

; doklejenie $ na koniec buforu
xor      ax, ax
mov      al, [bx + 1]               ; dlugosc wpisanego tekstu do buforu
cmp      al, 0h                     ; jesli nie wprowadzono niczego to wyswietl blad
je       wyswietl_blad
mov      byte ptr [bx + 3], '$'     ; dodajemy na koniec buforu $

; przeniesienie wczytanej wartosci do al
mov      byte ptr al, ds:[bx + 2]   ; w al mamy wartosc ASCII wpisanego znaku

cmp      al, 48                     ; jesli kod ASCII < 48
jb       wyswietl_blad
cmp      al, 58                     ; jesli jest cyfra
jb       obsluz_cyfre
cmp      al, 65                     ; jesli kod ASCII jest w przedziale [58; 70]
jb       wyswietl_blad
cmp      al, 71                     ; jesli jest duza litera
jb       obsluz_duza
cmp      al, 97
jb       wyswietl_blad
cmp      al, 103                    ; jesli jest duza litera
jb       obsluz_mala
jmp      wyswietl_blad              ; w innym wypadku

obsluz_cyfre:
sub      al, 48
jmp      wyswietl_baner

obsluz_duza:
sub      al, 55
jmp      wyswietl_baner

obsluz_mala:
sub      al, 87
jmp      wyswietl_baner

wyswietl_baner:
xor      ah, ah                            ; zerujemy ah
mov      cx, 4
przesun_do_lewej:
shl      al, 1                             ; przesuwa liczbe do lewej strony
loop     przesun_do_lewej

mov      cx, 7                             ; 7 iteracji wierszy
wyswietl_wiersz:
push     ax                                ; zachowujemy wczytana liczbe
push     cx                                ; zachowujemy liczbe iteracji
mov      cx, 4                             ; iteracje petli wewnetrznej
wyswietl_cyfre:
pop      bx                                ; zeby wiedziec po skoku ktory wiersz rysowac
push     bx                                ; mamy cx dalej na stosie
push     ax                                ; zachowujemy nasza liczbe
and      al, 10000000b                     ; andujemy pierwszy bit
cmp      al, 10000000b                     ; jeden czy zero?
je       wyswietl_jeden
jmp      wyswietl_zero

wyswietl_cyfre_powrot:
pop      ax                                ; nasza liczba z powrotem
shl      al, 1                             ; przesuwamy o 1 w lewo liczbe aby moc badac kolejny bit
loop     wyswietl_cyfre                    ; kolejna cyfra do wypisania

mov      ax, seg nowa_linia                ; przechodzimy do nowego wiersza
mov      ds, ax
mov      dx, offset nowa_linia
mov      ah, 09h
int      21h

pop      cx                                ; bierzemy ilosc iteracji zewn petli do wykonania
pop      ax                                ; wczytujemy pierwotna liczbe

loop     wyswietl_wiersz                   ; i lecimy kolejny poziom
jmp      zakoncz


wyswietl_zero:
xor      ax, ax
sub      bl, 1
mov      al, bl
mov      bl, 10
mul      bl
mov      bx, ax
mov      ax, seg zera
mov      ds, ax
mov      dx, offset zera
add      dx, bx
mov      ah, 09h
int      21h
jmp      wyswietl_cyfre_powrot

wyswietl_jeden:
xor      ax, ax
sub      bl, 1
mov      al, bl
mov      bl, 8
mul      bl
mov      bx, ax
mov      ax, seg jedynki
mov      ds, ax
mov      dx, offset jedynki
add      dx, bx
mov      ah, 09h
int      21h
jmp      wyswietl_cyfre_powrot

jmp      zakoncz

wyswietl_blad:
mov      ax, seg blad
mov      ds, ax
mov      dx, offset blad
mov      ah, 09h
int      21h
jmp      zakoncz

; koniec programu
zakoncz:
mov      ah, 04ch
int      21h

kod1     ends

stos1    segment STACK
stos1    ends

end start