data segment
    input db 'input.txt',0      ;входной файл
    output db 'output.txt',0        ;выходной файл
    o_err db 'Ошибка открытия файла$'
    r_err db 'Ошибка чтения файла$'
    w_err db 'Ошибка записи в файл$'
    str1 db 'Строка '
    str2 db ' не согласующиеся скобки '
    str3 db ' не хватает '
    str4 db ' лишняя(ие) '
    str5 db ' ")" '
    ent db 0dh,0ah
    buf db 128 dup(0)   ;буфер для чтения из файла
    buf2 db 50 dup(0)   ;буфер для перевода из строки в число     ; 50 - OCHEN много. 6 должно хватить ('65535$')
    buf3 db 128 dup(0)  ;буфер для вывода строки в файл
    l_count db 0    ;счетчик левых скобок
    r_count db 0    ;счетчик правых скобок
    st_count db 0   ;счетчик строк
    n_count db 0    ; счетчик для выявления несогласующихся скобок
    sim_count dw 0
    fl db 0         ;флаг поледней считаной из файла части
    fl_sc db 0      ;флаг открытой ковычки
    fl_n db 0       ;флаг несогласующихся скобок
    fl_n_v db 0     ;флаг вероятности несогласовных скобок
    ihandle dw ?    ;описатель файла input
    ohandle dw ?    ;описатель файла output
data ends

stackseg segment stack
    db 128 dup(?)
stackseg ends

body segment
assume cs:body, ds:data, ss:stackseg

printdec proc

    push cx ;сохраняем регистры
    push dx
    push bx
    mov bx,10   ;основание системы
    XOR CX,CX   ;в сх будет количество цифр в десятичном числе
@@m1:   XOR dx,dx       ;обнудяем dx
    DIV bx      ;делим число на степени 10
    PUSH DX     ;и сохраняем остаток от деления(коэффициенты при степенях) в стек
    INC CX      ;увеличиваем количество символов в числе
    TEST AX,AX  ;преобразовали все число?
    JNZ @@m1    ;если нет, то продолжить
@@m2:   POP AX      ;восстанавливаем остаток от деления
    ADD AL,'0'  ;преобразовываем число в ASCII символ
    STOSb       ;сохраняем в буфер
    LOOP @@m2       ;все цифры
    ;mov al, '$'    ; Ну вот нахуй же так делать? В файл же пишем.
    ;stosb
    pop bx      ;восстанавливаем регистры
    POP dx
    POP cx
    RET
printdec endp

write_str proc
    push ax
    push bx
    push cx
    push dx
    push si

    ;--отчистка буферов
    cld                 ;не нужно. Достаточно написать cld в начале проги, если не устанавливаешь DF где-нибудь.

    mov al,0
    lea di,buf2
    mov cx, 50   ; => 6
    rep stosb

    mov al,0
    lea di,buf3
    mov cx, 128
    rep stosb


    mov sim_count,7
    lea di,buf3
    lea si, str1
    mov cx, sim_count
    rep movsb

    xor ax,ax
    mov al, st_count
    lea di, buf2
    call printdec
    xor bx,bx
    lea si, buf2
    coun:
        lodsb
        cmp al,0
        je done
        inc bx
        jmp coun
    done:
    ;dec bx

    xor dx,dx
    lea di,[buf3]
    add di,sim_count
    lea si, buf2
    mov cx, bx
    rep movsb
    add sim_count,bx

    ;--Есть ли несогл скобки в строке
    cmp fl_n, 1
    jne work
    lea di,[buf3]
    add di,sim_count
    lea si, str2
    mov cx, 25
    rep movsb
    add sim_count,25
    jmp work2

    work:
        mov bh,r_count
        cmp l_count,bh
        jl lish
        xor dx,dx
        mov dh, l_count
        sub dh,r_count

        lea di,[buf3]
        add di,sim_count
        lea si, str3
        mov cx, 12
        rep movsb
        add sim_count,12

        xor ax,ax
        mov al, dh
        lea di, buf2
        call printdec
        xor bx,bx
        lea si, buf2
        coun1:
            lodsb
            cmp al,0
            je done1
            inc bx
            jmp coun1
        done1:
        dec bx

        lea di,[buf3]
        add di,sim_count
        lea si, buf2
        mov cx, bx
        rep movsb
        add sim_count,bx

        lea di,[buf3]
        add di,sim_count
        lea si, str5
        mov cx, 5
        rep movsb
        add sim_count,5
        jmp work2

        lish:
            xor dx,dx
            mov dh, r_count
            sub dh,l_count

            lea di,[buf3]
            add di,sim_count
            lea si, str4
            mov cx, 12
            rep movsb
            add sim_count,12

            xor ax,ax
            mov al, dh
            lea di, buf2
            call printdec
            xor bx,bx
            lea si, buf2
            coun2:
                lodsb
                cmp al,0
                je done2
                inc bx
                jmp coun2
            done2:
            dec bx

            lea di,[buf3]
            add di,sim_count
            lea si, buf2
            mov cx, bx
            rep movsb
            add sim_count,bx

            lea di,[buf3]
            add di,sim_count
            lea si, str5
            mov cx, 5
            rep movsb
            add sim_count,5

        work2:
            lea di,[buf3]
            add di,sim_count
            lea si, ent
            mov cx, 2
            rep movsb
            add sim_count,2

    ;--запись в файл
    xor ax,ax
    mov ah, 40h
    mov cx,sim_count
    mov bx, ohandle
    lea dx, buf3
    int 21h

    cmp ax,cx
    je succ
    jmp write_err
    succ:

    pop si
    pop dx
    pop cx
    pop bx
    pop ax
    ret
write_str endp

begin:
    mov ax,data
    mov ds,ax
    mov es, ax
    cld
;--Открываем файл
    mov ax,3d00h
    lea dx,input
    int 21h
    jnc norm
    jmp open_err        ;Проверка на ошибку
    norm:
        mov ihandle,ax

;--создание файла вывода
    mov ax, 3c00h
    lea dx, output
    mov cx,20h
    int 21h
    jnc norm1
    jmp open_err
    norm1:
        mov ohandle, ax

;--Чтение из файла
    mov st_count,1
    read:
        mov ah, 3fh
        mov bx, ihandle
        mov dx, offset buf
        mov cx,128
        int 21h
        jnc norm2
        jmp read_err
        norm2:
        mov si, offset Buf
        cmp ax,cx
        mov cx,ax
        je cont

        ;--Закрытие файла
        mov ah,3eh
        mov bx, ihandle
        int 21h
        mov fl,1    ;Ставим флаг (будет означать, что это последний проход)

        cont:
            lodsb   ;Загрузаем один байт из si в al, inc si                     ;(если DF == 0)
            cmp al,0dh      ;считаем строки
            jne next0
            ;--если конец строки
            xor bx,bx
            mov bh,r_count
            cmp l_count,bh      ;сравниваем ко-во левых и правых скобок
            jne next7
            cmp fl_n_v,1        ;если возможны несогласующиеся скобки
            jne next5
            mov fl_n,1      ;ставим флаг несогласующихся скобок
            next7:
                call write_str
            next5:
                inc st_count
                mov fl_n,0      ;обнуляем флаги
                mov fl_n_v,0
                mov l_count,0
                mov r_count,0
                mov n_count,0
            next0:
                cmp al, "'" ;если кавычка
                jne next
                cmp fl_sc,0 ;меняем флаг, чтобы не учитывать символы внутри
                je true
                mov fl_sc,0
                jmp next
            true:
                mov fl_sc,1
            next:
                cmp fl_sc, 1
                je next2
                cmp al, ')'
                jne next1
                inc r_count
                dec n_count     ;учитываем несоглас. скобки
            next1:
                cmp al, '('
                jne next2
                inc l_count
                inc n_count
            next2:
                cmp n_count, 0
                jl next3    ;Если счетчик хоть раз был отрицательным, значит был не верный порядок скобок
                jmp next4
            next3:
                mov fl_n_v,1
            next4:
                cmp fl,1     ;последний ли проход
                jne next6
                cmp cx,1        ;последний ли символ в последнем проходе
                jne next6
                xor bx,bx
                mov bh,r_count
                cmp l_count,bh      ;сравниваем ко-во левых и правых скобок
                jne next8
                cmp fl_n_v,1        ;если возможны несогласующиеся скобки
                jne next6
                mov fl_n,1      ;ставим флаг несогласующихся скобок
                next8:
                    call write_str
            next6:
        ;loop cont
        dec cx
        cmp cx,0
        je loop_exit
        jmp cont
        loop_exit:

        cmp fl,1
        je read1
        jmp read
        read1:

        ;--Закрытие фала записи
        mov ah, 3eh
        mov bx, ohandle
        int 21h



        jmp exit


;--Обработка ошибки открытия
    open_err:
        mov ah,09h
        mov dx, offset o_err
        int 21h

        mov ah,01h
        int 21h

        jmp exit

;--Обработка ошибки чтения
    read_err:
        mov ah,09h
        mov dx, offset r_err
        int 21h

        mov ah,01h
        int 21h

        jmp exit

    write_err:
        mov ah,09h
        mov dx, offset r_err
        int 21h

        mov ah,01h
        int 21h

        jmp exit

    exit:
        mov ax,4c00h
        int 21h



body ends
end begin