format pe console 4.0

        include 'win32ax.inc'

.data
        FileTitle db 'c:\fasm.txt',0
        FileHandle dd ?
        BytesWritten dd ?

.code
main:
        invoke CreateFile, FileTitle, GENERIC_WRITE, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0
        test eax, eax
        je ApiError

        mov [FileHandle], eax

        invoke WriteFile, [FileHandle], FileTitle, 11, BytesWritten, 0
        test eax, eax
        je ApiError

.exit:
        invoke CloseHandle, [FileHandle]
        invoke ExitProcess, 0
.end main



ApiError:
        ; api error routine
        ;
        jmp main.exit
    

MAX_NUMBER = 104729 ; Don't put a very high number here, besides the time required to make up the list, you'll get a stack overflow.
                    ; If curious, I got a stack overflow with a list generated up to the prime number 779327 (62417 prime numbers)

format pe console
include 'win32axp.inc'

start:
      push    ebp
      mov     ebp, esp

      invoke  CreateFile, 'output.txt', GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL
      mov     ebx, eax

      mov     eax, 2
      mov     esi, 1
      push    eax
      jmp     .printPrime

align 16
.isPrime:
      lea     edi, [ebp - 4]
      add     esi, 2
      cmp     esi, MAX_NUMBER
      jbe     .isTableProcessed

      jmp     .done

  align 16
  .checkPrimality:
        mov     ecx, [edi]
        sub     edi, 4

        xor     edx, edx
        mov     eax, esi
        div     ecx

        test    edx, edx
        jz      .isPrime

      ; This code never resulted in better performance even with MAX_NUMBER = 104729*8 with an AMD Athlon64 Venice
      ;  test    eax, eax
      ;  jz      .itIsPrime

  .isTableProcessed:
        cmp     edi, esp
        jae     .checkPrimality

.itIsPrime:
      push    esi
      mov     eax, esi

.printPrime:
      mov     ecx, separator
      mov     edi, 10

  .intToStr:
        dec     ecx
        xor     edx, edx
        div     edi
        add     dl, '0'
        mov     [ecx], dl

        test    eax, eax
        jnz     .intToStr


      mov     eax, separator + sizeof.separator
      sub     eax, ecx
      invoke  WriteFile, ebx, ecx, eax, numberOfBytesWritten, NULL

      jmp     .isPrime

.done:
      leave
      invoke  CloseHandle, ebx
      invoke  ExitProcess, 0


strBuffer rb 10
separator db 13, 10
sizeof.separator = $ - separator


numberOfBytesWritten rd 1

.end start    

push    ebp
mov     ebp, esp 
    

That did work, but I still have some questions:
How do you do it for 64-bit programs? Where do you actually code the contents of the file in the program? (a buffer, maybe?) Could I append strings to the file one by one, instead of writing it all at once?

Because the entry point is not a leaf function so to do this in "the right way", I use that prologue sequence, and before calling ExitProcess I execute leave. If you remove "push ebp" and "leave", and change "lea edi, [ebp-4]" with "mov edi, ebp", the code will work OK too, but just to be safe I better leave the code as it is now.

mov   esp, ebp      
pop   ebp            
    

format PE64 GUI
entry start

include 'win64a.inc'

section '.text' code readable executable

start:  invoke CreateFile,FileTitle,GENERIC_WRITE,0,0,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,0
        test   rax,rax
        je     exit
        mov    [FileHandle], rax
        invoke WriteFile,[FileHandle],FileContent,17,BytesWritten,0
exit:   invoke CloseHandle,[FileHandle]
        invoke ExitProcess,0

section '.data' data readable writeable

  FileTitle db 'C:\Users\---\Documents\itworked.txt',0
  FileHandle dq ?
  BytesWritten dq ?
  FileContent  db 'It really worked!',0

section '.idata' import data readable writeable
  library kernel32,'KERNEL32.DLL',\
          user32,'USER32.DLL'

  include 'api\kernel32.inc'
  include 'api\user32.inc'    

Now I'm wondering what the arguments on invoke WriteFile actually do. It looks like the 17 indicates that the first 17 bytes of the character string get written. But then what is the point of the last two arguments - BytesWritten and 0? Also, CreateFile seems to be returning with 0x10 in rax. How is this related to the actual location of the file?