LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/mat.c
// Function: moonglmath_mat_Clamp
int mat_Clamp(lua_State *L)
    {
    mat_t dst;
    mat_t m, minm, maxm;
    size_t nr, nc, nr1, nc1;
    checkmat(L, 1, m, &nr, &nc);
    checkmat(L, 2, minm, &nr1, &nc1);
    if(nr1 != nr || nc1 != nc)
        return luaL_error(L, OPERANDS_ERROR);
    checkmat(L, 3, maxm, &nr1, &nc1);
    if(nr1 != nr || nc1 != nc)
        return luaL_error(L, OPERANDS_ERROR);
    mat_clamp(dst, m, minm, maxm, nr, nc);
    return pushmat(L, dst, nr, nc, nr, nc);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
movq %rdi, %rbx
pushq $0x1
popq %rsi
leaq 0x120(%rsp), %rdx
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r8
movq %r14, %rcx
callq 0x8560
pushq $0x2
popq %rsi
leaq 0xa0(%rsp), %rdx
leaq 0x18(%rsp), %r15
movq %rsp, %r8
movq %rbx, %rdi
movq %r15, %rcx
callq 0x8560
movq (%r15), %rax
cmpq (%r14), %rax
jne 0xf1cd
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jne 0xf1cd
pushq $0x3
popq %rsi
leaq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %r14
movq %rsp, %r8
movq %rbx, %rdi
movq %r14, %rcx
callq 0x8560
movq (%r14), %r8
cmpq 0x10(%rsp), %r8
jne 0xf1f7
movq (%rsp), %r9
cmpq 0x8(%rsp), %r9
jne 0xf1f7
leaq 0x1a0(%rsp), %r14
leaq 0x120(%rsp), %rsi
leaq 0xa0(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %r14, %rdi
callq 0x8080
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rdx, %r8
movq %rcx, %r9
callq 0x8500
jmp 0xf1ea
leaq 0x742c(%rip), %rsi      # 0x16600
leaq 0x743f(%rip), %rdx      # 0x1661a
movq %rbx, %rdi
movl $0x334, %ecx            # imm = 0x334
xorl %eax, %eax
callq 0x8b00
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r14
popq %r15
retq
leaq 0x7402(%rip), %rsi      # 0x16600
leaq 0x7415(%rip), %rdx      # 0x1661a
movq %rbx, %rdi
movl $0x337, %ecx            # imm = 0x337
jmp 0xf1e3
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/mat.c
// Function: moonglmath_mat_Mix
int mat_Mix(lua_State *L)
    {
    mat_t dst, m1, m2;
    double k;
    size_t nr, nc, nr1, nc1;
    checkmat(L, 1, m1, &nr, &nc);
    checkmat(L, 2, m2, &nr1, &nc1);
    if(nr1 != nr || nc1 != nc)
        return luaL_error(L, OPERANDS_ERROR);
    k = luaL_checknumber(L, 3);
    mat_mix(dst, m1, m2, nr, nc, k);
    return pushmat(L, dst, nr, nc, nr, nc);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, %rbx
pushq $0x1
popq %rsi
leaq 0xa0(%rsp), %rdx
leaq 0x8(%rsp), %r14
movq %rsp, %r8
movq %r14, %rcx
callq 0x8560
pushq $0x2
popq %rsi
leaq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %r15
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rcx
callq 0x8560
movq (%r15), %rax
cmpq (%r14), %rax
jne 0xf2b6
movq 0x10(%rsp), %rax
cmpq (%rsp), %rax
jne 0xf2b6
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x8350
movq 0x8(%rsp), %rcx
movq (%rsp), %r8
leaq 0x120(%rsp), %r14
leaq 0xa0(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %r14, %rdi
callq 0x8440
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rdx, %r8
movq %rcx, %r9
callq 0x8500
jmp 0xf2d3
leaq 0x7343(%rip), %rsi      # 0x16600
leaq 0x7356(%rip), %rdx      # 0x1661a
movq %rbx, %rdi
movl $0x344, %ecx            # imm = 0x344
xorl %eax, %eax
callq 0x8b00
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/mat.c
// Function: moonglmath_mat_Step
int mat_Step(lua_State *L)
    {
    mat_t dst, m1, edge;
    size_t nr, nc, nr1, nc1, i, j;
    checkmat(L, 1, m1, &nr, &nc);
    if(lua_isnumber(L, 2))
        {
        double k = lua_tonumber(L, 2);
        for(i=0; i<nr; i++)
            for(j=0; j<nc; j++)
                edge[i][j] = k;
        }
    else
        {
        checkmat(L, 2, edge, &nr1, &nc1);
        if(nr1 != nr || nc1 != nc)
            return luaL_error(L, OPERANDS_ERROR);
        }
    mat_step(dst, m1, edge, nr, nc);
    return pushmat(L, dst, nr, nc, nr, nc);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rbx
pushq $0x1
popq %rsi
leaq 0xa0(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rsp, %r8
callq 0x8560
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x85a0
testl %eax, %eax
je 0xf351
xorl %r14d, %r14d
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x8680
movq 0x8(%rsp), %rcx
leaq 0x20(%rsp), %rax
movq (%rsp), %r8
cmpq %rcx, %r14
je 0xf383
xorl %edx, %edx
cmpq %rdx, %r8
je 0xf348
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
jmp 0xf339
incq %r14
addq $0x20, %rax
jmp 0xf332
pushq $0x2
popq %rsi
leaq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %r14
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r14, %rcx
callq 0x8560
movq (%r14), %rcx
cmpq 0x8(%rsp), %rcx
jne 0xf3bc
movq 0x10(%rsp), %r8
cmpq (%rsp), %r8
jne 0xf3bc
leaq 0x120(%rsp), %r14
leaq 0xa0(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %r14, %rdi
callq 0x8cc0
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rdx, %r8
movq %rcx, %r9
callq 0x8500
jmp 0xf3d9
leaq 0x723d(%rip), %rsi      # 0x16600
leaq 0x7250(%rip), %rdx      # 0x1661a
movq %rbx, %rdi
movl $0x35a, %ecx            # imm = 0x35A
xorl %eax, %eax
callq 0x8b00
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/mat.c
// Function: moonglmath_mat_Smoothstep
int mat_Smoothstep(lua_State *L)
    {
    mat_t dst, m, edge0, edge1;
    size_t nr, nc, nr1, nc1, i, j;
    checkmat(L, 1, m, &nr, &nc);
    if(lua_isnumber(L, 2))
        {
        double k = lua_tonumber(L, 2);
        for(i=0; i<nr; i++)
            for(j=0; j<nc; j++)
                edge0[i][j] = k;
        }
    else
        {
        checkmat(L, 2, edge0, &nr1, &nc1);
        if(nr1 != nr || nc1 != nc)
            return luaL_error(L, OPERANDS_ERROR);
        }
    if(lua_isnumber(L, 3))
        {
        double k = lua_tonumber(L, 3);
        for(i=0; i<nr; i++)
            for(j=0; j<nc; j++)
                edge1[i][j] = k;
        }
    else
        {
        checkmat(L, 3, edge1, &nr1, &nc1);
        if(nr1 != nr || nc1 != nc)
            return luaL_error(L, OPERANDS_ERROR);
        }
    mat_smoothstep(dst, m, edge0, edge1, nr, nc);
    return pushmat(L, dst, nr, nc, nr, nc);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
pushq $0x1
popq %rsi
leaq 0x120(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rsp, %r8
callq 0x8560
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x85a0
testl %eax, %eax
je 0xf458
xorl %r14d, %r14d
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x8680
movq 0x8(%rsp), %rax
leaq 0xa0(%rsp), %rcx
movq (%rsp), %rdx
cmpq %rax, %r14
je 0xf48d
xorl %esi, %esi
cmpq %rsi, %rdx
je 0xf44f
movsd %xmm0, (%rcx,%rsi,8)
incq %rsi
jmp 0xf440
incq %r14
addq $0x20, %rcx
jmp 0xf439
pushq $0x2
popq %rsi
leaq 0xa0(%rsp), %rdx
leaq 0x18(%rsp), %r14
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r14, %rcx
callq 0x8560
movq (%r14), %rax
cmpq 0x8(%rsp), %rax
jne 0xf4d9
movq 0x10(%rsp), %rax
cmpq (%rsp), %rax
jne 0xf4d9
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x85a0
testl %eax, %eax
je 0xf4f4
xorl %r14d, %r14d
pushq $0x3
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x8680
movq 0x8(%rsp), %r8
leaq 0x20(%rsp), %rax
movq (%rsp), %r9
cmpq %r8, %r14
je 0xf526
xorl %ecx, %ecx
cmpq %rcx, %r9
je 0xf4d0
movsd %xmm0, (%rax,%rcx,8)
incq %rcx
jmp 0xf4c1
incq %r14
addq $0x20, %rax
jmp 0xf4ba
leaq 0x7120(%rip), %rsi      # 0x16600
leaq 0x7133(%rip), %rdx      # 0x1661a
movq %rbx, %rdi
movl $0x370, %ecx            # imm = 0x370
jmp 0xf57d
pushq $0x3
popq %rsi
leaq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %r14
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r14, %rcx
callq 0x8560
movq (%r14), %r8
cmpq 0x8(%rsp), %r8
jne 0xf567
movq 0x10(%rsp), %r9
cmpq (%rsp), %r9
jne 0xf567
leaq 0x1a0(%rsp), %r14
leaq 0x120(%rsp), %rsi
leaq 0xa0(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %r14, %rdi
callq 0x8140
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rdx, %r8
movq %rcx, %r9
callq 0x8500
jmp 0xf584
leaq 0x7092(%rip), %rsi      # 0x16600
leaq 0x70a5(%rip), %rdx      # 0x1661a
movq %rbx, %rdi
movl $0x37d, %ecx            # imm = 0x37D
xorl %eax, %eax
callq 0x8b00
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/mat.c
// Function: Concat
static int Concat(lua_State *L)
    {
    size_t nr, nc;
    mat_t m;
//  printf("%s %s\n", lua_typename(L, lua_type(L, 1)), lua_typename(L, lua_type(L, 2)));
    if(testmat(L, 1, m, &nr, &nc))
        {
        ToString_(L, m, nr, nc);
        lua_pushvalue(L, 2);
        }
    else if(testmat(L, 2, m, &nr, &nc))
        {
        lua_pushvalue(L, 1);
        ToString_(L, m, nr, nc);
        }
    else 
        return unexpected(L);
    lua_concat(L, 2);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %r14
pushq $0x1
popq %rbx
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rsp, %r8
movl %ebx, %esi
callq 0x8a00
testl %eax, %eax
je 0xf81c
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0xff16
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x8650
jmp 0xf859
pushq $0x2
popq %rsi
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rsp, %r8
movq %r14, %rdi
callq 0x8a00
testl %eax, %eax
je 0xf871
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x8650
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0xff16
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x8c70
movl %ebx, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
leaq 0x67fc(%rip), %rsi      # 0x16074
leaq 0x6d9b(%rip), %rdx      # 0x1661a
movq %r14, %rdi
movl $0x11b, %ecx            # imm = 0x11B
xorl %eax, %eax
callq 0x8b00
movl %eax, %ebx
jmp 0xf864
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/mat.c
// Function: Unm
static int Unm(lua_State *L)
    {
    size_t i, j, nr, nc;
    mat_t m;
    checkmat(L, 1, m, &nr, &nc);
    for(i = 0; i < nr; i++)
        for(j = 0; j < nc; j++)
            m[i][j] = -m[i][j];
    return pushmat(L, m, nr, nc, nr, nc);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %rsp, %r12
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x8560
movq (%r15), %rdx
xorl %eax, %eax
movq (%r12), %rcx
movaps 0x67ff(%rip), %xmm0     # 0x160d0
cmpq %rdx, %rax
je 0xf8f9
xorl %esi, %esi
cmpq %rsi, %rcx
je 0xf8f0
movsd (%r14,%rsi,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%r14,%rsi,8)
incq %rsi
jmp 0xf8d8
incq %rax
addq $0x20, %r14
jmp 0xf8d1
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %rdx, %r8
movq %rcx, %r9
callq 0x8500
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/mat.c
// Function: Add
static int Add(lua_State *L)
    {
    size_t i, j, nr, nc, nr1, nc1;
    mat_t m, m1;
    checkmat(L, 1, m, &nr, &nc);
    checkmat(L, 2, m1, &nr1, &nc1);
    if((nr!=nr1) || (nc!=nc1))
        return luaL_error(L, OPERANDS_ERROR);
    for(i = 0; i < nr; i++)
        for(j = 0; j < nc; j++)
            m[i][j] += m1[i][j];
    return pushmat(L, m, nr, nc, nr, nc);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
movq %rdi, %rbx
pushq $0x1
popq %rsi
leaq 0x20(%rsp), %r14
leaq 0x18(%rsp), %r12
leaq 0x8(%rsp), %r8
movq %r14, %rdx
movq %r12, %rcx
callq 0x8560
pushq $0x2
popq %rsi
leaq 0xa0(%rsp), %r15
leaq 0x10(%rsp), %r13
movq %rsp, %r8
movq %rbx, %rdi
movq %r15, %rdx
movq %r13, %rcx
callq 0x8560
movq (%r12), %rdx
cmpq (%r13), %rdx
jne 0xf9b3
movq 0x8(%rsp), %rcx
cmpq (%rsp), %rcx
jne 0xf9b3
xorl %eax, %eax
cmpq %rdx, %rax
je 0xf9d2
xorl %esi, %esi
cmpq %rsi, %rcx
je 0xf9a6
movsd (%r15,%rsi,8), %xmm0
addsd (%r14,%rsi,8), %xmm0
movsd %xmm0, (%r14,%rsi,8)
incq %rsi
jmp 0xf98a
incq %rax
addq $0x20, %r14
addq $0x20, %r15
jmp 0xf983
leaq 0x6c46(%rip), %rsi      # 0x16600
leaq 0x6c59(%rip), %rdx      # 0x1661a
movq %rbx, %rdi
movl $0x23c, %ecx            # imm = 0x23C
xorl %eax, %eax
callq 0x8b00
jmp 0xf9e5
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
movq %rdx, %r8
movq %rcx, %r9
callq 0x8500
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/mat.c
// Function: Div
static int Div(lua_State *L)
    {
    size_t i, j, nr, nc;
    mat_t m;
    double s;
    checkmat(L, 1, m, &nr, &nc);
    s = luaL_checknumber(L, 2);
    for(i = 0; i < nr; i++)
        for(j = 0; j < nc; j++)
            m[i][j] /= s;
    return pushmat(L, m, nr, nc, nr, nc);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %rsp, %r12
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x8560
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x8350
movq (%r15), %rdx
xorl %eax, %eax
movq (%r12), %rcx
cmpq %rdx, %rax
je 0xfd72
xorl %esi, %esi
cmpq %rsi, %rcx
je 0xfd69
movsd (%r14,%rsi,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%r14,%rsi,8)
incq %rsi
jmp 0xfd4f
incq %rax
addq $0x20, %r14
jmp 0xfd48
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %rdx, %r8
movq %rcx, %r9
callq 0x8500
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/mat.c
// Function: Pow
static int Pow(lua_State *L)
    {
    size_t nr, nc;
    mat_t m, dst;
    lua_Integer n, i;
    checkmat(L, 1, m, &nr, &nc);
    if((nc != nr))
        return luaL_error(L, OPERANDS_ERROR);
    n = luaL_checkinteger(L, 2);
    if(n==0) /* m^0 = identity */
        {
        mat_clear(dst);
        dst[0][0] = dst[1][1] = dst[2][2] = dst[3][3]= 1;
        }
    else 
        {
        if(n > 0)
            mat_copy(dst, m);
        else /* n < 0 */
            { 
            if(!mat_inv(dst, m, nr))
                return luaL_argerror(L, 1, "singular matrix");
            mat_copy(m, dst); 
            n = -n; 
            }
        for(i = 0; i < (n-1); i++)
            mat_mulby(dst, m, nr, nr, nr);
        }
    return pushmat(L, dst, nr, nc, nr, nc);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdi, %rbx
pushq $0x1
popq %rsi
leaq 0x90(%rsp), %rdx
movq %rsp, %r14
leaq 0x8(%rsp), %r15
movq %r14, %rcx
movq %r15, %r8
callq 0x8560
movq (%r15), %rax
cmpq (%r14), %rax
jne 0xfe02
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x8740
testq %rax, %rax
je 0xfe21
movq %rax, %r14
jle 0xfea0
pushq $0x10
popq %rcx
leaq 0x10(%rsp), %rdi
leaq 0x90(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq (%rsp), %r15
jmp 0xfed3
leaq 0x67f7(%rip), %rsi      # 0x16600
leaq 0x680a(%rip), %rdx      # 0x1661a
movq %rbx, %rdi
movl $0x2ad, %ecx            # imm = 0x2AD
xorl %eax, %eax
callq 0x8b00
jmp 0xfe8f
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x20(%rsp)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x88(%rsp)
movq %rax, 0x60(%rsp)
movq %rax, 0x38(%rsp)
movq %rax, 0x10(%rsp)
movq (%rsp), %r15
movq 0x8(%rsp), %rcx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r15, %r8
movq %rcx, %r9
callq 0x8500
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq (%rsp), %r15
leaq 0x10(%rsp), %rdi
leaq 0x90(%rsp), %rsi
movq %r15, %rdx
callq 0x82e0
testl %eax, %eax
je 0xfeff
pushq $0x10
popq %rcx
leaq 0x90(%rsp), %rdi
leaq 0x10(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
negq %r14
decq %r14
leaq 0x10(%rsp), %r12
leaq 0x90(%rsp), %r13
subq $0x1, %r14
jb 0xfe74
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r15, %rcx
movq %r15, %r8
callq 0x8aa0
jmp 0xfee3
leaq 0x66c3(%rip), %rdx      # 0x165c9
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x81c0
jmp 0xfe8f
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/mat.c
// Function: Mxs
static int Mxs(lua_State *L, int sarg, int marg)
    {
    size_t i, j, nr, nc;
    mat_t m;
    double s = luaL_checknumber(L, sarg);
    checkmat(L, marg, m, &nr, &nc);
    for(i = 0; i < nr; i++)
        for(j = 0; j < nc; j++)
            m[i][j] *= s;
    return pushmat(L, m, nr, nc, nr, nc);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movl %edx, %ebp
movq %rdi, %rbx
callq 0x8350
movsd %xmm0, 0x8(%rsp)
leaq 0x20(%rsp), %r14
leaq 0x18(%rsp), %r15
leaq 0x10(%rsp), %r12
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x8560
movsd 0x8(%rsp), %xmm1
movq (%r15), %rdx
xorl %eax, %eax
movq (%r12), %rcx
cmpq %rdx, %rax
je 0x1012b
xorl %esi, %esi
cmpq %rsi, %rcx
je 0x10122
movsd (%r14,%rsi,8), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, (%r14,%rsi,8)
incq %rsi
jmp 0x10108
incq %rax
addq $0x20, %r14
jmp 0x10101
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
movq %rdx, %r8
movq %rcx, %r9
callq 0x8500
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/num.c
// Function: moonglmath_num_Clamp
int num_Clamp(lua_State *L)
    {
    double x = luaL_checknumber(L, 1);
    double minval = luaL_checknumber(L, 2);
    double maxval = luaL_checknumber(L, 3);
    lua_pushnumber(L, clamp(x, minval, maxval));
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x8350
movapd %xmm0, 0x10(%rsp)
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x8350
movapd %xmm0, (%rsp)
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x8350
movapd 0x10(%rsp), %xmm2
minsd %xmm2, %xmm0
movapd (%rsp), %xmm3
cmpltsd %xmm3, %xmm2
movapd %xmm2, %xmm1
andnpd %xmm0, %xmm1
andpd %xmm3, %xmm2
orpd %xmm1, %xmm2
movapd %xmm2, %xmm0
movq %r14, %rdi
callq 0x8840
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/num.c
// Function: moonglmath_num_Mix
int num_Mix(lua_State *L)
    {
    double x = luaL_checknumber(L, 1);
    double y = luaL_checknumber(L, 2);
    double k = luaL_checknumber(L, 3);
    lua_pushnumber(L, mix(x, y, k));
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x8350
movsd %xmm0, 0x10(%rsp)
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x8350
movsd %xmm0, 0x8(%rsp)
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x8350
movsd 0x5a7c(%rip), %xmm1     # 0x160c0
subsd %xmm0, %xmm1
mulsd 0x8(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm1
addsd %xmm1, %xmm0
movq %r14, %rdi
callq 0x8840
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/num.c
// Function: moonglmath_num_Step
int num_Step(lua_State *L)
    {
    double x = luaL_checknumber(L, 1);
    double edge = luaL_checknumber(L, 2);
    lua_pushnumber(L, step(x, edge));
    return 1;
    }

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x8350
movapd %xmm0, (%rsp)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x8350
movapd (%rsp), %xmm1
cmplesd %xmm0, %xmm1
movsd 0x5a0f(%rip), %xmm0     # 0x160c0
andnpd %xmm0, %xmm1
movapd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x8840
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/num.c
// Function: moonglmath_num_Smoothstep
int num_Smoothstep(lua_State *L)
    {
    double x = luaL_checknumber(L, 1);
    double edge0 = luaL_checknumber(L, 2);
    double edge1 = luaL_checknumber(L, 3);
    lua_pushnumber(L, smoothstep(x, edge0, edge1));
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x8350
movsd %xmm0, 0x10(%rsp)
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x8350
movsd %xmm0, 0x8(%rsp)
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x8350
movaps %xmm0, %xmm2
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x86f0
movq %r14, %rdi
callq 0x8840
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/num.c
// Function: moonglmath_num_Fade
int num_Fade(lua_State *L)
    {
    double x = luaL_checknumber(L, 1);
    double edge0 = luaL_checknumber(L, 2);
    double edge1 = luaL_checknumber(L, 3);
    lua_pushnumber(L, fade(x, edge0, edge1));
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x8350
movsd %xmm0, 0x10(%rsp)
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x8350
movsd %xmm0, 0x8(%rsp)
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x8350
movaps %xmm0, %xmm2
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x8800
movq %r14, %rdi
callq 0x8840
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/objects.c
// Function: moonglmath_newuserdata
ud_t *newuserdata(lua_State *L, void *handle, const char *mt, const char *tracename)
    {
    ud_t *ud;
    /* we use handle as search key */
    ud = (ud_t*)udata_new(L, sizeof(ud_t), (uint64_t)(uintptr_t)handle, mt);
    memset(ud, 0, sizeof(ud_t));
    ud->handle = handle;
    MarkValid(ud);
    if(trace_objects)
        printf("create %s %p (%p)\n", tracename, (void*)ud, handle);
    return ud;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdx, %rcx
movq %rsi, %rbx
pushq $0x28
popq %rsi
movq %rbx, %rdx
callq 0x8620
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
movq %rbx, (%rax)
movl $0x1, 0x18(%rax)
movq 0xe788(%rip), %rax      # 0x1efe0
cmpl $0x0, (%rax)
je 0x10874
leaq 0x5e84(%rip), %rdi      # 0x166e8
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x83a0
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/objects.c
// Function: moonglmath_checkxxxlist
void** checkxxxlist(lua_State *L, int arg, uint32_t *count, int *err, const char *mt)
/* xxx_t* checkxxxlist(lua_State *L, int arg, uint32_t *count, int *err)
 * Checks if the variable at arg on the Lua stack is a list of xxx_t objects.
 * On success, returns an array of xxx_t handles and sets its length in *count.
 * The array s Malloc'd and must be released by the caller using Free(L, ...).
 * On error, sets *err to ERR_XXX, *count to 0, and returns NULL. 
 */
    {
    void** list;
    uint32_t i;

    *count = 0;
    *err = 0;
    if(lua_isnoneornil(L, arg))
        { *err = ERR_NOTPRESENT; return NULL; }
    if(lua_type(L, arg) != LUA_TTABLE)
        { *err = ERR_TABLE; return NULL; }
    *count = luaL_len(L, arg);
    if(*count == 0)
        { *err = ERR_EMPTY; return NULL; }
    list = (void**)MallocNoErr(L, sizeof(void*) * (*count));

    if(!list)
        { *count = 0; *err = ERR_MEMORY; return NULL; }

    for(i=0; i<*count; i++)
        {
        lua_rawgeti(L, arg, i+1);
        list[i] = (void*)(uintptr_t)testxxx(L, -1, NULL, mt);
        if(!list[i])
            { Free(L, list); *count = 0; *err = ERR_TYPE; return NULL; }
        lua_pop(L, 1);
        }
    return list;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x10(%rsp)
movq %rcx, %r14
movl %esi, %ebp
movq %rdx, (%rsp)
andl $0x0, (%rdx)
movq %rdi, %r12
andl $0x0, (%rcx)
callq 0x8cf0
testl %eax, %eax
jle 0x10aac
movq %r12, %rdi
movl %ebp, %esi
callq 0x8cf0
cmpl $0x5, %eax
jne 0x10ab0
movq %r12, %rdi
movl %ebp, %esi
callq 0x8d10
movq (%rsp), %rcx
movl %eax, (%rcx)
testl %eax, %eax
je 0x10ab4
movl %eax, %esi
shlq $0x3, %rsi
movq %r12, %rdi
callq 0x8a60
testq %rax, %rax
je 0x10acf
movq %rax, %rbx
movq %r14, 0x8(%rsp)
xorl %r14d, %r14d
pushq $-0x2
popq %r13
movq (%rsp), %rax
movl (%rax), %eax
cmpq %rax, %r14
jae 0x10abd
leaq 0x1(%r14), %r15
movq %r12, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x83b0
movq %r12, %rdi
pushq $-0x1
popq %rsi
xorl %edx, %edx
movq 0x10(%rsp), %rcx
callq 0x86e0
movq %rax, (%rbx,%r14,8)
testq %rax, %rax
je 0x10ad5
movq %r12, %rdi
movl %r13d, %esi
callq 0x80c0
movq %r15, %r14
jmp 0x10a65
pushq $0x1
jmp 0x10ab6
pushq $-0x4
jmp 0x10ab6
pushq $-0x5
popq %r13
movl %r13d, (%r14)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x6
popq %r13
jmp 0x10ae5
movq %r12, %rdi
movq %rbx, %rsi
callq 0x8630
movq 0x8(%rsp), %r14
movq (%rsp), %rax
andl $0x0, (%rax)
jmp 0x10ab8
nop
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/quat.c
// Function: moonglmath_testquat
int testquat(lua_State *L, int arg, quat_t q)
/* Tests if the element at arg is a quaternion and sets q accordingly
 * (unless it is passed as 0).
 */
    {
    size_t i;
    if(!testmetatable(L, arg, QUAT_MT)) return 0;

    if(q != NULL)
        {
        for(i=0; i < 4; i++)
            {
            lua_geti(L, arg, i+1);
            q[i] = luaL_checknumber(L, -1);
            lua_pop(L, 1);
            }
        }
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x58b0(%rip), %rdx      # 0x163ba
callq 0x8180
testl %eax, %eax
je 0x10b61
pushq $0x1
popq %rax
testq %rbx, %rbx
je 0x10b63
pushq $0x1
popq %r12
pushq $-0x1
popq %r13
pushq $-0x2
popq %r15
cmpq $0x5, %r12
je 0x10b5c
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x8de0
movq %r14, %rdi
movl %r13d, %esi
callq 0x8350
movsd %xmm0, -0x8(%rbx,%r12,8)
movq %r14, %rdi
movl %r15d, %esi
callq 0x80c0
incq %r12
jmp 0x10b27
pushq $0x1
popq %rax
jmp 0x10b63
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/quat.c
// Function: moonglmath_pushquat
int pushquat(lua_State *L, quat_t q)
    {
    size_t i;
    lua_newtable(L);
    setmetatable(L, QUAT_MT);
    for(i=0; i<4; i++)
        {
        lua_pushnumber(L, q[i]);
        lua_seti(L, -2, i+1);
        }
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0x8320
leaq 0x57e2(%rip), %rsi      # 0x163ba
movq %r14, %rdi
callq 0x89c0
pushq $0x1
popq %r15
pushq $-0x2
popq %rbp
cmpq $0x5, %r15
je 0x10c0e
movsd -0x8(%rbx,%r15,8), %xmm0
movq %r14, %rdi
callq 0x8840
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x86a0
incq %r15
jmp 0x10be7
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/quat.c
// Function: moonglmath_quat_unm
void quat_unm(quat_t dst, quat_t q)
    {
    size_t i; 
    quat_clear(dst);
    for(i=0; i < 4; i++)    
        dst[i] = -q[i];
    }

// Assembly:
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %eax, %eax
movaps 0x54a1(%rip), %xmm0     # 0x160d0
cmpq $0x4, %rax
je 0x10c46
movsd (%rsi,%rax,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%rdi,%rax,8)
incq %rax
jmp 0x10c2f
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/quat.c
// Function: moonglmath_quat_norm
double quat_norm(quat_t q)
    {
    size_t i;
    double r = 0;
    for(i=0; i < 4; i++)
        r += q[i]*q[i];
    return sqrt(r);
    }

// Assembly:
xorpd %xmm0, %xmm0
xorl %eax, %eax
cmpq $0x4, %rax
je 0x10c9f
movsd (%rdi,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x10c87
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x8d80
sqrtsd %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/quat.c
// Function: moonglmath_quat_norm2
double quat_norm2(quat_t q)
    {
    size_t i;
    double r = 0;
    for(i=0; i < 4; i++)
        r += q[i]*q[i];
    return r;
    }

// Assembly:
xorpd %xmm0, %xmm0
xorl %eax, %eax
cmpq $0x4, %rax
je 0x10cd0
movsd (%rdi,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x10cb8
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/quat.c
// Function: moonglmath_quat_normalize
void quat_normalize(quat_t q) 
/* in place */
    {
    size_t i;
    double norm = quat_norm(q);
    for(i=0; i < 4; i++)    
        q[i] = q[i]/norm;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x8ea0
xorl %eax, %eax
cmpq $0x4, %rax
je 0x10cf5
movsd (%rbx,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%rax,8)
incq %rax
jmp 0x10cdc
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/quat.c
// Function: moonglmath_quat_conj
void quat_conj(quat_t dst, quat_t q) 
    {
    dst[0] = q[0];
    dst[1] = -q[1];
    dst[2] = -q[2];
    dst[3] = -q[3];
    }

// Assembly:
movsd (%rsi), %xmm0
movsd %xmm0, (%rdi)
movsd 0x8(%rsi), %xmm0
movaps 0x53c5(%rip), %xmm1     # 0x160d0
xorps %xmm1, %xmm0
movlps %xmm0, 0x8(%rdi)
movsd 0x10(%rsi), %xmm0
xorps %xmm1, %xmm0
movlps %xmm0, 0x10(%rdi)
movsd 0x18(%rsi), %xmm0
xorps %xmm1, %xmm0
movlps %xmm0, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/quat.c
// Function: moonglmath_quat_inv
void quat_inv(quat_t dst, quat_t q) 
    {
    double norm2 = quat_norm(q);
    norm2 = norm2*norm2;
    dst[0] = q[0]/norm2;
    dst[1] = -q[1]/norm2;
    dst[2] = -q[2]/norm2;
    dst[3] = -q[3]/norm2;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x8ea0
mulsd %xmm0, %xmm0
movsd (%rbx), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%r14)
movsd 0x8(%rbx), %xmm1
movapd 0x5375(%rip), %xmm2     # 0x160d0
xorpd %xmm2, %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%r14)
movsd 0x10(%rbx), %xmm1
xorpd %xmm2, %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x10(%r14)
movsd 0x18(%rbx), %xmm1
xorpd %xmm2, %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x18(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/quat.c
// Function: moonglmath_quat_mix
void quat_mix(quat_t dst, quat_t q, quat_t p, double t)
    {
    double t1 = 1.0f - t;
    dst[0] = t1*q[0] + t*p[0];
    dst[1] = t1*q[1] + t*p[1];
    dst[2] = t1*q[2] + t*p[2];
    dst[3] = t1*q[3] + t*p[3];
    }

// Assembly:
movsd 0x520d(%rip), %xmm1     # 0x160c0
subsd %xmm0, %xmm1
movsd (%rdx), %xmm2
mulsd %xmm0, %xmm2
movsd (%rsi), %xmm3
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, (%rdi)
movsd 0x8(%rdx), %xmm2
mulsd %xmm0, %xmm2
movsd 0x8(%rsi), %xmm3
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, 0x8(%rdi)
movsd 0x10(%rdx), %xmm2
mulsd %xmm0, %xmm2
movsd 0x10(%rsi), %xmm3
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, 0x10(%rdi)
mulsd 0x18(%rdx), %xmm0
mulsd 0x18(%rsi), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/quat.c
// Function: moonglmath_quat_slerp
void quat_slerp(quat_t dst, quat_t q, quat_t p, double t)
/* Rfr: "3D Math Primer for Graphics and Game Development", by F. Dunn, I. Parberry,
 *      AK Peters/CRC Press, section 8.5.11.
 */
    {
    double c, s, theta, t0, t1;
    c = q[0]*p[0] + q[1]*p[1] + q[2]*p[2] + q[3]*p[3];
    if(c < 0.0f)
        {
        c = -c;
        p[0] = - p[0];
        p[1] = - p[1];
        p[2] = - p[2];
        p[3] = - p[3];
        }
    if(c > .9999f) // q and p are very close: use linear interpolation
        quat_mix(dst, q, p, t);
    else
        {
        s = sqrt(1.0f - c*c);
        theta = atan2(s, c);
        t0 = sin((1.0f - t)*theta)/s;
        t1 = sin(t*theta)/s;
        dst[0] = t0*q[0] + t1*p[0];
        dst[1] = t0*q[1] + t1*p[1];
        dst[2] = t0*q[2] + t1*p[2];
        dst[3] = t0*q[3] + t1*p[3];
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movupd (%rdx), %xmm5
movupd 0x10(%rdx), %xmm4
movapd %xmm5, %xmm2
unpckhpd %xmm5, %xmm2            # xmm2 = xmm2[1],xmm5[1]
mulsd 0x8(%rsi), %xmm2
movsd (%rsi), %xmm3
mulsd %xmm5, %xmm3
addsd %xmm2, %xmm3
movsd 0x10(%rsi), %xmm2
mulsd %xmm4, %xmm2
addsd %xmm3, %xmm2
movapd %xmm4, %xmm1
unpckhpd %xmm4, %xmm1            # xmm1 = xmm1[1],xmm4[1]
mulsd 0x18(%rsi), %xmm1
addsd %xmm2, %xmm1
xorpd %xmm2, %xmm2
ucomisd %xmm1, %xmm2
jbe 0x10f94
movapd 0x5153(%rip), %xmm2     # 0x160d0
xorpd %xmm2, %xmm1
xorpd %xmm2, %xmm5
movupd %xmm5, (%r15)
xorpd %xmm2, %xmm4
movupd %xmm4, 0x10(%r15)
ucomisd 0x57b4(%rip), %xmm1     # 0x16750
jbe 0x10fb5
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x87b0
movsd %xmm0, 0x8(%rsp)
movapd %xmm1, %xmm2
mulsd %xmm1, %xmm2
movsd 0x50f5(%rip), %xmm0     # 0x160c0
subsd %xmm2, %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jb 0x10fdf
sqrtsd %xmm0, %xmm0
jmp 0x10ff0
movapd %xmm1, 0x10(%rsp)
callq 0x8d80
movapd 0x10(%rsp), %xmm1
movsd %xmm0, 0x10(%rsp)
callq 0x89a0
movapd %xmm0, %xmm1
movsd %xmm0, 0x20(%rsp)
movsd 0x50b3(%rip), %xmm0     # 0x160c0
subsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
callq 0x8c30
divsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x20(%rsp), %xmm0
mulsd 0x8(%rsp), %xmm0
callq 0x8c30
divsd 0x10(%rsp), %xmm0
movsd (%r15), %xmm1
mulsd %xmm0, %xmm1
movsd (%r14), %xmm2
movsd 0x28(%rsp), %xmm3
mulsd %xmm3, %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, (%rbx)
movsd 0x8(%r15), %xmm1
mulsd %xmm0, %xmm1
movsd 0x8(%r14), %xmm2
mulsd %xmm3, %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, 0x8(%rbx)
movsd 0x10(%r15), %xmm1
mulsd %xmm0, %xmm1
movsd 0x10(%r14), %xmm2
mulsd %xmm3, %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, 0x10(%rbx)
mulsd 0x18(%r15), %xmm0
movapd %xmm3, %xmm1
mulsd 0x18(%r14), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/quat.c
// Function: moonglmath_quat_Norm
int quat_Norm(lua_State *L)
    {
    quat_t q;
    size_t i;
    double r = 0;
    checkquat(L, 1, q);
    for(i=0; i < 4; i++)
        r += q[i]*q[i];
    lua_pushnumber(L, sqrt(r));
    return 1;
    }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
movq %rsp, %rdx
callq 0x8260
xorpd %xmm0, %xmm0
xorl %eax, %eax
cmpq $0x4, %rax
je 0x110ed
movsd (%rsp,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x110d5
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x110fd
sqrtsd %xmm0, %xmm0
jmp 0x11102
callq 0x8d80
movq %rbx, %rdi
callq 0x8840
pushq $0x1
popq %rax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/quat.c
// Function: moonglmath_quat_Norm2
int quat_Norm2(lua_State *L)
    {
    quat_t q;
    size_t i;
    double r = 0;
    checkquat(L, 1, q);
    for(i=0; i < 4; i++)
        r += q[i]*q[i];
    lua_pushnumber(L, r);
    return 1;
    }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
movq %rsp, %rdx
callq 0x8260
xorpd %xmm0, %xmm0
xorl %eax, %eax
cmpq $0x4, %rax
je 0x11144
movsd (%rsp,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x1112c
movq %rbx, %rdi
callq 0x8840
pushq $0x1
popq %rax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/quat.c
// Function: moonglmath_quat_Conj
int quat_Conj(lua_State *L)
    {
    quat_t q; 
    checkquat(L, 1, q);
    q[1] = -q[1];
    q[2] = -q[2];
    q[3] = -q[3];
    return pushquat(L, q);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rbp
movq %rsp, %r14
movl %ebp, %esi
movq %r14, %rdx
callq 0x8260
movups 0x8(%r14), %xmm0
movaps 0x4f54(%rip), %xmm1     # 0x160d0
xorps %xmm1, %xmm0
movups %xmm0, 0x8(%r14)
movsd 0x18(%r14), %xmm0
xorps %xmm1, %xmm0
movlps %xmm0, 0x18(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8300
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/quat.c
// Function: moonglmath_quat_Parts
int quat_Parts(lua_State *L)
    {
    quat_t q; 
    vec_t v;
    checkquat(L, 1, q);
    v[0] = q[1];
    v[1] = q[2];
    v[2] = q[3];
    lua_pushnumber(L, q[0]);
    pushvec(L, v, 3, 3, 0);
    return 2;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdx
callq 0x8260
movups 0x8(%r14), %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
movsd 0x18(%r14), %xmm0
movsd %xmm0, 0x10(%r15)
movsd (%r14), %xmm0
movq %rbx, %rdi
callq 0x8840
pushq $0x3
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %rcx, %rdx
xorl %r8d, %r8d
callq 0x8310
pushq $0x2
popq %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/quat.c
// Function: moonglmath_quat_FromMat
int quat_FromMat(lua_State *L)
    {
    size_t nr, nc;
    double t, s, r;
    mat_t m;
    quat_t q;
    checkmat(L, 1, m, &nr, &nc);
    if( !(((nr==3) && (nc==3)) || ((nr==4) && (nc==4))) )
        return luaL_argerror(L, 1, "expected 3x3 or 4x4 matrix");
    t = m[0][0] + m[1][1] + m[2][2];
    if( t < 0 )
        {
        r = sqrt(1 + m[0][0] - m[1][1] - m[2][2]);
        s = 0.5/r;
        q[0] = (m[2][1] - m[1][2])*s;
        q[1] = 0.5*r;
        q[2] = (m[0][1] + m[1][0])*s;
        q[3] = (m[2][0] + m[0][2])*s;
        }
    else
        {
        r = sqrt(1+t);
        s = 0.5/r;
        q[0] = 0.5*r;
        q[1] = (m[2][1] - m[1][2])*s;
        q[2] = (m[0][2] - m[2][0])*s;
        q[3] = (m[1][0] + m[0][1])*s;
        }
    return pushquat(L, q);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %r14
pushq $0x1
popq %rbx
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %r15
movq %rsp, %r12
movl %ebx, %esi
movq %r15, %rcx
movq %r12, %r8
callq 0x8560
movq (%r15), %rax
movq %rax, %rdx
xorq $0x3, %rdx
movq (%r12), %rcx
movq %rcx, %rsi
xorq $0x3, %rsi
orq %rdx, %rsi
je 0x112dd
xorq $0x4, %rax
xorq $0x4, %rcx
orq %rax, %rcx
jne 0x11335
movsd 0x10(%rsp), %xmm0
movsd 0x38(%rsp), %xmm3
movapd %xmm0, %xmm1
addsd %xmm3, %xmm1
movsd 0x60(%rsp), %xmm4
addsd %xmm4, %xmm1
xorpd %xmm2, %xmm2
ucomisd %xmm1, %xmm2
jbe 0x11321
addsd 0x4db3(%rip), %xmm0     # 0x160c0
subsd %xmm3, %xmm0
subsd %xmm4, %xmm0
ucomisd %xmm2, %xmm0
jb 0x1134e
sqrtsd %xmm0, %xmm0
jmp 0x11353
addsd 0x4d97(%rip), %xmm1     # 0x160c0
ucomisd %xmm2, %xmm1
jb 0x1139e
sqrtsd %xmm1, %xmm0
jmp 0x113a7
leaq 0x542c(%rip), %rdx      # 0x16768
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x81c0
movl %eax, %ebx
jmp 0x11417
callq 0x8d80
movsd 0x53fd(%rip), %xmm1     # 0x16758
divsd %xmm0, %xmm1
movsd 0x58(%rsp), %xmm2
subsd 0x40(%rsp), %xmm2
movapd %xmm1, %xmm3
unpcklpd %xmm0, %xmm3            # xmm3 = xmm3[0],xmm0[0]
shufpd $0x2, 0x53c4(%rip), %xmm2 # xmm2 = xmm2[0],mem[1]
movupd 0x18(%rsp), %xmm0
movapd 0x30(%rsp), %xmm4
movhpd 0x50(%rsp), %xmm0       # xmm0 = xmm0[0],mem[0]
movhpd 0x20(%rsp), %xmm4       # xmm4 = xmm4[0],mem[0]
mulpd %xmm3, %xmm2
addpd %xmm0, %xmm4
jmp 0x113f6
movapd %xmm1, %xmm0
callq 0x8d80
movsd 0x53a9(%rip), %xmm1     # 0x16758
movsd 0x58(%rsp), %xmm3
subsd 0x40(%rsp), %xmm3
divsd %xmm0, %xmm1
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
movapd 0x5365(%rip), %xmm2     # 0x16730
unpcklpd %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0]
mulpd %xmm0, %xmm2
movapd 0x30(%rsp), %xmm0
movupd 0x18(%rsp), %xmm3
movapd %xmm3, %xmm4
addpd %xmm0, %xmm3
movhpd 0x50(%rsp), %xmm0       # xmm0 = xmm0[0],mem[0]
subpd %xmm0, %xmm4
shufpd $0x1, %xmm3, %xmm4      # xmm4 = xmm4[1],xmm3[0]
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm4, %xmm1
leaq 0x90(%rsp), %rsi
movapd %xmm2, (%rsi)
movapd %xmm1, 0x10(%rsi)
movq %r14, %rdi
callq 0x8300
movl %ebx, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/quat.c
// Function: moonglmath_quat_Mix
int quat_Mix(lua_State *L)
    {
    quat_t dst, q, p;
    double t;
    checkquat(L, 1, q);
    checkquat(L, 2, p);
    t = luaL_checknumber(L, 3);
    quat_mix(dst, q, p, t);
    return pushquat(L, dst);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
pushq $0x1
popq %rbx
leaq 0x20(%rsp), %r15
movl %ebx, %esi
movq %r15, %rdx
callq 0x8260
pushq $0x2
popq %rsi
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rdx
callq 0x8260
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x8350
movsd 0x4c54(%rip), %xmm1     # 0x160c0
subsd %xmm0, %xmm1
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movapd (%r12), %xmm2
mulpd %xmm0, %xmm2
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
movapd (%r15), %xmm3
mulpd %xmm1, %xmm3
addpd %xmm2, %xmm3
leaq 0x40(%rsp), %rsi
movapd %xmm3, (%rsi)
mulpd 0x10(%r12), %xmm0
mulpd 0x10(%r15), %xmm1
addpd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsi)
movq %r14, %rdi
callq 0x8300
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/quat.c
// Function: moonglmath_quat_Slerp
int quat_Slerp(lua_State *L)
    {
    quat_t dst, q, p;
    double t;
    checkquat(L, 1, q);
    checkquat(L, 2, p);
    t = luaL_checknumber(L, 3);
    quat_slerp(dst, q, p, t);
    return pushquat(L, dst);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %r14
pushq $0x1
popq %rbx
leaq 0x20(%rsp), %r15
movl %ebx, %esi
movq %r15, %rdx
callq 0x8260
pushq $0x2
popq %rsi
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rdx
callq 0x8260
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x8350
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x8380
movq %r14, %rdi
movq %r13, %rsi
callq 0x8300
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/quat.c
// Function: Concat
static int Concat(lua_State *L)
    {
    quat_t q;
    if(testquat(L, 1, q))
        {
        ToString_(L, q);
        lua_pushvalue(L, 2);
        }
    else if(testquat(L, 2, q))
        {
        lua_pushvalue(L, 1);
        ToString_(L, q);
        }
    else 
        return unexpected(L);
    lua_concat(L, 2);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
pushq $0x1
popq %rbx
movq %rsp, %rdx
movl %ebx, %esi
callq 0x8170
testl %eax, %eax
je 0x115db
movq %rsp, %rsi
movq %r14, %rdi
callq 0x11a75
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x8650
jmp 0x11603
pushq $0x2
popq %rsi
movq %rsp, %rdx
movq %r14, %rdi
callq 0x8170
testl %eax, %eax
je 0x11618
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x8650
movq %rsp, %rsi
movq %r14, %rdi
callq 0x11a75
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x8c70
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x4a55(%rip), %rsi      # 0x16074
leaq 0x5170(%rip), %rdx      # 0x16796
movq %r14, %rdi
movl $0xb7, %ecx
xorl %eax, %eax
callq 0x8b00
movl %eax, %ebx
jmp 0x1160e
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/quat.c
// Function: Unm
static int Unm(lua_State *L)
    {
    quat_t q; 
    size_t i; 
    checkquat(L, 1, q);
    for(i=0; i < 4; i++)    
        q[i] = -q[i];
    return pushquat(L, q);
    }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
movq %rsp, %rdx
callq 0x8260
xorl %eax, %eax
movaps 0x4a7b(%rip), %xmm0     # 0x160d0
cmpq $0x4, %rax
je 0x1166c
movsd (%rsp,%rax,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%rsp,%rax,8)
incq %rax
jmp 0x11655
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x8300
pushq $0x1
popq %rax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/quat.c
// Function: Add
static int Add(lua_State *L)
    {
    quat_t q, q1; 
    size_t i; 
    checkquat(L, 1, q);
    checkquat(L, 2, q1);
    for(i=0; i < 4; i++)    
        q[i] += q1[i];
    return pushquat(L, q);
    }

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
movq %rsp, %rdx
callq 0x8260
pushq $0x2
popq %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x8260
xorl %eax, %eax
cmpq $0x4, %rax
je 0x116c0
movsd 0x20(%rsp,%rax,8), %xmm0
addsd (%rsp,%rax,8), %xmm0
movsd %xmm0, (%rsp,%rax,8)
incq %rax
jmp 0x116a5
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x8300
pushq $0x1
popq %rax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/quat.c
// Function: Sub
static int Sub(lua_State *L)
    {
    quat_t q, q1; 
    size_t i; 
    checkquat(L, 1, q);
    checkquat(L, 2, q1);
    for(i=0; i < 4; i++)    
        q[i] -= q1[i];
    return pushquat(L, q);
    }

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
movq %rsp, %rdx
callq 0x8260
pushq $0x2
popq %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x8260
xorl %eax, %eax
cmpq $0x4, %rax
je 0x11714
movsd (%rsp,%rax,8), %xmm0
subsd 0x20(%rsp,%rax,8), %xmm0
movsd %xmm0, (%rsp,%rax,8)
incq %rax
jmp 0x116f9
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x8300
pushq $0x1
popq %rax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/quat.c
// Function: Mul
static int Mul(lua_State *L)
    {
    quat_t q, p, r; 
    if(lua_isnumber(L, 1))
        return Qxs(L, 1, 2);
    if(lua_isnumber(L, 2))
        return Qxs(L, 2, 1);
    checkquat(L, 1, q);
    checkquat(L, 2, p);
    r[0] = q[0]*p[0] - q[1]*p[1] - q[2]*p[2] - q[3]*p[3];
    r[1] = q[0]*p[1] + q[1]*p[0] + q[2]*p[3] - q[3]*p[2];
    r[2] = q[0]*p[2] + q[2]*p[0] + q[3]*p[1] - q[1]*p[3];
    r[3] = q[0]*p[3] + q[3]*p[0] + q[1]*p[2] - q[2]*p[1];
    return pushquat(L, r);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x85a0
testl %eax, %eax
je 0x11747
pushq $0x1
popq %rsi
pushq $0x2
jmp 0x1175b
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x85a0
testl %eax, %eax
je 0x11771
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x11ac7
pushq $0x1
popq %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
pushq $0x1
popq %rsi
leaq 0x40(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x8260
pushq $0x2
popq %rsi
leaq 0x20(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x8260
movapd (%r14), %xmm1
movapd (%r15), %xmm4
movapd 0x10(%r15), %xmm0
movapd %xmm0, %xmm3
shufpd $0x1, %xmm0, %xmm3      # xmm3 = xmm3[1],xmm0[0]
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
movsd 0x18(%r14), %xmm2
movapd %xmm2, %xmm5
unpcklpd %xmm2, %xmm5            # xmm5 = xmm5[0],xmm2[0]
mulpd %xmm3, %xmm5
movupd 0x8(%r14), %xmm3
movapd 0x48fc(%rip), %xmm6     # 0x160d0
xorpd %xmm3, %xmm6
movapd %xmm6, %xmm7
unpcklpd %xmm3, %xmm7            # xmm7 = xmm7[0],xmm3[0]
movapd %xmm1, %xmm8
mulpd %xmm4, %xmm8
unpckhpd %xmm3, %xmm6            # xmm6 = xmm6[1],xmm3[1]
mulpd %xmm0, %xmm6
movapd %xmm4, %xmm9
mulpd %xmm0, %xmm1
movapd %xmm4, %xmm10
shufpd $0x1, %xmm0, %xmm10     # xmm10 = xmm10[1],xmm0[0]
unpckhpd %xmm4, %xmm0            # xmm0 = xmm0[1],xmm4[1]
shufpd $0x1, %xmm4, %xmm4      # xmm4 = xmm4[1,0]
mulpd %xmm7, %xmm4
addpd %xmm4, %xmm8
addpd %xmm8, %xmm6
subpd %xmm5, %xmm6
movq %rsp, %rsi
movapd %xmm6, (%rsi)
unpcklpd %xmm9, %xmm9            # xmm9 = xmm9[0,0]
movupd 0x10(%r14), %xmm4
mulpd %xmm9, %xmm4
addpd %xmm4, %xmm1
unpcklpd %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0]
mulpd %xmm2, %xmm10
addpd %xmm1, %xmm10
mulpd %xmm3, %xmm0
subpd %xmm0, %xmm10
movapd %xmm10, 0x10(%rsi)
movq %rbx, %rdi
callq 0x8300
jmp 0x11764
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonglmath/src/quat.c
// Function: Div
static int Div(lua_State *L)
    {
    quat_t q; 
    size_t i; 
    double s;
    checkquat(L, 1, q);
    s = luaL_checknumber(L, 2);
    for(i=0; i < 4; i++)    
        q[i] /= s;
    return pushquat(L, q);
    }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
movq %rsp, %rdx
callq 0x8260
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x8350
xorl %eax, %eax
cmpq $0x4, %rax
je 0x1189f
movsd (%rsp,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rsp,%rax,8)
incq %rax
jmp 0x11886
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x8300
pushq $0x1
popq %rax
addq $0x20, %rsp
popq %rbx
retq