format PE GUI
entry start

include 'win32a.inc'

section '.text' code readable writable executable

start:
        lea  edi,[powerfunction]  ; location to write code
        mov  ecx,5                ; exponent
        call writecode
      movaps xmm0,dqword[numbers]
        call powerfunction        ; calculates the nth power of packed singles
      invoke ExitProcess,0

writecode:
        push edx
        mov  edx,[.mov1c]
        mov  [edi],edx
        mov  edx,[.mov1c+4]
        mov  [edi+4],edx
        add  edi,7
.1:     shr  ecx,1
        jc   .2
        mov  edx,[.mul00]
        mov  [edi],edx
        lea  edi,[edi+3]
        jnz  .1
        jmp  .3
.2:     mov  edx,[.mul10]
        mov  [edi],edx
        mov  edx,[.mul00]
        mov  [edi+3],edx
        lea  edi,[edi+6]
        jnz  .1
.3:     mov  edx,[.mov01]
        mov  [edi-3],edx
        mov  edx,[.ret]
        mov  [edi],edx
        pop  edx
        ret
.mul10:  mulps xmm1,xmm0
         nop
.mul00:  mulps xmm0,xmm0
         nop
.mov1c:  movaps xmm1,dqword[const1]
         nop
.mov01:  movaps xmm0,xmm1
         nop
.ret:    ret
         nop
         nop
         nop

align 16
powerfunction: rept 256 {nop}

section '.data' data readable writeable

Align 8
 const1  dd 1.0,1.0,1.0,1.0
 numbers dd 1.2,-3.4,5.6,7.8

section ',idata' import data readable writable

library kernel,'KERNEL32.DLL'

import kernel,\
       ExitProcess,'ExitProcess'    

crazy (loco?)

       movaps xmm0,dqword[numbers]
       movaps xmm1,dqword[const1]
        mulps xmm1,xmm0
        mulps xmm0,xmm0
        mulps xmm0,xmm0
        mulps xmm1,xmm0
        mulps xmm0,xmm0
        mulps xmm0,xmm0
        mulps xmm1,xmm0
       movaps xmm0,xmm1    

         mov  ecx,21
       movaps xmm0,dqword[numbers]
       movaps xmm1,dqword[const1]
.1:      shr  ecx,1
         jc   .2
        mulps xmm0,xmm0
         jnz  .1
         jmp  .3
.2:     mulps xmm1,xmm0
        mulps xmm0,xmm0
         jnz  .1
.3:    movaps xmm0,xmm1    

MAX_POW equ 128

format pe console
include 'win32ax.inc'

      sub      esp, 16
      and      esp, -16
      xor      ebx, ebx

.loop:
      mov      eax, [.const2]
      mov      edx, [.const2+4]
      mov      [esp], eax
      mov      [esp+4], edx
      mov      eax, [.const2+8]
      mov      edx, [.const2+12]
      mov      [esp+8], eax
      mov      [esp+12], edx

      mov      eax, esp
      mov      ecx, ebx
      call     pow

      cvtss2sd xmm0, [esp]
      movaps   [esp], xmm0
      mov      eax, esp

      cinvoke  printf, <"%f", 10>, dword [eax], dword [eax+4]

      inc      ebx
      cmp      ebx, MAX_POW
      jbe       .loop

      cinvoke system, "pause"
  invoke  ExitProcess, 0

.const2 dd 2.0, 2.0, 2.0, 2.0

;;;;;;
;;;;;; POW code (There should be MAX_POW versions of your loop actually with their respective pow cases inlined)
;;;;;;
align 16
pow.const1 dd 1.0, 1.0, 1.0, 1.0
pow: ; Assumes valid numbers (i.e. no NaNs, INFs, etc.)
     ; Assumes ECX = [0..MAX_POW]

      movaps   xmm0, dqword [.const1]
      movaps   xmm1, [eax]

      jmp      [.powTable+ecx*4]

align 16
.pow0: ; Is it OK for 0^0?
      movaps   [eax], xmm0

      ret

align 16
.pow1:
      ret

rept (MAX_POW) - 1 power:2
{
common
  local i

forward
local ..powX

  i = power

align 16
..powX:

  while i > 0

    if i mod 2

      mulps   xmm0, xmm1
    end if
    if i > 1

      mulps   xmm1, xmm1
    end if

    i = i / 2
  end while
      movaps  [eax], xmm0

      ret
common

align 64
.powTable dd .pow0, .pow1

forward
  dd ..powX
}

align 4 ; Just to be safe
data import 
  library kernel32, 'kernel32.dll',\
          msvcrt,'msvcrt.dll'

  import kernel32,\
         ExitProcess, 'ExitProcess'

  import msvcrt,\
         printf, 'printf',\
         system, 'system'
end data    

include '/fasminc/unistd64.inc' ;dig for this in the macros section
format ELF64 executable at 0x100000000
entry $
       pop rax ;number of params, which we won't need unless we want to error check (pointless as this is just a tut)
     pop r13 ;program path, which we'll need later
      pop r12 ;current message

        syscalls sys_write, STDOUT, msg1, msg2-msg1
 syscalls sys_write, STDOUT, storage, DWORD [oldmsgsize]
     syscalls sys_write, STDOUT, msg2, oldmsgsize-msg2
   syscalls sys_unlink, r13 ;Don't know why, but you can only write to a running process if (a) you are not the process or (b) you delete yourself first
      syscalls sys_open, r13, O_RDWR or O_CREAT, 448 ;The last param's official name is so ugly you're more likely to remember the number than it

   mov ebx, eax
        mov rsi, r12
        lea rdi, [storage]
@@:   lodsb
       stosb
       or al, al
   jnz @b
      sub rsi, r12
        mov r14, rsi
        mov [oldmsgsize], esi

   syscalls sys_write, ebx, 0x100000000, endprog-0x100000000
   syscalls sys_write, STDOUT, r12, r14
        syscalls sys_write, STDOUT, newline, 1
      syscalls sys_close, ebx
     syscalls sys_exit
;=================================================================================================================================
storage rb 32
msg1 db "Old message was: "
msg2 db 10, "Current message is: "
oldmsgsize dd 0
newline db 10
;=================================================================================================================================
endprog: