; Copies AL to EAX:8, EAX:16, EAX:24
; How?
; Lets change the magic constant into an equivalent expression
; $01010101 = (1 shr 24) + (1 shr 16) + (1 shr 8 ) + (1 shr 0)
; Now, you see what happens? The resulting operation is this
; EBX = AL*(1 shr 24) + AL*(1 shr 16) + AL*(1 shr 8 ) + AL*(1 shr 0)
; NOTE: Actually the expression above is valid if and only if all the register except AL was cleared
        imul    ebx,eax,01010101h

; Now, by XORing we get a zero value if and only if the byte has the same value as the vowel
        xor     ebx,'aeio'
        mov     edx,ebx

; Vowels will be $FF ----------------------------------------+
        not     ebx                                        ; |
                                                           ; |
; The bytes that was vowels will have higher bit set to 1  ; |
        sub     edx,01010101h                              ; |
                                                           ; |
; Now lets keep high bits only ------------------------------+
        and     ebx,80808080h

; And now if one of the high bits was set then the char was one of the vowels
        and     ebx,edx ; Can be "test" instruction here
    

mov al,36h
add al,49h
;Here the al register is 7Fh but in BCD it should be 85
aaa
;That is where its modified so that last digit is 5 and 3+4+carry=8
;al=85h
    

mov  al,6h ;ONLY one digit
imul al,9h
;Here the al register is 36h but in BCD it should be 54
aam
;That is where its modified so that last digit is 4 and first is 5
;ax=54
    

;Code is intentionally long to make the internals clear
;displaying (al1+al2)/10,(al1+al2) mod 10 would explain anything 
al1=9
al2=6
myAL=al1+al2 ;0Fh
myAH=0
af=(myAL shr 4) and 1 ;Auxiliary flag for nibble carrys

if ((myAL and 0Fh)>9) | af=1
  myAL=(myAL+6) and 0Fh
  myAH=myAH+1
end if
display "AX=",myAH+30h,myAL+30h
    

al1=9
al2=6
myAL=al1*al2 ;36h

myAH = myAL / 10;
myAL = myAL MOD 10;
display "AX=",myAH+30h,myAL+30h
;Displays 54 for 6*9
    

;0609h => 69h
ah1=6
al1=9 ;This is 69 in unpacked form

al2=7

myAL=ah1*10+al1
myAH=0

display "AX=",myAL/10+30h,myAL mod 10+30h,'h'
    

mov ax,99h
add ax,99h
aaa    

please write not procedures, but examples.

Or rename thread.

; Make the executable in the following way:

; fasm tree.asm
; gcc -m32 tree.o -o tree
; rm tree.o (OPTIONAL)
; strip tree (OPTIONAL, reduce executable's size)
; PROGRAM Tree;
format ELF

; TYPE
struc TTree
{
.:
  .left    dd ?
  .right    dd ?
; DON'T CHANGE THE POSITION OF THE FIELDS ABOVE
  .datum   dd ?

  sizeof.#. = $ - .
}
; To be able to use the structure without associating it to a variable
virtual at 0
  TTree TTree
end virtual

; VAR
section '.bss' writable
  tree dd 0

section '.text' executable
  extrn   printf
  extrn   scanf
  extrn   malloc
  extrn   exit

  public  main
; BEGIN
main:
  call    readInt
  test    eax, eax
  jz      .print

  mov     edx, tree
  call    insert
  jmp     main

.print:
  push    message
  call    printf
  add     esp, 4

  mov     eax, tree
  call    printTree

  xor     eax, eax
  ret
message   db 10, "In-order print:", 10, 0

; #### TREE PROCEDURES
insert: ; EAX = datum ; EDX = var ^TTree
  mov     ecx, [edx]
  test    ecx, ecx
  jz      .createNode

  xor     edx, edx
  cmp     eax, [ecx+TTree.datum]
  setge   dl

  lea     edx, [ecx+edx*4]
  jmp     insert

.createNode:
  push    edx
  push    eax

  push    sizeof.TTree
  call    malloc
  add     esp, 4

  mov     [eax+TArbol.left], 0
  mov     [eax+TArbol.right], 0
  pop     [eax+TArbol.datum]

  pop     edx
  mov     [edx], eax
  ret

; ####

printTree: ; EAX = var ^TArbol
  mov     eax, [eax]
  test    eax, eax
  jz      .exit

  push    ebx
  mov     ebx, eax

  call    printTree
  mov     eax, [ebx+TTree.datum]
  call    writeLnInt

  lea     eax, [ebx+4]
  call    printTree

  pop     ebx

.exit:
  ret

; #### I/O PROCEDURES
readInt:
  push    eax   ; Reserves space to store the integer

  push    esp   ; Stores a pointer to the space reserved above
  push    .fmt
  call    scanf
  add     esp, 4*2

  test    eax, eax
  jz      .error

  pop     eax
  ret

.error:
  push    .errorStr
  call    printf
  pop     eax

  push    -1
  call    exit
.fmt      db "%d", 0
.errorStr db "ERROR: Invalid number", 10, 0

; ####

writeLnInt: ; EAX=integer
  push    eax
  push    .fmt
  call    printf
  add     esp, 8
  ret
.fmt      db "%d", 10, 0