LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/vec.c
// Function: moonglmath_vec_dot
double vec_dot(vec_t v1, vec_t v2, size_t n)
/* dot product */
    {
    size_t i;
    double s = 0;
    for(i=0; i < n; i++)    
        s += (v1[i]*v2[i]);
    return s;
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x18(%rsp), %rax
jae 0x1f40f
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x28(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rsp)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x1f3c1
movsd -0x28(%rsp), %xmm0
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/vec.c
// Function: moonglmath_vec_vxv
void vec_vxv(mat_t dst, vec_t v1, vec_t v2, size_t n)
/* v1 is a nx1 column vector
 * v2 is a 1xn row vector
 * m is a nxn square matrix (n x 1) * (1 x n) = (n x n)
 */
    {
    size_t i, j;
    for(i=0; i < n; i++)
        for(j=0; j < n; j++)
            dst[i][j] = v1[i] * v2[j];
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq $0x0, -0x28(%rsp)
movq -0x28(%rsp), %rax
cmpq -0x20(%rsp), %rax
jae 0x1f519
movq $0x0, -0x30(%rsp)
movq -0x30(%rsp), %rax
cmpq -0x20(%rsp), %rax
jae 0x1f507
movq -0x10(%rsp), %rax
movq -0x28(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rsp), %rax
movq -0x30(%rsp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movq -0x8(%rsp), %rax
movq -0x28(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq -0x30(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rsp)
jmp 0x1f4b2
jmp 0x1f509
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x1f49d
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/vec.c
// Function: moonglmath_vec_cross
void vec_cross(vec_t dst, vec_t v1, vec_t v2)
/* dst is always to be regarded as a size=3 vector */
    {
    dst[0] = v1[1]*v2[2] - v1[2]*v2[1];
    dst[1] = v1[2]*v2[0] - v1[0]*v2[2];
    dst[2] = v1[0]*v2[1] - v1[1]*v2[0];
    dst[3] = 0;
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rsp), %rax
movsd 0x10(%rax), %xmm2
movq -0x10(%rsp), %rax
movsd 0x10(%rax), %xmm1
movq -0x18(%rsp), %rax
mulsd 0x8(%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rsp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq -0x18(%rsp), %rax
movsd (%rax), %xmm2
movq -0x10(%rsp), %rax
movsd (%rax), %xmm1
movq -0x18(%rsp), %rax
mulsd 0x10(%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x10(%rsp), %rax
movsd (%rax), %xmm0
movq -0x18(%rsp), %rax
movsd 0x8(%rax), %xmm2
movq -0x10(%rsp), %rax
movsd 0x8(%rax), %xmm1
movq -0x18(%rsp), %rax
mulsd (%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x8(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/vec.c
// Function: moonglmath_vec_Norm
int vec_Norm(lua_State *L)
    {
    vec_t v;
    size_t size, i;
    double r = 0;
    checkvec(L, 1, v, &size, NULL);
    for(i=0; i < size; i++) 
        r += v[i]*v[i];
    lua_pushnumber(L, sqrt(r));
    return 1;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movl $0x1, %esi
leaq 0x18(%rsp), %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x86d0
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x1f94f
movq 0x10(%rsp), %rax
movsd 0x20(%rsp,%rax,8), %xmm0
movq 0x10(%rsp), %rax
movsd 0x20(%rsp,%rax,8), %xmm2
movsd 0x8(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x1f909
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x8db0
movq (%rsp), %rdi
callq 0x8840
movl $0x1, %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/vec.c
// Function: moonglmath_vec_Norm2
int vec_Norm2(lua_State *L)
    {
    vec_t v;
    size_t size, i;
    double r = 0;
    checkvec(L, 1, v, &size, NULL);
    for(i=0; i < size; i++)
        r += v[i]*v[i];
    lua_pushnumber(L, r);
    return 1;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movl $0x1, %esi
leaq 0x18(%rsp), %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x86d0
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x1f9ff
movq 0x10(%rsp), %rax
movsd 0x20(%rsp,%rax,8), %xmm0
movq 0x10(%rsp), %rax
movsd 0x20(%rsp,%rax,8), %xmm2
movsd 0x8(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x1f9b9
movq 0x40(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x8840
movl $0x1, %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/vec.c
// Function: moonglmath_vec_Clamp
int vec_Clamp(lua_State *L)
    {
    vec_t dst, v, minv, maxv;
    size_t size, size1;
    unsigned int isrow, isrow1;
    checkvec(L, 1, v, &size, &isrow);
    checkvec(L, 2, minv, &size1, &isrow1);
    if(size1 != size || isrow1 != isrow)
        return luaL_error(L, OPERANDS_ERROR);
    checkvec(L, 3, maxv, &size1, &isrow1);
    if(size1 != size || isrow1 != isrow)
        return luaL_error(L, OPERANDS_ERROR);
    vec_clamp(dst, v, minv, maxv, size);
    return pushvec(L, dst, size, size, isrow);
    }

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq 0xa8(%rsp), %rdi
leaq 0x60(%rsp), %rdx
movl $0x1, %esi
leaq 0x18(%rsp), %rcx
leaq 0xc(%rsp), %r8
callq 0x86d0
movq 0xa8(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movl $0x2, %esi
leaq 0x10(%rsp), %rcx
leaq 0x8(%rsp), %r8
callq 0x86d0
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jne 0x1fb47
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
je 0x1fb75
movq 0xa8(%rsp), %rdi
leaq 0x3a6a(%rip), %rsi      # 0x235c0
leaq 0x3f06(%rip), %rdx      # 0x23a63
movl $0x234, %ecx            # imm = 0x234
movb $0x0, %al
callq 0x8b30
movl %eax, 0xb4(%rsp)
jmp 0x1fc23
movq 0xa8(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movl $0x3, %esi
leaq 0x10(%rsp), %rcx
leaq 0x8(%rsp), %r8
callq 0x86d0
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jne 0x1fbac
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
je 0x1fbd7
movq 0xa8(%rsp), %rdi
leaq 0x3a05(%rip), %rsi      # 0x235c0
leaq 0x3ea1(%rip), %rdx      # 0x23a63
movl $0x237, %ecx            # imm = 0x237
movb $0x0, %al
callq 0x8b30
movl %eax, 0xb4(%rsp)
jmp 0x1fc23
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x40(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
callq 0x8510
movq 0xa8(%rsp), %rdi
leaq 0x80(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x18(%rsp), %rcx
movl 0xc(%rsp), %r8d
callq 0x8310
movl %eax, 0xb4(%rsp)
movl 0xb4(%rsp), %eax
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/vec.c
// Function: moonglmath_vec_Mix
int vec_Mix(lua_State *L)
    {
    vec_t dst, v1, v2;
    double k;
    size_t size, size1;
    unsigned int isrow, isrow1;
    checkvec(L, 1, v1, &size, &isrow);
    checkvec(L, 2, v2, &size1, &isrow1);
    if(size1 != size || isrow1 != isrow)
        return luaL_error(L, OPERANDS_ERROR);
    k = luaL_checknumber(L, 3);
    vec_mix(dst, v1, v2, size, k);
    return pushvec(L, dst, size, size, isrow);
    }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq 0x88(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movl $0x1, %esi
leaq 0x10(%rsp), %rcx
leaq 0x4(%rsp), %r8
callq 0x86d0
movq 0x88(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movl $0x2, %esi
leaq 0x8(%rsp), %rcx
movq %rsp, %r8
callq 0x86d0
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x1fca4
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
je 0x1fccf
movq 0x88(%rsp), %rdi
leaq 0x390d(%rip), %rsi      # 0x235c0
leaq 0x3da9(%rip), %rdx      # 0x23a63
movl $0x245, %ecx            # imm = 0x245
movb $0x0, %al
callq 0x8b30
movl %eax, 0x94(%rsp)
jmp 0x1fd2e
movq 0x88(%rsp), %rdi
movl $0x3, %esi
callq 0x8350
movsd %xmm0, 0x18(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq 0x10(%rsp), %rcx
movsd 0x18(%rsp), %xmm0
callq 0x8230
movq 0x88(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x10(%rsp), %rcx
movl 0x4(%rsp), %r8d
callq 0x8310
movl %eax, 0x94(%rsp)
movl 0x94(%rsp), %eax
addq $0x98, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/vec.c
// Function: moonglmath_vec_Step
int vec_Step(lua_State *L)
    {
    vec_t dst, v1, edge;
    double k;
    size_t size, size1;
    unsigned int isrow, isrow1;
    checkvec(L, 1, v1, &size, &isrow);
    if(lua_isnumber(L, 2))
        {
        k = lua_tonumber(L, 2);
        edge[0]=edge[1]=edge[2]=edge[3]=k;
        }
    else
        {
        checkvec(L, 2, edge, &size1, &isrow1);
        if(size1 != size || isrow1 != isrow)
            return luaL_error(L, OPERANDS_ERROR);
        }
    vec_step(dst, v1, edge, size);
    return pushvec(L, dst, size, size, isrow);
    }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq 0x88(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movl $0x1, %esi
leaq 0x10(%rsp), %rcx
leaq 0x4(%rsp), %r8
callq 0x86d0
movq 0x88(%rsp), %rdi
movl $0x2, %esi
callq 0x85a0
cmpl $0x0, %eax
je 0x1fdc3
movq 0x88(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x8680
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
jmp 0x1fe24
movq 0x88(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movl $0x2, %esi
leaq 0x8(%rsp), %rcx
movq %rsp, %r8
callq 0x86d0
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x1fdf7
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
je 0x1fe22
movq 0x88(%rsp), %rdi
leaq 0x37ba(%rip), %rsi      # 0x235c0
leaq 0x3c56(%rip), %rdx      # 0x23a63
movl $0x25b, %ecx            # imm = 0x25B
movb $0x0, %al
callq 0x8b30
movl %eax, 0x94(%rsp)
jmp 0x1fe65
jmp 0x1fe24
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x8b90
movq 0x88(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x10(%rsp), %rcx
movl 0x4(%rsp), %r8d
callq 0x8310
movl %eax, 0x94(%rsp)
movl 0x94(%rsp), %eax
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/vec.c
// Function: moonglmath_vec_Smoothstep
int vec_Smoothstep(lua_State *L)
    {
    vec_t dst, v, edge0, edge1;
    double k;
    size_t size, size1;
    unsigned int isrow, isrow1;
    checkvec(L, 1, v, &size, &isrow);
    if(lua_isnumber(L, 2))
        {
        k = lua_tonumber(L, 2);
        edge0[0]=edge0[1]=edge0[2]=edge0[3]=k;
        }
    else
        {
        checkvec(L, 2, edge0, &size1, &isrow1);
        if(size1 != size || isrow1 != isrow)
            return luaL_error(L, OPERANDS_ERROR);
        }
    if(lua_isnumber(L, 3))
        {
        k = lua_tonumber(L, 3);
        edge1[0]=edge1[1]=edge1[2]=edge1[3]=k;
        }
    else
        {
        checkvec(L, 3, edge1, &size1, &isrow1);
        if(size1 != size || isrow1 != isrow)
            return luaL_error(L, OPERANDS_ERROR);
        }
    vec_smoothstep(dst, v, edge0, edge1, size);
    return pushvec(L, dst, size, size, isrow);
    }

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq 0xa8(%rsp), %rdi
leaq 0x60(%rsp), %rdx
movl $0x1, %esi
leaq 0x10(%rsp), %rcx
leaq 0x4(%rsp), %r8
callq 0x86d0
movq 0xa8(%rsp), %rdi
movl $0x2, %esi
callq 0x85a0
cmpl $0x0, %eax
je 0x1ff03
movq 0xa8(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x8680
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x58(%rsp)
movsd %xmm0, 0x50(%rsp)
movsd %xmm0, 0x48(%rsp)
movsd %xmm0, 0x40(%rsp)
jmp 0x1ff67
movq 0xa8(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movl $0x2, %esi
leaq 0x8(%rsp), %rcx
movq %rsp, %r8
callq 0x86d0
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x1ff37
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
je 0x1ff65
movq 0xa8(%rsp), %rdi
leaq 0x367a(%rip), %rsi      # 0x235c0
leaq 0x3b16(%rip), %rdx      # 0x23a63
movl $0x272, %ecx            # imm = 0x272
movb $0x0, %al
callq 0x8b30
movl %eax, 0xb4(%rsp)
jmp 0x20067
jmp 0x1ff67
movq 0xa8(%rsp), %rdi
movl $0x3, %esi
callq 0x85a0
cmpl $0x0, %eax
je 0x1ffba
movq 0xa8(%rsp), %rdi
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x8680
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
jmp 0x2001b
movq 0xa8(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movl $0x3, %esi
leaq 0x8(%rsp), %rcx
movq %rsp, %r8
callq 0x86d0
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x1ffee
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
je 0x20019
movq 0xa8(%rsp), %rdi
leaq 0x35c3(%rip), %rsi      # 0x235c0
leaq 0x3a5f(%rip), %rdx      # 0x23a63
movl $0x27d, %ecx            # imm = 0x27D
movb $0x0, %al
callq 0x8b30
movl %eax, 0xb4(%rsp)
jmp 0x20067
jmp 0x2001b
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x40(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0x8690
movq 0xa8(%rsp), %rdi
leaq 0x80(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x10(%rsp), %rcx
movl 0x4(%rsp), %r8d
callq 0x8310
movl %eax, 0xb4(%rsp)
movl 0xb4(%rsp), %eax
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/vec.c
// Function: moonglmath_vec_Fade
int vec_Fade(lua_State *L)
    {
    vec_t dst, v, edge0, edge1;
    double k;
    size_t size, size1;
    unsigned int isrow, isrow1;
    checkvec(L, 1, v, &size, &isrow);
    if(lua_isnumber(L, 2))
        {
        k = lua_tonumber(L, 2);
        edge0[0]=edge0[1]=edge0[2]=edge0[3]=k;
        }
    else
        {
        checkvec(L, 2, edge0, &size1, &isrow1);
        if(size1 != size || isrow1 != isrow)
            return luaL_error(L, OPERANDS_ERROR);
        }
    if(lua_isnumber(L, 3))
        {
        k = lua_tonumber(L, 3);
        edge1[0]=edge1[1]=edge1[2]=edge1[3]=k;
        }
    else
        {
        checkvec(L, 3, edge1, &size1, &isrow1);
        if(size1 != size || isrow1 != isrow)
            return luaL_error(L, OPERANDS_ERROR);
        }
    vec_fade(dst, v, edge0, edge1, size);
    return pushvec(L, dst, size, size, isrow);
    }

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq 0xa8(%rsp), %rdi
leaq 0x60(%rsp), %rdx
movl $0x1, %esi
leaq 0x10(%rsp), %rcx
leaq 0x4(%rsp), %r8
callq 0x86d0
movq 0xa8(%rsp), %rdi
movl $0x2, %esi
callq 0x85a0
cmpl $0x0, %eax
je 0x20103
movq 0xa8(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x8680
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x58(%rsp)
movsd %xmm0, 0x50(%rsp)
movsd %xmm0, 0x48(%rsp)
movsd %xmm0, 0x40(%rsp)
jmp 0x20167
movq 0xa8(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movl $0x2, %esi
leaq 0x8(%rsp), %rcx
movq %rsp, %r8
callq 0x86d0
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x20137
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
je 0x20165
movq 0xa8(%rsp), %rdi
leaq 0x347a(%rip), %rsi      # 0x235c0
leaq 0x3916(%rip), %rdx      # 0x23a63
movl $0x293, %ecx            # imm = 0x293
movb $0x0, %al
callq 0x8b30
movl %eax, 0xb4(%rsp)
jmp 0x20267
jmp 0x20167
movq 0xa8(%rsp), %rdi
movl $0x3, %esi
callq 0x85a0
cmpl $0x0, %eax
je 0x201ba
movq 0xa8(%rsp), %rdi
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x8680
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
jmp 0x2021b
movq 0xa8(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movl $0x3, %esi
leaq 0x8(%rsp), %rcx
movq %rsp, %r8
callq 0x86d0
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x201ee
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
je 0x20219
movq 0xa8(%rsp), %rdi
leaq 0x33c3(%rip), %rsi      # 0x235c0
leaq 0x385f(%rip), %rdx      # 0x23a63
movl $0x29e, %ecx            # imm = 0x29E
movb $0x0, %al
callq 0x8b30
movl %eax, 0xb4(%rsp)
jmp 0x20267
jmp 0x2021b
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x40(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0x8130
movq 0xa8(%rsp), %rdi
leaq 0x80(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x10(%rsp), %rcx
movl 0x4(%rsp), %r8d
callq 0x8310
movl %eax, 0xb4(%rsp)
movl 0xb4(%rsp), %eax
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/vec.c
// Function: Concat
static int Concat(lua_State *L)
    {
    vec_t v;
    size_t size;
    unsigned int isrow;
    if(testvec(L, 1, v, &size, &isrow))
        {
        ToString_(L, v, size, isrow);
        lua_pushvalue(L, 2);
        }
    else if(testvec(L, 2, v, &size, &isrow))
        {
        lua_pushvalue(L, 1);
        ToString_(L, v, size, isrow);
        }
    else 
        return unexpected(L);
    lua_concat(L, 2);
    return 1;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movl $0x1, %esi
leaq 0x8(%rsp), %rcx
leaq 0x4(%rsp), %r8
callq 0x8b00
cmpl $0x0, %eax
je 0x20375
movq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movl 0x4(%rsp), %ecx
callq 0x20a10
movq 0x38(%rsp), %rdi
movl $0x2, %esi
callq 0x8650
jmp 0x203e8
movq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movl $0x2, %esi
leaq 0x8(%rsp), %rcx
leaq 0x4(%rsp), %r8
callq 0x8b00
cmpl $0x0, %eax
je 0x203c1
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x8650
movq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movl 0x4(%rsp), %ecx
callq 0x20a10
jmp 0x203e6
movq 0x38(%rsp), %rdi
leaq 0x2ca7(%rip), %rsi      # 0x23074
leaq 0x368f(%rip), %rdx      # 0x23a63
movl $0xe4, %ecx
movb $0x0, %al
callq 0x8b30
movl %eax, 0x44(%rsp)
jmp 0x203ff
jmp 0x203e8
movq 0x38(%rsp), %rdi
movl $0x2, %esi
callq 0x8ca0
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/vec.c
// Function: Unm
static int Unm(lua_State *L)
    {
    vec_t v; 
    size_t size, i; 
    unsigned int isrow;
    checkvec(L, 1, v, &size, &isrow);
    for(i=0; i < 4; i++)    
        v[i] = -v[i];
    return pushvec(L, v, size, size, isrow);
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movl $0x1, %esi
leaq 0x18(%rsp), %rcx
leaq 0xc(%rsp), %r8
callq 0x86d0
movq $0x0, 0x10(%rsp)
cmpq $0x4, 0x10(%rsp)
jae 0x20485
movq 0x10(%rsp), %rax
movsd 0x20(%rsp,%rax,8), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, 0x20(%rsp,%rax,8)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x20440
movq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x18(%rsp), %rcx
movl 0xc(%rsp), %r8d
callq 0x8310
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/vec.c
// Function: Add
static int Add(lua_State *L)
    {
    vec_t v, v1; 
    size_t size, size1, i; 
    unsigned int isrow, isrow1;
    checkvec(L, 1, v, &size, &isrow);
    checkvec(L, 2, v1, &size1, &isrow1);
    if((isrow != isrow1) || (size != size1))
        return luaL_error(L, OPERANDS_ERROR);
    for(i=0; i < size; i++) 
        v[i] += v1[i];
    return pushvec(L, v, size, size, isrow);
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq 0x68(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movl $0x1, %esi
leaq 0x18(%rsp), %rcx
leaq 0x4(%rsp), %r8
callq 0x86d0
movq 0x68(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movl $0x2, %esi
leaq 0x10(%rsp), %rcx
movq %rsp, %r8
callq 0x86d0
movl 0x4(%rsp), %eax
cmpl (%rsp), %eax
jne 0x20508
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x2052d
movq 0x68(%rsp), %rdi
leaq 0x30ac(%rip), %rsi      # 0x235c0
leaq 0x3548(%rip), %rdx      # 0x23a63
movl $0x18b, %ecx            # imm = 0x18B
movb $0x0, %al
callq 0x8b30
movl %eax, 0x74(%rsp)
jmp 0x20590
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x2056e
movq 0x8(%rsp), %rax
movsd 0x20(%rsp,%rax,8), %xmm0
movq 0x8(%rsp), %rax
addsd 0x40(%rsp,%rax,8), %xmm0
movsd %xmm0, 0x40(%rsp,%rax,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x20536
movq 0x68(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x18(%rsp), %rcx
movl 0x4(%rsp), %r8d
callq 0x8310
movl %eax, 0x74(%rsp)
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/vec.c
// Function: Mul
static int Mul(lua_State *L)
    {
    vec_t v, v1; 
    size_t size, size1, i; 
    unsigned int isrow, isrow1;
    double r = 0;
    if(lua_isnumber(L, 1))
        return Vxs(L, 1, 2);
    if(lua_isnumber(L, 2))
        return Vxs(L, 2, 1);
    if(testmat(L, 2, NULL, NULL, NULL))
        return Vxm(L);
    checkvec(L, 1, v, &size, &isrow);
    checkvec(L, 2, v1, &size1, &isrow1);
    if((!isrow) && isrow1) /* Nx1 * 1xM = NxM */
        return Vxv(L, v, size, v1, size1);
    if(size != size1)
        return luaL_error(L, OPERANDS_ERROR);
    /* dot product:  1*N * Nx1, but also Nx1 * Nx1 and 1xN * 1*N are admitted */
    for(i=0; i < size; i++) 
        r += (v[i]*v1[i]);
    lua_pushnumber(L, r);
    return 1;
    }

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x78(%rsp), %rdi
movl $0x1, %esi
callq 0x85a0
cmpl $0x0, %eax
je 0x206d9
movq 0x78(%rsp), %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x20c80
movl %eax, 0x84(%rsp)
jmp 0x20854
movq 0x78(%rsp), %rdi
movl $0x2, %esi
callq 0x85a0
cmpl $0x0, %eax
je 0x2070d
movq 0x78(%rsp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x20c80
movl %eax, 0x84(%rsp)
jmp 0x20854
movq 0x78(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdx
movq %r8, %rcx
callq 0x8a30
cmpl $0x0, %eax
je 0x20742
movq 0x78(%rsp), %rdi
callq 0x20d20
movl %eax, 0x84(%rsp)
jmp 0x20854
movq 0x78(%rsp), %rdi
leaq 0x50(%rsp), %rdx
movl $0x1, %esi
leaq 0x28(%rsp), %rcx
leaq 0x14(%rsp), %r8
callq 0x86d0
movq 0x78(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movl $0x2, %esi
leaq 0x20(%rsp), %rcx
leaq 0x10(%rsp), %r8
callq 0x86d0
cmpl $0x0, 0x14(%rsp)
jne 0x207b6
cmpl $0x0, 0x10(%rsp)
je 0x207b6
movq 0x78(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x30(%rsp), %rcx
movq 0x20(%rsp), %r8
callq 0x20ee0
movl %eax, 0x84(%rsp)
jmp 0x20854
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0x207ea
movq 0x78(%rsp), %rdi
leaq 0x2df2(%rip), %rsi      # 0x235c0
leaq 0x328e(%rip), %rdx      # 0x23a63
movl $0x1dc, %ecx            # imm = 0x1DC
movb $0x0, %al
callq 0x8b30
movl %eax, 0x84(%rsp)
jmp 0x20854
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x20839
movq 0x18(%rsp), %rax
movsd 0x50(%rsp,%rax,8), %xmm0
movq 0x18(%rsp), %rax
movsd 0x30(%rsp,%rax,8), %xmm2
movsd 0x8(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x207f3
movq 0x78(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x8840
movl $0x1, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/vec.c
// Function: Div
static int Div(lua_State *L)
    {
    vec_t v; 
    size_t size, i; 
    unsigned int isrow;
    double s;
    checkvec(L, 1, v, &size, &isrow);
    s = luaL_checknumber(L, 2);
    for(i=0; i < size; i++) 
        v[i] /= s;
    return pushvec(L, v, size, size, isrow);
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movl $0x1, %esi
leaq 0x18(%rsp), %rcx
leaq 0xc(%rsp), %r8
callq 0x86d0
movq 0x40(%rsp), %rdi
movl $0x2, %esi
callq 0x8350
movsd %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x208ea
movsd (%rsp), %xmm1
movq 0x10(%rsp), %rax
movsd 0x20(%rsp,%rax,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp,%rax,8)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x208b4
movq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x18(%rsp), %rcx
movl 0xc(%rsp), %r8d
callq 0x8310
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/vec.c
// Function: Cross
static int Cross(lua_State *L)
/* always return a size=3 vector */
//@@ TODO?: v % scalar = component-wise mod
    {
    vec_t v1, v2, v;
    size_t size1, size2; 
    unsigned int isrow1, isrow2;
    checkvec(L, 1, v1, &size1, &isrow1);
    checkvec(L, 2, v2, &size2, &isrow2);
    if((isrow1 != isrow2) || (size1 != size2))
        return luaL_error(L, OPERANDS_ERROR);
    if(size1==2)
        v1[2] = v2[2] = 0;
    vec_cross(v, v1, v2);
    return pushvec(L, v, 3, 3, isrow1);
    }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq 0x88(%rsp), %rdi
leaq 0x60(%rsp), %rdx
movl $0x1, %esi
leaq 0x18(%rsp), %rcx
leaq 0xc(%rsp), %r8
callq 0x86d0
movq 0x88(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movl $0x2, %esi
leaq 0x10(%rsp), %rcx
leaq 0x8(%rsp), %r8
callq 0x86d0
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jne 0x20977
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x209a2
movq 0x88(%rsp), %rdi
leaq 0x2c3a(%rip), %rsi      # 0x235c0
leaq 0x30d6(%rip), %rdx      # 0x23a63
movl $0x1fb, %ecx            # imm = 0x1FB
movb $0x0, %al
callq 0x8b30
movl %eax, 0x94(%rsp)
jmp 0x209f6
cmpq $0x2, 0x18(%rsp)
jne 0x209bc
xorps %xmm0, %xmm0
movsd %xmm0, 0x50(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x70(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x8cd0
movq 0x88(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl 0xc(%rsp), %r8d
movl $0x3, %ecx
movq %rcx, %rdx
callq 0x8310
movl %eax, 0x94(%rsp)
movl 0x94(%rsp), %eax
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/vec.c
// Function: Vxs
static int Vxs(lua_State *L, int sarg, int varg)
    {
    vec_t v; 
    size_t size, i; 
    unsigned int isrow;
    double s = luaL_checknumber(L, sarg);
    checkvec(L, varg, v, &size, &isrow);
    for(i=0; i < size; i++) 
        v[i] *= s;
    return pushvec(L, v, size, size, isrow);
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl %edx, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movl 0x4c(%rsp), %esi
callq 0x8350
movsd %xmm0, (%rsp)
movq 0x50(%rsp), %rdi
movl 0x48(%rsp), %esi
leaq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %rcx
leaq 0xc(%rsp), %r8
callq 0x86d0
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x20cfc
movsd (%rsp), %xmm0
movq 0x10(%rsp), %rax
mulsd 0x20(%rsp,%rax,8), %xmm0
movsd %xmm0, 0x20(%rsp,%rax,8)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x20cca
movq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x18(%rsp), %rcx
movl 0xc(%rsp), %r8d
callq 0x8310
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/vec.c
// Function: Vxm
static int Vxm(lua_State *L) /* 1xM * M*N = 1*N (row vector)*/
    {
    unsigned int isrow;
    size_t i, j, nr, nc, size;
    mat_t m;
    vec_t v, v1;
    double s;
    checkvec(L, 1, v, &size, &isrow);
    checkmat(L, 2, m, &nr, &nc);
    if( (!isrow) || (size != nr))
        return luaL_error(L, OPERANDS_ERROR);
    for(i=0; i < nc; i++)
        {
        s = 0;
        for(j=0; j < size; j++)
            s += (v[j] * m[j][i]);
        v1[i] = s;
        }
    return pushvec(L, v1, nc, nc, 1);
    }

// Assembly:
subq $0x118, %rsp            # imm = 0x118
movq %rdi, 0x108(%rsp)
movq 0x108(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movl $0x1, %esi
leaq 0xd8(%rsp), %rcx
leaq 0x104(%rsp), %r8
callq 0x86d0
movq 0x108(%rsp), %rdi
leaq 0x50(%rsp), %rdx
movl $0x2, %esi
leaq 0xe8(%rsp), %rcx
leaq 0xe0(%rsp), %r8
callq 0x8560
cmpl $0x0, 0x104(%rsp)
je 0x20d99
movq 0xd8(%rsp), %rax
cmpq 0xe8(%rsp), %rax
je 0x20dc7
movq 0x108(%rsp), %rdi
leaq 0x2818(%rip), %rsi      # 0x235c0
leaq 0x2cb4(%rip), %rdx      # 0x23a63
movl $0x1c0, %ecx            # imm = 0x1C0
movb $0x0, %al
callq 0x8b30
movl %eax, 0x114(%rsp)
jmp 0x20ec5
movq $0x0, 0xf8(%rsp)
movq 0xf8(%rsp), %rax
cmpq 0xe0(%rsp), %rax
jae 0x20e96
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq $0x0, 0xf0(%rsp)
movq 0xf0(%rsp), %rax
cmpq 0xd8(%rsp), %rax
jae 0x20e69
movq 0xf0(%rsp), %rax
movsd 0x30(%rsp,%rax,8), %xmm0
movq 0xf0(%rsp), %rcx
leaq 0x50(%rsp), %rax
shlq $0x5, %rcx
addq %rcx, %rax
movq 0xf8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd 0x8(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0xf0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xf0(%rsp)
jmp 0x20dfe
movsd 0x8(%rsp), %xmm0
movq 0xf8(%rsp), %rax
movsd %xmm0, 0x10(%rsp,%rax,8)
movq 0xf8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xf8(%rsp)
jmp 0x20dd3
movq 0x108(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0xe0(%rsp), %rdx
movq 0xe0(%rsp), %rcx
movl $0x1, %r8d
callq 0x8310
movl %eax, 0x114(%rsp)
movl 0x114(%rsp), %eax
addq $0x118, %rsp            # imm = 0x118
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/vec.c
// Function: Vxv
static int Vxv(lua_State *L, vec_t v1, size_t nr,  vec_t v2, size_t nc) 
/* Nx1 * 1xM = NxM   (column) x (row) = matrix */
    {
    mat_t m;
    size_t i, j;
    for(i=0; i < nr; i++)
        for(j=0; j < nc; j++)
            m[i][j] = v1[i] * v2[j];
    return pushmat(L, m, nr, nc, nr, nc);
    }

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq %rcx, 0x98(%rsp)
movq %r8, 0x90(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0xa0(%rsp), %rax
jae 0x20f9d
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x90(%rsp), %rax
jae 0x20f88
movq 0xa8(%rsp), %rax
movq 0x8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x98(%rsp), %rax
movq (%rsp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movq 0x8(%rsp), %rcx
leaq 0x10(%rsp), %rax
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x20f2f
jmp 0x20f8a
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x20f18
movq 0xb0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0xa0(%rsp), %rdx
movq 0x90(%rsp), %rcx
movq 0xa0(%rsp), %r8
movq 0x90(%rsp), %r9
callq 0x8500
addq $0xb8, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/vec.c
// Function: Vec
static int Vec(lua_State *L, size_t size, unsigned int isrow)
/* creates a vector of size 'size', from a vector or a list of values 
 * the size is adapted by discarding exceeding values or adding zeros
 * in lieu of missing values.
 * vecN(v)
 * vecN([x1 ,[x2,...[,xN]]])
 */
    {
    vec_t v;
    size_t vsize, i, arg;
    arg = 1;
    if(testvec(L, arg, v, &vsize, NULL))
        return pushvec(L, v, vsize, size, isrow);
    checkvecsize(L, size);
    for(i = 0; i < size; i++)
        v[i] = luaL_optnumber(L, arg++, 0);
    return pushvec(L, v, size, size, isrow);
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movl %edx, 0x4c(%rsp)
movq $0x1, 0x8(%rsp)
movq 0x58(%rsp), %rdi
movq 0x8(%rsp), %rax
movl %eax, %esi
leaq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x8b00
cmpl $0x0, %eax
je 0x211c7
movq 0x58(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x50(%rsp), %rcx
movl 0x4c(%rsp), %r8d
callq 0x8310
movl %eax, 0x64(%rsp)
jmp 0x21266
jmp 0x211c9
cmpq $0x1, 0x50(%rsp)
jb 0x211d9
cmpq $0x4, 0x50(%rsp)
jbe 0x211f2
movq 0x58(%rsp), %rdi
leaq 0x286a(%rip), %rsi      # 0x23a4f
movb $0x0, %al
callq 0x8b30
movl %eax, 0x64(%rsp)
jmp 0x21266
jmp 0x211f4
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x50(%rsp), %rax
jae 0x21244
movq 0x58(%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rsp)
movl %eax, %esi
xorps %xmm0, %xmm0
callq 0x8370
movq 0x10(%rsp), %rax
movsd %xmm0, 0x20(%rsp,%rax,8)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x211fd
movq 0x58(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x50(%rsp), %rcx
movl 0x4c(%rsp), %r8d
callq 0x8310
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/vec.c
// Function: IsVec
static int IsVec(lua_State *L, size_t size, unsigned int isrow)
    {
    size_t vsize;
    unsigned int visrow;
    if(!testvec(L, 1, NULL, &vsize, &visrow))
        lua_pushboolean(L, 0);
    else
        lua_pushboolean(L, (vsize==size) && (visrow==isrow));
    return 1;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x18(%rsp), %rcx
leaq 0x14(%rsp), %r8
callq 0x8b00
cmpl $0x0, %eax
jne 0x212b2
movq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x8890
jmp 0x212f0
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
xorl %eax, %eax
cmpq 0x28(%rsp), %rcx
movb %al, 0x13(%rsp)
jne 0x212dd
movl 0x14(%rsp), %eax
cmpl 0x24(%rsp), %eax
sete %al
movb %al, 0x13(%rsp)
movq 0x8(%rsp), %rdi
movb 0x13(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x8890
movl $0x1, %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/viewing.c
// Function: moonglmath_frustum
int frustum(mat_t dst, double l, double r, double b, double t, double n, double f)
    {
    mat_clear(dst);
    dst[0][0] = 2.0*n/(r-l);
    dst[0][2] = (r+l)/(r-l);
    dst[1][1] = 2.0*n/(t-b);
    dst[1][2] = (t+b)/(t-b);
    dst[2][2] = -(f+n)/(f-n);
    dst[2][3] = -2.0*f*n/(f-n);
    dst[3][2] = -1.0;
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movsd %xmm1, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm3, 0x10(%rsp)
movsd %xmm4, 0x8(%rsp)
movsd %xmm5, (%rsp)
movq 0x30(%rsp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x8530
movsd 0x1fdb(%rip), %xmm0     # 0x23700
mulsd 0x8(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
subsd 0x28(%rsp), %xmm1
divsd %xmm1, %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0x20(%rsp), %xmm0
addsd 0x28(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
subsd 0x28(%rsp), %xmm1
divsd %xmm1, %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movsd 0x1f8e(%rip), %xmm0     # 0x23700
mulsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
subsd 0x18(%rsp), %xmm1
divsd %xmm1, %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, 0x28(%rax)
movsd 0x10(%rsp), %xmm0
addsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
subsd 0x18(%rsp), %xmm1
divsd %xmm1, %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, 0x30(%rax)
movsd (%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd (%rsp), %xmm1
subsd 0x8(%rsp), %xmm1
divsd %xmm1, %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, 0x50(%rax)
movsd 0x22d5(%rip), %xmm0     # 0x23ad0
mulsd (%rsp), %xmm0
mulsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
subsd 0x8(%rsp), %xmm1
divsd %xmm1, %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, 0x58(%rax)
movq 0x30(%rsp), %rax
movsd 0x209c(%rip), %xmm0     # 0x238c8
movsd %xmm0, 0x70(%rax)
xorl %eax, %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/viewing.c
// Function: moonglmath_perspective
int perspective(mat_t dst, double fovy, double aspect, double n, double f)
    {
    double t = tan(fovy/2) * n; /* top */
    double r = t * aspect; /* right */
    mat_clear(dst);
    dst[0][0] = n/r;
    dst[1][1] = n/t;
    dst[2][2] = -(f+n)/(f-n);
    dst[2][3] = -2.0*f*n/(f-n);
    dst[3][2] = -1.0;
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movsd %xmm1, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm3, 0x10(%rsp)
movsd 0x28(%rsp), %xmm0
movsd 0x1e91(%rip), %xmm1     # 0x23700
divsd %xmm1, %xmm0
callq 0x8920
mulsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x30(%rsp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x8530
movsd 0x18(%rsp), %xmm0
divsd (%rsp), %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0x18(%rsp), %xmm0
divsd 0x8(%rsp), %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, 0x28(%rax)
movsd 0x10(%rsp), %xmm0
addsd 0x18(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x10(%rsp), %xmm1
subsd 0x18(%rsp), %xmm1
divsd %xmm1, %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, 0x50(%rax)
movsd 0x21bb(%rip), %xmm0     # 0x23ad0
mulsd 0x10(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
subsd 0x18(%rsp), %xmm1
divsd %xmm1, %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, 0x58(%rax)
movq 0x30(%rsp), %rax
movsd 0x1f80(%rip), %xmm0     # 0x238c8
movsd %xmm0, 0x70(%rax)
xorl %eax, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/viewing.c
// Function: LookAt
static int LookAt(lua_State *L)
    {
    mat_t m;
    vec_t eye, at, up;
    checkvec(L, 1, eye, NULL, NULL);
    checkvec(L, 2, at, NULL, NULL);
    checkvec(L, 3, up, NULL, NULL);
    look_at(m, eye, at, up);
    return pushmat(L, m, 4, 4, 4, 4);
    }

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq 0xe0(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x86d0
movq 0xe0(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x86d0
movq 0xe0(%rsp), %rdi
movq %rsp, %rdx
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x86d0
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rsp, %rcx
callq 0x80d0
movq 0xe0(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movl $0x4, %r9d
movq %r9, %rdx
movq %r9, %rcx
movq %r9, %r8
callq 0x8500
addq $0xe8, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/viewing.c
// Function: Ortho
static int Ortho(lua_State *L)
    {
    mat_t m;
    double l = luaL_checknumber(L, 1); /* left */
    double r = luaL_checknumber(L, 2); /* right */
    double b = luaL_checknumber(L, 3); /* bottom */
    double t = luaL_checknumber(L, 4); /* top */
    double n = luaL_optnumber(L, 5, -1.0); /* near */
    double f = luaL_optnumber(L, 6, 1.0); /* far */
    ortho(m, l, r, b, t, n, f);
    return pushmat(L, m, 4, 4, 4, 4);
    }

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rdi
movl $0x1, %esi
callq 0x8350
movsd %xmm0, 0x28(%rsp)
movq 0xb0(%rsp), %rdi
movl $0x2, %esi
callq 0x8350
movsd %xmm0, 0x20(%rsp)
movq 0xb0(%rsp), %rdi
movl $0x3, %esi
callq 0x8350
movsd %xmm0, 0x18(%rsp)
movq 0xb0(%rsp), %rdi
movl $0x4, %esi
callq 0x8350
movsd %xmm0, 0x10(%rsp)
movq 0xb0(%rsp), %rdi
movl $0x5, %esi
movsd 0x1e14(%rip), %xmm0     # 0x238c8
callq 0x8370
movsd %xmm0, 0x8(%rsp)
movq 0xb0(%rsp), %rdi
movl $0x6, %esi
movsd 0x15ec(%rip), %xmm0     # 0x230c0
callq 0x8370
movsd %xmm0, (%rsp)
leaq 0x30(%rsp), %rdi
movsd 0x28(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
movsd 0x10(%rsp), %xmm3
movsd 0x8(%rsp), %xmm4
movsd (%rsp), %xmm5
callq 0x8ba0
movq 0xb0(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl $0x4, %r9d
movq %r9, %rdx
movq %r9, %rcx
movq %r9, %r8
callq 0x8500
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/viewing.c
// Function: Frustum
static int Frustum(lua_State *L)
    {
    mat_t m;
    double l = luaL_checknumber(L, 1); /* left */
    double r = luaL_checknumber(L, 2); /* right */
    double b = luaL_checknumber(L, 3); /* bottom */
    double t = luaL_checknumber(L, 4); /* top */
    double n = luaL_checknumber(L, 5); /* near */
    double f = luaL_checknumber(L, 6); /* far */
    frustum(m, l, r, b, t, n, f);
    return pushmat(L, m, 4, 4, 4, 4);
    }

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rdi
movl $0x1, %esi
callq 0x8350
movsd %xmm0, 0x28(%rsp)
movq 0xb0(%rsp), %rdi
movl $0x2, %esi
callq 0x8350
movsd %xmm0, 0x20(%rsp)
movq 0xb0(%rsp), %rdi
movl $0x3, %esi
callq 0x8350
movsd %xmm0, 0x18(%rsp)
movq 0xb0(%rsp), %rdi
movl $0x4, %esi
callq 0x8350
movsd %xmm0, 0x10(%rsp)
movq 0xb0(%rsp), %rdi
movl $0x5, %esi
callq 0x8350
movsd %xmm0, 0x8(%rsp)
movq 0xb0(%rsp), %rdi
movl $0x6, %esi
callq 0x8350
movsd %xmm0, (%rsp)
leaq 0x30(%rsp), %rdi
movsd 0x28(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
movsd 0x10(%rsp), %xmm3
movsd 0x8(%rsp), %xmm4
movsd (%rsp), %xmm5
callq 0x8c20
movq 0xb0(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl $0x4, %r9d
movq %r9, %rdx
movq %r9, %rcx
movq %r9, %r8
callq 0x8500
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/viewing.c
// Function: Perspective
static int Perspective(lua_State *L)
/* perspective(fovy, aspect, near, far)
 */
    {
    mat_t m;
    double fovy = luaL_checknumber(L, 1); /* radians */
    double aspect = luaL_checknumber(L, 2);
    double n = luaL_checknumber(L, 3); /* near */
    double f = luaL_checknumber(L, 4); /* far */
    perspective(m, fovy, aspect, n, f);
    return pushmat(L, m, 4, 4, 4, 4);
    }

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq 0xa0(%rsp), %rdi
movl $0x1, %esi
callq 0x8350
movsd %xmm0, 0x18(%rsp)
movq 0xa0(%rsp), %rdi
movl $0x2, %esi
callq 0x8350
movsd %xmm0, 0x10(%rsp)
movq 0xa0(%rsp), %rdi
movl $0x3, %esi
callq 0x8350
movsd %xmm0, 0x8(%rsp)
movq 0xa0(%rsp), %rdi
movl $0x4, %esi
callq 0x8350
movsd %xmm0, (%rsp)
leaq 0x20(%rsp), %rdi
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
movsd (%rsp), %xmm3
callq 0x8af0
movq 0xa0(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x4, %r9d
movq %r9, %rdx
movq %r9, %rcx
movq %r9, %r8
callq 0x8500
addq $0xa8, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv1aes4/ni/aes-ni.c
// Function: AESNI_Key_Expansion4
void AESNI_Key_Expansion4(const unsigned char *userkey, AUX_KEY key)
{
   __m128i temp1, temp2;
    __m128i *Key_Schedule = (__m128i*)key;

    temp1 = _mm_loadu_si128((__m128i*)userkey);
    _mm_storeu_si128(&Key_Schedule[0], temp1);
    temp2= _mm_aeskeygenassist_si128 (temp1 ,0x1);
    temp1 = AES_128_ASSIST(temp1, temp2);
    _mm_storeu_si128(&Key_Schedule[1], temp1);
    temp2 = _mm_aeskeygenassist_si128 (temp1,0x2);
    temp1 = AES_128_ASSIST(temp1, temp2);
    _mm_storeu_si128(&Key_Schedule[2], temp1);
    temp2 = _mm_aeskeygenassist_si128 (temp1,0x4);
    temp1 = AES_128_ASSIST(temp1, temp2);
    _mm_storeu_si128(&Key_Schedule[3], temp1);
    temp2 = _mm_aeskeygenassist_si128 (temp1,0x8);
    temp1 = AES_128_ASSIST(temp1, temp2);
    _mm_storeu_si128(&Key_Schedule[4], temp1);
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
vmovdqu (%rax), %xmm0
vmovdqa %xmm0, 0x20(%rsp)
movq 0x8(%rsp), %rax
vmovdqa 0x20(%rsp), %xmm0
movq %rax, 0xe0(%rsp)
vmovdqa %xmm0, 0xd0(%rsp)
vmovdqa 0xd0(%rsp), %xmm0
movq 0xe0(%rsp), %rax
vmovdqu %xmm0, (%rax)
vmovdqa 0x20(%rsp), %xmm0
vaeskeygenassist $0x1, %xmm0, %xmm0
vmovdqa %xmm0, 0x10(%rsp)
vmovdqa 0x20(%rsp), %xmm0
vmovdqa 0x10(%rsp), %xmm1
callq 0x1810
vmovdqa %xmm0, 0x20(%rsp)
movq 0x8(%rsp), %rax
addq $0x10, %rax
vmovdqa 0x20(%rsp), %xmm0
movq %rax, 0xc8(%rsp)
vmovdqa %xmm0, 0xb0(%rsp)
vmovdqa 0xb0(%rsp), %xmm0
movq 0xc8(%rsp), %rax
vmovdqu %xmm0, (%rax)
vmovdqa 0x20(%rsp), %xmm0
vaeskeygenassist $0x2, %xmm0, %xmm0
vmovdqa %xmm0, 0x10(%rsp)
vmovdqa 0x20(%rsp), %xmm0
vmovdqa 0x10(%rsp), %xmm1
callq 0x1810
vmovdqa %xmm0, 0x20(%rsp)
movq 0x8(%rsp), %rax
addq $0x20, %rax
vmovdqa 0x20(%rsp), %xmm0
movq %rax, 0xa8(%rsp)
vmovdqa %xmm0, 0x90(%rsp)
vmovdqa 0x90(%rsp), %xmm0
movq 0xa8(%rsp), %rax
vmovdqu %xmm0, (%rax)
vmovdqa 0x20(%rsp), %xmm0
vaeskeygenassist $0x4, %xmm0, %xmm0
vmovdqa %xmm0, 0x10(%rsp)
vmovdqa 0x20(%rsp), %xmm0
vmovdqa 0x10(%rsp), %xmm1
callq 0x1810
vmovdqa %xmm0, 0x20(%rsp)
movq 0x8(%rsp), %rax
addq $0x30, %rax
vmovdqa 0x20(%rsp), %xmm0
movq %rax, 0x88(%rsp)
vmovdqa %xmm0, 0x70(%rsp)
vmovdqa 0x70(%rsp), %xmm0
movq 0x88(%rsp), %rax
vmovdqu %xmm0, (%rax)
vmovdqa 0x20(%rsp), %xmm0
vaeskeygenassist $0x8, %xmm0, %xmm0
vmovdqa %xmm0, 0x10(%rsp)
vmovdqa 0x20(%rsp), %xmm0
vmovdqa 0x10(%rsp), %xmm1
callq 0x1810
vmovdqa %xmm0, 0x20(%rsp)
movq 0x8(%rsp), %rax
addq $0x40, %rax
vmovdqa 0x20(%rsp), %xmm0
movq %rax, 0x68(%rsp)
vmovdqa %xmm0, 0x50(%rsp)
vmovdqa 0x50(%rsp), %xmm0
movq 0x68(%rsp), %rax
vmovdqu %xmm0, (%rax)
addq $0xe8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv1aes4/ni/aes-ni.c
// Function: AESNI_encrypt4
void AESNI_encrypt4(const uint8_t *in, uint8_t *out, const AUX_KEY key)
{
    __m128i tmp;

    tmp = _mm_loadu_si128 ((__m128i*)in);

    tmp = _mm_xor_si128 (tmp,key[0]);
    tmp = _mm_aesenc_si128 (tmp, key[1]);
    tmp = _mm_aesenc_si128 (tmp, key[2]);
    tmp = _mm_aesenc_si128 (tmp, key[3]);
    tmp = _mm_aesenc_si128 (tmp, key[4]);

   _mm_storeu_si128 ((__m128i*)out,tmp);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, -0x60(%rsp)
movq %rsi, -0x68(%rsp)
movq %rdx, -0x70(%rsp)
movq -0x60(%rsp), %rax
movq %rax, -0x58(%rsp)
movq -0x58(%rsp), %rax
vmovdqu (%rax), %xmm0
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x80(%rsp), %xmm1
movq -0x70(%rsp), %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, -0x20(%rsp)
vmovdqa %xmm0, -0x30(%rsp)
vmovdqa -0x20(%rsp), %xmm0
vpxor -0x30(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x80(%rsp), %xmm1
movq -0x70(%rsp), %rax
vmovdqa 0x10(%rax), %xmm0
vmovdqa %xmm1, 0x60(%rsp)
vmovdqa %xmm0, 0x50(%rsp)
vmovdqa 0x60(%rsp), %xmm0
vmovdqa 0x50(%rsp), %xmm1
vaesenc %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x80(%rsp), %xmm1
movq -0x70(%rsp), %rax
vmovdqa 0x20(%rax), %xmm0
vmovdqa %xmm1, 0x40(%rsp)
vmovdqa %xmm0, 0x30(%rsp)
vmovdqa 0x40(%rsp), %xmm0
vmovdqa 0x30(%rsp), %xmm1
vaesenc %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x80(%rsp), %xmm1
movq -0x70(%rsp), %rax
vmovdqa 0x30(%rax), %xmm0
vmovdqa %xmm1, 0x20(%rsp)
vmovdqa %xmm0, 0x10(%rsp)
vmovdqa 0x20(%rsp), %xmm0
vmovdqa 0x10(%rsp), %xmm1
vaesenc %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x80(%rsp)
vmovdqa -0x80(%rsp), %xmm1
movq -0x70(%rsp), %rax
vmovdqa 0x40(%rax), %xmm0
vmovdqa %xmm1, (%rsp)
vmovdqa %xmm0, -0x10(%rsp)
vmovdqa (%rsp), %xmm0
vmovdqa -0x10(%rsp), %xmm1
vaesenc %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, -0x80(%rsp)
movq -0x68(%rsp), %rax
vmovdqa -0x80(%rsp), %xmm0
movq %rax, -0x38(%rsp)
vmovdqa %xmm0, -0x50(%rsp)
vmovdqa -0x50(%rsp), %xmm0
movq -0x38(%rsp), %rax
vmovdqu %xmm0, (%rax)
addq $0x78, %rsp
retq
nopl (%rax)