Untitled

Code	Segment
	assume CS:Code, DS:Data, SS:Stack

    Start:
    	mov di,82h
        	
            	mov si,80h

                	mov cx,10
                    	
                        Keres:
                        	mov dl,[di]
                            	cmp dl,"/"
                                	jz KerdoJel
                                    	inc di
                                        	loop Keres
                                            	jmp Default
                                                	
                                                    KerdoJel:
                                                    	inc di
                                                        	mov bl,[di]
                                                            	cmp bl, '?'
                                                                	jz Help
                                                                    	
                                                                        ParaM:
                                                                        	xor ax,ax
                                                                            	mov al,[si]
                                                                                	cmp al,3
                                                                                    	jz EgyPara
                                                                                        	cmp al,5
                                                                                            	jz HaromPara
                                                                                                	jmp KetPara
                                                                                                    	
                                                                                                        HaromPara:
                                                                                                        	inc di
                                                                                                            	mov bl,[di]
                                                                                                                	
                                                                                                                    KetPara:
                                                                                                                    	mov cx,10
                                                                                                                        	mov ah,'0'
                                                                                                                            	
                                                                                                                                NumE:
                                                                                                                                	cmp bl,ah
                                                                                                                                    	jz Tovabb
                                                                                                                                        	inc ah
                                                                                                                                            	loop NumE
                                                                                                                                                	jmp ErrorS
                                                                                                                                                    	
                                                                                                                                                        Tovabb:
                                                                                                                                                        	sub bl,'0'
                                                                                                                                                            	inc di
                                                                                                                                                                	mov bh,[di]
                                                                                                                                                                    	mov cx,10
                                                                                                                                                                        	mov ah,48
                                                                                                                                                                            	
                                                                                                                                                                                NumE2:
                                                                                                                                                                                	cmp bh,ah
                                                                                                                                                                                    	jz Tovabb2
                                                                                                                                                                                        	inc ah
                                                                                                                                                                                            	loop NumE2
                                                                                                                                                                                                	jmp ErrorS
                                                                                                                                                                                                    	
                                                                                                                                                                                                        Tovabb2:
                                                                                                                                                                                                        	sub bh,48
                                                                                                                                                                                                            	mov ax,10
                                                                                                                                                                                                                	mul bl
                                                                                                                                                                                                                    	
                                                                                                                                                                                                                        	add al,bh
                                                                                                                                                                                                                            	mov cx,ax
                                                                                                                                                                                                                                	jmp Ini
                                                                                                                                                                                                                                    	
                                                                                                                                                                                                                                        EgyPara:
                                                                                                                                                                                                                                        	xor cx,cx
                                                                                                                                                                                                                                            	mov cl,[di]
                                                                                                                                                                                                                                                	sub cl,48
                                                                                                                                                                                                                                                    	jmp Ini
                                                                                                                                                                                                                                                        	
                                                                                                                                                                                                                                                            Help:
                                                                                                                                                                                                                                                            	mov ax,Code
                                                                                                                                                                                                                                                                	mov ds,ax
                                                                                                                                                                                                                                                                    	
                                                                                                                                                                                                                                                                        	mov dx, offset Helper
                                                                                                                                                                                                                                                                            	mov ah,09h
                                                                                                                                                                                                                                                                                	int 21h
                                                                                                                                                                                                                                                                                    	jmp Waiter
                                                                                                                                                                                                                                                                                        	
                                                                                                                                                                                                                                                                                            ErrorS:
                                                                                                                                                                                                                                                                                            	mov ax,Code
                                                                                                                                                                                                                                                                                                	mov ds,ax
                                                                                                                                                                                                                                                                                                    	mov dx, offset Kivetel
                                                                                                                                                                                                                                                                                                        	mov ah,09h
                                                                                                                                                                                                                                                                                                            	int 21h
                                                                                                                                                                                                                                                                                                                	xor ax,ax
                                                                                                                                                                                                                                                                                                                    	int 16h
                                                                                                                                                                                                                                                                                                                        	
                                                                                                                                                                                                                                                                                                                            Default:
                                                                                                                                                                                                                                                                                                                            	mov cx,10
                                                                                                                                                                                                                                                                                                                                	
                                                                                                                                                                                                                                                                                                                                    Ini:
                                                                                                                                                                                                                                                                                                                                    	mov	ax, Code
                                                                                                                                                                                                                                                                                                                                        	mov	DS, AX
                                                                                                                                                                                                                                                                                                                                            	
                                                                                                                                                                                                                                                                                                                                                	xor di,di
                                                                                                                                                                                                                                                                                                                                                    	xor si,si
                                                                                                                                                                                                                                                                                                                                                        	
                                                                                                                                                                                                                                                                                                                                                            	xor dx,dx
                                                                                                                                                                                                                                                                                                                                                                	push dx
                                                                                                                                                                                                                                                                                                                                                                    	mov ax,03h
                                                                                                                                                                                                                                                                                                                                                                        	int 10h
                                                                                                                                                                                                                                                                                                                                                                            	
                                                                                                                                                                                                                                                                                                                                                                                Rajz:
                                                                                                                                                                                                                                                                                                                                                                                	mov bx, di
                                                                                                                                                                                                                                                                                                                                                                                    	mov dh, bl
                                                                                                                                                                                                                                                                                                                                                                                        	mov bx, si
                                                                                                                                                                                                                                                                                                                                                                                            	mov dl, bl
                                                                                                                                                                                                                                                                                                                                                                                                	xor bh, bh
                                                                                                                                                                                                                                                                                                                                                                                                    	mov ah, 02h
                                                                                                                                                                                                                                                                                                                                                                                                        	int 10h
                                                                                                                                                                                                                                                                                                                                                                                                            	
                                                                                                                                                                                                                                                                                                                                                                                                                	mov dx, offset Labda
                                                                                                                                                                                                                                                                                                                                                                                                                    	mov ah, 09h
                                                                                                                                                                                                                                                                                                                                                                                                                        	int 21h
                                                                                                                                                                                                                                                                                                                                                                                                                            	
                                                                                                                                                                                                                                                                                                                                                                                                                                	pop ax
                                                                                                                                                                                                                                                                                                                                                                                                                                    	push ax
                                                                                                                                                                                                                                                                                                                                                                                                                                        	mov bl, al
                                                                                                                                                                                                                                                                                                                                                                                                                                            	mul bl
                                                                                                                                                                                                                                                                                                                                                                                                                                                	shr ax, 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                    	shr ax, 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	shr ax, 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                            	mov di, ax
                                                                                                                                                                                                                                                                                                                                                                                                                                                                	pop ax
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	inc ax
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	push ax
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	dec ax
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	mov bl, cl
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	mul bl
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	shr ax, 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	shr ax, 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	mov si, ax
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	cmp si, 80
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	jnc Waiter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	cmp di, 25
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	jnc Waiter
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	jmp Rajz

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Waiter:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	xor ax,ax
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	int 16h
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Program_Vege:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	mov	ax, 4c00h
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	int	21h
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Helper db "Megfelelo alak: nev /parameter$"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Kivetel db "Nem megfelelo$"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Labda db"0$"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Code	Ends
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Data	Segment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Data	Ends
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Stack	Segment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Stack	Ends
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	End	Start