Esta claro que tenes problemas con la logica, si te resulta imposible imaginar lo que va haciendo el programa entonces tenes que depurarlo linea por linea, que es lo ideal, o cuanto menos ayudarte generando una salida en pantalla.

cout << "menor " << menor << " pila.top " << pila.top() << endl;  
if ( pila.top() < menor ) 
{
  cout << "CAMBIANDO menor, era " << menor << " sera " << pila.top() << endl; 
  menor = pila.top();
}

El valor de retorno de top es 10, no por ese comentario, es 10 por el simple hecho de que en la linea 21 el ultimo llamado a push tuvo como parametro 10. ¿Como puede ser que? ¿Que menor sea 10? Se le asigna ese valor en la linea 27. No hay ninguna incoherencia y una vez asignado el resultado de pila.top a menor, linea 27, deberias llamar a pila.pop, esa primera comparacion que haces es futil.

Ese 0x70 o 0xA0 esta muy pasado de los bytes necesarios para las 2 estructuras ya que estas empujando 8 bytes en cada iteracion del bucle. RCX deberia ser 0x10 (o simplemente restar 0x80) y despues deberias restarle 0x50 en lugar de 0x58.

Igual sinceramente no se que te impide acomodar la pila de una vez como hace el VC++.

Sin usar ninguna variable local tenes que restarle 0x58 a la pila, eso es lo minimo indispensable. 0x20 para el shadow space, 0x30 para los parametros que necesita la funcion (son 10 en total, 4 en registros y 6 en pila, 6 * 8 = 0x30) y 8 para alinear la pila a 16.

No me voy a poner a hacer ese trabajo a mano para las variables locales pero aca tenes un ejemplo generado por VC++:

  0000000000000000: 48 8B C4           mov         rax,rsp
  0000000000000003: 48 81 EC E8 00 00  sub         rsp,0E8h
                    00
  000000000000000A: 33 D2              xor         edx,edx
  000000000000000C: C7 40 08 63 6D 64  mov         dword ptr [rax+8],646D63h
                    00
  0000000000000013: 48 8D 48 8C        lea         rcx,[rax-74h]
  0000000000000017: 44 8D 42 64        lea         r8d,[rdx+64h]
  000000000000001B: E8 00 00 00 00     call        memset
  0000000000000020: 48 8D 44 24 50     lea         rax,[rsp+50h]
  0000000000000025: C7 44 24 70 68 00  mov         dword ptr [rsp+70h],68h
                    00 00
  000000000000002D: 48 89 44 24 48     mov         qword ptr [rsp+48h],rax
  0000000000000032: 48 8D 8C 24 F0 00  lea         rcx,[rsp+0F0h]
                    00 00
  000000000000003A: 48 8D 44 24 70     lea         rax,[rsp+70h]
  000000000000003F: 45 33 C9           xor         r9d,r9d
  0000000000000042: 48 89 44 24 40     mov         qword ptr [rsp+40h],rax
  0000000000000047: 45 33 C0           xor         r8d,r8d
  000000000000004A: 33 C0              xor         eax,eax
  000000000000004C: 33 D2              xor         edx,edx
  000000000000004E: 48 89 44 24 38     mov         qword ptr [rsp+38h],rax
  0000000000000053: 48 89 44 24 30     mov         qword ptr [rsp+30h],rax
  0000000000000058: 89 44 24 28        mov         dword ptr [rsp+28h],eax
  000000000000005C: C7 44 24 20 01 00  mov         dword ptr [rsp+20h],1
                    00 00
  0000000000000064: FF 15 00 00 00 00  call        qword ptr [__imp_CreateProcessA]
  000000000000006A: 33 C0              xor         eax,eax
  000000000000006C: 48 81 C4 E8 00 00  add         rsp,0E8h
                    00
  0000000000000073: C3                 ret

Al llamar a CreateProcessA en RSP + 0x20 arrancan los parametros (antes esta el shadow space), en RSP + 0x50 la estructura PROCESS_INFORMATION, en RSP + 0x70 la estructura STARTUPINFOA y en RSP + 0xF0 esta la cadena 'cmd\0'.

El entry point en Windows x64 esta alineado a 8 bytes. Teniendo en cuenta el ultimo codigo le estas restando 8 (primer push rdx), 0x400 - 0x80 * 8 - (push rdx dentro del loop) y 0x58 (sub rsp, 0x58). Un total de 0x460 y por lo tanto desalineado.

No, no se dice eso, sacaste la parte del prologo, DENTRO del prologo se puede dejar la pila desalineada momentaneamente, eso es lo que dice. Si todavia no entendes lo que esta dentro del prologo lee de nuevo:
https://en.wikipedia.org/wiki/Function_prologue_and_epilogue

¿A que se refiere con excepto? ¿Es una pregunta en serio? ¿De verdad? Me rindo por un tiempo.

Las instrucciones que momentaneamente pueden dejar la pila desalineada.

https://en.wikipedia.org/wiki/Function_prologue_and_epilogue

"There are basically two types of functions. A function that requires a stack frame is called a frame function. A function that does not require a stack frame is called a leaf function."
https://docs.microsoft.com/en-us/cpp/build/stack-usage?view=msvc-170

rdx edx dx dl
https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/x64-architecture

Si. "The stack will always be maintained 16-byte aligned, except within the prolog (for example, after the return address is pushed), and except where indicated in Function Types for a certain class of frame functions."

https://docs.microsoft.com/en-us/cpp/build/stack-usage?view=msvc-170

Y es basicamente lo mismo para AMD64 System V ABI (https://coderedirect.com/questions/51914/why-does-the-x86-64-amd64-system-v-abi-mandate-a-16-byte-stack-alignment).

Por cierto asi provoque el mismo error, en cuanto hace un syscall se detecta el problema:

entry:
push dx ;;;;;;;;;;;;;
mov qword ptr [rsp + 030h], 0
mov dword ptr [rsp + 028h], 80
mov dword ptr [rsp + 020h], 2  
mov r9d, 0
mov r8d, 0
mov edx, 040000000h
lea rcx, offset msg
call CreateFileA
int 3

(299c.368c): Break instruction exception - code 80000003 (first chance)
cfe!entry+0x43:
00007ff7`74391043 cc              int     3
0:000> r eax
eax=ffffffff
0:000> !gle
LastErrorValue: (Win32) 0x3e6 (998) - Invalid access to memory location.
LastStatusValue: (NTSTATUS) 0x80000002 - {EXCEPTION}  Alignment Fault  A datatype misalignment was detected in a load or store instruction.

En teoria no deberia ser un problema del primer parametro pasado a CreateFileA, esto funciona por ejemplo:

extrn CreateFileA:   PROC
 
PUBLIC entry
.data
msg db "hello.txt", 0
 
.code
entry:
mov qword ptr [rsp + 030h], 0 
mov dword ptr [rsp + 028h], 80
mov dword ptr [rsp + 020h], 2  
mov r9d, 0
mov r8d, 0
mov edx, 040000000h
lea rcx, offset msg
inc rcx
call CreateFileA

Adivinando (jugar con un depurador e intentar hacer una llamada es algo ambiguo, podes estar escribiendo codigo a mano dentro de la memoria del proceso por ejemplo) te diria que la pila en si misma, RSP, puede estar desalineada.

¿Que parte no entendes de que es un array de punteros a cadena? ¿Ves el *? Tal vez asi lo entiendas mejor:
char *s[20];

---

Un puntero a cadena:
char *s;
20 punteros a cadena:
char *s[20];

Una cadena de 20 caracteres (incluyendo el cero terminador o caracter nulo, si, obviamente):
char s[20];

---

Y si, alguna idea al respecto tengo:


https://foro.elhacker.net/buscador2-t259688.0.html;msg1262234#msg1262234