format PE console 4.0
include 'WIN32AX.INC'
entry main
.data
wbytes rd 1
itdb db ?
.code
proc main
xor eax,eax
start:
push eax
invoke itoa,ecx,itdb,10
invoke WriteFile,STD_OUTPUT_HANDLE,itdb,1,wbytes,0
invoke getchar
pop eax
inc eax
cmp eax,7
jne start
invoke ExitProcess,0
endp
data import
library kernel32,'kernel32.dll',msvcrt,'msvcrt.dll'
include 'API\KERNEL32.INC'
import msvcrt,itoa,'_itoa',getchar,'getchar'
end data    

format PE console 4.0
include 'WIN32AX.INC'
entry main
.data
wbytes rd 1
itdb db ?
.code
proc main
xor eax,eax
start:
push eax
cinvoke itoa,eax,itdb,10
invoke WriteFile,STD_OUTPUT_HANDLE,itdb,1,wbytes,0
cinvoke getchar
pop eax
inc eax
cmp eax,7
jne start
invoke ExitProcess,0
endp
data import
library kernel32,'kernel32.dll',msvcrt,'msvcrt.dll'
include 'API\KERNEL32.INC'
import msvcrt,itoa,'_itoa',getchar,'getchar'
end data    

invoke lstrlen,itdb ;return size of text buffer in EAX    

itdb rb 10 ;in case of 9 digit number maximum    

format PE console 4.0
include 'WIN32AX.INC'
entry main
.data
wbytes rd 1
itdb rb 10
.code
proc main
xor eax,eax
start:
push eax
cinvoke itoa,eax,itdb,10
invoke lstrlen,itdb
invoke WriteFile,STD_OUTPUT_HANDLE,itdb,eax,wbytes,0
cinvoke getchar
pop eax
inc eax
cmp eax,11
jne start
invoke ExitProcess,0
endp
data import
library kernel32,'kernel32.dll',msvcrt,'msvcrt.dll'
include 'API\KERNEL32.INC'
import msvcrt,itoa,'_itoa',getchar,'getchar'
end data    

proc itoa2 stdcall value,buf,base      ;Return will be in eax, 0:fine, -1:base too small/large

  local table db '0123456789ABCDEF' ;Table used in conversion

  cmp  [base],16      ;Nothing over base 16(Hex) is supported. You could add support for them by just modifying this line and the table above
  ja   .base_error
  cmp  [base],2       ;Nothing below base 2 is supported
  jb   .base_error

  pushad              ;Save the registers. No one likes a procedure that thrashes everything

  mov  eax,[value]    ;Load up the registers
  mov  ebx,[base]
  mov  edi,[buf]
  mov  edx,0          ;Important note if you didn't know this, division by a dword is a 64-bit divide, edx will interfere if it's not cleared
                      ;Division by a dword does edx:eax div r/m32      where edx:eax is treated as one 64-bit number

  push 0xFFFF         ;This push is used later in the reversing part, it tells it that it's done.

  @@:
    or   eax,eax      ;Is the value to convert zero?
    jz   .reverse     ;If so, we're done here, lets reverse it.
    div  ebx          ;Else, divide it by the base.  Result stored in eax, remainder in edx
    lea  edx,[edx+table] ;Point edx to the byte in the table holding the value we need
    movzx edx,byte[edx]  ;Put that byte in edx
    push edx             ;Push it
    mov  edx,0           ;and as I explained earlier, edx MUST be zero before the next divide, or it will interfere with the divide
    jmp @b               ;Lather, rinse, and repeat



;The routine above gets the numbers backwards, so we must reverse them.
  .reverse:
    pop  eax          ;Pop a converted value off the stack
    cmp  eax,0xFFFF   ;Are we done reversing(was the popped value the 0xFFFF we pushed before we started)?
    je   @f
    stosb             ;If not, store the byte in the buffer
    jmp  .reverse

  @@:
    mov  eax,0        ;The string needs to be zero terminated, so this just places a 0x0 at the end
    stosb

  popad
  mov  eax,0          ;Out: eax = 0, everything went fine
  ret

  .base_error:
    mov  eax,-1       ;Out: eax = -1, Bad base
    ret
endp
    

stdcall itoa2,4660,buf,16
    

Isn't there other EASYEST way ?

cinvoke itoa,eax,itdb,10