$ ./prog
12           input
24           output
34
68
56
112
    

$ cat n
12
34
56

$ cat n | ./prog
460766
460766
460766
    

format elf executable
entry main

use32

main:

   xor eax,eax
.a:
   cmp eax,3
   jge exit
   push eax

   mov eax, 3               ; sys_read
   mov ebx, 0             ; stdin
   mov ecx, buf
   mov edx, 0x20
   int 0x80 

; chop nl
   dec eax
   mov [buf+eax],0


   mov ebx,10
   mov edi,buf
   call StrToInt
   shl eax,1
   mov  ebx,10              ; \
   mov  [base],ebx          ;   configure dot
   xor  edx,edx            
   call dot
   
   pop eax
   inc eax
   jmp .a


;  mov ecx, buf
;  mov ebx, 1           ; stdout
;  mov eax, 4           ; sys_write
;  int 80h              ; Linux syscall

exit:
   xor ebx,ebx  ; exit 0
   mov eax, 1
   int 80h



StrToInt:
        ; edi = buffer, ebx = base
        xor     eax,eax
        xor     edx,edx
     .loop:
        mov     dl,byte [edi] ; get char
        test    dl,dl             ; empty?
        jz      .end
        imul    eax,ebx             ; multiply with base
        sub     dl,'0'                ; 'n' - '0'
        cmp     dl,9         ; hex number?
        jle     .ok
        sub     dl,7            ; substract 7 on top
      .ok:
        add     eax,edx               ; add result
        inc     edi
        jmp     .loop
      .end:
        ret




dot:    ; print a number
   ; eax = number, ebx = base, edi = buffer
   push eax
   push ebx
   push ecx
   push edx
   mov     ebx, [base]
   cmp  ebx,10
   jne  udot
   mov     edi,buffer
   or      eax,eax         ; negative?
   jns     udot
   push eax
   mov     al,'-'          ; eax is altered
   stosb                   ; only al is stored
   mov  edx, 1
   mov     ecx, buffer
   mov     ebx, 1          ; stdout
   mov     eax, 4          ; sys_write
   int     80h             ; Linux syscall
   pop  eax
   neg  eax
udot:   ;  print a unsigned number
   ; eax = number, ebx = base, edi = buffer
   mov  ebx, [base]
   mov     edi,buffer
   xor     ecx,ecx
.new:
   xor  edx,edx
   div  ebx
   push    edx          ; push remainder
   inc     ecx          ; loop cnt, see below
   test    eax,eax
   jnz     .new
   mov  edx,ecx         ; for type above
.loop:
   pop     eax
   add     al,30h
   cmp     al,'9'
   jng     .ok
   add     al,27h       ; lowercases
.ok:
   stosb                ; mov edi,[al], and inc edi, inc edx
   loop    .loop        ; loop bails out on eci=0
   mov     al,10        ; terminate with nl
   inc  edx
   stosb
type:
                        ; edx = count
   mov ecx, buffer
   mov ebx, 1           ; stdout
   mov eax, 4           ; sys_write
   int 80h              ; Linux syscall
   pop  edx
   pop  ecx
   pop  ebx
   pop  eax
   ret

buffer  rb 33           ; 32 + 1
base    rd 1    


buf      rb      0x20 
a       rd     20
    

   mov eax, 3           ; sys_read
   mov ebx, 0           ; stdin
   mov ecx, buf
   mov edx, 0x4       ; read exactly four characters
   int 0x80


$ more n
123
234
345
$ cat n | ./prog
246
468
690