LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/mat.c
// Function: moonglmath_mat_Column
int mat_Column(lua_State *L)
    {
    mat_t m;
    vec_t v;
    size_t i, j, nr, nc;
    checkmat(L, 1, m, &nr, &nc);
    j = luaL_checkinteger(L, 2);
    if(j < 1 || j > nc)
        return luaL_argerror(L, 2, "invalid column index");
    j--;
    for(i = 0; i < nr; i++)
        v[i] = m[i][j];
    return pushvec(L, v, nr, nr, 0);
    }

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0xc8(%rsp)
movq 0xc8(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movl $0x1, %esi
leaq 0x8(%rsp), %rcx
movq %rsp, %r8
callq 0x8560
movq 0xc8(%rsp), %rdi
movl $0x2, %esi
callq 0x8740
movq %rax, 0x10(%rsp)
cmpq $0x1, 0x10(%rsp)
jb 0x15ee8
movq 0x10(%rsp), %rax
cmpq (%rsp), %rax
jbe 0x15f0a
movq 0xc8(%rsp), %rdi
movl $0x2, %esi
leaq 0xd69d(%rip), %rdx      # 0x23599
callq 0x81b0
movl %eax, 0xd4(%rsp)
jmp 0x15f89
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x15f63
movq 0x18(%rsp), %rcx
leaq 0x40(%rsp), %rax
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, 0x20(%rsp,%rax,8)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x15f21
movq 0xc8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x8(%rsp), %rcx
xorl %r8d, %r8d
callq 0x8310
movl %eax, 0xd4(%rsp)
movl 0xd4(%rsp), %eax
addq $0xd8, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/mat.c
// Function: moonglmath_mat_Row
int mat_Row(lua_State *L)
    {
    mat_t m;
    vec_t v;
    size_t i, j, nr, nc;
    checkmat(L, 1, m, &nr, &nc);
    i = luaL_checkinteger(L, 2);
    if(i < 1 || i > nr)
        return luaL_argerror(L, 2, "invalid row index");
    i--;
    for(j = 0; j < nc; j++)
        v[j] = m[i][j];
    return pushvec(L, v, nc, nc, 1);
    }

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0xc8(%rsp)
movq 0xc8(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movl $0x1, %esi
leaq 0x8(%rsp), %rcx
movq %rsp, %r8
callq 0x8560
movq 0xc8(%rsp), %rdi
movl $0x2, %esi
callq 0x8740
movq %rax, 0x18(%rsp)
cmpq $0x1, 0x18(%rsp)
jb 0x15ff9
movq 0x18(%rsp), %rax
cmpq 0x8(%rsp), %rax
jbe 0x1601b
movq 0xc8(%rsp), %rdi
movl $0x2, %esi
leaq 0xd5a1(%rip), %rdx      # 0x235ae
callq 0x81b0
movl %eax, 0xd4(%rsp)
jmp 0x1609a
movq 0x18(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq (%rsp), %rax
jae 0x16073
movq 0x18(%rsp), %rcx
leaq 0x40(%rsp), %rax
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, 0x20(%rsp,%rax,8)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x16032
movq 0xc8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq (%rsp), %rdx
movq (%rsp), %rcx
movl $0x1, %r8d
callq 0x8310
movl %eax, 0xd4(%rsp)
movl 0xd4(%rsp), %eax
addq $0xd8, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x238, %rsp            # imm = 0x238
movq %rdi, 0x228(%rsp)
movq 0x228(%rsp), %rdi
leaq 0x120(%rsp), %rdx
movl $0x1, %esi
leaq 0x18(%rsp), %rcx
leaq 0x10(%rsp), %r8
callq 0x8560
movq 0x228(%rsp), %rdi
leaq 0xa0(%rsp), %rdx
movl $0x2, %esi
leaq 0x8(%rsp), %rcx
movq %rsp, %r8
callq 0x8560
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
jne 0x1611c
movq (%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x1614a
movq 0x228(%rsp), %rdi
leaq 0xd495(%rip), %rsi      # 0x235c0
leaq 0xd4a8(%rip), %rdx      # 0x235da
movl $0x334, %ecx            # imm = 0x334
movb $0x0, %al
callq 0x8b30
movl %eax, 0x234(%rsp)
jmp 0x16207
movq 0x228(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movl $0x3, %esi
leaq 0x8(%rsp), %rcx
movq %rsp, %r8
callq 0x8560
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
jne 0x16180
movq (%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x161ab
movq 0x228(%rsp), %rdi
leaq 0xd431(%rip), %rsi      # 0x235c0
leaq 0xd444(%rip), %rdx      # 0x235da
movl $0x337, %ecx            # imm = 0x337
movb $0x0, %al
callq 0x8b30
movl %eax, 0x234(%rsp)
jmp 0x16207
leaq 0x1a0(%rsp), %rdi
leaq 0x120(%rsp), %rsi
leaq 0xa0(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x10(%rsp), %r9
callq 0x8080
movq 0x228(%rsp), %rdi
leaq 0x1a0(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x10(%rsp), %r9
callq 0x8500
movl %eax, 0x234(%rsp)
movl 0x234(%rsp), %eax
addq $0x238, %rsp            # imm = 0x238
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdi, 0x1b8(%rsp)
movq 0x1b8(%rsp), %rdi
leaq 0xb0(%rsp), %rdx
movl $0x1, %esi
leaq 0x20(%rsp), %rcx
leaq 0x18(%rsp), %r8
callq 0x8560
movq 0x1b8(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movl $0x2, %esi
leaq 0x10(%rsp), %rcx
leaq 0x8(%rsp), %r8
callq 0x8560
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
jne 0x1628c
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x162b7
movq 0x1b8(%rsp), %rdi
leaq 0xd325(%rip), %rsi      # 0x235c0
leaq 0xd338(%rip), %rdx      # 0x235da
movl $0x344, %ecx            # imm = 0x344
movb $0x0, %al
callq 0x8b30
movl %eax, 0x1c4(%rsp)
jmp 0x16329
movq 0x1b8(%rsp), %rdi
movl $0x3, %esi
callq 0x8350
movsd %xmm0, 0x28(%rsp)
leaq 0x130(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movsd 0x28(%rsp), %xmm0
callq 0x8440
movq 0x1b8(%rsp), %rdi
leaq 0x130(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %r9
callq 0x8500
movl %eax, 0x1c4(%rsp)
movl 0x1c4(%rsp), %eax
addq $0x1c8, %rsp            # imm = 0x1C8
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, 0x1c8(%rsp)
movq 0x1c8(%rsp), %rdi
leaq 0xc0(%rsp), %rdx
movl $0x1, %esi
leaq 0x38(%rsp), %rcx
leaq 0x30(%rsp), %r8
callq 0x8560
movq 0x1c8(%rsp), %rdi
movl $0x2, %esi
callq 0x85a0
cmpl $0x0, %eax
je 0x16419
movq 0x1c8(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x8680
movsd %xmm0, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x38(%rsp), %rax
jae 0x16417
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x16405
movsd 0x8(%rsp), %xmm0
movq 0x18(%rsp), %rcx
leaq 0x40(%rsp), %rax
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x163c8
jmp 0x16407
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x163b3
jmp 0x1647f
movq 0x1c8(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movl $0x2, %esi
leaq 0x28(%rsp), %rcx
leaq 0x20(%rsp), %r8
callq 0x8560
movq 0x28(%rsp), %rax
cmpq 0x38(%rsp), %rax
jne 0x16452
movq 0x20(%rsp), %rax
cmpq 0x30(%rsp), %rax
je 0x1647d
movq 0x1c8(%rsp), %rdi
leaq 0xd15f(%rip), %rsi      # 0x235c0
leaq 0xd172(%rip), %rdx      # 0x235da
movl $0x35a, %ecx            # imm = 0x35A
movb $0x0, %al
callq 0x8b30
movl %eax, 0x1d4(%rsp)
jmp 0x164d3
jmp 0x1647f
leaq 0x140(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r8
callq 0x8cf0
movq 0x1c8(%rsp), %rdi
leaq 0x140(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %r8
movq 0x30(%rsp), %r9
callq 0x8500
movl %eax, 0x1d4(%rsp)
movl 0x1d4(%rsp), %eax
addq $0x1d8, %rsp            # imm = 0x1D8
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq 0x98(%rsp), %rdi
movq %rsp, %rdx
movl $0x1, %esi
leaq 0x90(%rsp), %rcx
leaq 0x88(%rsp), %r8
callq 0x8a30
cmpl $0x0, %eax
je 0x16b90
movq 0x98(%rsp), %rdi
movq %rsp, %rsi
movq 0x90(%rsp), %rdx
movq 0x88(%rsp), %rcx
callq 0x17730
movq 0x98(%rsp), %rdi
movl $0x2, %esi
callq 0x8650
jmp 0x16c1b
movq 0x98(%rsp), %rdi
movq %rsp, %rdx
movl $0x2, %esi
leaq 0x90(%rsp), %rcx
leaq 0x88(%rsp), %r8
callq 0x8a30
cmpl $0x0, %eax
je 0x16bee
movq 0x98(%rsp), %rdi
movl $0x1, %esi
callq 0x8650
movq 0x98(%rsp), %rdi
movq %rsp, %rsi
movq 0x90(%rsp), %rdx
movq 0x88(%rsp), %rcx
callq 0x17730
jmp 0x16c19
movq 0x98(%rsp), %rdi
leaq 0xc477(%rip), %rsi      # 0x23074
leaq 0xc9d6(%rip), %rdx      # 0x235da
movl $0x11b, %ecx            # imm = 0x11B
movb $0x0, %al
callq 0x8b30
movl %eax, 0xa4(%rsp)
jmp 0x16c38
jmp 0x16c1b
movq 0x98(%rsp), %rdi
movl $0x2, %esi
callq 0x8ca0
movl $0x1, 0xa4(%rsp)
movl 0xa4(%rsp), %eax
addq $0xa8, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq 0xa0(%rsp), %rdi
movq %rsp, %rdx
movl $0x1, %esi
leaq 0x88(%rsp), %rcx
leaq 0x80(%rsp), %r8
callq 0x8560
movq $0x0, 0x98(%rsp)
movq 0x98(%rsp), %rax
cmpq 0x88(%rsp), %rax
jae 0x16d4a
movq $0x0, 0x90(%rsp)
movq 0x90(%rsp), %rax
cmpq 0x80(%rsp), %rax
jae 0x16d2f
movq 0x98(%rsp), %rcx
movq %rsp, %rax
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x90(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq 0x98(%rsp), %rcx
movq %rsp, %rax
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x90(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x90(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x90(%rsp)
jmp 0x16cb2
jmp 0x16d31
movq 0x98(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x98(%rsp)
jmp 0x16c90
movq 0xa0(%rsp), %rdi
movq %rsp, %rsi
movq 0x88(%rsp), %rdx
movq 0x80(%rsp), %rcx
movq 0x88(%rsp), %r8
movq 0x80(%rsp), %r9
callq 0x8500
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x148, %rsp            # imm = 0x148
movq %rdi, 0x138(%rsp)
movq 0x138(%rsp), %rdi
leaq 0x80(%rsp), %rdx
movl $0x1, %esi
leaq 0x120(%rsp), %rcx
leaq 0x118(%rsp), %r8
callq 0x8560
movq 0x138(%rsp), %rdi
movq %rsp, %rdx
movl $0x2, %esi
leaq 0x110(%rsp), %rcx
leaq 0x108(%rsp), %r8
callq 0x8560
movq 0x120(%rsp), %rax
cmpq 0x110(%rsp), %rax
jne 0x16e12
movq 0x118(%rsp), %rax
cmpq 0x108(%rsp), %rax
je 0x16e40
movq 0x138(%rsp), %rdi
leaq 0xc79f(%rip), %rsi      # 0x235c0
leaq 0xc7b2(%rip), %rdx      # 0x235da
movl $0x23c, %ecx            # imm = 0x23C
movb $0x0, %al
callq 0x8b30
movl %eax, 0x144(%rsp)
jmp 0x16f35
movq $0x0, 0x130(%rsp)
movq 0x130(%rsp), %rax
cmpq 0x120(%rsp), %rax
jae 0x16ef9
movq $0x0, 0x128(%rsp)
movq 0x128(%rsp), %rax
cmpq 0x118(%rsp), %rax
jae 0x16ede
movq 0x130(%rsp), %rcx
movq %rsp, %rax
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x128(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x130(%rsp), %rcx
leaq 0x80(%rsp), %rax
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x128(%rsp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq 0x128(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x128(%rsp)
jmp 0x16e6e
jmp 0x16ee0
movq 0x130(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x130(%rsp)
jmp 0x16e4c
movq 0x138(%rsp), %rdi
leaq 0x80(%rsp), %rsi
movq 0x120(%rsp), %rdx
movq 0x118(%rsp), %rcx
movq 0x120(%rsp), %r8
movq 0x118(%rsp), %r9
callq 0x8500
movl %eax, 0x144(%rsp)
movl 0x144(%rsp), %eax
addq $0x148, %rsp            # imm = 0x148
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movl $0x1, %esi
leaq 0x98(%rsp), %rcx
leaq 0x90(%rsp), %r8
callq 0x8560
movq 0xb0(%rsp), %rdi
movl $0x2, %esi
callq 0x8350
movsd %xmm0, 0x8(%rsp)
movq $0x0, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
cmpq 0x98(%rsp), %rax
jae 0x174db
movq $0x0, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
cmpq 0x90(%rsp), %rax
jae 0x174c0
movsd 0x8(%rsp), %xmm1
movq 0xa8(%rsp), %rcx
leaq 0x10(%rsp), %rax
shlq $0x5, %rcx
addq %rcx, %rax
movq 0xa0(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq 0xa0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xa0(%rsp)
jmp 0x17468
jmp 0x174c2
movq 0xa8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xa8(%rsp)
jmp 0x1744a
movq 0xb0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x98(%rsp), %rdx
movq 0x90(%rsp), %rcx
movq 0x98(%rsp), %r8
movq 0x90(%rsp), %r9
callq 0x8500
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x138, %rsp            # imm = 0x138
movq %rdi, 0x128(%rsp)
movq 0x128(%rsp), %rdi
leaq 0x90(%rsp), %rdx
movl $0x1, %esi
leaq 0x120(%rsp), %rcx
leaq 0x118(%rsp), %r8
callq 0x8560
movq 0x118(%rsp), %rax
cmpq 0x120(%rsp), %rax
je 0x17599
movq 0x128(%rsp), %rdi
leaq 0xc046(%rip), %rsi      # 0x235c0
leaq 0xc059(%rip), %rdx      # 0x235da
movl $0x2ad, %ecx            # imm = 0x2AD
movb $0x0, %al
callq 0x8b30
movl %eax, 0x134(%rsp)
jmp 0x1771e
movq 0x128(%rsp), %rdi
movl $0x2, %esi
callq 0x8740
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x17609
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x8530
movsd 0xbaef(%rip), %xmm0     # 0x230c0
movsd %xmm0, 0x88(%rsp)
movsd 0xbade(%rip), %xmm0     # 0x230c0
movsd %xmm0, 0x60(%rsp)
movsd 0xbad0(%rip), %xmm0     # 0x230c0
movsd %xmm0, 0x38(%rsp)
movsd 0xbac2(%rip), %xmm0     # 0x230c0
movsd %xmm0, 0x10(%rsp)
jmp 0x176e5
cmpq $0x0, 0x8(%rsp)
jle 0x1762a
leaq 0x10(%rsp), %rdi
leaq 0x90(%rsp), %rsi
movl $0x80, %edx
callq 0x87d0
jmp 0x17691
leaq 0x10(%rsp), %rdi
leaq 0x90(%rsp), %rsi
movq 0x120(%rsp), %rdx
callq 0x82e0
cmpl $0x0, %eax
jne 0x1766e
movq 0x128(%rsp), %rdi
movl $0x1, %esi
leaq 0xbf2c(%rip), %rdx      # 0x23589
callq 0x81b0
movl %eax, 0x134(%rsp)
jmp 0x1771e
leaq 0x90(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x80, %edx
callq 0x87d0
xorl %eax, %eax
subq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jge 0x176e3
leaq 0x10(%rsp), %rdi
leaq 0x90(%rsp), %rsi
movq 0x120(%rsp), %rdx
movq 0x120(%rsp), %rcx
movq 0x120(%rsp), %r8
callq 0x8ad0
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x17699
jmp 0x176e5
movq 0x128(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x120(%rsp), %rdx
movq 0x118(%rsp), %rcx
movq 0x120(%rsp), %r8
movq 0x118(%rsp), %r9
callq 0x8500
movl %eax, 0x134(%rsp)
movl 0x134(%rsp), %eax
addq $0x138, %rsp            # imm = 0x138
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movl %esi, 0xbc(%rsp)
movl %edx, 0xb8(%rsp)
movq 0xc0(%rsp), %rdi
movl 0xbc(%rsp), %esi
callq 0x8350
movsd %xmm0, 0x8(%rsp)
movq 0xc0(%rsp), %rdi
movl 0xb8(%rsp), %esi
leaq 0x10(%rsp), %rdx
leaq 0xa0(%rsp), %rcx
leaq 0x98(%rsp), %r8
callq 0x8560
movq $0x0, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
cmpq 0xa0(%rsp), %rax
jae 0x17b69
movq $0x0, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
cmpq 0x98(%rsp), %rax
jae 0x17b4e
movsd 0x8(%rsp), %xmm0
movq 0xb0(%rsp), %rcx
leaq 0x10(%rsp), %rax
shlq $0x5, %rcx
addq %rcx, %rax
movq 0xa8(%rsp), %rcx
mulsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq 0xa8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xa8(%rsp)
jmp 0x17afa
jmp 0x17b50
movq 0xb0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xb0(%rsp)
jmp 0x17adc
movq 0xc0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0xa0(%rsp), %rdx
movq 0x98(%rsp), %rcx
movq 0xa0(%rsp), %r8
movq 0x98(%rsp), %r9
callq 0x8500
addq $0xc8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/mat.c
// Function: Mxv
static int Mxv(lua_State *L) /* MxN * Nx1 = N*1 (column vector)*/
    {
    unsigned int isrow;
    size_t i, j, nr, nc, size;
    mat_t m;
    vec_t v, v1;
    double s;
    checkmat(L, 1, m, &nr, &nc);
    checkvec(L, 2, v, &size, &isrow);
    if( isrow || (size != nc))
        {
#if 0
        if((size == 3) && (nr == 4) && (nc == 4))
            {
            /* Keep only the upper left 3x3 matrix */
            nr = nc = 3;
            }
        else
#endif
            return luaL_error(L, OPERANDS_ERROR);
        }
    for(i=0; i < nr; i++)
        {
        s = 0;
        for(j=0; j < size; j++)
            s += (m[i][j] * v[j]);
        v1[i] = s;
        }
    return pushvec(L, v1, size, size, 0);
    }

// Assembly:
subq $0x118, %rsp            # imm = 0x118
movq %rdi, 0x108(%rsp)
movq 0x108(%rsp), %rdi
leaq 0x50(%rsp), %rdx
movl $0x1, %esi
leaq 0xe8(%rsp), %rcx
leaq 0xe0(%rsp), %r8
callq 0x8560
movq 0x108(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movl $0x2, %esi
leaq 0xd8(%rsp), %rcx
leaq 0x104(%rsp), %r8
callq 0x86d0
cmpl $0x0, 0x104(%rsp)
jne 0x17c29
movq 0xd8(%rsp), %rax
cmpq 0xe0(%rsp), %rax
je 0x17c57
movq 0x108(%rsp), %rdi
leaq 0xb988(%rip), %rsi      # 0x235c0
leaq 0xb99b(%rip), %rdx      # 0x235da
movl $0x270, %ecx            # imm = 0x270
movb $0x0, %al
callq 0x8b30
movl %eax, 0x114(%rsp)
jmp 0x17d52
movq $0x0, 0xf8(%rsp)
movq 0xf8(%rsp), %rax
cmpq 0xe8(%rsp), %rax
jae 0x17d26
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq $0x0, 0xf0(%rsp)
movq 0xf0(%rsp), %rax
cmpq 0xd8(%rsp), %rax
jae 0x17cf9
movq 0xf8(%rsp), %rcx
leaq 0x50(%rsp), %rax
shlq $0x5, %rcx
addq %rcx, %rax
movq 0xf0(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0xf0(%rsp), %rax
movsd 0x30(%rsp,%rax,8), %xmm2
movsd 0x8(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0xf0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xf0(%rsp)
jmp 0x17c8e
movsd 0x8(%rsp), %xmm0
movq 0xf8(%rsp), %rax
movsd %xmm0, 0x10(%rsp,%rax,8)
movq 0xf8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xf8(%rsp)
jmp 0x17c63
movq 0x108(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0xd8(%rsp), %rdx
movq 0xd8(%rsp), %rcx
xorl %r8d, %r8d
callq 0x8310
movl %eax, 0x114(%rsp)
movl 0x114(%rsp), %eax
addq $0x118, %rsp            # imm = 0x118
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglmath/src/mat.c
// Function: IsMat
static int IsMat(lua_State *L, size_t nr, size_t nc)
    {
    size_t nr_, nc_;
    if(!testmat(L, 1, NULL, &nr_, &nc_))
        lua_pushboolean(L, 0);
    else
        lua_pushboolean(L, (nr_==nr) && (nc_==nc));
    return 1;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x18(%rsp), %rcx
leaq 0x10(%rsp), %r8
callq 0x8a30
cmpl $0x0, %eax
jne 0x18693
movq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x8890
jmp 0x186d1
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rcx
xorl %eax, %eax
cmpq 0x28(%rsp), %rcx
movb %al, 0xf(%rsp)
jne 0x186bf
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
sete %al
movb %al, 0xf(%rsp)
movq (%rsp), %rdi
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x8890
movl $0x1, %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x8350
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x8350
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x8350
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
callq 0x83c0
movq (%rsp), %rdi
callq 0x8840
movl $0x1, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x8350
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x8350
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x88e0
movq 0x8(%rsp), %rdi
callq 0x8840
movl $0x1, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x8350
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x8350
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x3, %esi
callq 0x8350
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
callq 0x86f0
movq (%rsp), %rdi
callq 0x8840
movl $0x1, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movl $0x28, %esi
callq 0x8620
movq %rax, (%rsp)
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x8530
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movl 0x18(%rax), %ecx
orl $0x1, %ecx
movq (%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x11417(%rip), %rax     # 0x29fe0
cmpl $0x0, (%rax)
je 0x18bea
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
movq 0x18(%rsp), %rcx
leaq 0xaacd(%rip), %rdi      # 0x236b0
movb $0x0, %al
callq 0x83a0
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
leaq 0xa1d8(%rip), %rdx      # 0x2337a
callq 0x8180
cmpl $0x0, %eax
jne 0x191b6
movl $0x0, 0x24(%rsp)
jmp 0x19227
cmpq $0x0, 0x8(%rsp)
je 0x1921f
movq $0x0, (%rsp)
cmpq $0x4, (%rsp)
jae 0x1921d
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movq (%rsp), %rdx
addq $0x1, %rdx
callq 0x8e10
movq 0x18(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x8350
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x80c0
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x191c6
jmp 0x1921f
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x8320
movq 0x10(%rsp), %rdi
leaq 0xa0a2(%rip), %rsi      # 0x2337a
callq 0x89f0
movq $0x0, (%rsp)
cmpq $0x4, (%rsp)
jae 0x19329
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x8840
movq 0x10(%rsp), %rdi
movq (%rsp), %rdx
addq $0x1, %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x86a0
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x192e5
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x8530
movq $0x0, (%rsp)
cmpq $0x4, (%rsp)
jae 0x193af
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x19367
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x4, 0x8(%rsp)
jae 0x194e2
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd (%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1949a
movsd (%rsp), %xmm0
callq 0x8db0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rsp)
movq $0x0, -0x10(%rsp)
cmpq $0x4, -0x10(%rsp)
jae 0x19561
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x18(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rsp)
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x19517
movsd -0x18(%rsp), %xmm0
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x8ed0
movsd %xmm0, (%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x4, 0x8(%rsp)
jae 0x195cc
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd (%rsp), %xmm0
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x19591
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movsd (%rax), %xmm0
movq -0x8(%rsp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x8(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x10(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x8(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x10(%rsp), %rax
movsd 0x18(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x8(%rsp), %rax
movsd %xmm0, 0x18(%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x8ed0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x8(%rsp), %rax
movsd (%rax), %xmm0
divsd (%rsp), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x8(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
divsd (%rsp), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq 0x8(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
divsd (%rsp), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movq 0x8(%rsp), %rax
movsd 0x18(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
divsd (%rsp), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, 0x18(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movsd %xmm0, -0x20(%rsp)
movsd 0x9623(%rip), %xmm0     # 0x230c0
subsd -0x20(%rsp), %xmm0
movsd %xmm0, -0x28(%rsp)
movsd -0x28(%rsp), %xmm0
movq -0x10(%rsp), %rax
movsd (%rax), %xmm2
movsd -0x20(%rsp), %xmm1
movq -0x18(%rsp), %rax
mulsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rsp), %rax
movsd %xmm0, (%rax)
movsd -0x28(%rsp), %xmm0
movq -0x10(%rsp), %rax
movsd 0x8(%rax), %xmm2
movsd -0x20(%rsp), %xmm1
movq -0x18(%rsp), %rax
mulsd 0x8(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movsd -0x28(%rsp), %xmm0
movq -0x10(%rsp), %rax
movsd 0x10(%rax), %xmm2
movsd -0x20(%rsp), %xmm1
movq -0x18(%rsp), %rax
mulsd 0x10(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x28(%rsp), %xmm0
movq -0x10(%rsp), %rax
movsd 0x18(%rax), %xmm2
movsd -0x20(%rsp), %xmm1
movq -0x18(%rsp), %rax
mulsd 0x18(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rsp), %rax
movsd %xmm0, 0x18(%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movl $0x1, %esi
callq 0x8260
movq $0x0, 0x18(%rsp)
cmpq $0x4, 0x18(%rsp)
jae 0x19ed1
movq 0x18(%rsp), %rax
movsd 0x20(%rsp,%rax,8), %xmm0
movq 0x18(%rsp), %rax
movsd 0x20(%rsp,%rax,8), %xmm2
movsd 0x10(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x19e8f
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x8db0
movq 0x8(%rsp), %rdi
callq 0x8840
movl $0x1, %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movl $0x1, %esi
callq 0x8260
movq $0x0, 0x8(%rsp)
cmpq $0x4, 0x8(%rsp)
jae 0x19f6e
movq 0x8(%rsp), %rax
movsd 0x10(%rsp,%rax,8), %xmm0
movq 0x8(%rsp), %rax
movsd 0x10(%rsp,%rax,8), %xmm2
movsd (%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x19f2e
movq 0x30(%rsp), %rdi
movsd (%rsp), %xmm0
callq 0x8840
movl $0x1, %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rsp, %rdx
movl $0x1, %esi
callq 0x8260
movsd 0x8(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x8300
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movl $0x1, %esi
callq 0x8260
movsd 0x28(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x40(%rsp), %rdi
movsd 0x20(%rsp), %xmm0
callq 0x8840
movq 0x40(%rsp), %rdi
movq %rsp, %rsi
movl $0x3, %ecx
xorl %r8d, %r8d
movq %rcx, %rdx
callq 0x8310
movl $0x2, %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xd8, %rsp
movq %rdi, 0xc8(%rsp)
movq 0xc8(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movl $0x1, %esi
leaq 0xc0(%rsp), %rcx
leaq 0xb8(%rsp), %r8
callq 0x8560
cmpq $0x3, 0xc0(%rsp)
jne 0x1a17c
cmpq $0x3, 0xb8(%rsp)
je 0x1a1b7
cmpq $0x4, 0xc0(%rsp)
jne 0x1a192
cmpq $0x4, 0xb8(%rsp)
je 0x1a1b7
movq 0xc8(%rsp), %rdi
movl $0x1, %esi
leaq 0x9562(%rip), %rdx      # 0x23708
callq 0x81b0
movl %eax, 0xd4(%rsp)
jmp 0x1a349
movsd 0x20(%rsp), %xmm0
addsd 0x48(%rsp), %xmm0
addsd 0x70(%rsp), %xmm0
movsd %xmm0, 0xb0(%rsp)
xorps %xmm0, %xmm0
ucomisd 0xb0(%rsp), %xmm0
jbe 0x1a292
movsd 0x8ed4(%rip), %xmm0     # 0x230c0
addsd 0x20(%rsp), %xmm0
subsd 0x48(%rsp), %xmm0
subsd 0x70(%rsp), %xmm0
callq 0x8db0
movsd %xmm0, 0xa0(%rsp)
movsd 0x94e4(%rip), %xmm0     # 0x236f8
divsd 0xa0(%rsp), %xmm0
movsd %xmm0, 0xa8(%rsp)
movsd 0x68(%rsp), %xmm0
subsd 0x50(%rsp), %xmm0
mulsd 0xa8(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x94b0(%rip), %xmm0     # 0x236f8
mulsd 0xa0(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x28(%rsp), %xmm0
addsd 0x40(%rsp), %xmm0
mulsd 0xa8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x60(%rsp), %xmm0
addsd 0x30(%rsp), %xmm0
mulsd 0xa8(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
jmp 0x1a332
movsd 0x8e26(%rip), %xmm0     # 0x230c0
addsd 0xb0(%rsp), %xmm0
callq 0x8db0
movsd %xmm0, 0xa0(%rsp)
movsd 0x943f(%rip), %xmm0     # 0x236f8
divsd 0xa0(%rsp), %xmm0
movsd %xmm0, 0xa8(%rsp)
movsd 0x9425(%rip), %xmm0     # 0x236f8
mulsd 0xa0(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x68(%rsp), %xmm0
subsd 0x50(%rsp), %xmm0
mulsd 0xa8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x30(%rsp), %xmm0
subsd 0x60(%rsp), %xmm0
mulsd 0xa8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x40(%rsp), %xmm0
addsd 0x28(%rsp), %xmm0
mulsd 0xa8(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0xc8(%rsp), %rdi
movq %rsp, %rsi
callq 0x8300
movl %eax, 0xd4(%rsp)
movl 0xd4(%rsp), %eax
addq $0xd8, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movl $0x1, %esi
callq 0x8260
movq 0x70(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movl $0x2, %esi
callq 0x8260
movq 0x70(%rsp), %rdi
movl $0x3, %esi
callq 0x8350
movsd %xmm0, 0x8(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movsd 0x8(%rsp), %xmm0
callq 0x87b0
movq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x8300
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movl $0x1, %esi
callq 0x8260
movq 0x70(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movl $0x2, %esi
callq 0x8260
movq 0x70(%rsp), %rdi
movl $0x3, %esi
callq 0x8350
movsd %xmm0, 0x8(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movsd 0x8(%rsp), %xmm0
callq 0x8380
movq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x8300
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rsp, %rdx
movl $0x1, %esi
callq 0x8170
cmpl $0x0, %eax
je 0x1a51e
movq 0x28(%rsp), %rdi
movq %rsp, %rsi
callq 0x1ab50
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x8650
jmp 0x1a57a
movq 0x28(%rsp), %rdi
movq %rsp, %rdx
movl $0x2, %esi
callq 0x8170
cmpl $0x0, %eax
je 0x1a553
movq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x8650
movq 0x28(%rsp), %rdi
movq %rsp, %rsi
callq 0x1ab50
jmp 0x1a578
movq 0x28(%rsp), %rdi
leaq 0x8b15(%rip), %rsi      # 0x23074
leaq 0x91d0(%rip), %rdx      # 0x23736
movl $0xb7, %ecx
movb $0x0, %al
callq 0x8b30
movl %eax, 0x34(%rsp)
jmp 0x1a591
jmp 0x1a57a
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x8ca0
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movl $0x1, %esi
callq 0x8260
movq $0x0, 0x8(%rsp)
cmpq $0x4, 0x8(%rsp)
jae 0x1a60b
movq 0x8(%rsp), %rax
movsd 0x10(%rsp,%rax,8), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x10(%rsp,%rax,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1a5c6
movq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x8300
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movl $0x1, %esi
callq 0x8260
movq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movl $0x2, %esi
callq 0x8260
movq $0x0, 0x8(%rsp)
cmpq $0x4, 0x8(%rsp)
jae 0x1a68e
movq 0x8(%rsp), %rax
movsd 0x10(%rsp,%rax,8), %xmm0
movq 0x8(%rsp), %rax
addsd 0x30(%rsp,%rax,8), %xmm0
movsd %xmm0, 0x30(%rsp,%rax,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1a65a
movq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x8300
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movl $0x1, %esi
callq 0x8260
movq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movl $0x2, %esi
callq 0x8260
movq $0x0, 0x8(%rsp)
cmpq $0x4, 0x8(%rsp)
jae 0x1a722
movq 0x8(%rsp), %rax
movsd 0x10(%rsp,%rax,8), %xmm1
movq 0x8(%rsp), %rax
movsd 0x30(%rsp,%rax,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp,%rax,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1a6ea
movq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x8300
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movl $0x1, %esi
callq 0x8260
movq 0x30(%rsp), %rdi
movl $0x2, %esi
callq 0x8350
movsd %xmm0, (%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x4, 0x8(%rsp)
jae 0x1aa1c
movsd (%rsp), %xmm1
movq 0x8(%rsp), %rax
movsd 0x10(%rsp,%rax,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp,%rax,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1a9ea
movq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x8300
addq $0x38, %rsp
retq