ensamblador – Violación de segmento (`core’ generado) SSE

He estado trabajando en un código en ensamblador que permita realizar una multiplicación rápida de matrices siguiendo el siguiente código en C.introducir la descripción de la imagen aquí

El código main y el código ensamblador son los siguientes

#include <iostream>

using namespace std;

extern "C" void quickMatrixMul(float* matrixNM, float* matrixMP, float* matrixNP, unsigned n, unsigned m, unsigned p);

int main(){
    float a() = {2.2,3.1,8.2,4.1,5.2,1.2,0.1,6.2,1.1,4.8,5.4,1.2,4.6,2.3};
    float b() = {1.1,2.1,3.1,4.1,5.1,6.1,7.1,8.1,9.1,10.1,11.1,12.1,13.1,14.1,15.1,16.1,17.1,18.1,19.1
    ,20.1,21.1,22.1,23.1,24.1,25.1,1.1,2.1,3.1,4.1,5.1,6.1,7.1,8.1,9.1,10.1,11.1,12.1,13.1
    ,14.1,15.1,16.1,17.1,18.1,19.1,20.1,21.1,22.1,23.1,24.1};
        float c() = {0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0};
    quickMatrixMul(&a(0), &b(0), &c(0), 2, 7, 7);
    for(int i=0; i<16; i++)
        cout << c(i) << " ";
    cout << endl;
    return 0;
}

.section .text
        .globl quickMatrixMul
quickMatrixMul:
    push    %rbx    
    mov     $0,%r10                     # i = 0 
C1:
    mov     $0, %r11                    # k = 0
    mov %r10, %rax
    imul    %r8, %rax           # i * M -> rax 
    lea     (%rdi, %rax, 0x4), %r14     # r14 = i * c * 4 + rdi === a(i)
    mov     %r10, %rbx
    imul    %r9, %rbx           # i * P -> rbx
    lea     (%rdx, %rbx, 0x4), %r15     # r15 = i * c * 4 + rdx === c(i)
    push    %r14
    push    %r15
C2:
    #mov     0x8(%rsp), %r14
    #mov    (%rsp), %r15
    mov     %r9, %rax
    imul    %r11, %rax
    lea     (%rsi, %rax, 0x4), %rax     # k * C + rsi -> rax === b(k)
    lea (%r14, %r11, 0x4), %r14     # === a(i)(k)       
    vbroadcastss  (%r14), %xmm0                 # xmm0 = a(i)(k) = r
    
    mov %r9, %r13
    and $0x3, %r13                      # p % 4 -> r13
    sub %r13, %r9                       # p - (p % 4) -> r9
    add %r9, %r13                   # p -> r13
    cmp $0, %r9
    je C3b
                                                    
    mov $0, %r12                        # j = 0
C3:
    lea (%r15, %r12, 0x4), %r15    # === c(i)(j)
    lea (%rax, %r12, 0x4), %rax    # === b(k)(j)
    movaps  (%r15), %xmm1               # xmm1 = c(i)(j, j+1, j+2, j+3)
    movaps  (%rax), %xmm2               # xmm2 = b(k)(j, j+1, j+2, j+3)
    mulps   %xmm0, %xmm2                # xmm2 = r * b(k)(j, j+1, j+2, j+3) 
    addps   %xmm2, %xmm1                # xmm1 += xmm2
    movaps  %xmm1, (%r15)
    
    add $0x4, %r12
    cmp %r9, %r12
    jl C3
    
C3b:
    cmp %r9, %r13
    je C3b_end
    
    lea (%r15, %r9, 0x4), %r15     # === c(i)(j)
    lea (%rax, %r9, 0x4), %rax     # === b(k)(j)
    movss   (%r15), %xmm1
    movss   (%rax), %xmm2
    mulss   %xmm0, %xmm2
    addss   %xmm2, %xmm1
    movss  %xmm1, (%r15)
    
    add $0x1, %r9
    cmp %r13, %r9
    jl C3b
C3b_end:    

    mov     0x8(%rsp), %r14
    mov     (%rsp), %r15
    
    add $0x1, %r11
    cmp %r8, %r11
    jl C2
    
    pop %r15
    pop %r14
    
    add $0x1, %r10
    cmp %rcx, %r10
    jl C1
end:
    mov $0, %rax
    pop %rbx
    ret

Cuando trato de hacer multiplicaciones en donde el tercer parametro es múltiplo de 4, todo funciona bien y sin problemas, sin embargo, al momento de hacer pruebas con valores diferentes de 4 me da el siguiente error Violación de segmento (`core’ generado).
He “ejecutado” el código en papel y todo parece estar bien, por eso no he logrado entender cual puede ser el problema con este código.
Cualquier ayuda será muy apreciada.