(1)
printf, "\n\tTried %u times\n\n", 10000000

(2)
mov eax, 3.14159265

(3)
.if st0 ge balance
   printf, "\tOver draft\n"
.endif

(4)
eax = ebx+ecx*edx

(5)
if a function have been declared or prototyped it's signatures should be used to enable high-level function calling.

(6)
Duplicate string constants should be merges into one.

eg:
   scanf "%f", addr bal
   scanf "%f", addr rate   

(7)
If, While construct should be implemented in Fasm itself and should not be
just emulated by macros.

(8)
Same for high level function declarations, local variables, structures
etc. they too should be implemented in Fasm itself.

(9)
Signed and unsigned comparisons in Constructs (If, while etc) may be
distinguished by using Mneomnic look alikes.
eg:
    ; signed
    .if eax ge 5
    .end if

    ; unsigned
    .if eax ae 5
    .end if

(10)
Full support for structures at Fasm level. (non macro)

(11)
Buildin preprocessed and assembled listings are missing.

(12)
Finally i believe that this should be compilable under core Fasm i.e. no
macro preprocessor emulation:

void sort(dword *array, dword length)
{
    for (eax = 0; eax < length; eax++)
    {
       for (ebx = 0; ebx < length-eax; ebx++)
       {
           edx = ebx + 1
           if (array[ebx] > array[edx])
           {
              ecx = array[ebx];
              array[ebx] = array[edx];
              array[edx] = ecx; 
            }
       }
    }
}

    

Day Dreaming is Productive Too

Except for the "mov eax, 3.14159265". which is pretty valid with fasm.

mov eax, 3,14159265    

Pity is Good.

He allows it because floating point number can be represented by dword value. and dword value can be stored in EAX. But i was asking WHY to do it, not if it is possible.

         cmp ebx, 5
         jb .lesser
         mov eax, 5.5
         jmp .rate_set
.lesser:
         mov eax, 2.2
         jmp .rate_set
         ;
         ; ...
         ;
.rate_set:
        mov [interest_rate], eax
        jmp .do_prinitng
       ;
       ; ...
       ;
    

this work? i am not sure about structure of flotaing point numbers, but i wouldn't count on this

Yeah, it works.
Count on me.

mov eax, -1  ;10111111100000...
cmp eax, 1    ;00111111100000...
jb lesser ;doesn't jump    

mov eax, 1  ;001111111000000...
cmp eax, 2  ;010000000000000...
jl lesser ;doesn't jump    

He allows it because floating point number can be represented by dword value. and dword value can be stored in EAX. But i was asking WHY to do it, not if it is possible.

MOV    ecx, [v_FLOAT]
XOR    edx, edx
CMP    ecx, 1084227584
SETE   dl
MOV    [v_A], edx
    

FLD    dword [v_FLOAT]
FLD    dword [F0]
XOr    ecx, ecx
FCOMIP st1
FSTP st0
JZ     rq_L1
MOV    ecx, 1
rq_L1:
MOV    [v_A], ecx
..
F0 dd 1085276160