Por que o código C++ para testar a hipótese de Collatz é mais rápido que a inserção manual em assembly?

Olá a todos! Estou estudando C++ e assembly, e decidi testar a hipótese de Collatz (3n+1) para números grandes. Escrevi duas versões do código: uma em C++ puro com otimizações, e a segunda com uma inserção manual em assembly para x86-64. Esperava que o assembly fosse mais rápido, mas obtive o resultado oposto.

Aqui está meu código C++ (compilado com -O2 no GCC):

#include <iostream>
#include <cstdint>

int collatz_steps(uint64_t n) {
    int steps = 0;
    while (n != 1) {
        if (n % 2 == 0) {
            n /= 2;
        } else {
            n = 3 * n + 1;
        }
        steps++;
    }
    return steps;
}

int main() {
    uint64_t max_n = 1000000;
    for (uint64_t i = 1; i <= max_n; ++i) {
        collatz_steps(i);
    }
    return 0;
}

E aqui está a versão com inserção em assembly (usando __asm no estilo MSVC):

int collatz_asm(uint64_t n) {
    int steps = 0;
    __asm {
        mov rax, n
        xor ecx, ecx        ; st