Programa que separa los bits pares y nones de una variable en Turbo Assembler (MASM/TASM)

tarea505.asm

; TITULO: Programa que separa los bits pares y nones de una variable
ideal
dosseg
model small
stack 256

dataseg
    codsal  db  0
    ; Mis variables {
    dato    dw  1010101010101010b
    pares   db  0
    nones   db  0
    ;}

codeseg
    proc PrintDecimal
        push ax
        push bx
        push cx
        push dx
        
        ; check if negative
        test ax,08000h
        jz PositiveAx
                
        ;  put '-' on the screen
        push ax
        mov dl,'-'
        mov ah,2
        int 21h
        pop ax
        
        neg ax ; make it positive
        PositiveAx:
            mov cx,0   ; will count how many time we did push 
            mov bx,10  ; the divider

        put_mode_to_stack:
            xor dx,dx
            div bx
            add dl,30h
            ; dl is the current LSB digit 
            ; we cant push only dl so we push all dx
            push dx    
            inc cx
            cmp ax,9   ; check if it is the last time to div
            jg put_mode_to_stack
            
            cmp ax,0
            jz pop_next  ; jump if ax was totally 0
            add al,30h  
            mov dl, al    
            mov ah, 2h
            int 21h        ; show first digit MSB

        pop_next: 
            pop ax    ; remove all rest LIFO (reverse) (MSB to LSB)
            mov dl, al
            mov ah, 2h
            int 21h        ; show all rest digits
            loop pop_next
            
            pop dx
            pop cx
            pop bx
            pop ax
            
        ret
    endp PrintDecimal
    proc PrintNewLine
        push dx
        mov dx, 0Ah
        call PrintChar
        pop dx
        ret
    endp PrintNewLine
    proc PrintChar
        push ax
        mov ah, 02h
        int 21h
        pop ax
        ret
    endp PrintChar
inicio:
    mov ax, @data
    mov ds, ax
    
    ; ###### MI CODIGO ####### {
    ; Para separar los bits en las posiciones pares e impares, vamos a ir recorriendo a la derecha la variable 'dato'
    ; y otro valor que guardaremos en 'al', ya veran por que
    ; Para obtener un bit en la posicion que queramos, haremos la instruccion and con 'dato' y un valor que tenga puros 0s pero
    ; un 1 en la posicion que queremos
    ; Por eso guardamos este valor en 'al'
    mov al, 00000001b
    ; En cada repeticion del ciclo, vamos a ir moviendo ese 1
    ; Guardamos 8 en 'cx' para que nuestro ciclo se ejecute 8 veces
    mov cx, 8
    mientras:
        ; bl = al
        mov bl, al
        ; aqui estamos usando la operacion 'and' como dijimos antes para obtener el bit que queremos
        and bl, [byte dato]
        ; sumamos 'bl' a 'pares' para que se guarde el bit que acabamos de obtener
        add [pares], bl

        ; recorremos dato un paso a la derecha
        shr [dato], 1

        ; bl = al
        mov bl, al
        ; Obtenemos el bit que queremos. (La palabra byte no es obligatoria)
        and bl, [byte dato]
        ; sumamos 'bl' a 'nones' para que se guarde el bit que acabamos de obtener
        add [nones], bl

        ; recorremos 'al' un paso a la izquierda
        shl al, 1 

        ; Nunca deben olvidar restarle 1 a 'cx' para que el contador no se cicle
        dec cx
        jcxz fin_mientras
    jmp mientras
    fin_mientras:
    ; }
salir:
    mov ah, 04Ch
    mov al, [codsal]
    int 21h
end inicio