function IntToText(Buffer: PChar; MaxLen: Cardinal; Value: Integer): Integer;

  procedure __Int32ToStr(Value: Integer);
  asm
    PUSH    ESI
    MOV     ESI, ESP
    SUB     ESP, 16
    XOR     ECX, ECX       // base: 0 for signed decimal
    PUSH    EDX            // result ptr
    XOR     EDX, EDX       // zero filled field width: 0 for no leading zeros
    CALL    __CvtInt
    MOV     EDX, ESI
    POP     EAX            // result ptr
    ADD     ESP, 16
    POP     ESI
  end;
var
  Pter : PChar;
  Length : integer;
begin
  __Int32ToStr(Value);

  asm
    mov Pter, EAX
    mov Length , ECX
  end;
  if Length <= MaxLen then begin
    Move(Pter^,Buffer^,Length);
    Result := Length;
  end
  else begin
    Result := -1;
    exit;
  end;
end;

use16                       ;Генерировать 16-битный код
org 100h                    ;Программа начинается с адреса 100h
    jmp start               ;Перепрыгнуть данные
;-------------------------------------------------------------------------------
; Данные
a       dq 1600000000000000
b       dq 33000000
c       dq 12345678901234567890
s_a     db 'a = $'
s_b     db 'b = $'
s_c     db 'c = $'
endline db 13,10,'$'
s_pak   db 'Press any key...$'
;-------------------------------------------------------------------------------
; Код
start:
    mov di,s_a
    call print_str          ;Вывод строки 'a = '
    mov bx,a
    call print_qword_udec   ;Вывод числа a
    call print_endline      ;CR+LF
 
    mov di,s_b
    call print_str          ;Вывод строки 'b = '
    mov bx,b
    call print_qword_udec   ;Вывод числа b
    call print_endline      ;CR+LF
 
    mov di,s_c
    call print_str          ;Вывод строки 'c = '
    mov bx,c
    call print_qword_udec   ;Вывод числа c
    call print_endline      ;CR+LF
 
    mov di,s_pak
    call print_str          ;Вывод строки 'Press any key...'
    mov ah,8                ;\
    int 21h                 ;/ Ввод символа без эха
    mov ax,4C00h            ;\
    int 21h                 ;/ Завершение программы
 
;-------------------------------------------------------------------------------
;Процедура вывода учетверённого слова на консоль в десятичном виде (без знака)
; BX - адрес qword
print_qword_udec:
    push di
    sub sp,22               ;Выделение места в стеке для буфера
    mov di,sp               ;DI = адрес буфера
    push word[bx+6]         ;\
    push word[bx+4]         ; \
    push word[bx+2]         ; / Помещение qword в стек
    push word[bx]           ;/
    call qword_to_udec_str  ;Преобразование qword в строку
    mov byte[di],'$'        ;Добавление символа конца строки
    mov di,sp               ;DI = адрес буфера со строкой
    call print_str          ;Вывод строки на консоль
    add sp,22               ;Восстановление указателя стека
    pop di
    ret
 
;-------------------------------------------------------------------------------
;Процедура преобразования учетверённого слова
;в строку в десятичном виде (без знака)
;Вход: qword в стеке (младший байт по младшему адресу!)
;  DI - буфер для строки (20 символов). Значение регистра не сохраняется.
qword_to_udec_str:
    push bp                 ;Сохранение BP
    mov bp,sp               ;BP=SP
    push ax                 ;Сохранение используемых регистров
    push cx
    push bx
    push si
 
    xor cx,cx               ;Обнуление CX
    mov bx,10               ;В BX делитель (10 для десятичной системы)
 
.lp1:                       ;Цикл получения остатков от деления
    xor dx,dx
    mov si,8                ;SI = смещение слова для деления
 
.div64:                     ;Цикл 64-битного деления
    mov ax,[bp+si+2]        ;Загрузка слова в AX
    div bx                  ;AX = (DX:AX)/10; DX = остаток
    mov [bp+si+2],ax        ;Сохранение результата деления слова
    sub si,2                ;Уменьшение смещения на 2
    jnz .div64              ;Переход к началу цикла, если SI != 0
 
    add dl,'0'              ;Преобразование остатка в код символа
    push dx                 ;Сохранение в стеке
    inc cx                  ;Увеличение счетчика символов
    or ax,[bp+6]            ;\
    or ax,[bp+8]            ; > Проверка частного на равенство 0 ;)
    or ax,[bp+10]           ;/
    jnz .lp1                ;Переход к началу цикла, если частное не 0.
 
.lp2:                       ;Цикл извлечения символов из стека
    pop dx                  ;Восстановление символа из стека
    mov [di],dl             ;Сохранение символа в буфере
    inc di                  ;Инкремент адреса буфера
    loop .lp2               ;Команда цикла
 
    pop si                  ;Восстановление сохранённых регистров
    pop bx
    pop cx
    pop ax
    leave                   ;Восстановление SP и BP
    ret 8                   ;Возврат с выталкиванием 8 байт из стека

function Int64ToText(Arg: PAnsiChar; Value: Int64):integer; assembler;
var
  Ch2 : array [0..10] of Char;
  PCh1,Pch2 :PAnsiChar;
  Val : int64;
  part, n, count1,count2: integer;
begin
  Ch2 := ('          ');
  val := value;
  PCh2 := @Ch2;
  part := val mod 1000000000;
  n := val div 1000000000;
  Count1 := intToText(Arg,n);
  Count2 := intToText(PCh2,abs(part));
  Result := Count1 + Count2;
  StrCopy(StrEnd(Arg), PCh2);
end;

function IntToText(Arg: PAnsiChar; Value: Integer):integer; assembler;
asm
//Подготовка:
    push eax
    push ebx
    push ecx
    push edx
    push esi
    mov esi,eax
    mov eax,edx
    mov ebx,10               //;В BX делитель (10 для десятичной системы)
    xor ecx,ecx               //;Обнуление CX
    mov byte [esi],0
//Проверяем знак:
    test eax,eax              //;Проверка знака AX
    jns @wtsds_no_sign       //;Если >= 0, преобразуем как беззнаковое
    mov byte[esi],'-'        //;Добавление знака в начало строки
    inc esi                  //;Инкремент DI
    neg eax                  //;Изменение знака значения AX
@wtsds_no_sign:
@wtuds_lp1:                  //;Цикл получения остатков от деления
    xor edx,edx               //;Обнуление старшей части двойного слова
    div ebx                  //;Деление AX=(DX:AX)/BX, остаток в DX
    add dl,'0'              //;Преобразование остатка в код символа
    push edx                 //;Сохранение в стеке
    inc ecx                  //;Увеличение счетчика символов
    test eax,eax              //;Проверка AX
    jnz @wtuds_lp1           //;Переход к началу цикла, если частное не 0.
    mov Result,ecx
@wtuds_lp2:                  //;Цикл извлечения символов из стека
    pop edx                  //;Восстановление символа из стека
    mov [esi],edx             //;Сохранение символа в буфере
    inc esi                  //;Инкремент адреса буфера
    loop @wtuds_lp2          //;Команда цикла
    pop esi
    pop edx
    pop ecx
    pop ebx
    pop eax
end;

function Int64ToText(Arg: PAnsiChar; Value: Int64):integer; assembler;
var
  Ch1,Ch2,Ch3,Ch1_old,Ch2_old : array [0..10] of Char;
  PCh1,Pch2,PCh3,PCh1_old,PCh2_old :PAnsiChar;
  Val,n : int64;
  count, part : integer;
begin
  Ch1 := ('');
  Ch2 := ('');
  Ch3 := ('');
  Ch1_old := ('');
  Ch2_old := ('');
  val := value;
  PCh1 := @Ch1;
  PCh2 := @Ch2;
  PCh3 := @Ch3;
  PCh1_old := @Ch1_old;
  PCh2_old := @Ch2_old;
  Result := 0;
  if val < 0 then begin
    StrCopy(Arg,'-');
  end;
  //первая часть
  if (val <> 0) then begin
    part := val mod 1000000000;
    n := val div 1000000000;
    Count := IntToText(PCh1,abs(part));
    if (abs(part) < 1000000000)and(n<>0) then begin
      while Count < 9 do begin
        StrCopy(StrEnd(Pch1_old), '0');
        Inc(Count);
      end;
    end;
    StrCopy(StrEnd(Pch1_old), PCh1);

    Result := Result + Count;
  end;
  //Вторая часть
  if n <> 0 then begin
    part := n mod 1000000000;
    n := n div 1000000000;
    Count := IntToText(PCh2,abs(part));
    if (abs(part) < 1000000000)and(n<>0) then begin
      while Count < 9 do begin
        StrCopy(StrEnd(Pch2_old), '0');
        Inc(Count);
      end;
    end;
    StrCopy(StrEnd(Pch2_old), PCh2);
    Result := Result + Count;
  end;
  //третья часть
  if n <> 0 then begin
  part := n mod 10;
  Count := IntToText(PCh3,abs(part));
  Result := Result + Count;
  end;
  StrCopy(StrEnd(Arg), PCh3);
  StrCopy(StrEnd(Arg), PCh2_old);
  StrCopy(StrEnd(Arg), PCh1_old);

end;