section .data
    hello db 'Введите число: ', 0xa
    len equ $-hello
    error db 'Ошибка', 0xa
    len1 equ $-error

section .bss
    string resb 200
    factor resb 200
    reverse resb 200

section .text
    global _start
    _start:
        mov eax, 4
        mov ebx, 1
        mov ecx, hello
        mov edx, len
        int 0x80

        call .read
        mov eax, [esp]          ; Длина собщения

        push eax
        call .translate
        mov ebx, [esp +4]       ; Число

        cmp eax, 0              ;проверка на ноль
        jnz .n
        call .error
        call .exit
        .n:

        push ebx
        call .fact


        call .write

    mov eax, 1
    mov ebx, 0
    int 0x80

.read:
    mov eax, 3
    mov ebx, 0
    mov ecx, string
    mov edx, 200
    int 0x80
    mov [esp+4], eax              ;длина вводимого сообщения
ret

.translate:                         ;перевод из символов в число
    mov ebx, 10
    mov ecx, [esp+4]
    dec ecx                     ;убираем символ переноса строки
    mov esi, string         ;адрес массива стринг
    xor eax, eax            ;это как Х на доске
    .perevod:
        mul ebx             ;умножаем еах на 10
        jc .b               ;проверка на переполнение
        mov dl, [esi]
        sub dl, '0'         ;отнимаем код нуля
        add eax, edx
        inc esi
    loop .perevod
    mov [esp+8], eax                ;превратилось символы в число
    jmp .end
        .b:                 ;блок ошибки, в .fact есть проверка на 0
        mov eax, 0
        mov [esp+8], eax
    .end:
ret

.fact:
    mov ecx, factor         ;адрес начала массива factor
    mov eax, [esp+4]
    mov ebx, 2
    .e:
        xor edx, edx
        mov edi, eax        ;чтобы не портить число при возрате при делении
        div ebx             ;остаток в edx
        cmp edx, 0
        jnz .r              ;если остаток не ноль
        push eax            ;исходное число
        push ebx
        push edx
        push edi
        push ecx
        mov eax, ebx        ;делитель
        mov ebx, 10
        xor edi, edi
        mov ecx, reverse
        .y:                     ;переводим число в символы
            xor edx, edx
            div ebx
            add edx, '0'
            mov [ecx], dl
            inc ecx         ;адрес reverse
            inc edi         ;длина делителя
            cmp eax, 0
        jnz .y
        push edi            ;запоминаем длину делителя
        mov eax, ecx
        dec eax             ; последний символ в реверсе
        mov ecx, [esp+4]        ;адрес фактора
        .h:                 ;переворачиваем делитель и записываем в фактор
            mov bl, [eax]
            mov [ecx], bl
            dec eax
            inc ecx
            dec edi
            cmp edi, 0
        jnz .h
        pop edi
        pop ecx
        add ecx, edi            ;увеличиваем адрес на длину
        pop edi
        pop edx
        pop ebx
        pop eax

        mov byte [ecx], '*'
        inc ecx
        jmp .w
        .r:
        mov eax, edi            ;восстанавливаем исходное число
        inc ebx                 ;берем следующий делитель
        xor edx, edx            ;обнулюем остаток
        .w:
        cmp eax, 1
    jnz .e                  ;если еах не равно единице
    mov byte [ecx-1], 0xa

ret

.write:
    mov eax, 4
    mov ebx, 1
    mov ecx, factor
    mov edx, 200
    int 0x80
ret

.error:
    mov eax, 4
    mov ebx, 1
    mov ecx, error
    mov edx, len1
    int 0x80
ret

.exit:
  mov ebx, 0
  mov eax, 1
  int 80h
ret