MIT PROGRAMS: April 2015

Sunday, 19 April 2015

concatB

section .data
concatstrmsg db 'Concatenation of two strings is',10
conln equ $-concatstrmsg
occurstr db 'occurences of substrings is ',10
occurstrln equ $-occurstr

section .bss
concatstr resb 40
concatstrlnn: equ $-concatstr
cntr resb 1
dispnum resb 2
Extern mainstr,substr,mstrl,sbstrl
%include "m.asm"

section .text
global _main
_main:
global concat,subcnt
concat:xor rcx,rcx
    mov cx,[mstrl]
    mov rsi,mainstr
    mov rdi,concatstr
    call l1
    mov rsi,substr
    mov cx,[sbstrl]
    call l1
         disp concatstrmsg,conln
    disp concatstr,concatstrlnn
    ret

    l1:
    mov al,[rsi]
    mov [rdi],al
    inc rsi
    inc rdi
    dec rcx
    jnz l1
    ret

subcnt:
mov ebp,mainstr
mov esi,mainstr
mov edi,substr
mov rcx,[sbstrl]
xor rbx,rbx
mov bx,[mstrl]
sub rbx,rcx
inc rbx
b1:cld
repe cmpsb
jne b2
inc byte[cntr]
b2:inc ebp
mov esi,ebp
mov edi,substr
mov rcx,[sbstrl]
dec rbx
jnz b1
disp occurstr,occurstrln
mov rax,[cntr]
call display8
ret

display8:mov rcx,2
    mov rsi,dispnum+1

L:    mov     rdx,0
    mov     rbx,10
    div     rbx
    cmp     dl, 09h
    jbe     add30
    add     dl, 07h

add30:
    add     dl,30h
    mov     [rsi],dl
dec     rsi

    dec     rcx
    jnz     L
    disp dispnum,2
    ret

concatA

section .data
menumsg db '-----------------Menu---------------------'
    db '1:Concatenation of two strings',10
    db '2:Occurences of substrings',10
    db '3:Exit',10
menumsgln equ $-menumsg
mainstrmsg db 'Enter main string',10
mainstrln equ $-mainstrmsg
substrmsg db 'Enter sub-string',10
substrln equ $-substrmsg
concatstrmsg db 'Concatenation of two strings is',10
conln equ $-concatstrmsg

chomsg db 'Enter the choice',10
chomsgln equ $-chomsg

section .bss
global mainstr,substr,mstrl,sbstrl
%include "m.asm"
Extern concat,subcnt

mainstr resb 20
mainstrlnn: equ $-mainstr

substr resb 20
substrlnn: equ $-substr

cho resb 2
choln: equ $-cho
mstrl resb 2

sbstrl resb 2

section .text
global _start
_start:

menu:disp menumsg,menumsgln

    disp chomsg,chomsgln
    accept cho,choln

case1:cmp byte[cho],'1'
    jne case2
    disp mainstrmsg,mainstrln
    accept mainstr,mainstrlnn
    dec rax
    mov [mstrl],ax

    disp substrmsg,substrln
    accept substr,substrlnn
    dec ax
    mov [sbstrl],ax

    call concat
    jmp menu

case2:cmp byte[cho],'2'
    jne case3
    disp mainstrmsg,mainstrln
    accept mainstr,mainstrlnn
    dec rax
    mov [mstrl],ax

    disp substrmsg,substrln
    accept substr,substrlnn
    dec ax
    mov [sbstrl],ax

    call subcnt
    jmp menu

case3:cmp byte[cho],'3'
    je ext

    ext:mov eax,1
    mov ebx,0
    int 80h

string

section .data
    menu    db 10,"-------MENU------",10
        db "1.ENTER THE STRING",10
        db "2.DISPLAY THE LENGTH OF STRING",10
        db "3.REVERSE THE STRING",10
        db "4.EXIT",10
        db "Enter Your Choice:",10
    menumsglen equ $-menu

    msg1 db "ENTER THE STRING??",10
    msg1len equ $-msg1

    msg2 db "LENGTH OF STRING",10
    msg2len equ $-msg2

    msg3 db "REVERSE STRING IS",10
    msg3len equ $-msg3

    msgdsp db "U ENTERED THE STRING:" ,10
    msgdsplen equ $-msgdsp

section .bss
    str1 resb 20
    str1len: equ $-str1

    strlen1 resb 2

    strrev resb 20
            strrev_len equ $-strrev

    cho resb 2
    chlen: equ $-cho

    displen resb 2
    displength: equ $-displen

%macro disp 2
    mov rax,4
    mov ebx,1
    mov ecx,%1
    mov edx,%2
    int 80h
%endmacro

%macro accept 2
    mov rax,3
    mov ebx,0
    mov ecx,%1
    mov edx,%2
    int 80h
%endmacro

section .text
global _start
    _start:

mn:    disp menu,menumsglen
    accept cho,chlen

case1:
    cmp byte[cho],'1'
    jne case2
           disp msg1,msg1len
    accept str1,str1len

    disp msgdsp,msgdsplen
    disp str1,str1len
    dec ax
    mov [strlen1],ax

case2:
    cmp byte[cho],'2'
    jne case3
            disp msg2,msg2len
    mov rax,[strlen1]
    call hextoascii

case3:
    cmp byte[cho],'3'
            jne case4

            mov rsi,str1
            xor rcx,rcx
    mov cx,[strlen1]
            add rsi,rcx
           dec rsi
           mov rdi,strrev
           mov rbp,rcx
L9:
           mov al,[rsi]
           mov [rdi],al
          dec rsi
          inc rdi
          dec rbp
          jnz L9
         disp msg3,msg3len
          disp strrev,strrev_len



case4:
    cmp byte[cho],'4'
    je ext

jmp mn

   ext: mov eax,1
    mov ebx,0
    int 80h

hextoascii:
    mov rcx,02
    mov rsi,displen+1
   l2:    mov rdx,00
    mov rbx,16
    div rbx
    add dl,30h
    mov [rsi],dl
    dec rsi
    dec rcx
    jnz l2
    disp displen,2
ret

succadd

section .data

    msg_enter db 10,'Enter two digit Number::'
    msg_enter_len equ $-msg_enter
    res db 10,'Multiplication of elements is::'
    res_len equ $-res


section .bss
    num resb 03
    num1 resb 01
    result resb 04
    numascii resb 2

%macro dispmsg 2
    mov rax,1
    mov rdi,1
    mov rsi,%1
    mov rdx,%2
    syscall
%endmacro

%macro accept 2
    mov rax,0
    mov rdi,0
    mov rsi,%1
    mov rdx,%2
    syscall
%endmacro

section .text

global _start
_start:


    xor rax,rax
    xor rbx,rbx
    xor rcx,rcx
    xor rdx,rdx
    mov byte[result],0
    mov byte[num],0
    mov byte[num1],0


    call succ_add_proc
    jmp exit



exit:
    mov rax,60
    mov rdi,0
    syscall

succ_add_proc:

    dispmsg msg_enter,msg_enter_len
    accept num,3
    call packnum

    mov [num1],bl

    dispmsg msg_enter,msg_enter_len
    accept num,3
    call packnum


    xor rcx,rcx
    xor rax,rax
    mov rax,[num1]

repet:
    add rcx,rax
    dec bl
    jnz repet

    mov [result],rcx
    dispmsg res,res_len
    mov rbx,[result]

    call display_16bit_proc
ret

packnum:
    xor rbx,rbx
    xor rcx,rcx
    xor rax,rax

    mov rcx,02
    mov rsi,num
up1:
    rol bl,04

    mov al,[rsi]
    cmp al,39h
    jg p1
    sub al,30h
    jmp p2
p1:     sub al,37h
p2:    add bl,al
    inc rsi
    loop up1
ret

display_16bit_proc:
    mov rcx,4
    mov rdi,result
dup1:
    rol bx,4
    mov al,bl
    and al,0fh
    cmp al,09h
    jg p3
    add al,30h
    jmp p4
p3:     add al,37h
p4:    mov [rdi],al
    inc rdi
    loop dup1

    dispmsg result,4
ret

shiftadd

section .data

    msg_enter db 10,'Enter two digit Number::'
    msg_enter_len equ $-msg_enter
    res db 10,'Multiplication of elements is::'
    res_len equ $-res


section .bss
    num resb 03
    num1 resb 01
    result resb 04
    numascii resb 2

%macro dispmsg 2
    mov rax,1
    mov rdi,1
    mov rsi,%1
    mov rdx,%2
    syscall
%endmacro

%macro accept 2
    mov rax,0
    mov rdi,0
    mov rsi,%1
    mov rdx,%2
    syscall
%endmacro

section .text

global _start
_start:


    xor rax,rax
    xor rbx,rbx
    xor rcx,rcx
    xor rdx,rdx
    mov byte[result],0
    mov byte[num],0
    mov byte[num1],0






    call add_shift_proc
    call exit


exit:
    mov rax,60
    mov rdi,0
    syscall

add_shift_proc:
    dispmsg msg_enter,msg_enter_len
    accept num,3

    call packnum
    mov [num1],bl

    dispmsg msg_enter,msg_enter_len
    accept num,3
    call packnum

    mov [num],bl

    xor rbx,rbx
    xor rcx,rcx
    xor rdx,rdx
    xor rax,rax

    mov dl,08
    mov al,[num1]
    mov bl,[num]

p11:    shr bx,01
    jnc p
    add cx,ax
p:    shl ax,01
    dec dl
    jnz p11

    mov [result],rcx
    dispmsg res,res_len

    mov rbx,[result]
    call display_16bit_proc

ret

packnum:
    xor rbx,rbx
    xor rcx,rcx
    xor rax,rax

    mov rcx,02
    mov rsi,num
up1:
    rol bl,04

    mov al,[rsi]
    cmp al,39h
    jg p1
    sub al,30h
    jmp p2
p1:     sub al,37h
p2:    add bl,al
    inc rsi
    loop up1
ret

display_16bit_proc:
    mov rcx,4
    mov rdi,result
dup1:
    rol bx,4
    mov al,bl
    and al,0fh
    cmp al,09h
    jg p3
    add al,30h
    jmp p4
p3:     add al,37h
p4:    mov [rdi],al
    inc rdi
    loop dup1

    dispmsg result,4
ret

tsr

CODE SEGMENT
ASSUME CS:CODE,DS:CODE,ES:CODE,SS:CODE
ORG 0100H
START:
        JMP INIT
        OLDCSIP DD ?
        TEMP DB 00H
        HR DB 00H
        MN DB 00H
        S1 DB 00H

USER:

        PUSH AX
        PUSH BX
        PUSH CX
        PUSH DX

        MOV AH,00H      ;INITIALAISE GRAPHICS MODE..
        MOV AL,03H
        INT 10H

        MOV AH,02H
        MOV BH,00H
        MOV DH,10
        MOV DL,50
        INT 10H

        MOV AH,02H      ;GET TIME FROM CMOS
        INT 1AH

        MOV HR,CH
        MOV MN,CL
        MOV S1,DH

        MOV AL,HR
        CALL DISPLAY

        MOV AH,02H
        MOV DL,":"
        INT 21H

        MOV AL,MN
        CALL DISPLAY

        MOV AH,02H
        MOV DL,":"
        INT 21H

        MOV AL,S1
        CALL DISPLAY

        POP DX
        POP CX
        POP BX
        POP AX

        JMP CS:OLDCSIP

INIT:
        CLD
        MOV AH,35H        ;get current intrrupt adddres
        MOV AL,00H
        INT 21H

        MOV WORD PTR[OLDCSIP],BX
        MOV WORD PTR[OLDCSIP+2],ES

        MOV AH,25H      ;SET VECTOR ADDRESS
        MOV AL,00H
        MOV DX,OFFSET[USER]
        INT 21H

        MOV AH,31H      ;MAKE PROGAM RSIDENT IN MEMORY
        MOV DX,OFFSET INIT
        INT 21H

        STI

DISPLAY PROC NEAR
        MOV TEMP,AL
        AND AL,0F0H
        MOV CL,04H
        ROL AL,CL
        CMP AL,09H
        JBE L5
        ADD AL,07H
L5:
        ADD AL,30H
        MOV AH,02H
        MOV DL,AL
        INT 21H

        MOV DL,TEMP
        AND DL,0FH
        CMP DL,09H
        JBE L6
        ADD DL,07H
L6:
        ADD DL,30H
        MOV AH,02H
        INT 21H
        RET
DISPLAY ENDP

CODE ENDS
END START

tsrdiv0

DATA SEGMENT
     DID DW ooo8H
    DR DB 00H
DATA ENDS

CODE SEGMENT
ASSUME CS:CODE,DS:DATA

START:

    MOV AX,DATA
    MOV DS,AX

    MOV AX,DID
    DIV DR

    MOV AH,4CH
    INT 21H

CODE ENDS
END STARTS

ov

section .data
            msgmenu db 10,10,"----------------------------MENU----------------------------"

        db 10,"1.overlapped without string"
        db 10,"2.overlapped with string"
        db 10,"3.Exit"
        db 10,"Enter your choice:-"

        menulen equ $-msgmenu


    msgsr1 db "Contents of source block before data transfer",10
    sr1len equ $-msgsr1

    msgdt1 db 10,"Contents of destination block before data transfer",10
    dt1len equ $-msgdt1

    msgsr2 db 10,"Contents of source block after data transfer",10
    sr2len equ $-msgsr2

    msgdt2 db 10,"Contents of destination block after data transfer",10
    dt2len equ $-msgdt2

    msgspace db " "
    spacelen equ $-msgspace

    msgpos db 10, "Enter position",10
    msgposlen equ $-msgpos

    srcblk db 01h,02h,03h,04h,05h
    destblk times 5 db 00

    sdblk db 01h,02h,03h,04h,05h,00h,00h,00h,00h,00h
        cnt equ 05

section .bss

optionmsg resb 2
optlen: equ $-optionmsg
buffno resb 3
buffnolen: equ $-buffno
dispnum resb 2
position resb 2
positionlen: equ $-position
pos resb 1

%macro read 2
     mov rax,3
     mov rbx,0
     mov rcx,%1
     mov edx,%2
     int 80h

%endmacro

%macro dispmsg 2

    mov rax,4
    mov rbx,1
    mov rcx,%1
    mov rdx,%2
    int 80h
%endmacro

section .text
global _start
_start:

menu:    dispmsg msgmenu,menulen

    read optionmsg,optlen

case1:    cmp byte[optionmsg],'1'
    jne case2

    dispmsg msgdt1,dt1len
    mov rdi,sdblk
        mov rbp,10
    call displayblock

        dispmsg msgpos,msgposlen
        read position,positionlen
         call conv
        mov [pos],bl
        mov esi,sdblk+4
        mov edi,esi
        add edi,[pos]
        dec edi
        mov ecx,cnt

l7:
        mov al,[esi]
        mov [edi],al
        dec edi
        dec esi
        dec ecx
        jnz l7

        mov rdi,sdblk
        mov rbp,10
        call displayblock


case2:    cmp byte[optionmsg],'2'
    jne case3
        dispmsg msgdt1,dt1len
    mov rdi,sdblk
        mov rbp,10
    call displayblock

    dispmsg msgpos,msgposlen
        read position,positionlen

        call conv
        mov [pos],bl
    mov esi,sdblk+4
    mov edi,esi
    add edi,[pos]

        dec edi
    mov ecx,cnt
        std
        rep movsb
        mov rdi,sdblk
        mov rbp,10
        call displayblock


case3:    cmp byte[optionmsg],'3'
    je ext
    jmp menu

ext:    mov rax,1
    mov rbx,0
    int 80h

hextoascii:
    mov rcx,02
    mov rsi,dispnum+1

l2:    mov rdx,00
    mov rbx,16
    div rbx
    cmp dl,09h
    jbe skip2
    add dl,07h

skip2:    add dl,30h
    mov [rsi],dl
    dec rsi
    dec rcx
    jnz l2
    dispmsg dispnum,2
    ret

displayblock:

l5:    mov eax,[rdi]
    call hextoascii
    dispmsg msgspace,spacelen
    inc rdi
    dec rbp
    jnz l5
    ret

conv:

    mov bl,00
    mov rcx,01
    mov rsi,position

L1:
    shl bl,4
    mov al,[rsi]
    cmp al,39h
    jbe skip
    sub al,7h

    skip:sub al,30h
    add bl,al
    ret

nonov

section .data
            msgmenu db 10,10,"----------------------------MENU----------------------------"
        db 10,10,"1.Non-overlapped with string"
        db 10,"2.Non-overlapped without string"
        db 10,"3.Exit"
        db 10,"Enter your choice:-"

        menulen equ $-msgmenu



    msgsr1 db "Contents of source block before data transfer",10
    sr1len equ $-msgsr1

    msgdt1 db 10,"Contents of destination block before data transfer",10
    dt1len equ $-msgdt1

    msgsr2 db 10,"Contents of source block after data transfer",10
    sr2len equ $-msgsr2

    msgdt2 db 10,"Contents of destination block after data transfer",10
    dt2len equ $-msgdt2

    msgspace db " "
    spacelen equ $-msgspace


    srcblk db 01h,02h,03h,04h,05h
    destblk times 5 db 00

    sdblk db 01h,02h,03h,04h,05h,00h,00h,00h,00h,00h
        cnt equ 05

section .bss

optionmsg resb 2
optlen: equ $-optionmsg
buffno resb 3
buffnolen: equ $-buffno
dispnum resb 2

%macro read 2                 ;macro for accepting values
     mov rax,3
     mov rbx,0
     mov rcx,%1
     mov edx,%2
     int 80h

%endmacro

%macro dispmsg 2               ;macro for Printing values

    mov rax,4
    mov rbx,1
    mov rcx,%1
    mov rdx,%2
    int 80h
%endmacro

section .text
global _start
_start:

menu:    dispmsg msgmenu,menulen

    read optionmsg,optlen       ;Store choice value in optionmsg buffer

case1:    cmp byte[optionmsg],'1'     ;Non-overlapped block transfer with string
        jne case2

        dispmsg msgsr1,sr1len        ;Display Source Block before Transfer
        mov rdi,srcblk
        mov rbp,5
    call displayblock

    dispmsg msgdt1,dt1len        ;Display Destination Block before Transfer

        mov rdi,destblk
        mov rbp,5
    call displayblock

    mov esi,srcblk               ;Source to destination Block Transfer
    mov edi,destblk
        mov ecx,5

    cld                            ;clear direction flag
    rep movsb                      ;repeat move string byte

    dispmsg msgsr2,sr2len          ;Display Source Block After Transfer
    mov rdi,srcblk
        mov rbp,5
        call displayblock

    dispmsg msgdt2,dt2len         ;Display Destination Block After Transfer
    mov rdi,destblk
    mov rbp,5
        call displayblock

case2:    cmp byte[optionmsg],'2'        ;Non-overlapped block transfer without string
    jne case3
        dispmsg msgsr1,sr1len
    mov rdi,srcblk
        mov rbp,5
    call displayblock

    dispmsg msgdt1,dt1len
    mov rdi,destblk
        mov rbp,5
    call displayblock

    mov esi,srcblk
    mov edi,destblk
        mov ecx,5

   ldt:    mov al,[esi]            ; byte by byte block transfer from source to destination with use of al
    mov [edi],al
    inc esi
    inc edi
    dec ecx
    jnz ldt

    dispmsg msgsr2,sr2len
    mov rdi,srcblk
    mov rbp,5
        call displayblock

    dispmsg msgdt2,dt2len
    mov rdi,destblk
        mov rbp,5
        call displayblock

case3:    cmp byte[optionmsg],'3'
    je ext
    jmp menu

ext:    mov rax,1            ; exit macro
    mov rbx,0
    int 80h

hextoascii:                ; hextoascii conversion of block data for display
    mov rcx,02
    mov rsi,dispnum+1

l2:    mov rdx,00
    mov rbx,16
    div rbx
    cmp dl,09h
    jbe skip2
    add dl,07h

skip2:    add dl,30h
    mov [rsi],dl
    dec rsi
    dec rcx
    jnz l2
    dispmsg dispnum,2
    ret

displayblock:                ; hextoascii conversion of block data for display

l5:    mov eax,[rdi]
    call hextoascii
    dispmsg msgspace,spacelen
    inc rdi
    dec rbp
    jnz l5
    ret

mean

section .data
    welmsg db 10,"***WELCOME TO 64 BIT PROGRAMMING***"
    welmsg_len equ $-welmsg

    meanmsg db 10,"CALCULATED MEAN IS:-"
    meanmsg_len equ $-meanmsg

    sdmsg db 10,"CALCULATED STANDARD DEVIATION IS:-"
    sdmsg_len equ $-sdmsg

    varmsg db 10,"CALCULATED VARIANCE IS:-"
    varmsg_len equ $-varmsg


    array dd 100.56,200.21,50.67,230.78,67.93
    arraycnt dw 05

    dpoint db '.'
    hdec dq 100

section .bss
    dispbuff resb 1
    resbuff rest 1

    mean resd 1
    variance resd 1
    %macro disp 2
           mov rax,4
       mov rbx,1
       mov rcx,%1
       mov rdx,%2
       int 80h
        %endmacro


    %macro accept 2

        mov rax,3
        mov rbx,0
        mov rcx,%1
        mov rdx,%2
        int 80h
    %endmacro

section .text
   global _start
_start:

    disp welmsg,welmsg_len
    finit
    fldz
    mov rbx,array
    mov rsi,00
    xor rcx,rcx
    mov cx,[arraycnt]
up:    fadd dword[RBX+RSI*4]
    inc rsi                                      ;increment rsi
    loop up

    fidiv word[arraycnt]
    fst dword[mean]
    disp meanmsg,meanmsg_len
    call dispres

    MOV RCX,00
    MOV CX,[arraycnt]
    MOV RBX,array
    MOV RSI,00
    FLDZ
up1:    FLDZ
    FLD DWORD[RBX+RSI*4]
    FSUB DWORD[mean]
    FST ST1
    FMUL
    FADD
    INC RSI
    LOOP up1
    FIDIV word[arraycnt]
    FST dWORD[variance]
    FSQRT

    disp sdmsg,sdmsg_len
    CALL dispres

    FLD dWORD[variance]
    disp varmsg,varmsg_len
    CALL dispres


exit: mov rax,60
      mov rdi,0
      int 80h

disp8_proc:
    mov rdi,dispbuff
    mov rcx,02
back:    rol bl,04
    mov dl,bl
    and dl,0FH
    cmp dl,09
    jbe next1
    add dl,07H
next1: add dl,30H
    mov [rdi],dl
    inc rdi
    loop back
    ret

dispres:
    fimul dword[hdec]
    fbstp tword[resbuff]
    xor rcx,rcx
    mov rcx,09H
    mov rsi,resbuff+9
up2:    push rcx
    push rsi
    mov bl,[rsi]
    call disp8_proc
    disp dispbuff,2
    pop rsi
    dec rsi
    pop rcx
    loop up2

    disp dpoint,1

     mov bl,[resbuff]
    call disp8_proc
    disp dispbuff,2
    ret

h2b

section .data


         menu         db       10,"-----------Menu----------"
            db     10,"1. Hex to BCD "
            db     10,"2. BCD to Hex"
            db     10,"3. Exit "
            db    10
            db     10,"Enter your choice: "
    menu_len:    equ     $-menu

        hbmsg db     10,"Hex to BCD "
            db     10,"Enter 4-digit Hex number: "
        hbmsg_len:    equ     $-hbmsg

            bhmsg     db     10,"BCD to Hex "
            db     10,"enter 5-digit BCD number: "
    bhmsg_len:    equ     $-bhmsg

    hmsg   db       10,13,"Equivalent Hex number is:"
    hmsg_len:    equ     $-hmsg

    bmsg           db     10,13,"Equivalent BCD number is: "
    bmsg_len:    equ     $-bmsg

section .bss

    buf         resb     6
    buf_len:    equ    $-buf

    digitcount    resb    1

    ans        resw    1
    char_ans    resb    4

%macro dispmsg 2
    mov rax,4
    mov rbx,1
    mov rcx,%1
     mov rdx,%2
    int 80h
%endmacro

%macro accept 2
    mov rax,3
    mov rbx,1
    mov rcx,%1
    mov rdx,%2
    int 80h
%endmacro

section .text
    global _start
_start:
menum:
    dispmsg    menu, menu_len
    accept buf,buf_len
        mov    al,[buf]

case1:    cmp     byte[buf],'1'
    jne     case2
    call     hex_bcd
    jmp menum


case2:    cmp     byte[buf],'2'
    jne     case3
    call bcd_hex

case3:    cmp     byte[buf],'3'
    je exit
jmp menum

exit:
       mov rax,1
    mov rbx,0
    int 80h
hex_bcd:
    dispmsg    hbmsg, hbmsg_len

    call     accept_16
    mov     ax,bx

    mov     rbx,10
back:
    xor     rdx,rdx
    div     rbx

    push     dx
    inc     byte[digitcount]

    cmp     rax,0h
    jne     back

    dispmsg    bmsg, bmsg_len
;--------------------------------------------------------------------------------------------
print_bcd:
pop     dx
add     dl,30h
mov    [char_ans],dl

    dispmsg    char_ans,1
    dec     byte[digitcount]
    jnz     print_bcd

    ret

bcd_hex:
    dispmsg    bhmsg, bhmsg_len
    accept    buf,buf_len
    mov    rsi,buf
    xor    rax,rax
    mov     rbx,10
    mov     rcx,05

back1:
xor    rdx,rdx
mul     ebx

    xor    rdx,rdx
    mov     dl,[rsi]
    sub     dl,30h
     add rax,rdx

    inc     rsi

    dec    rcx
    jnz    back1

    mov    [ans],ax

    dispmsg    hmsg, hmsg_len
    mov    ax,[ans]
    call    display_16

    ret

accept_16:
    accept buf,5
    xor     bx,bx
    mov     rcx,4
    mov     rsi,buf

next_digit:    shl    bx,04
        mov    al,[rsi]
              cmp    al,39h
                jbe    sub30
        sub        al,7h

sub30: sub        al,30h
        add    bx,ax
    inc    rsi
    loop    next_digit
ret

display_16:
    mov     rsi,char_ans+3
    mov     rcx,4

cnt:    mov     rdx,0
    mov     rbx,16
    div     rbx
    cmp     dl, 09h
    jbe     add30
    add     dl, 07h
add30:
    add     dl,30h
    mov     [rsi],dl
    dec     rsi

    dec     rcx
    jnz     cnt

    dispmsg char_ans,4
ret

b2h

addhex

section .data
    msg1 db 'ACCEPT N HEXADECIMAL NUMBER & ADD THEM',10
    msg1len equ $-msg1

    msg2 db 'Enter the number you want:',10
    msg2len equ $-msg2

    msg3 db 'Enter the 64-bit hexadecimal numbers:',10
    msg3len equ $-msg3

    msg4 db 'addition of given number is:',10
    msg4len equ $-msg4
section .bss

    nascii resb 3
    nascii_len equ $-nascii
         count resb 1
    dispnum resb 16
    resultl resq 1
    resulth resq 1
    buffer resb 17
    buffer_len: equ $-buffer

%macro dispmsg 2

    mov rax,4
    mov rbx,1
    mov rcx,%1
    mov rdx,%2
    int 80h
%endmacro

%macro accept 2

    mov rax,3
    mov rbx,1
    mov rcx,%1
    mov rdx,%2
    int 80h
%endmacro

section .text
global _start:
_start:
    dispmsg msg1,msg1len

    dispmsg msg2,msg2len
    accept nascii,nascii_len
    call accept8

    mov [count],bl
        mov rdi,[count]

nextnum:
    dispmsg msg3,msg3len
    accept buffer,buffer_len
    call accept64

    add [resultl],rbx
    jnc next
    inc word[resulth]
next:
    dec rdi
    jnz nextnum
        dispmsg msg4,msg4len

    mov rax,[resulth]
    call display64

    mov rax,[resultl]
    call display64


    mov rax,1
    mov rbx,0
    int 80h

accept8:
    xor bl,bl
    mov rcx,02
    mov rsi,nascii

l1:    shl bl,4
    mov al,[rsi]
    cmp al,39h

jbe sub30
    sub al,07h

sub30: sub al,30h
    add bl,al
    inc rsi
    loop l1
ret

accept64:
    mov rbx,00
    mov ecx,16
    mov esi,buffer
    mov rax,00

L3:    shl rbx,4
    mov al,[esi]
    cmp al,39h
    jbe skip2
    sub al,07h

skip2:    sub al,30h
    add rbx,rax
        inc esi
    loop L3
ret

display64:

    mov     rsi,dispnum+15
    mov     rcx,16

cnt:    mov     rdx,0
    mov     rbx,16
    div     rbx
    cmp     dl, 09h
    jbe     add30
    add     dl, 07h
add30:
    add     dl,30h
    mov     [rsi],dl
    dec     rsi
    dec     rcx
    jnz     cnt

     dispmsg dispnum,16
ret