DIV in NASM always return 1 - linux

Question

There are my all code:
SYS_EXIT equ 1
SYS_READ equ 3
SYS_WRITE equ 4
STDIN equ 0
STDOUT equ 1
section .data
msg1 db `\xF0\x9F\x98\x8E`, " Enter the A: "
len1 equ $- msg1
msg2 db `\xF0\x9F\x98\x89`, " Than the B: "
len2 equ $- msg2
msg3 db `\xF0\x9F\x8D\xB0`, " A > B: A / B - 1 = "
len3 equ $- msg3
msg4 db `\xF0\x9F\x8D\xAA`, " A = B: -25"
len4 equ $- msg4
msg5 db `\xF0\x9F\x8D\x95`, " A < B: (B^3 - 5) / A = "
len5 equ $- msg5
section .bss
a resb 32
b resb 32
x resb 32
section .text
global _start ;must be declared for using gcc
_start: ;tell linker entry point
mov eax, SYS_WRITE
mov ebx, STDOUT
mov ecx, msg1
mov edx, len1
int 0x80
mov eax, SYS_READ
mov ebx, STDIN
mov ecx, a
mov edx, 32
int 0x80
mov eax, SYS_WRITE
mov ebx, STDOUT
mov ecx, msg2
mov edx, len2
int 0x80
mov eax, SYS_READ
mov ebx, STDIN
mov ecx, b
mov edx, 32
int 0x80
; Comparing
mov eax, [a]
sub eax, '0'
mov ecx, [b]
sub ecx, '0'
cmp eax, ecx
jg Ab ;A grate than b
je AB ;A and B are equal
jl aB ;a smoller than B
Ab:
cdq
idiv ecx
dec eax
add eax, '0'
mov [x], eax
mov eax, SYS_WRITE
mov ebx, STDOUT
mov ecx, msg3
mov edx, len3
int 0x80
mov eax, SYS_WRITE
mov ebx, STDOUT
mov ecx, x
mov edx, 32
int 0x80
jmp exit ;go to exit
AB:
mov eax, SYS_WRITE
mov ebx, STDOUT
mov ecx, msg4
mov edx, len4
int 0x80
jmp exit ;go to exit
aB:
mov eax, ecx
imul ecx
imul ecx
mov ebx, '5'
sub ebx, '0'
sub eax, ebx
mov ecx, [a]
sub ecx, '0'
idiv ecx
add eax, '0'
mov [x], eax
mov eax, SYS_WRITE
mov ebx, STDOUT
mov ecx, msg5
mov edx, len5
int 0x80
mov eax, SYS_WRITE
mov ebx, STDOUT
mov ecx, x
mov edx, 1
int 0x80
exit:
mov eax, SYS_EXIT
xor ebx, ebx
int 0x80
In 'a' and 'b' I put different number between 0 and 9 but this operation always return 1. I checked out EDX and noticed that processor subtracts ECX from EAX only one times. In EAX he write 1, and in EDX - remainder from subtraction EAX and ECX.
When I enter a = 9 and b = 4 : EAX after dividing = 1 and EDX = 5. If I enter a = 6 and b = 2 : EAX = 1, EDX = 4
What happened?

Answer 1

Presumably there's a newline character (0xA) after each of the digits. So you end up dividing 0xA09 by 0xA04. You could e.g. use movzx eax, byte [a] instead (and similarly for b).