MPS PROEKT

; multi-segment executable file template.

data segment
    ;COBE
    brojElementiF dw 0
    brojElementiC dw 0
    mnozenje dw 10
    pomosna dw 0
    ;pom dw 0
    promenliva dw 0
    arrayA dw 64 dup(?)
    brojacC dw 8
    brzinaC dw 0
    denC dw 0
    mesecC dw 0
    godinaC dw 0
    sumaC dw 0
    greska db "GRESKA$"

    ;ALEK
    countDevideA dw 8
    digitsA dw 5 dup(?)
    onesA dw 0
    tensA dw 0
    tenA dw 10
    arrayCountA dw 0
    newArrayCountA dw 0
    maxArrayCountA dw 4
    fitElementsCountA dw 0
    newArrayA dw 32 dup (?)
    maxPriceArrayA dw 8 dup (?)
    monthA dw 0
    yearA dw 0
    dotA dw 0
    exclamationPointA dw 0
    maxDayA dw -1
    maxPriceA dw -1
    negOneA dw -1
    denStringA dw "Na den $"
    maxSumaA dw "maksimalnata suma e $"
    errorStringA dw "GRESHKA$"
    promenlivaAlek dw 0

    ;FILIP
    indexF dw 0
    startDeleteF dw 0
    localMF dw 0 ;promenliva vo koja se chuva mesecot prochitan od tastatura
    localYF dw 0 ;promenliva vo koja se chuva godinata prochitana od tastatura
    localDF dw 0 ;promenliva vo koja se chuva denot prochitan od tastatura
    localPF dw 0 ;promenliva vo koja se chuva sumata prochitana od tastatura
    desetF dw 10
    chetriF dw 4
    flagF dw 0 ;dali se brishelo neshto
    errorStringF dw "GRESHKA$"

    inputNiza db 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
    brKarakteri db 0
    indexKarakteri db 0
    addString db 'a', 'd', 'd'
    maxString db 'm', 'a', 'x'
    eraseString db 'e', 'r', 'a', 's', 'e'

    brisi db "erase$"
    dodaj db "add$"
    maksimum db "max$"
    errKarakteri db "GRESHKA$"

    flagNegative dw 0
    prvBrojFlag dw 1


    addStr dw "ADD$"
    maxStr dw "MAX$"
    eraseStr dw "ERASE$"
    tmpStr dw "$"
    fistLetter dw 0

ends

stack segment
    dw   128  dup(0)
ends

code segment
  ;;COBE

  vnesuvanjeBroeviC PROC           ; se prekinuva koga ke se vnese znakot "."
        mov ah, 1
        int 21h

        mov ah, 0
        sub al, 30h
        mul mnozenje
        mov bx, ax
        mov promenliva, bx


        loopcobe:
            mov ah, 1
            int 21h
            mov ah, 0

            cmp al, 46
            jz kraj

            sub ax, 30h
            mov cx, ax



            add bx, cx
            mov promenliva, bx
            mov ax, bx
            mul mnozenje
            mov bx, ax
            mov promenliva, bx

            jmp loopcobe

    kraj:

        mov ax, bx

        div mnozenje
        mov promenliva, ax

   RET
   vnesuvanjeBroeviC ENDP


   vnesuvanjeSumaC PROC            ; se prekinuva koga ke se vnese znakot ">"
        mov ah, 1
        int 21h

        mov ah, 0

        cmp ax, '-'
        jne dontChangeFlag
        mov flagNegative, 1
        dontChangeFlag:

        sub al, 30h
        mul mnozenje
        mov bx, ax
        mov promenliva, bx

        loopexample:
            mov ah, 1
            int 21h
            mov ah, 0

            cmp al, 62
            jz krajC

            sub ax, 30h
            mov cx, ax



            add bx, cx
            mov promenliva, bx
            mov ax, bx
            mul mnozenje
            mov bx, ax
            mov promenliva, bx

            jmp loopexample

    krajC:

        mov ax, bx

        div mnozenje
        mov promenliva, ax

   RET
   vnesuvanjeSumaC ENDP

   ;;;;;;;;;;;;;;
   ;;;;;ADD;;;;;;
   ;;;;;;;;;;;;;;


   addC PROC
   mov flagNegative, 0

   call vnesuvanjeSumaC               ; se vnesuva sumata i se stava vo stek
   mov cx, promenliva
   mov sumaC, cx

   call vnesuvanjeBroeviC             ; se vnesuva denot i se stava vo stek
   mov cx, promenliva
   mov denC, cx

                                        ; se vnesuvaat mesecot i godinata i se stavaat na
                                       ; pocetok na nizata
    call vnesuvanjeBroeviC
    mov cx, promenliva
    mov mesecC, cx



    call vnesuvanjeBroeviC
    mov cx, promenliva
    mov godinaC, cx



    cmp flagNegative, 1
    je izlez


    cmp mesecC, 12d              ; sporedba
        jg izlez
    cmp mesecC, 1d              ; sporedba
        jl izlez




    cmp godinaC, 99d             ;sporedba za izlez
        jg izlez
    cmp godinaC, 1d
        jl izlez



    cmp denC, 31d       ; proverka
        jg izlez
    cmp denC, 1d
        jl izlez





    mov bx, 0

    mov bx, brzinaC                    ; se stava mesec
    mov cx, mesecC
    mov arrayA[bx], cx
    mov dl, 2
    add brzinaC, 2

    mov bx, brzinaC                    ; se stava godina
    mov cx, godinaC
    mov arrayA[bx], cx
    mov dl, 2
    add brzinaC, 2


    mov bx, brzinaC                    ; se stava den
    mov cx, denC
    mov arrayA[bx], cx
    mov dl, 2
    add brzinaC, 2

    mov bx, brzinaC                    ; se stava suma
    mov cx, sumaC
    mov arrayA[bx], cx
    mov dl, 2
    add brzinaC, 2

    add brojElementiF, 4
    add brojElementiC, 8
    call newLine


    jmp tabla

    izlez:
        call newLine
        lea dx, greska
        mov ah, 9
        int 21h
        call newLine

     tabla:

   RET
   addC ENDP

   newLine PROC                          ; nova linija

        mov dl, 10
        mov ah, 2h
        int 21h
        mov dl, 13
        mov ah, 2h
        int 21h

        RET
    newLine ENDP

  ;;END COBE

  ;;ALEK

  ;;;;;;;;;;;;;;;;;;;
    ;;;;;printDateA;;;;
    ;;;;;;;;;;;;;;;;;;;

    printDate PROC

        div tenA
        mov onesA, dx
        cmp ax, 0
        jz addZeroA
        mov tensA, ax

        jmp echoDateA

        addZeroA:

            mov tensA, 0

        echoDateA:

            mov ah, 2
            mov dx, tensA
            add dx, 30h
            int 21h

            mov dx, onesA
            add dx, 30h
            int 21h

        RET
    printDate ENDP

    ;;;;;;;;;;;;;;;;;;;
    ;;;;;AnewLineA;;;;;;
    ;;;;;;;;;;;;;;;;;;;

    ;newLine PROC

        ;mov dl, 10
        ;mov ah, 2h
        ;int 21h
        ;mov dl, 13
        ;mov ah, 2h
        ;int 21h

        ;RET
    ;newLine ENDP

    ;;;;;;;;;;;;;;;;;;;;
    ;;;;devideDigitsA;;;
    ;;;;;;;;;;;;;;;;;;;;

    devideDigitsA PROC

        mov ax, maxPriceA

        devideA:

            div tenA

            mov bx, countDevideA
            mov digitsA[bx], dx

            mov dx, 0

            sub countDevideA, 2

            cmp countDevideA, -2
            jz endDevideA

            jmp devideA

    RET
    devideDigitsA ENDP

    printNumberA PROC

        mov ax, maxPriceA

        mov countDevideA, 0

        cmp maxPriceA, 0
        jz printZeroA

        printDigitsA:

            cmp countDevideA, 10
            jz exitPrintNumberA

            mov bx, countDevideA
            mov dx, digitsA[bx]
            add dx, 30h

            cmp dx, 48
            jz removeLeadingZeroA

            ;add countDevideA, 2

            jmp printDigitsNonZeroA

            mov ah, 2
            int 21h
            mov dx, 0

            add countDevideA, 2
            jmp printDigitsA

        removeLeadingZeroA:

           add countDevideA, 2
           jmp printDigitsA

        printZeroA:

           mov dx, 30h
           mov ah, 2
           int 21h

        printDigitsNonZeroA:

            cmp countDevideA, 10
            jz exitPrintNumberA

            mov bx, countDevideA
            mov dx, digitsA[bx]
            add dx, 30h

            mov ah, 2
            int 21h
            mov dx, 0

            add countDevideA, 2
            jmp printDigitsNonZeroA



        RET
    printNumberA ENDP

    formatedPrint PROC

        lea dx, denStringA
        mov ah, 9
        int 21h
        mov dx, 0

        mov ax, maxDayA

        call printDate

        mov ah, 2
        mov dx, '.'
        int 21h
        mov dx, 0

        mov ax, monthA

        call printDate

        mov ah, 2
        mov dx, '.'
        int 21h
        mov dx, 0

        mov ax, yearA

        call printDate

        mov ah, 2
        mov dx, ' '
        int 21h
        mov dx, 0

        lea dx, maxSumaA
        mov ah, 9
        int 21h
        mov dx, 0

        call devideDigitsA
        endDevideA:

        call printNumberA
        exitPrintNumberA:

        jmp exitFormatedPrint

        RET
    formatedPrint ENDP

    ;;;;;;;;;;;;;;;;;;;
    ;;;;;filterDate;;;;
    ;;;;;;;;;;;;;;;;;;;

    filterDate PROC

        ;reset newArrayA
        mov cx, 32
        mov bx, 0
        resetLoop:
            mov newArrayA[bx], -1
            add bx, 2
        loop resetLoop

        mov arrayCountA, 0

        mvAllValid:
        mov bx, brojElementiC
        cmp arrayCountA, bx
        jg exitFilterDate

        mov bx, arrayCountA

        mov dx, arrayA[bx]

        cmp dx, monthA
        jnz incrementArrayCountA

        add bx, 2
        mov dx, arrayA[bx]

        cmp dx, yearA
        jz addToArray


        add arrayCountA, 8

        jmp mvAllValid


    addToArray:

        mov cx, 2

        mvElements:

            mov bx, arrayCountA
            add bx, 4
            mov dx, arrayA[bx]
            add arrayCountA, 2

            mov bx, newArrayCountA
            mov newArrayA[bx], dx
            add newArrayCountA, 2

            add fitElementsCountA, 2

        loop mvElements

        mov dx, arrayCountA
        add dx, 4
        mov arrayCountA, dx

        mov bx, brojElementiC
        cmp arrayCountA, bx
        jz exitFilterDate
        jmp mvAllValid

    incrementArrayCountA:

        add arrayCountA, 8
        jmp mvAllValid

        RET
    filterDate ENDP

    ;;;;;;;;;;;;;;;;;;;;
    ;;createArrayDateA;;
    ;;;;;;;;;;;;;;;;;;;;

    createArrayDateA PROC

        setNegativeOneA:

        mov dx, brojElementiC
        cmp dx, 0
        jz end

        mov dx, newArrayCountA
        cmp dx, fitElementsCountA
        jz end

        mov maxArrayCountA, 4
        mov bx, newArrayCountA
        mov dx, newArrayA[bx]


        cmp dx, -1
        jz incBy2

        mov maxDayA, dx
        mov dx, negOneA
        mov newArrayA[bx], dx

        add bx, 2
        mov dx, newArrayA[bx]
        mov maxPriceA, dx
        mov dx, negOneA
        mov newArrayA[bx], dx

        loopArrayA:

            mov dx, maxArrayCountA
            cmp dx, fitElementsCountA
            jz printMessageA

            mov bx, maxArrayCountA
            mov dx, newArrayA[bx]

            cmp dx, maxDayA
            jnz incBy4
            mov newArrayA[bx], -1

            add bx, 2
            mov dx, newArrayA[bx]
            mov newArrayA[bx], -1

            cmp dx, maxPriceA
            jl incBy4

            add maxArrayCountA, 4

            mov maxPriceA, dx

            jmp loopArrayA

        incBy4:

            add maxArrayCountA, 4
            jmp loopArrayA

        incBy2:

            add newArrayCountA, 2
            mov maxPriceA, 0
            jmp setNegativeOneA

        printMessageA:

            mov countDevideA, 8
            call formatedPrint
            exitFormatedPrint:
            call newLine

            add newArrayCountA, 2
            mov maxPriceA, 0
            jmp setNegativeOneA

        RET
    createArrayDateA ENDP

    maxAlek PROC

        mov monthA, 0
        mov yearA, 0

        mov ah, 1
        int 21h
        mov ah, 0
        sub al, 30h
        mul tenA
        mov bx, ax
        mov monthA, bx



        loopMonthA:                       ; vnes na mesec alek

            mov ah, 1
            int 21h
            mov ah, 0

            cmp al, '.'
            jz endLoopMonthA

            sub ax, 30h
            mov cx, ax



            add bx, cx
            mov monthA, bx
            mov ax, bx
            mul tenA
            mov bx, ax
            mov monthA, bx

            jmp loopMonthA


        endLoopMonthA:

            mov ax, bx
            div tenA
            mov monthA, ax


        mov ah, 1
        int 21h
        mov ah, 0
        sub al, 30h
        mul tenA
        mov bx, ax
        mov yearA, bx



        loopYearA:                       ; vnes na mesec alek

            mov ah, 1
            int 21h
            mov ah, 0

            cmp al, '!'
            jz endLoopYearA

            sub ax, 30h
            mov cx, ax



            add bx, cx
            mov yearA, bx
            mov ax, bx
            mul tenA
            mov bx, ax
            mov YearA, bx

            jmp loopYearA


        endLoopYearA:

            mov ax, bx
            div tenA
            mov yearA, ax



        cmp monthA, 12
        jg errorA

        cmp monthA, 1
        jl errorA

        cmp yearA, 99
        jg errorA

        cmp yearA, 1
        jl errorA



    call newLine

    call filterDate
    exitFilterDate:

    mov newArrayCountA, 0

    call createArrayDateA

    errorA:

        call newLine

        lea dx, errorStringA
        mov ah, 9
        int 21h
        mov dx, 0

        call newLine


        RET
    maxAlek ENDP

  ;;END ALEK


  ;;FILIP

  eraseF PROC

        ;sekogash koga kje se povika ovaa procedura treba da se resetiraat promenlivite na 0
        mov localPF, 0
        mov localDF, 0
        mov localMF, 0
        mov localYF, 0
        mov indexF, 0
        mov startDeleteF, 0
        mov flagF, 0
        mov prvBrojFlag, 1
        mov flagNegative, 1

        ;chitanje na vrednosti od tastatura

        dodadiLocalVrednostP:
        mov ah,1
        int 21h ;chitanje na vrednost i chuvanje vo AL
        cmp prvBrojFlag, 1
        jne notANegative

            cmp ax, '-'
            jne notANegative
            mov flagNegative, 1

        notANegative:
        cmp al, '>'
        je krajVrednostP
        mov ah, 0
        sub al, 30h ;odzemame 30h za da ja dobieme cifrata dekadno
        mov bx, ax ;ja chuvam vo "temp", bx
        mov ax, localPF
        mul desetF
        add ax, bx
        mov localPF, ax
        jmp dodadiLocalVrednostP

        krajVrednostP: ;prochitana cena, chitaj den

        dodadiLocalVrednostD:
        mov ah,1
        int 21h ;chitanje na vrednost i chuvanje vo AL
        cmp al, '.'
        je krajVrednostD
        mov ah, 0
        sub al, 30h ;odzemame 30h za da ja dobieme cifrata dekadno
        mov bx, ax ;ja chuvam vo "temp", bx
        mov ax, localDF
        mul desetF
        add ax, bx
        mov localDF, ax
        jmp dodadiLocalVrednostD

        krajVrednostD: ;prochitan den, chitaj mesec

        dodadiLocalVrednostM:
        mov ah,1
        int 21h ;chitanje na vrednost i chuvanje vo AL
        cmp al, '.'
        je krajVrednostM
        mov ah, 0
        sub al, 30h ;odzemame 30h za da ja dobieme cifrata dekadno
        mov bx, ax ;ja chuvam vo "temp", bx
        mov ax, localMF
        mul desetF
        add ax, bx
        mov localMF, ax
        jmp dodadiLocalVrednostM

        krajVrednostM: ;prochitan mesec, chitaj godina

        dodadiLocalVrednostY:
        mov ah,1
        int 21h ;chitanje na vrednost i chuvanje vo AL
        cmp al, '.'
        je krajVrednostY
        mov ah, 0
        sub al, 30h ;odzemame 30h za da ja dobieme cifrata dekadno
        mov bx, ax ;ja chuvam vo "temp", bx
        mov ax, localYF
        mul desetF
        add ax, bx
        mov localYF, ax
        jmp dodadiLocalVrednostY

        krajVrednostY: ;prochitana godina

        ;zavrsheno chitanje od tastura, gi imam vrednostite po koi treba da ja prebaruvam nizata

        ;prvo da proveram za greshka vo vrednostite
        cmp flagNegative, 1
        je errorF

        cmp localPF, 1
        jl errorF

        cmp localDF, 1
        jl errorF

        cmp localDF, 31
        jg errorF

        cmp localMF, 1
        jl errorF

        cmp localMF, 12
        jg errorF

        cmp localYF, 1
        jl errorF

        cmp localYF, 99
        jg errorF

        ;dokolku gi projde site, treba da se izmine nizata

        izminiF:
        mov indexF, 0

        startloopF:
        mov bx, indexF ;index od memorija vo registar
        cmp bx, brojElementiF
        jg krajF ;dokolku indeksot e pogolem od vkupniot broj na elementi, tolku (nema shto da se brishe)

        add bx, bx ;dupliranje na registarot (*2) zoshto rabotam so dw
        mov ax, arrayA[bx] ;zoshto imeto na promenlivata e adresata na promenlivata, mozham vaka da go dobijam elementot

        ;go imam mesecot vo AX
        ;go sporeduvam so localMF
        cmp ax, localMF
        jne nextSetCetF

        ;mesecot e tamanka
        ;chuvaj go indexov vo startDeleteF
        mov bx, indexF
        mov startDeleteF, bx

        ;proveri godina
        add indexF, 1
        mov bx, indexF
        add bx, bx ;dupliram radi DW
        mov ax, arrayA[bx] ;godina e vo ax
        cmp ax, localYF
        jne nextSetTriF
        ;godina e tamanka

        ;proveri den
        add indexF, 1
        mov bx, indexF
        add bx, bx ;dupliram radi DW
        mov ax, arrayA[bx] ;godina e vo ax
        cmp ax, localDF
        jne nextSetDvaF
        ;den e tamanka

        ;proveri suma
        add indexF, 1
        mov bx, indexF
        add bx, bx ;dupliram radi DW
        mov ax, arrayA[bx] ;godina e vo ax
        cmp ax, localPF
        jne nextSetEdenF
        ;cena e tamanka

        add indexF, 1
        ;go zgolemiv index-ot za 1 za da stignam do prviot element shto ne treba da se brishe
        jmp brishiF

        nextSetCetF:
        mov bx, indexF
        add bx, 4
        mov indexF, bx ;go zgolemiv index-ot za 4 (odam na sledniot set)
        jmp startloopF

        nextSetTriF:
        mov bx, indexF
        add bx, 3
        mov indexF, bx ;go zgolemiv index-ot za 3 (odam na sledniot set)
        jmp startloopF

        nextSetDvaF:
        mov bx, indexF
        add bx, 2
        mov indexF, bx ;go zgolemiv index-ot za 2 (odam na sledniot set)
        jmp startloopF

        nextSetEdenF:
        mov bx, indexF
        add bx, 1
        mov indexF, bx ;go zgolemiv index-ot za 1 (odam na sledniot set)
        jmp startloopF

        brishiF:
        ;elementot shto treba da se brishe e na pozicija startDeleteF
        ;elementot shto treba da go zameni e na indexF
        ;toa treba da se napravi 4pati za sekoj element
        cmp brojElementiF, 4
        je samoNamaliF

        mov bx, brojElementiF
        sub bx, indexF ;ushte kolku elementi ostanuvaat (broj elementi e od 1 pa nagore,
        mov ax, bx     ;a index e od 0 pa nagore, taka da mi odgovara  posledniot inkrement)
        div chetriF ;posle delenje so 4, dobivam broj na setovi

        mov cx, ax ;broj na setovi koi treba da se pomestat

        mov flagF, 1 ;brishevme neshto

        startloop2F:
        mov bx, indexF
        add bx, bx
        mov ax, arrayA[bx]
        mov bx, startDeleteF
        add bx, bx
        mov arrayA[bx], ax ;(prvo shiftanje)
        mov bx, indexF
        add bx, 1
        mov indexF, bx
        mov bx, startDeleteF
        add bx, 1
        mov startDeleteF, bx

        mov bx, indexF
        add bx, bx
        mov ax, arrayA[bx]
        mov bx, startDeleteF
        add bx, bx
        mov arrayA[bx], ax ;(vtoro shiftanje)
        mov bx, indexF
        add bx, 1
        mov indexF, bx
        mov bx, startDeleteF
        add bx, 1
        mov startDeleteF, bx

        mov bx, indexF
        add bx, bx
        mov ax, arrayA[bx]
        mov bx, startDeleteF
        add bx, bx
        mov arrayA[bx], ax ;(treto shiftanje)
        mov bx, indexF
        add bx, 1
        mov indexF, bx
        mov bx, startDeleteF
        add bx, 1
        mov startDeleteF, bx

        mov bx, indexF
        add bx, bx
        mov ax, arrayA[bx]
        mov bx, startDeleteF
        add bx, bx
        mov arrayA[bx], ax ;(chetvrto shiftanje)
        mov bx, indexF
        add bx, 1
        mov indexF, bx
        mov bx, startDeleteF
        add bx, 1
        mov startDeleteF, bx
        loop startloop2F

        samoNamaliF:
        sub brojElementiF, 4
        sub brojElementiC, 8
        sub brzinaC, 8

        cmp flagF, 1
        je izminiF

        jmp greshka

        errorF:
        call newLine

        lea dx, errorStringF
        mov ah, 9
        int 21h
        mov dx, 0

        greshka:

        krajF:

		mov dl, 10
        mov ah, 2h
        int 21h
        mov dl, 13
        mov ah, 2h
        int 21h

        RET
    eraseF ENDP

  ;;END FILIP

  resetirajNiza PROC
        resetiraj:
        mov bl, indexKarakteri
        mov bh, 0
        mov inputNiza[bx], 0
        loop resetiraj
    RET
    resetirajNiza ENDP

    pecatiNovRed PROC
        mov dl, 10
        mov ah, 2
        int 21h
        mov dl, 13
        mov ah, 2
        int 21h
    RET
    pecatiNovRed ENDP

start:
; set segment registers:
    mov ax, data
    mov ds, ax
    mov es, ax

    ; add your code here

    jamka:

    mov ah, 1
    int 21h

    cmp al, ' ' ;prazno mesto
    je sporediKarakteri

    mov bl, indexKarakteri
    mov bh, 0
    mov inputNiza[bx], al
    add indexKarakteri, 1

    jmp jamka


    sporediKarakteri:
    cmp indexKarakteri, 5 ;ako ima 5, neka proveri dali e erase
    je daliErase

    ;neka vidi dali e add
    mov cx, 3
    mov indexKarakteri, 0

    daliAddLoop:
        mov bl, indexKarakteri
        mov bh, 0
        mov dl, addString[bx]
        cmp inputNiza[bx], dl
        jne neEAdd
    loop daliAddLoop
    ;ako izleze od loop add e
    call addC

    ;reset inputNiza
    ;reset indexKarakteri
    mov cx, 10 ;tolku ima nizata
    call resetirajNiza
    mov indexKarakteri, 0
    call pecatiNovRed
    jmp jamka ;pak od pochetok se ova

    neEAdd: ;ako ne e add, vidi dali e max

    mov cx, 3
    mov indexKarakteri, 0

    daliMaxLoop:
        mov bl, indexKarakteri
        mov bh, 0
        mov dl, maxString[bx]
        cmp inputNiza[bx], dl
        jne printGreshka
    loop daliMaxLoop
    ;ako izleze od loop add e
    call maxAlek
    end:

    ;reset inputNiza
    ;reset indexKarakteri
    mov cx, 10 ;tolku ima nizata
    call resetirajNiza
    mov indexKarakteri, 0
    call pecatiNovRed
    jmp jamka ;pak od pochetok se ova

    ;;;;;;;;;;;;;;;;;;

    daliErase:
    mov cx, 5
    mov indexKarakteri, 0

    daliEraseLoop:
        mov bl, indexKarakteri
        mov bh, 0
        mov dl, eraseString[bx]
        cmp inputNiza[bx], dl
        jne printGreshka
    loop daliEraseLoop

    ;ako izleze od loop erase e
    call eraseF

    ;reset inputNiza
    ;reset indexKarakteri
    mov cx, 10 ;tolku ima nizata
    call resetirajNiza
    mov indexKarakteri, 0
    call pecatiNovRed
    jmp jamka ;pak od pochetok se ova

    ;;;;;;;;;;;;;;;;

    printGreshka:
        mov dl, 10
        mov ah, 2
        int 21h
        mov dl, 13
        mov ah, 2
        int 21h
        lea dx, errKarakteri
        mov ah, 9
        int 21h
        call pecatiNovRed

    ;pak mora reset
    ;reset inputNiza
    ;reset indexKarakteri
    mov cx, 10 ;tolku ima nizata
    call resetirajNiza
    mov indexKarakteri, 0
    call pecatiNovRed
    jmp jamka ;pak od pochetok se ova

    mov ax, 4c00h ; exit to operating system.
    int 21h
ends

end start ; set entry point and stop the assembler.