_TEXT   segment word public 'CODE'
        org     100h
        assume  cs:_TEXT,ds:_TEXT,es:_TEXT,ss:_TEXT

bog     proc    near

        jmp     ok

state   db      0

numb    db      0

old     dd      0

dir     db      0B1h,0ACh,0A1h,0A9h,0C8h,0ADh,0A1h
        db      0

passw   db      0ADh,0BCh,0AFh,0A0h,0ACh,0ABh,0BCh,0BCh,0A7h,0ABh,0BDh,0BDh
        db      0

name1   db      1 dup (0)

name2   db      1 dup (0)

name3   db      1 dup (0)

ok:
        xor     ax, ax
        mov     es, ax
        mov     bx, 4*0E6h
        cmp     word ptr es:[bx], 0F5F5h
        je      qu
        mov     word ptr es:[bx], 0F5F5h
        mov     ax, cs
        mov     es, ax
        mov     bx, 002Ch
cle:    mov     word ptr es:[bx], 0
        add     bx, 2
        cmp     bx, 0FDh
        jb      cle
        ;
        push    ds
        mov     ax, offset dir
        push    ax
        call    unscr
        push    ds
        mov     ax, offset passw
        push    ax
        call    unscr
        ;
        cli
        mov     ax, 0
        mov     es, ax
        mov     bx, 21h*4
        mov     cx, es:[bx]
        mov     dx, es:[bx+2]
        push    bx
        mov     bx, 0E5h*4
        mov     es:[bx], cx
        mov     es:[bx+2], dx
        pop     bx
        mov     word ptr old, cx
        mov     word ptr old+2, dx
        mov     dx, ds
        mov     cx, offset new
        mov     es:[bx], cx
        mov     es:[bx+2], dx
        sti
        mov     ax, 3100h
        mov	dx, 50
        int     0E5h

qu:     mov     ax, 4C00h
        int     21h

bog     endp

new     proc    far

        cmp     ah, 3Bh
        jne     next1
        jmp     start
next1:  cmp     ah, 3Dh
        jne     next2
        jmp     start
next2:  cmp     ah, 6Ch
        jne     next3
        jmp     start
next3:  cmp     ah, 41h
        jne     next4
        jmp     start
next4:  cmp     ah, 56h
        jne     next5
        jmp     start
next5:  cmp     ah, 17h
        je      next6
        jmp     exec
next6:  jmp     plock
start:
        push    bx
        push    cx
        push    si
        push    di
        push    bp
        push    es
        push    ax
        push    ds
        push    dx
        mov     ax, cs
        mov     ds, ax
        mov     bp, sp
        ;
        xor     ax, ax
        mov     es, ax
        mov     bx, 0E5h*4
        mov     cx, word ptr old
        mov     dx, word ptr old+2
        cli
        mov     word ptr es:[bx], cx
        mov     word ptr es:[bx+2], dx
        sti
        ;
        call    upcase
        cmp     byte ptr [bp+5], 3Bh
        jne     notpas
        push    ds
        mov     ax, offset passw
        push    ax
        call    compare
        jc      notpas
        not     state
        mov     ax, 0B800h
        mov     es, ax
        mov     bx, 0
        mov     ah, 8Fh
        mov     al, 'L'
        mov     es:[bx], ax
        mov     cx, 2000
fill:   mov     word ptr es:[bx], 0720h
        inc     bx
        inc     bx
        loop    fill
        ;
notpas: push    ds
        mov     ax, offset dir
        push    ax
        call    compare
        jnc     check
        cmp     numb, 1
        jnae    nstop
        push    ds
        mov     ax, offset name1
        push    ax
        call    compare
        jnc     check
        cmp     numb, 2
        jnae    nstop
        push    ds
        mov     ax, offset name2
        push    ax
        call    compare
        jnc     check
        cmp     numb, 3
        jnae    nstop
        push    ds
        mov     ax, offset name3
        push    ax
        call    compare
        jc      nstop
check:  cmp     state, 0FFh
        je      nstop
        mov     ax, 0F5F5h
        mov     word ptr ss:[bp+4], ax
nstop:  pop     dx
        pop     ds
        pop     ax
        pop     es
        pop     bp
        pop     di
        pop     si
        pop     cx
        pop     bx
        cmp     ax, 0F5F5h
        jne     exec
plock:  push    bp
        mov     bp, sp
        or      word ptr ss:[bp+6], 0001h
        mov     ax, 0002h
        pop     bp
        jmp     short quit
exec:   int     0E5h
        jnc     cclear
        push    bp
        mov     bp, sp
        or      word ptr ss:[bp+6], 0001h
        pop     bp
        jmp     short quit
cclear: push    bp
        mov     bp, sp
        and     word ptr ss:[bp+6], 0FFFEh
        pop     bp
quit:   iret

new     endp

compare proc    near

        push    bp
        mov     bp,sp
	PUSH	DS
	CLD
	XOR	AL,AL
	LES	DI,dword ptr ss:[bp+4]
	MOV	CX,0FFFFH
	REPNE	SCASB
	NOT	CX
	DEC	CX
	JE	b
	MOV	DX,CX
	MOV	BX,ES
	MOV	DS,BX
	LES	DI,dword ptr ss:[bp+8]
	MOV	BX,DI
	MOV	CX,0FFFFH
	REPNE	SCASB
	NOT	CX
	SUB	CX,DX
	JBE	b
	MOV	DI,BX
a:	MOV	SI,word ptr ss:[bp+4]
	LODSB
	REPNE	SCASB
	JNE	b
	MOV	AX,CX
	MOV	BX,DI
	MOV	CX,DX
	DEC	CX
	REPE	CMPSB
	MOV	CX,AX
	MOV	DI,BX
	JNE	a
        clc
	JMP	c
b:      stc
c:	POP	DS
        pop     bp
        ret     4

compare endp

upcase  proc    near

        mov     bx, sp
        les     di, dword ptr ss:[bx+2]
        mov     dx, 7A61h
        mov     bx, 0
        mov     cx, 100
next:   mov     al, byte ptr es:[bx+di]
        cmp     al, 0
        je      done
        cmp     al, dl
        jb      notup
        cmp     al, dh
        ja      notup
        sub     al, 32
        mov     byte ptr es:[bx+di], al
notup:  inc     bx
        loop    next
done:   ret

upcase  endp

unscr   proc    near

        mov     bx, sp
        les     di, dword ptr ss:[bx+2]
        mov     bx, 0
        mov     cx, 15
nnext:  mov     al, byte ptr es:[bx+di]
        cmp     al, 0
        je      ndone
        xor     al, 0EEh
        mov     byte ptr es:[bx+di], al
        inc     bx
        loop    nnext
ndone:  ret     4

unscr   endp

_TEXT	ends

	end	bog