How can I display total sum in assembly language?

I'm working on program to calculate the sum in roll number and display output as the sum is even or odd. I have done everything and I'm getting the right output. The only issue is that my programing is not displaying the total sum on screen. It is just display the even or odd after calculation. I also want to display the sum output on screen.

here is my code:

org 100h

section .data
    roll_num db '210405702'     ; Roll Number
    roll_len equ $ - roll_num   ; Length of roll number string
    sum_msg db 'The sum is: $'
    output_buffer db 16         ; Buffer to store the converted sum as a string
    result_msg db 'The received number is: $'

section .text
    global _start

_start:
    mov si, 0
    mov cx, 0
    
sum_loop:
    mov al, byte [roll_num + si] ; Changed 'a1' to 'al' (8-bit register)
    sub al, 48                  ; Subtract 48 to convert from ASCII to decimal
    add cx, ax                  ; Changed 'ax' to 'cx' for addition
    inc si                      ; Increment si by 1
    cmp si, roll_len            ; Compare si with roll_len
    jl sum_loop                 ; Jump back to sum_loop if si < roll_len
    
    mov ax, cx
    
    test al, 1                  ; Changed 'a1' to 'al' (8-bit register)
    jz even
    
    mov di, 1
    jmp print_result

even:
    mov di, 0
    
print_result:
    mov ah, 09h
    cmp di, 0
    je even_num
    mov dx, odd_msg             ; Display odd message
    int 21h
    jmp end_program

even_num:
    mov dx, even_msg            ; Display even message
    int 21h

    ; Call print_sum to display the total sum
    call print_sum
    
end_program:
    mov ah, 4Ch
    xor al, al
    int 21h

print_sum:
    mov ah, 09h
    mov dx, sum_msg             ; Display the sum message
    int 21h
    
    mov bx, 10                  ; Divide by 10 to convert sum to decimal string
    xor cx, cx                  ; Clear cx register
    mov si, output_buffer + 15  ; Start at the end of the buffer
    
convert_loop:
    xor dx, dx                  ; Clear dx register
    div bx                      ; Divide ax by 10
    add dl, 48                  ; Convert remainder to ASCII
    dec si                      ; Decrement si
    mov [si], dl                ; Store converted digit in buffer
    inc cx                      ; Increment digit count
    test ax, ax
    jnz convert_loop            ; Jump back to convert_loop if ax != 0
    
    mov dx, si                  ; Display the converted sum string
    add dx, 1                   ; Increment dx to skip the '$' at the end of the string
    mov ah, 09h
    int 21h

section .data
    odd_msg db 'The received number is odd', 0Dh, 0Ah, '$'
    even_msg db 'The received number is even', 0Dh, 0Ah, '$'

I tried to write some code. The code is working fine but still it's not showing total sum in output.

> output_buffer db 16

You don't have a buffer. The above just provides a single byte whereas your program expects a 16-byte buffer. Use output_buffer db 16 dup (0), or output_buffer times 16 db 0 (depending on the assembler).

> xor cx, cx
> mov si, output_buffer + 15

By the time you reach print_sum, the AX register no longer contains the sum, but CX does. And the string needs $-termination. Therefore write it like:

mov  ax, cx
xor  cx, cx
mov  si, output_buffer + 15
mov  byte [si], "$"

> mov dx, si ; Display the converted sum string
> add dx, 1 ; Increment dx to skip the '$' at the end of the string
> mov ah, 09h
> int 21h

It is wrong to add 1 to DX because SI was already pointing at the first digit to display.

> add cx, ax ; Changed 'ax' to 'cx' for addition

Make sure AH is 0 before you do this word-sized addition.

> mov dx, odd_msg ; Display odd message
> int 21h
> jmp end_program

You exit the program before printing the sum in case the sum is odd. Maybe this is intentional? If it is, it is bad because the sum is indeed an odd number (21).

> mov ah, 09h
> int 21h
>
> section .data

Here you have forgotten to exit the program!

    mov ah, 09h
    int 21h
    jmp end_program         <<<< new

section .data

First change output_buffer db 16 to output_buffer db 16 dup(0)

In this example sum is odd and equal 21.
Then You use test al, 1 so ZF is cleared because least sigificant bit is 1.

0 0 0 1 0 1 0 1

0 0 0 0 0 0 0 1

0 0 0 0 0 0 0 1 ZF=0

Next DI = 1 and You jump to print_result, print odd_msg and jmp to end_program. Print_sum is totally omitted.

You should change jmp end_program to jmp print_sum.
And call print_sum same to jmp print_sum because when You use call, instruction pointer is put on the stack and You don't have ret instruction in the code.

And use push ax to keep sum intact after sum_loop and pop ax before convert_loop.

Sum is printed on the screen + "The received number is:" after it because printing string stops when $ is at the end of the string. So You should print result_msg before convert_loop and then calculate sum. And maybe add before convert_loop lines with $ as last character in string

 mov si, output_buffer + 15     ;$ is last in the buffer
 mov dl,'$'
 mov [si],dl
 mov si, output_buffer + 14    ; and we put digits before $

Add jmp end_program before section .data

:)))