LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x120(%rsp), %rdx
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r8
movl $0x1, %esi
movq %r14, %rcx
callq 0x8520
leaq 0xa0(%rsp), %rdx
leaq 0x18(%rsp), %r15
movq %rsp, %r8
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rcx
callq 0x8520
movq (%r15), %rax
cmpq (%r14), %rax
jne 0xf507
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jne 0xf507
leaq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %r14
movq %rsp, %r8
movq %rbx, %rdi
movl $0x3, %esi
movq %r14, %rcx
callq 0x8520
movq 0x10(%rsp), %r8
cmpq %r8, (%r14)
jne 0xf531
movq 0x8(%rsp), %r9
cmpq %r9, (%rsp)
jne 0xf531
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 0x84d0
jmp 0xf524
leaq 0x812f(%rip), %rsi      # 0x1763d
leaq 0x8142(%rip), %rdx      # 0x17657
movq %rbx, %rdi
movl $0x334, %ecx            # imm = 0x334
xorl %eax, %eax
callq 0x8a80
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8105(%rip), %rsi      # 0x1763d
leaq 0x8118(%rip), %rdx      # 0x17657
movq %rbx, %rdi
movl $0x337, %ecx            # imm = 0x337
jmp 0xf51d
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0xa0(%rsp), %rdx
leaq 0x8(%rsp), %r14
movq %rsp, %r8
movl $0x1, %esi
movq %r14, %rcx
callq 0x8520
leaq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %r15
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rcx
callq 0x8520
movq (%r15), %rax
cmpq (%r14), %rax
jne 0xf5f6
movq 0x10(%rsp), %rax
cmpq (%rsp), %rax
jne 0xf5f6
movq %rbx, %rdi
movl $0x3, %esi
callq 0x8320
movq 0x8(%rsp), %rcx
movq (%rsp), %r8
leaq 0x120(%rsp), %r14
leaq 0xa0(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %r14, %rdi
callq 0x8410
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rdx, %r8
movq %rcx, %r9
callq 0x84d0
jmp 0xf613
leaq 0x8040(%rip), %rsi      # 0x1763d
leaq 0x8053(%rip), %rdx      # 0x17657
movq %rbx, %rdi
movl $0x344, %ecx            # imm = 0x344
xorl %eax, %eax
callq 0x8a80
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0xa0(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rsp, %r8
movl $0x1, %esi
callq 0x8520
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8560
testl %eax, %eax
je 0xf778
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x8630
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0xf736
movq (%rsp), %rcx
leaq 0x1(%rcx), %rdx
andq $-0x2, %rdx
leaq -0x1(%rcx), %rsi
movq %rsi, %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
leaq 0x28(%rsp), %rsi
xorl %edi, %edi
movdqa 0x7eee(%rip), %xmm2     # 0x17590
movdqa 0x7ef6(%rip), %xmm3     # 0x175a0
pxor %xmm3, %xmm1
pcmpeqd %xmm4, %xmm4
movdqa 0x7ef6(%rip), %xmm5     # 0x175b0
testq %rcx, %rcx
je 0xf72a
xorl %r8d, %r8d
movdqa %xmm2, %xmm6
movdqa %xmm6, %xmm7
pxor %xmm3, %xmm7
movdqa %xmm7, %xmm8
pcmpgtd %xmm1, %xmm8
pcmpeqd %xmm1, %xmm7
pshufd $0xf5, %xmm7, %xmm9     # xmm9 = xmm7[1,1,3,3]
pand %xmm8, %xmm9
pshufd $0xf5, %xmm8, %xmm7     # xmm7 = xmm8[1,1,3,3]
por %xmm9, %xmm7
movd %xmm7, %r9d
notl %r9d
testb $0x1, %r9b
je 0xf707
movsd %xmm0, -0x8(%rsi,%r8,8)
pxor %xmm4, %xmm7
pextrw $0x4, %xmm7, %r9d
testb $0x1, %r9b
je 0xf71d
movsd %xmm0, (%rsi,%r8,8)
addq $0x2, %r8
paddq %xmm5, %xmm6
cmpq %r8, %rdx
jne 0xf6c6
incq %rdi
addq $0x20, %rsi
cmpq %rax, %rdi
jne 0xf6ba
movq 0x8(%rsp), %rcx
movq (%rsp), %r8
leaq 0x120(%rsp), %r14
leaq 0xa0(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %r14, %rdi
callq 0x8c10
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %rdx, %r8
movq %rcx, %r9
callq 0x84d0
jmp 0xf7c9
leaq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %r14
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rcx
callq 0x8520
movq (%r14), %rax
cmpq 0x8(%rsp), %rax
jne 0xf7ac
movq 0x10(%rsp), %rax
cmpq (%rsp), %rax
je 0xf736
leaq 0x7e8a(%rip), %rsi      # 0x1763d
leaq 0x7e9d(%rip), %rdx      # 0x17657
movq %rbx, %rdi
movl $0x35a, %ecx            # imm = 0x35A
xorl %eax, %eax
callq 0x8a80
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rsp, %r8
movl $0x1, %esi
callq 0x8990
testl %eax, %eax
je 0xfec8
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1061c
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8600
jmp 0xff09
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rsp, %r8
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8990
testl %eax, %eax
je 0xff24
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8600
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1061c
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8bc0
movl $0x1, %eax
addq $0x90, %rsp
popq %rbx
retq
leaq 0x7149(%rip), %rsi      # 0x17074
leaq 0x7725(%rip), %rdx      # 0x17657
movq %rbx, %rdi
movl $0x11b, %ecx            # imm = 0x11B
xorl %eax, %eax
callq 0x8a80
jmp 0xff1b
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %rsp, %r8
movl $0x1, %esi
movq %r14, %rdx
movq %r15, %rcx
callq 0x8520
movq (%r15), %rdx
testq %rdx, %rdx
je 0xffad
movq (%rsp), %rax
xorl %ecx, %ecx
movaps 0x714c(%rip), %xmm0     # 0x170d0
testq %rax, %rax
je 0xffa1
xorl %esi, %esi
movsd (%r14,%rsi,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%r14,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0xff8b
incq %rcx
addq $0x20, %r14
cmpq %rdx, %rcx
jne 0xff84
movq (%rsp), %rcx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %rdx, %r8
movq %rcx, %r9
callq 0x84d0
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x20(%rsp), %r14
leaq 0x18(%rsp), %r12
leaq 0x8(%rsp), %r8
movl $0x1, %esi
movq %r14, %rdx
movq %r12, %rcx
callq 0x8520
leaq 0xa0(%rsp), %r15
leaq 0x10(%rsp), %r13
movq %rsp, %r8
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
movq %r13, %rcx
callq 0x8520
movq (%r12), %rdx
cmpq (%r13), %rdx
jne 0x10088
movq 0x8(%rsp), %rcx
cmpq (%rsp), %rcx
jne 0x10088
testq %rdx, %rdx
je 0x10073
xorl %eax, %eax
testq %rcx, %rcx
je 0x10063
xorl %esi, %esi
movsd (%r15,%rsi,8), %xmm0
addsd (%r14,%rsi,8), %xmm0
movsd %xmm0, (%r14,%rsi,8)
incq %rsi
cmpq %rsi, %rcx
jne 0x10049
incq %rax
addq $0x20, %r15
addq $0x20, %r14
cmpq %rdx, %rax
jne 0x10042
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
movq %rdx, %r8
movq %rcx, %r9
callq 0x84d0
jmp 0x100a5
leaq 0x75ae(%rip), %rsi      # 0x1763d
leaq 0x75c1(%rip), %rdx      # 0x17657
movq %rbx, %rdi
movl $0x23c, %ecx            # imm = 0x23C
xorl %eax, %eax
callq 0x8a80
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %rsp, %r8
movl $0x1, %esi
movq %r14, %rdx
movq %r15, %rcx
callq 0x8520
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8320
movq (%r15), %rdx
testq %rdx, %rdx
je 0x1046d
movq (%rsp), %rax
xorl %ecx, %ecx
testq %rax, %rax
je 0x10461
xorl %esi, %esi
movsd (%r14,%rsi,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%r14,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x10449
incq %rcx
addq $0x20, %r14
cmpq %rdx, %rcx
jne 0x10442
movq (%rsp), %rcx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %rdx, %r8
movq %rcx, %r9
callq 0x84d0
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x90(%rsp), %rdx
movq %rsp, %r14
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r14, %rcx
movq %r15, %r8
callq 0x8520
movq (%r15), %rax
cmpq (%r14), %rax
jne 0x10501
movq %rbx, %rdi
movl $0x2, %esi
callq 0x86e0
testq %rax, %rax
je 0x10523
movq %rax, %r14
jle 0x10574
leaq 0x10(%rsp), %rdi
leaq 0x90(%rsp), %rsi
movl $0x10, %ecx
rep  movsq (%rsi), %es:(%rdi)
jmp 0x105a6
leaq 0x7135(%rip), %rsi      # 0x1763d
leaq 0x7148(%rip), %rdx      # 0x17657
movq %rbx, %rdi
movl $0x2ad, %ecx            # imm = 0x2AD
xorl %eax, %eax
callq 0x8a80
jmp 0x105f5
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)
jmp 0x105d9
movq (%rsp), %rdx
leaq 0x10(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x82b0
testl %eax, %eax
je 0x10606
leaq 0x90(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x10, %ecx
rep  movsq (%rsi), %es:(%rdi)
negq %r14
cmpq $0x2, %r14
jl 0x105d9
movq (%rsp), %r15
decq %r14
leaq 0x10(%rsp), %r12
leaq 0x90(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r15, %rcx
movq %r15, %r8
callq 0x8a30
decq %r14
jne 0x105c0
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %rdx, %r8
movq %rcx, %r9
callq 0x84d0
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x6ff9(%rip), %rdx      # 0x17606
movq %rbx, %rdi
movl $0x1, %esi
callq 0x81b0
jmp 0x105f5
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/mat.c
// Function: ToString_
static int ToString_(lua_State *L, mat_t m, size_t nr, size_t nc)
/* With snprintf because lua_pushfstring does not support the %g conversion specifier */
    {
#define SZ 512
#define space (SZ-p)
    char str[SZ];
    int p=0;
    size_t i;
    p += snprintf(str, space, "{");
    for(i=0; i < nr; i++)
        {
        switch(nc)
            {
            case 2: p+=snprintf(str+p, space, "{ "FMT", "FMT" }, ", 
                            m[i][0], m[i][1]); break;
            case 3: p+=snprintf(str+p, space, "{ "FMT", "FMT", "FMT" }, ",
                            m[i][0], m[i][1], m[i][2]); break;
            case 4: p+=snprintf(str+p, space, "{ "FMT", "FMT", "FMT", "FMT" }, ", 
                            m[i][0], m[i][1], m[i][2], m[i][3]); break;
            default:
                return luaL_error(L, UNEXPECTED_ERROR);
            }
        if(space<0)
            { 
            /* truncate */
            p = SZ - 5; 
            p+=snprintf(str+p, space, " ...");
            lua_pushlstring(L, str, p);
            return 1;
            }
        }
    p-=2; /* strip the last separator */
    p+=snprintf(str+p, space, "}");
    lua_pushlstring(L, str, p);
    return 1;
#undef space
#undef SZ
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
movw $0x7b, (%rsp)
testq %rdx, %rdx
je 0x106e4
movq %rcx, %r14
leaq -0x2(%rcx), %rax
cmpq $0x2, %rax
ja 0x10721
movq %rdx, %r15
movq %rsi, %r12
addq $0x18, %r12
movl $0x1, %ebp
leaq 0x7015(%rip), %r13      # 0x1767b
movslq %ebp, %rax
leaq (%rsp,%rax), %rdi
movl $0x200, %ecx            # imm = 0x200
subl %eax, %ecx
movslq %ecx, %rsi
movsd -0x18(%r12), %xmm0
movsd -0x10(%r12), %xmm1
cmpq $0x3, %r14
je 0x106a1
cmpq $0x2, %r14
jne 0x106b8
leaq 0x6fc5(%rip), %rdx      # 0x1765d
movb $0x2, %al
callq 0x83f0
jmp 0x106cf
movsd -0x8(%r12), %xmm2
leaq 0x6fbb(%rip), %rdx      # 0x1766a
movb $0x3, %al
callq 0x83f0
jmp 0x106cf
movsd -0x8(%r12), %xmm2
movsd (%r12), %xmm3
movq %r13, %rdx
movb $0x4, %al
callq 0x83f0
addl %eax, %ebp
cmpl $0x201, %ebp            # imm = 0x201
jge 0x1074f
addq $0x20, %r12
decq %r15
jne 0x10666
jmp 0x106e9
movl $0x1, %ebp
movslq %ebp, %r15
movq %rsp, %r14
leaq (%r15,%r14), %rdi
addq $-0x2, %rdi
movl $0x202, %eax            # imm = 0x202
subl %r15d, %eax
movslq %eax, %rsi
leaq 0x6f87(%rip), %rdx      # 0x17690
xorl %eax, %eax
callq 0x83f0
addl %r15d, %eax
addl $-0x2, %eax
movslq %eax, %rdx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x1076b
leaq 0x694c(%rip), %rsi      # 0x17074
leaq 0x6f28(%rip), %rdx      # 0x17657
movq %rbx, %rdi
movl $0xf0, %ecx
xorl %eax, %eax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8a80
movq %rsp, %rsi
movb $0x0, 0x1ff(%rsi)
movl $0x2e2e2e20, 0x1fb(%rsi) # imm = 0x2E2E2E20
movl $0x1ff, %edx            # imm = 0x1FF
movq %rbx, %rdi
callq 0x8960
movl $0x1, %eax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0xa8, %rsp
movl %edx, %ebp
movq %rdi, %rbx
callq 0x8320
movsd %xmm0, 0x10(%rsp)
leaq 0x20(%rsp), %r14
leaq 0x18(%rsp), %r15
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %r15, %rcx
callq 0x8520
movsd 0x10(%rsp), %xmm1
movq (%r15), %rdx
testq %rdx, %rdx
je 0x10803
movq 0x8(%rsp), %rax
xorl %ecx, %ecx
testq %rax, %rax
je 0x107f7
xorl %esi, %esi
movsd (%r14,%rsi,8), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, (%r14,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x107df
incq %rcx
addq $0x20, %r14
cmpq %rdx, %rcx
jne 0x107d8
movq 0x8(%rsp), %rcx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
movq %rdx, %r8
movq %rcx, %r9
callq 0x84d0
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x8320
movapd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8320
movapd %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x8320
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 %rbx, %rdi
callq 0x87d0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x8320
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8320
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x8320
movsd 0x624c(%rip), %xmm1     # 0x170c0
subsd %xmm0, %xmm1
mulsd (%rsp), %xmm0
mulsd 0x8(%rsp), %xmm1
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x87d0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x8320
movapd %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8320
movapd (%rsp), %xmm1
cmplesd %xmm0, %xmm1
movsd 0x61de(%rip), %xmm0     # 0x170c0
andnpd %xmm0, %xmm1
movapd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x87d0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x8320
movapd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8320
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x8320
movapd 0x10(%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
subsd %xmm1, %xmm2
subsd %xmm1, %xmm0
divsd %xmm0, %xmm2
movsd 0x6125(%rip), %xmm0     # 0x170c0
minsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
cmpltsd %xmm1, %xmm2
andnpd %xmm0, %xmm2
movapd %xmm2, %xmm1
mulsd %xmm2, %xmm1
addsd %xmm2, %xmm2
movsd 0x6748(%rip), %xmm0     # 0x17708
subsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x87d0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x8320
movapd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8320
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x8320
movapd 0x10(%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
subsd %xmm1, %xmm2
subsd %xmm1, %xmm0
divsd %xmm0, %xmm2
movsd 0x6037(%rip), %xmm0     # 0x170c0
minsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
cmpltsd %xmm1, %xmm2
andnpd %xmm0, %xmm2
movapd %xmm2, %xmm1
mulsd %xmm2, %xmm1
mulsd %xmm2, %xmm1
movsd 0x6662(%rip), %xmm0     # 0x17710
mulsd %xmm2, %xmm0
addsd 0x665e(%rip), %xmm0     # 0x17718
mulsd %xmm2, %xmm0
addsd 0x665a(%rip), %xmm0     # 0x17720
mulsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x87d0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x28, %esi
movq %rbx, %rdx
callq 0x85e0
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movq %rbx, (%rax)
orb $0x1, 0x18(%rax)
movq 0xdec2(%rip), %rax      # 0x1efe0
cmpl $0x0, (%rax)
je 0x1113a
leaq 0x65fe(%rip), %rdi      # 0x17728
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x8370
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r12
xorl %eax, %eax
movl %eax, (%rdx)
movl %eax, (%rcx)
callq 0x8c40
testl %eax, %eax
jle 0x11398
movq %r12, %rdi
movl %ebp, %esi
callq 0x8c40
movl $0xfffffffc, %ecx       # imm = 0xFFFFFFFC
cmpl $0x5, %eax
jne 0x113c9
movq %r12, %rdi
movl %ebp, %esi
callq 0x8c60
movl %eax, (%r14)
testl %eax, %eax
je 0x1139f
movl %eax, %esi
shlq $0x3, %rsi
movq %r12, %rdi
callq 0x89f0
testq %rax, %rax
je 0x113a6
movq %rax, %r13
cmpl $0x0, (%r14)
je 0x113ce
movq %rbx, 0x8(%rsp)
xorl %r15d, %r15d
leaq 0x1(%r15), %rbx
movq %r12, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x8380
movq %r12, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq 0x10(%rsp), %rdx
callq 0x8750
testq %rax, %rax
je 0x1136d
testb $0x1, 0x18(%rax)
jne 0x11371
xorl %eax, %eax
jmp 0x11374
movq (%rax), %rax
movq %rax, (%r13,%r15,8)
testq %rax, %rax
je 0x113ad
movq %r12, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x80c0
movl (%r14), %eax
movq %rbx, %r15
cmpq %rax, %rbx
jb 0x1133f
jmp 0x113ce
movl $0x1, %ecx
jmp 0x113c9
movl $0xfffffffb, %ecx       # imm = 0xFFFFFFFB
jmp 0x113c9
movl $0xfffffffa, %ecx       # imm = 0xFFFFFFFA
jmp 0x113c2
movq %r12, %rdi
movq %r13, %rsi
callq 0x85f0
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
movq 0x8(%rsp), %rbx
movl $0x0, (%r14)
movl %ecx, (%rbx)
xorl %r13d, %r13d
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x5fc3(%rip), %rdx      # 0x173ba
callq 0x8170
testl %eax, %eax
je 0x1144a
movl $0x1, %r15d
testq %rbx, %rbx
je 0x1144d
movl $0x1, %r12d
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x8d30
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x8320
movsd %xmm0, -0x8(%rbx,%r12,8)
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x80c0
incq %r12
cmpq $0x5, %r12
jne 0x11411
jmp 0x1144d
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0x82f0
leaq 0x5efb(%rip), %rsi      # 0x173ba
movq %r14, %rdi
callq 0x8950
movl $0x1, %r15d
movsd -0x8(%rbx,%r15,8), %xmm0
movq %r14, %rdi
callq 0x87d0
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r15, %rdx
callq 0x8640
incq %r15
cmpq $0x5, %r15
jne 0x114cd
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
xorpd %xmm0, %xmm0
xorl %eax, %eax
movsd (%rbx,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq $0x4, %rax
jne 0x115b5
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x115db
sqrtsd %xmm0, %xmm0
jmp 0x115e0
callq 0x8cd0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
xorl %eax, %eax
movupd (%rbx,%rax,8), %xmm1
divpd %xmm0, %xmm1
movupd %xmm1, (%rbx,%rax,8)
addq $0x2, %rax
cmpq $0x4, %rax
jne 0x115e6
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5abc(%rip), %xmm1     # 0x170d0
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_O1/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, %r14
movq %rdi, %rbx
xorpd %xmm0, %xmm0
xorl %eax, %eax
movsd (%r14,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq $0x4, %rax
jne 0x11644
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1166b
sqrtsd %xmm0, %xmm0
jmp 0x11670
callq 0x8cd0
mulsd %xmm0, %xmm0
movsd (%r14), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx)
movsd 0x8(%r14), %xmm1
movapd 0x5a41(%rip), %xmm2     # 0x170d0
xorpd %xmm2, %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rbx)
movsd 0x10(%r14), %xmm1
xorpd %xmm2, %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rbx)
movsd 0x18(%r14), %xmm1
xorpd %xmm2, %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/quat.c
// Function: moonglmath_quat_mul
void quat_mul(quat_t dst, quat_t q, quat_t p)
    {
    dst[0] = q[0]*p[0] - q[1]*p[1] - q[2]*p[2] - q[3]*p[3];
    dst[1] = q[0]*p[1] + q[1]*p[0] + q[2]*p[3] - q[3]*p[2];
    dst[2] = q[0]*p[2] + q[2]*p[0] + q[3]*p[1] - q[1]*p[3];
    dst[3] = q[0]*p[3] + q[3]*p[0] + q[1]*p[2] - q[2]*p[1];
    }

// Assembly:
movsd 0x8(%rdx), %xmm0
mulsd 0x8(%rsi), %xmm0
movsd (%rsi), %xmm1
movsd 0x10(%rsi), %xmm2
mulsd (%rdx), %xmm1
subsd %xmm0, %xmm1
mulsd 0x10(%rdx), %xmm2
subsd %xmm2, %xmm1
movsd 0x18(%rsi), %xmm0
mulsd 0x18(%rdx), %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, (%rdi)
movsd (%rsi), %xmm0
movsd 0x8(%rsi), %xmm1
mulsd (%rdx), %xmm1
mulsd 0x8(%rdx), %xmm0
addsd %xmm1, %xmm0
movsd 0x10(%rsi), %xmm1
mulsd 0x18(%rdx), %xmm1
addsd %xmm0, %xmm1
movsd 0x18(%rsi), %xmm0
mulsd 0x10(%rdx), %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rdi)
movsd 0x10(%rsi), %xmm0
mulsd (%rdx), %xmm0
movsd (%rsi), %xmm1
movsd 0x8(%rsi), %xmm2
mulsd 0x10(%rdx), %xmm1
addsd %xmm0, %xmm1
movsd 0x18(%rsi), %xmm0
mulsd 0x8(%rdx), %xmm0
addsd %xmm1, %xmm0
mulsd 0x18(%rdx), %xmm2
subsd %xmm2, %xmm0
movsd %xmm0, 0x10(%rdi)
movsd 0x18(%rsi), %xmm0
mulsd (%rdx), %xmm0
movsd (%rsi), %xmm1
movsd 0x8(%rsi), %xmm2
mulsd 0x18(%rdx), %xmm1
addsd %xmm0, %xmm1
mulsd 0x10(%rdx), %xmm2
addsd %xmm1, %xmm2
movsd 0x10(%rsi), %xmm0
mulsd 0x8(%rdx), %xmm0
subsd %xmm0, %xmm2
movsd %xmm2, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x58de(%rip), %xmm1     # 0x170c0
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_O1/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
movq %rsp, %rdx
movl $0x1, %esi
callq 0x8240
xorpd %xmm0, %xmm0
xorl %eax, %eax
movsd (%rsp,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq $0x4, %rax
jne 0x11a50
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x11a76
sqrtsd %xmm0, %xmm0
jmp 0x11a7b
callq 0x8cd0
movq %rbx, %rdi
callq 0x87d0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rsp, %rdx
movl $0x1, %esi
callq 0x8240
xorpd %xmm0, %xmm0
xorl %eax, %eax
movsd (%rsp,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq $0x4, %rax
jne 0x11aa9
movq %rbx, %rdi
callq 0x87d0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x8240
movups 0x8(%r14), %xmm0
movaps 0x55d8(%rip), %xmm1     # 0x170d0
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 0x82d0
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/quat.c
// Function: moonglmath_quat_Normalize
int quat_Normalize(lua_State *L)
    {
    quat_t q; 
    checkquat(L, 1, q);
    quat_normalize(q);
    return pushquat(L, q);
    }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsp, %rdx
movl $0x1, %esi
callq 0x8240
xorpd %xmm0, %xmm0
xorl %eax, %eax
movsd (%rsp,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq $0x4, %rax
jne 0x11b41
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x11b67
sqrtsd %xmm0, %xmm0
jmp 0x11b6c
callq 0x8cd0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
xorl %eax, %eax
movapd (%rsp,%rax,8), %xmm1
divpd %xmm0, %xmm1
movapd %xmm1, (%rsp,%rax,8)
addq $0x2, %rax
cmpq $0x4, %rax
jne 0x11b72
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x82d0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x20(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x8240
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 0x87d0
movl $0x3, %edx
movl $0x3, %ecx
movq %rbx, %rdi
movq %r15, %rsi
xorl %r8d, %r8d
callq 0x82e0
movl $0x2, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdx
leaq 0xa8(%rsp), %r14
leaq 0xa0(%rsp), %r15
movl $0x1, %esi
movq %r14, %rcx
movq %r15, %r8
callq 0x8520
movq (%r14), %rax
movq %rax, %rdx
xorq $0x3, %rdx
movq (%r15), %rcx
movq %rcx, %rsi
xorq $0x3, %rsi
orq %rdx, %rsi
je 0x11caa
xorq $0x4, %rax
xorq $0x4, %rcx
orq %rax, %rcx
jne 0x11d05
movsd 0x20(%rsp), %xmm0
movsd 0x48(%rsp), %xmm3
movapd %xmm0, %xmm1
addsd %xmm3, %xmm1
movsd 0x70(%rsp), %xmm4
addsd %xmm4, %xmm1
xorpd %xmm2, %xmm2
ucomisd %xmm1, %xmm2
jbe 0x11cee
addsd 0x53e6(%rip), %xmm0     # 0x170c0
subsd %xmm3, %xmm0
subsd %xmm4, %xmm0
ucomisd %xmm2, %xmm0
jb 0x11d1e
sqrtsd %xmm0, %xmm0
jmp 0x11d23
addsd 0x53ca(%rip), %xmm1     # 0x170c0
ucomisd %xmm2, %xmm1
jb 0x11d79
xorps %xmm0, %xmm0
sqrtsd %xmm1, %xmm0
jmp 0x11d82
leaq 0x5a9c(%rip), %rdx      # 0x177a8
movq %rbx, %rdi
movl $0x1, %esi
callq 0x81b0
jmp 0x11dee
callq 0x8cd0
movsd 0x5a6d(%rip), %xmm2     # 0x17798
movsd 0x68(%rsp), %xmm3
subsd 0x50(%rsp), %xmm3
divsd %xmm0, %xmm2
movsd 0x28(%rsp), %xmm4
addsd 0x40(%rsp), %xmm4
movsd 0x60(%rsp), %xmm1
mulsd %xmm2, %xmm4
addsd 0x30(%rsp), %xmm1
mulsd %xmm2, %xmm1
shufpd $0x2, 0x5a1c(%rip), %xmm3 # xmm3 = xmm3[0],mem[1]
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
mulpd %xmm2, %xmm3
movapd %xmm3, (%rsp)
movsd %xmm4, 0x10(%rsp)
jmp 0x11dd9
movapd %xmm1, %xmm0
callq 0x8cd0
movsd 0x5a0e(%rip), %xmm2     # 0x17798
divsd %xmm0, %xmm2
movsd 0x68(%rsp), %xmm1
subsd 0x50(%rsp), %xmm1
unpcklpd %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0]
movapd 0x59ca(%rip), %xmm3     # 0x17770
unpcklpd %xmm1, %xmm3            # xmm3 = xmm3[0],xmm1[0]
mulpd %xmm0, %xmm3
movapd %xmm3, (%rsp)
movsd 0x30(%rsp), %xmm0
movsd 0x40(%rsp), %xmm1
subsd 0x60(%rsp), %xmm0
mulsd %xmm2, %xmm0
movsd %xmm0, 0x10(%rsp)
addsd 0x28(%rsp), %xmm1
mulsd %xmm2, %xmm1
movq %rsp, %rsi
movsd %xmm1, 0x18(%rsi)
movq %rbx, %rdi
callq 0x82d0
movl $0x1, %eax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x8240
movq %rsp, %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x8240
movq %rbx, %rdi
movl $0x3, %esi
callq 0x8320
movsd 0x527f(%rip), %xmm1     # 0x170c0
subsd %xmm0, %xmm1
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movapd (%r15), %xmm2
mulpd %xmm0, %xmm2
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
movapd (%r14), %xmm3
mulpd %xmm1, %xmm3
addpd %xmm2, %xmm3
leaq 0x40(%rsp), %rsi
movapd %xmm3, (%rsi)
mulpd 0x10(%r15), %xmm0
mulpd 0x10(%r14), %xmm1
addpd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsi)
movq %rbx, %rdi
callq 0x82d0
movl $0x1, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x8240
movq %rsp, %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x8240
movq %rbx, %rdi
movl $0x3, %esi
callq 0x8320
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x8350
movq %rbx, %rdi
movq %r12, %rsi
callq 0x82d0
movl $0x1, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsp, %rdx
movl $0x1, %esi
callq 0x8160
testl %eax, %eax
je 0x11fb3
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x124a4
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8600
jmp 0x11fdf
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8160
testl %eax, %eax
je 0x11ff7
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8600
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x124a4
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8bc0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbx
retq
leaq 0x5076(%rip), %rsi      # 0x17074
leaq 0x57d1(%rip), %rdx      # 0x177d6
movq %rbx, %rdi
movl $0xb7, %ecx
xorl %eax, %eax
callq 0x8a80
jmp 0x11ff1
// File: /workspace/github_c_makefile_star2_O1/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
movq %rsp, %rdx
movl $0x1, %esi
callq 0x8240
xorl %eax, %eax
movaps 0x509c(%rip), %xmm0     # 0x170d0
movaps (%rsp,%rax,8), %xmm1
xorps %xmm0, %xmm1
movaps %xmm1, (%rsp,%rax,8)
addq $0x2, %rax
cmpq $0x4, %rax
jne 0x12034
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x82d0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rsp, %rdx
movl $0x1, %esi
callq 0x8240
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8240
xorl %eax, %eax
movapd 0x20(%rsp,%rax,8), %xmm0
addpd (%rsp,%rax,8), %xmm0
movapd %xmm0, (%rsp,%rax,8)
addq $0x2, %rax
cmpq $0x4, %rax
jne 0x12088
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x82d0
movl $0x1, %eax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rsp, %rdx
movl $0x1, %esi
callq 0x8240
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8240
xorl %eax, %eax
movapd (%rsp,%rax,8), %xmm0
subpd 0x20(%rsp,%rax,8), %xmm0
movapd %xmm0, (%rsp,%rax,8)
addq $0x2, %rax
cmpq $0x4, %rax
jne 0x120e1
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x82d0
movl $0x1, %eax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %esi
callq 0x8560
testl %eax, %eax
je 0x1213a
movq %rbx, %rdi
movl $0x1, %esi
movl $0x2, %edx
jmp 0x12158
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8560
testl %eax, %eax
je 0x1216c
movq %rbx, %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x124f6
movl $0x1, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x40(%rsp), %r14
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0x8240
leaq 0x20(%rsp), %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rdx
callq 0x8240
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 0x4efd(%rip), %xmm6     # 0x170d0
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 0x82d0
jmp 0x1215d
// File: /workspace/github_c_makefile_star2_O1/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
movq %rsp, %rdx
movl $0x1, %esi
callq 0x8240
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8320
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
xorl %eax, %eax
movapd (%rsp,%rax,8), %xmm1
divpd %xmm0, %xmm1
movapd %xmm1, (%rsp,%rax,8)
addq $0x2, %rax
cmpq $0x4, %rax
jne 0x1228d
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x82d0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbx
retq