LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/quat.c
// Function: Pow
static int Pow(lua_State *L)
    {
    quat_t q, dst; 
    lua_Integer n, i;
    checkquat(L, 1, q);
    n = luaL_checkinteger(L, 2);
    if(n == 0)
        {
        quat_clear(dst); dst[0]=1;  
        }
    else
        {
        if(n > 0)
            quat_copy(dst, q);
        else
            {
            quat_inv(dst, q);
            quat_copy(q, dst);
            n = -n;
            }
        for(i = 0; i < (n-1); i++)
            quat_mulby(dst, q);
        }
    return pushquat(L, dst);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdx
movl $0x1, %esi
callq 0x8240
movq %rbx, %rdi
movl $0x2, %esi
callq 0x86e0
testq %rax, %rax
je 0x12306
movq %rax, %r14
jle 0x1231f
movaps 0x20(%rsp), %xmm0
movapd 0x30(%rsp), %xmm1
movapd %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
jmp 0x1234b
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movsd 0x4da6(%rip), %xmm0     # 0x170c0
jmp 0x12484
movq %rsp, %r15
leaq 0x20(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x8d50
movaps (%r15), %xmm0
movapd 0x10(%r15), %xmm1
movapd %xmm1, 0x10(%r12)
movaps %xmm0, (%r12)
negq %r14
movsd (%rsp), %xmm0
cmpq $0x2, %r14
jl 0x12484
movsd 0x20(%rsp), %xmm1
movsd 0x28(%rsp), %xmm2
movapd 0x30(%rsp), %xmm3
movsd 0x10(%rsp), %xmm4
movsd 0x18(%rsp), %xmm8
movhps 0x8(%rsp), %xmm8        # xmm8 = xmm8[0,1],mem[0,1]
movapd %xmm1, %xmm5
unpcklpd %xmm1, %xmm5            # xmm5 = xmm5[0],xmm1[0]
movapd %xmm3, %xmm6
unpckhpd %xmm3, %xmm6            # xmm6 = xmm6[1],xmm3[1]
movapd %xmm3, %xmm7
shufpd $0x1, %xmm2, %xmm7      # xmm7 = xmm7[1],xmm2[0]
movapd %xmm2, %xmm9
unpcklpd %xmm3, %xmm9            # xmm9 = xmm9[0],xmm3[0]
decq %r14
movaps 0x4d23(%rip), %xmm10    # 0x170d0
movapd %xmm0, %xmm12
movaps %xmm8, %xmm0
xorps %xmm10, %xmm0
pshufd $0xee, %xmm0, %xmm11    # xmm11 = xmm0[2,3,2,3]
mulsd %xmm2, %xmm11
movapd %xmm12, %xmm13
mulsd %xmm1, %xmm13
addsd %xmm11, %xmm13
movapd %xmm4, %xmm11
mulsd %xmm3, %xmm11
subsd %xmm11, %xmm13
mulsd %xmm6, %xmm0
addsd %xmm13, %xmm0
movaps %xmm8, %xmm11
unpckhpd %xmm8, %xmm11           # xmm11 = xmm11[1],xmm8[1]
movaps %xmm8, %xmm13
shufps $0x4e, %xmm4, %xmm13    # xmm13 = xmm13[2,3],xmm4[0,1]
mulpd %xmm5, %xmm13
movapd %xmm12, %xmm14
unpcklpd %xmm12, %xmm14          # xmm14 = xmm14[0],xmm12[0]
mulpd %xmm9, %xmm14
addpd %xmm13, %xmm14
movaps %xmm4, %xmm13
movlhps %xmm8, %xmm13           # xmm13 = xmm13[0],xmm8[0]
mulpd %xmm7, %xmm13
addpd %xmm14, %xmm13
movaps %xmm8, %xmm14
mulpd %xmm3, %xmm14
subpd %xmm14, %xmm13
mulsd %xmm1, %xmm8
mulsd %xmm6, %xmm12
addsd %xmm8, %xmm12
mulsd %xmm3, %xmm11
addsd %xmm12, %xmm11
mulsd %xmm2, %xmm4
subsd %xmm4, %xmm11
movapd %xmm11, %xmm8
unpcklpd %xmm13, %xmm8           # xmm8 = xmm8[0],xmm13[0]
movapd %xmm13, %xmm4
unpckhpd %xmm13, %xmm4           # xmm4 = xmm4[1],xmm13[1]
decq %r14
jne 0x123ad
movupd %xmm13, 0x8(%rsp)
movsd %xmm11, 0x18(%rsp)
movq %rsp, %rsi
movsd %xmm0, (%rsi)
movq %rbx, %rdi
callq 0x82d0
movl $0x1, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/quat.c
// Function: Qxs
static int Qxs(lua_State *L, int sarg, int qarg)
    {
    quat_t q; 
    size_t i; 
    double s = luaL_checknumber(L, sarg);
    checkquat(L, qarg, q);
    for(i=0; i < 4; i++)    
        q[i] *= s;
    return pushquat(L, q);
    }

// Assembly:
pushq %rbp
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rdi, %rbx
callq 0x8320
movapd %xmm0, (%rsp)
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8240
movapd (%rsp), %xmm1
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
xorl %eax, %eax
movapd 0x10(%rsp,%rax,8), %xmm0
mulpd %xmm1, %xmm0
movapd %xmm0, 0x10(%rsp,%rax,8)
addq $0x2, %rax
cmpq $0x4, %rax
jne 0x12525
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x82d0
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/quat.c
// Function: quat_Mat
static int quat_Mat(lua_State *L, size_t n)
/* returns the rotation matrix corresponding to the quaternion */
    {
#define w q[0]
#define x q[1]
#define y q[2]
#define z q[3]
    quat_t q; 
    mat_t m;
    double s, wx, wy, wz, xx, yy, zz, xy, xz, yz;
    checkquat(L, 1, q);
    mat_clear(m);
    s = w*w + x*x + y*y +z*z;
    if(s == 0)
        {
        m[0][0] = m[1][1] = m[2][2] = m[3][3] = 1;
        return pushmat(L, m, 4, 4, n, n);
        }
    s = 2 / s;  
    wx = s*w*x;
    wy = s*w*y;
    wz = s*w*z;
    xx = s*x*x;
    yy = s*y*y;
    zz = s*z*z;
    xy = s*x*y;
    xz = s*x*z;
    yz = s*y*z;
    
    m[0][0] = 1 - yy - zz;
    m[1][1] = 1 - xx - zz;
    m[2][2] = 1 - xx - yy;
    m[3][3] = 1;
    m[0][1] = xy - wz;
    m[1][0] = xy + wz;
    m[0][2] = xz + wy;
    m[2][0] = xz - wy;
    m[1][2] = yz - wx;
    m[2][1] = yz + wx;
    return pushmat(L, m, 4, 4, n, n);
#undef w
#undef x
#undef y
#undef z
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x80(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
callq 0x8240
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x70(%rsp)
movsd (%r15), %xmm0
movsd 0x8(%r15), %xmm2
movapd %xmm2, %xmm1
mulsd %xmm2, %xmm1
movapd %xmm0, %xmm3
mulsd %xmm0, %xmm3
addsd %xmm1, %xmm3
movsd 0x10(%r15), %xmm1
movapd %xmm1, %xmm4
mulsd %xmm1, %xmm4
addsd %xmm3, %xmm4
movsd 0x18(%r15), %xmm7
movapd %xmm7, %xmm3
mulsd %xmm7, %xmm3
addsd %xmm4, %xmm3
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm3
jne 0x12623
jp 0x12623
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x78(%rsp)
movq %rax, 0x50(%rsp)
movq %rax, 0x28(%rsp)
movq %rax, (%rsp)
jmp 0x12712
movsd 0x5174(%rip), %xmm8     # 0x177a0
divsd %xmm3, %xmm8
mulsd %xmm8, %xmm0
movapd %xmm2, %xmm3
mulsd %xmm0, %xmm3
movapd %xmm1, %xmm4
mulsd %xmm0, %xmm4
mulsd %xmm7, %xmm0
movapd %xmm2, %xmm6
mulsd %xmm8, %xmm6
mulsd %xmm6, %xmm2
movapd %xmm1, %xmm5
mulsd %xmm8, %xmm5
movapd %xmm1, %xmm9
mulsd %xmm5, %xmm9
mulsd %xmm7, %xmm8
mulsd %xmm7, %xmm8
mulsd %xmm6, %xmm1
mulsd %xmm7, %xmm6
mulsd %xmm7, %xmm5
movsd 0x4a38(%rip), %xmm7     # 0x170c0
movapd %xmm7, %xmm10
subsd %xmm9, %xmm10
subsd %xmm8, %xmm10
movsd %xmm10, (%rsp)
subsd %xmm2, %xmm7
movapd %xmm7, %xmm2
subsd %xmm8, %xmm2
movsd %xmm2, 0x28(%rsp)
subsd %xmm9, %xmm7
movsd %xmm7, 0x50(%rsp)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x78(%rsp)
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
movsd %xmm2, 0x8(%rsp)
addsd %xmm0, %xmm1
movsd %xmm1, 0x20(%rsp)
movapd %xmm6, %xmm0
addsd %xmm4, %xmm0
movsd %xmm0, 0x10(%rsp)
subsd %xmm4, %xmm6
movsd %xmm6, 0x40(%rsp)
movapd %xmm5, %xmm0
subsd %xmm3, %xmm0
movsd %xmm0, 0x30(%rsp)
addsd %xmm3, %xmm5
movsd %xmm5, 0x48(%rsp)
movq %rsp, %rsi
movl $0x4, %edx
movl $0x4, %ecx
movq %r14, %rdi
movq %rbx, %r8
movq %rbx, %r9
callq 0x84d0
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/rect.c
// Function: moonglmath_testrect
int testrect(lua_State *L, int arg, rect_t r)
/* Tests if the element at arg is a rect and sets r accordingly */
    {
    size_t i;
    if(!testmetatable(L, arg, RECT_MT)) return 0;

    if(r != NULL)
        {
        rect_clear(r);
        for(i=0; i < 4; i++)
            {
            lua_geti(L, arg, i+1);
            r[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 0x4eb1(%rip), %rdx      # 0x177e4
callq 0x8170
testl %eax, %eax
je 0x12990
movl $0x1, %r15d
testq %rbx, %rbx
je 0x12993
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
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 0x12957
jmp 0x12993
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/rect.c
// Function: moonglmath_pushrect
int pushrect(lua_State *L, rect_t r)
    {
    size_t i;
    lua_newtable(L);
    setmetatable(L, RECT_MT);
    for(i=0; i<4; i++)
        {
        lua_pushnumber(L, r[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 0x4ddf(%rip), %rsi      # 0x177e4
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 0x12a13
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/rect.c
// Function: Concat
static int Concat(lua_State *L)
    {
    rect_t r;
    if(testrect(L, 1, r))
        {
        ToString_(L, r);
        lua_pushvalue(L, 2);
        }
    else if(testrect(L, 2, r))
        {
        lua_pushvalue(L, 1);
        ToString_(L, r);
        }
    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 0x88b0
testl %eax, %eax
je 0x12af2
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x12b55
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8600
jmp 0x12b1e
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x88b0
testl %eax, %eax
je 0x12b36
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8600
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x12b55
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8bc0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbx
retq
leaq 0x4537(%rip), %rsi      # 0x17074
leaq 0x4cb0(%rip), %rdx      # 0x177f4
movq %rbx, %rdi
movl $0x93, %ecx
xorl %eax, %eax
callq 0x8a80
jmp 0x12b30
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/rect.c
// Function: ToString_
static int ToString_(lua_State *L, rect_t r)
/* 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;
    p = snprintf(str, space, "[ "FMT", "FMT", "FMT", "FMT" ]", r[0], r[1], r[2], r[3]);
    if(space<0)
        { 
        /* truncate */
        p = SZ - 5; 
        p+=snprintf(str+p, space, " ...");
        lua_pushlstring(L, str, p);
        return 1;
        }
    lua_pushlstring(L, str, p);
    return 1;
#undef space
#undef SZ
    }

// Assembly:
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdi, %rbx
movsd (%rsi), %xmm0
movsd 0x8(%rsi), %xmm1
movsd 0x10(%rsi), %xmm2
movsd 0x18(%rsi), %xmm3
leaq 0x44cc(%rip), %rdx      # 0x17046
movq %rsp, %rdi
movl $0x200, %esi            # imm = 0x200
movb $0x4, %al
callq 0x83f0
cmpl $0x201, %eax            # imm = 0x201
jl 0x12baa
movb $0x0, 0x1ff(%rsp)
movl $0x2e2e2e20, 0x1fb(%rsp) # imm = 0x2E2E2E20
movl $0x1ff, %edx            # imm = 0x1FF
jmp 0x12bad
movslq %eax, %rdx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x8960
addq $0x200, %rsp            # imm = 0x200
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/transform.c
// Function: moonglmath_translate
void translate(mat_t m, double x, double y, double z)
/* 1 0 0 x
 * 0 1 0 y
 * 0 0 1 z
 * 0 0 0 1
 *
 * T^-1(x,y,z) = T(-x, -y, -z)
 */
    {
    mat_clear(m);
    m[0][3] = x;
    m[1][3] = y;
    m[2][3] = z;
    m[0][0] = m[1][1] = m[2][2] = m[3][3] = 1.0;
    }

// Assembly:
xorps %xmm3, %xmm3
movups %xmm3, 0x10(%rdi)
movups %xmm3, 0x30(%rdi)
movups %xmm3, 0x50(%rdi)
movups %xmm3, 0x70(%rdi)
movups %xmm3, 0x20(%rdi)
movups %xmm3, (%rdi)
movups %xmm3, 0x60(%rdi)
movups %xmm3, 0x40(%rdi)
movsd %xmm0, 0x18(%rdi)
movsd %xmm1, 0x38(%rdi)
movsd %xmm2, 0x58(%rdi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x78(%rdi)
movq %rax, 0x50(%rdi)
movq %rax, 0x28(%rdi)
movq %rax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/transform.c
// Function: moonglmath_scale
void scale(mat_t m, double x, double y, double z)
/* x 0 0 0
 * 0 y 0 0
 * 0 0 z 0
 * 0 0 0 1
 */
    {
    mat_clear(m);
    m[0][0] = x;
    m[1][1] = y;
    m[2][2] = z;
    m[3][3] = 1.0;
    }

// Assembly:
xorps %xmm3, %xmm3
movups %xmm3, (%rdi)
movups %xmm3, 0x20(%rdi)
movups %xmm3, 0x50(%rdi)
movups %xmm3, 0x70(%rdi)
movups %xmm3, 0x60(%rdi)
movups %xmm3, 0x40(%rdi)
movups %xmm3, 0x30(%rdi)
movups %xmm3, 0x10(%rdi)
movsd %xmm0, (%rdi)
movsd %xmm1, 0x28(%rdi)
movsd %xmm2, 0x50(%rdi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x78(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/transform.c
// Function: moonglmath_rotate_x
void rotate_x(mat_t m, double rad)
/*  1  0  0  0
 *  0  c -s  0
 *  0  s  c  0
 *  0  0  0  1
 */
    {
    double c = cos(rad);
    double s = sin(rad);
    mat_clear(m);
    m[0][0] = m[3][3] = 1;
    m[1][1] = m[2][2] = c;
    m[1][2] = -s;
    m[2][1] = s;
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
callq 0x85d0
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
callq 0x8b80
xorps %xmm1, %xmm1
movups %xmm1, 0x70(%rbx)
movups %xmm1, (%rbx)
movups %xmm1, 0x50(%rbx)
movups %xmm1, 0x20(%rbx)
movups %xmm1, 0x30(%rbx)
movups %xmm1, 0x40(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm1, 0x60(%rbx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x78(%rbx)
movq %rax, (%rbx)
movsd 0x8(%rsp), %xmm1
movsd %xmm1, 0x50(%rbx)
movsd %xmm1, 0x28(%rbx)
movaps 0x42da(%rip), %xmm1     # 0x170d0
xorps %xmm0, %xmm1
movlps %xmm1, 0x30(%rbx)
movsd %xmm0, 0x48(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/transform.c
// Function: moonglmath_rotate_y
void rotate_y(mat_t m, double rad)
/*  c  0  s  0
 *  0  1  0  0
 * -s  0  c  0
 *  0  0  0  1
 */
    {
    double c = cos(rad);
    double s = sin(rad);
    mat_clear(m);
    m[1][1] = m[3][3] = 1;
    m[0][0] = m[2][2] = c;
    m[2][0] = -s;
    m[0][2] = s;
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
callq 0x85d0
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
callq 0x8b80
xorps %xmm1, %xmm1
movups %xmm1, 0x70(%rbx)
movups %xmm1, 0x20(%rbx)
movups %xmm1, 0x50(%rbx)
movups %xmm1, (%rbx)
movups %xmm1, 0x40(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm1, 0x30(%rbx)
movups %xmm1, 0x60(%rbx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x78(%rbx)
movq %rax, 0x28(%rbx)
movsd 0x8(%rsp), %xmm1
movsd %xmm1, 0x50(%rbx)
movsd %xmm1, (%rbx)
movaps 0x425c(%rip), %xmm1     # 0x170d0
xorps %xmm0, %xmm1
movlps %xmm1, 0x40(%rbx)
movsd %xmm0, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/transform.c
// Function: moonglmath_rotate_z
void rotate_z(mat_t m, double rad)
/*  c -s  0  0
 *  s  c  0  0
 *  0  0  1  0
 *  0  0  0  1
 */
    {
    double c = cos(rad);
    double s = sin(rad);
    mat_clear(m);
    m[0][0] = m[1][1] = c;
    m[2][2] = m[3][3] = 1;
    m[0][1] = -s;
    m[1][0] = s;
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
callq 0x85d0
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
callq 0x8b80
xorps %xmm1, %xmm1
movups %xmm1, 0x20(%rbx)
movups %xmm1, (%rbx)
movups %xmm1, 0x70(%rbx)
movups %xmm1, 0x50(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm1, 0x30(%rbx)
movups %xmm1, 0x40(%rbx)
movups %xmm1, 0x60(%rbx)
movsd 0x8(%rsp), %xmm1
movsd %xmm1, 0x28(%rbx)
movsd %xmm1, (%rbx)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x78(%rbx)
movq %rax, 0x50(%rbx)
movaps 0x41de(%rip), %xmm1     # 0x170d0
xorps %xmm0, %xmm1
movlps %xmm1, 0x8(%rbx)
movsd %xmm0, 0x20(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/transform.c
// Function: Translate
static int Translate(lua_State *L)
    {
    vec_t v;
    mat_t m;
    if(!testvec(L, 1, v, NULL, NULL)) 
        {
        v[0] = luaL_checknumber(L, 1);
        v[1] = luaL_checknumber(L, 2);
        v[2] = luaL_checknumber(L, 3);
        }
    translate(m, v[0], v[1], v[2]);
    return pushmat(L, m, 4, 4, 4, 4);
    }

// Assembly:
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
movq %rsp, %rdx
movl $0x1, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x8a50
testl %eax, %eax
jne 0x12f6b
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8320
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8320
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x8320
movsd %xmm0, 0x10(%rsp)
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
xorps %xmm3, %xmm3
leaq 0x20(%rsp), %rsi
movaps %xmm3, 0x10(%rsi)
movaps %xmm3, 0x30(%rsi)
movaps %xmm3, 0x50(%rsi)
movaps %xmm3, 0x70(%rsi)
movaps %xmm3, 0x20(%rsi)
movaps %xmm3, (%rsi)
movaps %xmm3, 0x40(%rsi)
movaps %xmm3, 0x60(%rsi)
movsd %xmm0, 0x18(%rsi)
movsd %xmm1, 0x38(%rsi)
movsd %xmm2, 0x58(%rsi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x78(%rsi)
movq %rax, 0x50(%rsi)
movq %rax, 0x28(%rsi)
movq %rax, (%rsi)
movl $0x4, %edx
movl $0x4, %ecx
movl $0x4, %r8d
movl $0x4, %r9d
movq %rbx, %rdi
callq 0x84d0
addq $0xa0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/transform.c
// Function: Scale
static int Scale(lua_State *L)
    {
    vec_t v;
    mat_t m;
    if(!testvec(L, 1, v, NULL, NULL)) 
        {
        v[0] = luaL_checknumber(L, 1);
        if(lua_isnoneornil(L, 2) && lua_isnoneornil(L, 3))
            v[1] = v[2] = v[0];
        else
            {
            v[1] = luaL_checknumber(L, 2);
            v[2] = luaL_checknumber(L, 3);
            }
        }
    scale(m, v[0], v[1], v[2]);
    return pushmat(L, m, 4, 4, 4, 4);
    }

// Assembly:
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
movq %rsp, %rdx
movl $0x1, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x8a50
testl %eax, %eax
jne 0x13071
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8320
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8c40
testl %eax, %eax
jg 0x1304b
movq %rbx, %rdi
movl $0x3, %esi
callq 0x8c40
testl %eax, %eax
jle 0x130ec
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8320
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x8320
movsd %xmm0, 0x10(%rsp)
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
xorps %xmm3, %xmm3
leaq 0x20(%rsp), %rsi
movaps %xmm3, (%rsi)
movaps %xmm3, 0x20(%rsi)
movaps %xmm3, 0x50(%rsi)
movaps %xmm3, 0x70(%rsi)
movaps %xmm3, 0x10(%rsi)
movaps %xmm3, 0x30(%rsi)
movaps %xmm3, 0x40(%rsi)
movaps %xmm3, 0x60(%rsi)
movsd %xmm0, (%rsi)
movsd %xmm1, 0x28(%rsi)
movsd %xmm2, 0x50(%rsi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x78(%rsi)
movl $0x4, %edx
movl $0x4, %ecx
movl $0x4, %r8d
movl $0x4, %r9d
movq %rbx, %rdi
callq 0x84d0
addq $0xa0, %rsp
popq %rbx
retq
movsd (%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
jmp 0x13071
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/transform.c
// Function: Rotate
static int Rotate(lua_State *L)
    {
    vec_t v;
    mat_t m;
    double rad = luaL_checknumber(L, 1);
    if(!testvec(L, 2, v, NULL, NULL)) 
        {
        v[0] = luaL_checknumber(L, 2);
        v[1] = luaL_checknumber(L, 3);
        v[2] = luaL_checknumber(L, 4);
        }
    rotate(m, v[0], v[1], v[2], rad);
    return pushmat(L, m, 4, 4, 4, 4);
    }

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x8320
movsd %xmm0, 0x8(%rsp)
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x8a50
testl %eax, %eax
jne 0x13171
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8320
movsd %xmm0, 0x30(%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x8320
movsd %xmm0, 0x38(%rsp)
movq %rbx, %rdi
movl $0x4, %esi
callq 0x8320
movsd %xmm0, 0x40(%rsp)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x85d0
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x8b80
movsd 0x3f07(%rip), %xmm3     # 0x170c0
movsd 0x10(%rsp), %xmm7
subsd %xmm7, %xmm3
xorps %xmm1, %xmm1
leaq 0x50(%rsp), %rsi
movaps %xmm1, (%rsi)
movaps %xmm1, 0x20(%rsi)
movaps %xmm1, 0x50(%rsi)
movaps %xmm1, 0x70(%rsi)
movaps %xmm1, 0x10(%rsi)
movaps %xmm1, 0x40(%rsi)
movaps %xmm1, 0x30(%rsi)
movaps %xmm1, 0x60(%rsi)
movsd 0x18(%rsp), %xmm6
movapd %xmm6, %xmm2
mulsd %xmm3, %xmm2
movapd %xmm2, %xmm1
mulsd %xmm6, %xmm1
addsd %xmm7, %xmm1
movsd %xmm1, (%rsi)
movsd 0x20(%rsp), %xmm5
movapd %xmm5, %xmm1
mulsd %xmm3, %xmm1
movapd %xmm1, %xmm4
mulsd %xmm5, %xmm4
movapd %xmm5, %xmm8
addsd %xmm7, %xmm4
movapd %xmm7, %xmm5
movsd %xmm4, 0x28(%rsi)
movsd 0x28(%rsp), %xmm7
mulsd %xmm7, %xmm3
mulsd %xmm7, %xmm3
addsd %xmm5, %xmm3
movsd %xmm3, 0x50(%rsi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x78(%rsi)
movapd %xmm8, %xmm3
mulsd %xmm2, %xmm3
movapd %xmm7, %xmm4
mulsd %xmm0, %xmm4
movapd %xmm3, %xmm5
subsd %xmm4, %xmm5
movsd %xmm5, 0x8(%rsi)
addsd %xmm3, %xmm4
movsd %xmm4, 0x20(%rsi)
mulsd %xmm7, %xmm2
movapd %xmm8, %xmm4
mulsd %xmm0, %xmm4
movapd %xmm4, %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, 0x10(%rsi)
subsd %xmm4, %xmm2
movsd %xmm2, 0x40(%rsi)
mulsd %xmm7, %xmm1
movapd %xmm6, %xmm2
mulsd %xmm0, %xmm2
movapd %xmm1, %xmm0
subsd %xmm2, %xmm0
movsd %xmm0, 0x30(%rsi)
addsd %xmm1, %xmm2
movsd %xmm2, 0x48(%rsi)
movl $0x4, %edx
movl $0x4, %ecx
movl $0x4, %r8d
movl $0x4, %r9d
movq %rbx, %rdi
callq 0x84d0
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/transform.c
// Function: RotateX
static int RotateX(lua_State *L)
    {
    mat_t m;
    double rad = luaL_checknumber(L, 1);
    rotate_x(m, rad);
    return pushmat(L, m, 4, 4, 4, 4);
    }

// Assembly:
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x8320
movsd %xmm0, (%rsp)
callq 0x85d0
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
callq 0x8b80
xorps %xmm1, %xmm1
leaq 0x10(%rsp), %rsi
movaps %xmm1, 0x70(%rsi)
movaps %xmm1, (%rsi)
movaps %xmm1, 0x50(%rsi)
movaps %xmm1, 0x20(%rsi)
movaps %xmm1, 0x30(%rsi)
movaps %xmm1, 0x40(%rsi)
movaps %xmm1, 0x10(%rsi)
movaps %xmm1, 0x60(%rsi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x78(%rsi)
movq %rax, (%rsi)
movsd 0x8(%rsp), %xmm1
movsd %xmm1, 0x50(%rsi)
movsd %xmm1, 0x28(%rsi)
movaps 0x3d6a(%rip), %xmm1     # 0x170d0
xorps %xmm0, %xmm1
movlps %xmm1, 0x30(%rsi)
movsd %xmm0, 0x48(%rsi)
movl $0x4, %edx
movl $0x4, %ecx
movl $0x4, %r8d
movl $0x4, %r9d
movq %rbx, %rdi
callq 0x84d0
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/transform.c
// Function: RotateY
static int RotateY(lua_State *L)
    {
    mat_t m;
    double rad = luaL_checknumber(L, 1);
    rotate_y(m, rad);
    return pushmat(L, m, 4, 4, 4, 4);
    }

// Assembly:
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x8320
movsd %xmm0, (%rsp)
callq 0x85d0
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
callq 0x8b80
xorps %xmm1, %xmm1
leaq 0x10(%rsp), %rsi
movaps %xmm1, 0x70(%rsi)
movaps %xmm1, 0x20(%rsi)
movaps %xmm1, 0x50(%rsi)
movaps %xmm1, (%rsi)
movaps %xmm1, 0x40(%rsi)
movaps %xmm1, 0x10(%rsi)
movaps %xmm1, 0x30(%rsi)
movaps %xmm1, 0x60(%rsi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x78(%rsi)
movq %rax, 0x28(%rsi)
movsd 0x8(%rsp), %xmm1
movsd %xmm1, 0x50(%rsi)
movsd %xmm1, (%rsi)
movaps 0x3cb9(%rip), %xmm1     # 0x170d0
xorps %xmm0, %xmm1
movlps %xmm1, 0x40(%rsi)
movsd %xmm0, 0x10(%rsi)
movl $0x4, %edx
movl $0x4, %ecx
movl $0x4, %r8d
movl $0x4, %r9d
movq %rbx, %rdi
callq 0x84d0
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/transform.c
// Function: RotateZ
static int RotateZ(lua_State *L)
    {
    mat_t m;
    double rad = luaL_checknumber(L, 1);
    rotate_z(m, rad);
    return pushmat(L, m, 4, 4, 4, 4);
    }

// Assembly:
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x8320
movsd %xmm0, (%rsp)
callq 0x85d0
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
callq 0x8b80
xorps %xmm1, %xmm1
leaq 0x10(%rsp), %rsi
movaps %xmm1, 0x20(%rsi)
movaps %xmm1, (%rsi)
movaps %xmm1, 0x70(%rsi)
movaps %xmm1, 0x50(%rsi)
movaps %xmm1, 0x10(%rsi)
movaps %xmm1, 0x30(%rsi)
movaps %xmm1, 0x40(%rsi)
movaps %xmm1, 0x60(%rsi)
movsd 0x8(%rsp), %xmm1
movsd %xmm1, 0x28(%rsi)
movsd %xmm1, (%rsi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x78(%rsi)
movq %rax, 0x50(%rsi)
movaps 0x3c08(%rip), %xmm1     # 0x170d0
xorps %xmm0, %xmm1
movlps %xmm1, 0x8(%rsi)
movsd %xmm0, 0x20(%rsi)
movl $0x4, %edx
movl $0x4, %ecx
movl $0x4, %r8d
movl $0x4, %r9d
movq %rbx, %rdi
callq 0x84d0
addq $0x90, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/udata.c
// Function: moonglmath_udata_unref
int udata_unref(lua_State *L, uint64_t id)
/* unreference udata so that it will be garbage collected */
    {
//  printf("unref object %lu\n", id);
    udata_t *udata = udata_search(id);
    if(!udata) 
        return luaL_error(L, "invalid object identifier %I", id);
    if(udata->ref != LUA_NOREF)
        {
        luaL_unref(L, LUA_REGISTRYINDEX, udata->ref);
        udata->ref = LUA_NOREF;
        }
    return 0;
    }

// Assembly:
pushq %rbx
movq %rsi, %rdx
movq 0xbebf(%rip), %rbx      # 0x1f738
testq %rbx, %rbx
je 0x1388f
cmpq %rdx, 0x20(%rbx)
ja 0x1388a
jae 0x13891
addq $0x8, %rbx
movq (%rbx), %rbx
jmp 0x13879
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x138b3
movl 0x28(%rbx), %edx
cmpl $-0x2, %edx
je 0x138af
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x8ce0
movl $0xfffffffe, 0x28(%rbx) # imm = 0xFFFFFFFE
xorl %eax, %eax
popq %rbx
retq
leaq 0x3ff2(%rip), %rsi      # 0x178ac
xorl %eax, %eax
popq %rbx
jmp 0x8a80
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/udata.c
// Function: moonglmath_udata_free
int udata_free(lua_State *L, uint64_t id)
/* this should be called in the __gc metamethod
 */
    {
    udata_t *udata = udata_search(id);
//  printf("free object %lu\n", id);
    if(!udata) 
        return luaL_error(L, "invalid object identifier %I", id);
    /* release all references */
    if(udata->ref != LUA_NOREF)
        luaL_unref(L, LUA_REGISTRYINDEX, udata->ref);
    udata_remove(udata);
    Free(L, udata);
    /* mem is released by Lua at garbage collection */
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
movq 0xbe65(%rip), %r14      # 0x1f738
testq %r14, %r14
je 0x138e9
cmpq %rdx, 0x20(%r14)
ja 0x138e4
jae 0x138ec
addq $0x8, %r14
movq (%r14), %r14
jmp 0x138d3
xorl %r14d, %r14d
testq %r14, %r14
je 0x13924
movl 0x28(%r14), %edx
cmpl $-0x2, %edx
je 0x13907
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x8ce0
movq %r14, %rdi
callq 0x1393c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x85f0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3f81(%rip), %rsi      # 0x178ac
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8a80
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/udata.c
// Function: moonglmath_udata_push
int udata_push(lua_State *L, uint64_t id)
    {
    udata_t *udata = udata_search(id);
    if(!udata) 
        return luaL_error(L, "invalid object identifier %I", id);
    if(udata->ref == LUA_NOREF)
        return luaL_error(L, "unreferenced object");
    if(lua_rawgeti(L, LUA_REGISTRYINDEX, udata->ref) != LUA_TUSERDATA)
        return luaL_error(L, UNEXPECTED_ERROR);
    return 1; /* one value pushed */
    }

// Assembly:
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0xba19(%rip), %rax      # 0x1f738
testq %rax, %rax
je 0x13d35
cmpq %rdx, 0x20(%rax)
ja 0x13d30
jae 0x13d37
addq $0x8, %rax
movq (%rax), %rax
jmp 0x13d1f
xorl %eax, %eax
testq %rax, %rax
je 0x13d58
movslq 0x28(%rax), %rdx
cmpq $-0x2, %rdx
jne 0x13d6a
leaq 0x3b7c(%rip), %rsi      # 0x178c9
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x8a80
leaq 0x3b4d(%rip), %rsi      # 0x178ac
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x8a80
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x8380
cmpl $0x7, %eax
jne 0x13d83
movl $0x1, %eax
popq %rbx
retq
leaq 0x32ea(%rip), %rsi      # 0x17074
leaq 0x3b4c(%rip), %rdx      # 0x178dd
movq %rbx, %rdi
movl $0xa4, %ecx
xorl %eax, %eax
popq %rbx
jmp 0x8a80
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/utils.c
// Function: moonglmath_now
double now(void)
    {
#if _POSIX_C_SOURCE >= 199309L
    struct timespec ts;
    if(clock_gettime(CLOCK_MONOTONIC,&ts)!=0)
        { printf("clock_gettime error\n"); return -1; }
    return ts.tv_sec + ts.tv_nsec*1.0e-9;
#else
    struct timeval tv;
    if(gettimeofday(&tv, NULL) != 0)
        { printf("gettimeofday error\n"); return -1; }
    return tv.tv_sec + tv.tv_usec*1.0e-6;
#endif
    }

// Assembly:
subq $0x18, %rsp
leaq 0x8(%rsp), %rsi
movl $0x1, %edi
callq 0x8230
testl %eax, %eax
je 0x142ac
leaq 0x3805(%rip), %rdi      # 0x17aa2
callq 0x8180
movsd 0x367e(%rip), %xmm0     # 0x17928
jmp 0x142c6
cvtsi2sdq 0x8(%rsp), %xmm1
cvtsi2sdq 0x10(%rsp), %xmm0
mulsd 0x366e(%rip), %xmm0     # 0x17930
addsd %xmm1, %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/utils.c
// Function: moonglmath_newmetatable
int newmetatable(lua_State *L, const char *metatable)
    {
    luaL_newmetatable(L, metatable);
    lua_pushvalue(L, -1);
    lua_setfield(L, -2, "__index"); /* metatable.__index = metatable */
    lua_pop(L, 1);
    return 0;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x8c90
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x8600
leaq 0x35e2(%rip), %rdx      # 0x1791d
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x84b0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x80c0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/utils.c
// Function: moonglmath_testmetatable
int testmetatable(lua_State *L, int arg, const char *metatable)
/* Tests the metatable of the table at index arg */
    {
    int ok = 0;
    if(lua_getmetatable(L, arg) == 0) return 0;
    luaL_getmetatable(L, metatable);
    ok = lua_compare(L, -1, -2, LUA_OPEQ);
    lua_pop(L, 2);
    return ok;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
callq 0x8d10
testl %eax, %eax
je 0x143c5
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movq %r14, %rdx
callq 0x8da0
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
xorl %ecx, %ecx
callq 0x8cf0
movl %eax, %ebp
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x80c0
movl %ebp, %eax
jmp 0x143c7
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/utils.c
// Function: moonglmath_metatable_setfuncs
int metatable_setfuncs(lua_State *L, const char *metatable, const luaL_Reg *metamethods, 
            const luaL_Reg *methods)
    {
    luaL_getmetatable(L, metatable);
    if(metamethods)
        luaL_setfuncs(L, metamethods, 0);
    if(methods)
        {
        luaL_getsubtable(L, -1, "__index");
        luaL_setfuncs(L, methods, 0);   
        lua_pop(L, 1);
        }
    lua_pop(L, 1);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %rbx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x8da0
testq %r15, %r15
je 0x14440
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x81a0
testq %r14, %r14
je 0x14473
leaq 0x34d1(%rip), %rdx      # 0x1791d
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x8590
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x81a0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x80c0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x80c0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/utils.c
// Function: moonglmath_checkoption_hint
int checkoption_hint(lua_State *L, int arg, const char *def, const char *const lst[])
/* Variant of luaL_checkoption(), with an added hint in the error message */
    {
    const char *hint = NULL;
    const char *name = (def) ? luaL_optstring(L, arg, def) : luaL_checkstring(L, arg);
    int i;
    for (i=0; lst[i]; i++)
        if (strcmp(lst[i], name) == 0)  return i;

    if(lua_checkstack(L, i*2))
        {
        for(i=0; lst[i]; i++)
            {
            lua_pushfstring(L, "'%s'", lst[i]);
            lua_pushstring(L, "|");
            }
        i = i*2;
        if(i>0)
            {
            lua_pop(L, 1); /* the last separator */
            lua_concat(L, i-1);
            hint = lua_tostring(L, -1); 
            }
        }
    if(hint)
        return luaL_argerror(L, arg, lua_pushfstring(L, 
                    "invalid option '%s', valid options are: %s", name, hint));
    return luaL_argerror(L, arg, lua_pushfstring(L, "invalid option '%s'", name));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movl %esi, %ebx
movq %rdi, %r14
testq %rdx, %rdx
je 0x144ef
xorl %ecx, %ecx
callq 0x8330
jmp 0x144f6
xorl %edx, %edx
callq 0x85c0
movq %rax, %r15
movq (%r12), %rdi
xorl %r13d, %r13d
testq %rdi, %rdi
je 0x14527
xorl %ebp, %ebp
movq %r15, %rsi
callq 0x86a0
testl %eax, %eax
je 0x145ba
movq 0x8(%r12,%r13,4), %rdi
incl %ebp
addq $0x2, %r13
testq %rdi, %rdi
jne 0x14507
movq %r14, %rdi
movl %r13d, %esi
callq 0x8030
xorl %r13d, %r13d
testl %eax, %eax
je 0x145ce
movq (%r12), %rdx
testq %rdx, %rdx
je 0x14584
movl %ebx, 0x4(%rsp)
leaq 0x33aa(%rip), %rbp      # 0x178fb
leaq 0x3410(%rip), %rbx      # 0x17968
xorl %r13d, %r13d
movq %r14, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x8610
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8d00
movq 0x8(%r12,%r13,8), %rdx
incq %r13
testq %rdx, %rdx
jne 0x1455b
movl 0x4(%rsp), %ebx
testl %r13d, %r13d
je 0x145cb
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x80c0
leal -0x1(,%r13,2), %esi
movq %r14, %rdi
callq 0x8bc0
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x8290
movq %rax, %r13
jmp 0x145ce
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r13d, %r13d
testq %r13, %r13
je 0x145ec
leaq 0x3390(%rip), %rsi      # 0x1796a
movq %r14, %rdi
movq %r15, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x8610
jmp 0x14600
leaq 0x33a2(%rip), %rsi      # 0x17995
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x8610
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x81b0
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/utils.c
// Function: moonglmath_isoption
int isoption(lua_State *L, int arg, const char *const lst[])
/* Variant of luaL_checkoption(), checks only and returns a boolean */
    {
    int i;
    const char *name;

    if(!lua_isstring(L, arg)) return 0;
    name = lua_tostring(L, arg);
    for (i=0; lst[i]; i++)
        if (strcmp(lst[i], name) == 0)  return 1;
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
callq 0x8e00
xorl %r14d, %r14d
testl %eax, %eax
je 0x14671
movq %r15, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x8290
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x14671
movq %rax, %r15
addq $0x8, %rbx
movq %r15, %rsi
callq 0x86a0
testl %eax, %eax
je 0x1466b
movq (%rbx), %rdi
addq $0x8, %rbx
testq %rdi, %rdi
jne 0x14651
jmp 0x14671
movl $0x1, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/vec.c
// Function: moonglmath_testvec
int testvec(lua_State *L, int arg, vec_t v, size_t *size, unsigned int *isrow)
/* Tests if the element at arg is a vector and sets v, *size and *isrow accordingly
 * (unless they are passed as 0).
 */
    {
    size_t i;
    size_t size_;
    unsigned int isrow_;
    if(!testmetatable(L, arg, VEC_MT)) return 0;

    lua_getfield(L, arg, "type");   
    isrow_ = checkisrow(L, -1);
    lua_pop(L, 1);

    lua_getfield(L, arg, "size");
    size_ = luaL_checkinteger(L, -1);
    lua_pop(L, 1);
    checkvecsize(L, size_);

    if(isrow != NULL) *isrow = isrow_;
    if(size != NULL) *size = size_;
    if(v != NULL)
        {
        vec_clear(v);
        for(i=0; i < size_; i++)
            {
            lua_geti(L, arg, i+1);
            v[i] = luaL_checknumber(L, -1);
            lua_pop(L, 1);
            }
        }
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r13
movq %rcx, %r15
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x2c2e(%rip), %rdx      # 0x173ca
callq 0x8170
testl %eax, %eax
je 0x14832
leaq 0x3261(%rip), %rdx      # 0x17a11
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8da0
movq %rbx, %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x8050
movl %eax, 0x4(%rsp)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x80c0
leaq 0x331a(%rip), %rdx      # 0x17afb
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8da0
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x86e0
movq %rax, %r12
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x80c0
leaq -0x5(%r12), %rax
cmpq $-0x5, %rax
ja 0x14837
leaq 0x32d2(%rip), %rsi      # 0x17aec
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8a80
xorl %r15d, %r15d
jmp 0x148af
testq %r13, %r13
je 0x14844
movl 0x4(%rsp), %eax
movl %eax, (%r13)
testq %r15, %r15
je 0x1484c
movq %r12, (%r15)
movl $0x1, %r15d
testq %r14, %r14
je 0x148af
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
testq %r12, %r12
je 0x148af
negq %r12
movl $0x1, %r13d
movq %rbx, %rdi
movl %ebp, %esi
movq %r13, %rdx
callq 0x8d30
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x8320
movsd %xmm0, -0x8(%r14,%r13,8)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x80c0
leaq (%r12,%r13), %rax
incq %rax
incq %r13
cmpq $0x1, %rax
jne 0x14871
movl %r15d, %eax
addq $0x8, %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/vec.c
// Function: moonglmath_pushvec
int pushvec(lua_State *L, vec_t v, size_t vsize, size_t size, unsigned int isrow)
/* vsize = no. of valid elements in v
 * if vsize > size, the exceeding elements are discarded,
 * if vsize < size, the missing elements are set to 0.
 */
    {
    size_t i;
    checkvecsize(L, size);
    lua_newtable(L);
    setmetatable(L, VEC_MT);
    for(i=0; i<size; i++)
        {
        lua_pushnumber(L, i < vsize ? v[i] : 0);
        lua_seti(L, -2, i+1);
        }
    lua_pushinteger(L, size);
    lua_setfield(L, -2, "size");
    pushisrow(L, isrow);
    lua_setfield(L, -2, "type");
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x5(%rcx), %rax
cmpq $-0x5, %rax
ja 0x14943
leaq 0x31c1(%rip), %rsi      # 0x17aec
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8a80
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x82f0
leaq 0x2a68(%rip), %rsi      # 0x173ca
movq %rbx, %rdi
callq 0x8950
testq %r14, %r14
je 0x149a0
xorl %r13d, %r13d
xorps %xmm0, %xmm0
cmpq %r15, %r13
jae 0x14980
movsd (%r12,%r13,8), %xmm0
movq %rbx, %rdi
callq 0x87d0
incq %r13
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r13, %rdx
callq 0x8640
cmpq %r13, %r14
jne 0x14972
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8500
leaq 0x3149(%rip), %rdx      # 0x17afb
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x84b0
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x8580
leaq 0x303f(%rip), %rdx      # 0x17a11
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x84b0
movl $0x1, %eax
addq $0x8, %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/vec.c
// Function: moonglmath_vec_unm
void vec_unm(vec_t dst, vec_t v, size_t n)
    {
    size_t i;
    vec_clear(dst);
    for(i=0; i < n; i++)    
        dst[i] = -v[i];
    }

// Assembly:
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
testq %rdx, %rdx
je 0x14a1f
xorl %eax, %eax
movaps 0x26c5(%rip), %xmm0     # 0x170d0
movsd (%rsi,%rax,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%rdi,%rax,8)
incq %rax
cmpq %rax, %rdx
jne 0x14a0b
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/vec.c
// Function: moonglmath_vec_add
void vec_add(vec_t dst, vec_t v1, vec_t v2, size_t n)
    {
    size_t i;
    vec_clear(dst);
    for(i=0; i < n; i++)    
        dst[i] = v1[i] + v2[i];
    }

// Assembly:
xorpd %xmm0, %xmm0
movupd %xmm0, 0x10(%rdi)
movupd %xmm0, (%rdi)
testq %rcx, %rcx
je 0x14a4b
xorl %eax, %eax
movsd (%rsi,%rax,8), %xmm0
addsd (%rdx,%rax,8), %xmm0
movsd %xmm0, (%rdi,%rax,8)
incq %rax
cmpq %rax, %rcx
jne 0x14a34
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/vec.c
// Function: moonglmath_vec_norm
double vec_norm(vec_t v, size_t n)
    {
    size_t i;
    double r = 0;
    for(i=0; i < n; i++)
        r += v[i]*v[i];
    return sqrt(r);
    }

// Assembly:
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
testq %rsi, %rsi
je 0x14a9c
xorl %eax, %eax
movsd (%rdi,%rax,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rax
cmpq %rax, %rsi
jne 0x14a87
ucomisd %xmm1, %xmm0
jb 0x8cd0
sqrtsd %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/vec.c
// Function: moonglmath_vec_norm2
double vec_norm2(vec_t v, size_t n)
    {
    size_t i;
    double r = 0;
    for(i=0; i < n; i++)
        r += v[i]*v[i];
    return r;
    }

// Assembly:
xorpd %xmm0, %xmm0
testq %rsi, %rsi
je 0x14acb
xorl %eax, %eax
movsd (%rdi,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq %rax, %rsi
jne 0x14ab6
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/vec.c
// Function: moonglmath_vec_normalize
void vec_normalize(vec_t v, size_t n) 
/* in place */
    {
    size_t i;
    double norm = vec_norm(v, n);
    for(i=0; i < n; i++)    
        v[i] = v[i]/norm;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
testq %rsi, %rsi
je 0x14afb
xorl %eax, %eax
movsd (%r14,%rax,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rax
cmpq %rax, %rbx
jne 0x14ae5
ucomisd %xmm1, %xmm0
jb 0x14b07
sqrtsd %xmm0, %xmm0
jmp 0x14b0c
callq 0x8cd0
testq %rbx, %rbx
je 0x14b2b
xorl %eax, %eax
movsd (%r14,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%r14,%rax,8)
incq %rax
cmpq %rax, %rbx
jne 0x14b13
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/vec.c
// Function: moonglmath_vec_div
void vec_div(vec_t dst, vec_t v, double s, size_t n)
    {
    size_t i; 
    vec_clear(dst);
    for(i=0; i < n; i++)    
        dst[i] = v[i] / s;
    }

// Assembly:
xorpd %xmm1, %xmm1
movupd %xmm1, 0x10(%rdi)
movupd %xmm1, (%rdi)
testq %rdx, %rdx
je 0x14b5d
xorl %eax, %eax
movsd (%rsi,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rdi,%rax,8)
incq %rax
cmpq %rax, %rdx
jne 0x14b47
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/vec.c
// Function: moonglmath_vec_dot
double vec_dot(vec_t v1, vec_t v2, size_t n)
/* dot product */
    {
    size_t i;
    double s = 0;
    for(i=0; i < n; i++)    
        s += (v1[i]*v2[i]);
    return s;
    }

// Assembly:
xorpd %xmm0, %xmm0
testq %rdx, %rdx
je 0x14b7f
xorl %eax, %eax
movsd (%rdi,%rax,8), %xmm1
mulsd (%rsi,%rax,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq %rax, %rdx
jne 0x14b69
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/vec.c
// Function: moonglmath_vec_vxv
void vec_vxv(mat_t dst, vec_t v1, vec_t v2, size_t n)
/* v1 is a nx1 column vector
 * v2 is a 1xn row vector
 * m is a nxn square matrix (n x 1) * (1 x n) = (n x n)
 */
    {
    size_t i, j;
    for(i=0; i < n; i++)
        for(j=0; j < n; j++)
            dst[i][j] = v1[i] * v2[j];
    }

// Assembly:
testq %rcx, %rcx
je 0x14bcd
xorl %eax, %eax
xorl %r8d, %r8d
movsd (%rsi,%rax,8), %xmm0
mulsd (%rdx,%r8,8), %xmm0
movsd %xmm0, (%rdi,%r8,8)
incq %r8
cmpq %r8, %rcx
jne 0x14ba8
incq %rax
addq $0x20, %rdi
cmpq %rcx, %rax
jne 0x14ba5
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/vec.c
// Function: moonglmath_vec_cross
void vec_cross(vec_t dst, vec_t v1, vec_t v2)
/* dst is always to be regarded as a size=3 vector */
    {
    dst[0] = v1[1]*v2[2] - v1[2]*v2[1];
    dst[1] = v1[2]*v2[0] - v1[0]*v2[2];
    dst[2] = v1[0]*v2[1] - v1[1]*v2[0];
    dst[3] = 0;
    }

// Assembly:
movsd 0x8(%rsi), %xmm0
movsd 0x8(%rdx), %xmm1
mulsd 0x10(%rsi), %xmm1
mulsd 0x10(%rdx), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rdi)
movsd 0x10(%rsi), %xmm0
movsd 0x10(%rdx), %xmm1
mulsd (%rsi), %xmm1
mulsd (%rdx), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rdi)
movsd (%rsi), %xmm0
movsd (%rdx), %xmm1
mulsd 0x8(%rsi), %xmm1
mulsd 0x8(%rdx), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/vec.c
// Function: moonglmath_vec_Norm
int vec_Norm(lua_State *L)
    {
    vec_t v;
    size_t size, i;
    double r = 0;
    checkvec(L, 1, v, &size, NULL);
    for(i=0; i < size; i++) 
        r += v[i]*v[i];
    lua_pushnumber(L, sqrt(r));
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %r14
movl $0x1, %esi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x8670
movq (%r14), %rax
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
testq %rax, %rax
je 0x14e17
xorl %ecx, %ecx
movsd 0x10(%rsp,%rcx,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x14e01
ucomisd %xmm1, %xmm0
jb 0x14e23
sqrtsd %xmm0, %xmm0
jmp 0x14e28
callq 0x8cd0
movq %rbx, %rdi
callq 0x87d0
movl $0x1, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/vec.c
// Function: moonglmath_vec_Norm2
int vec_Norm2(lua_State *L)
    {
    vec_t v;
    size_t size, i;
    double r = 0;
    checkvec(L, 1, v, &size, NULL);
    for(i=0; i < size; i++)
        r += v[i]*v[i];
    lua_pushnumber(L, r);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %r14
movl $0x1, %esi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x8670
movq (%r14), %rax
xorpd %xmm0, %xmm0
testq %rax, %rax
je 0x14e85
xorl %ecx, %ecx
movsd 0x10(%rsp,%rcx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x14e6f
movq %rbx, %rdi
callq 0x87d0
movl $0x1, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/vec.c
// Function: moonglmath_vec_Normalize
int vec_Normalize(lua_State *L)
    {
    vec_t v; 
    size_t size; 
    unsigned int isrow;
    checkvec(L, 1, v, &size, &isrow);
    vec_normalize(v, size);
    return pushvec(L, v, size, size, isrow);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %r14
leaq 0x4(%rsp), %r8
movl $0x1, %esi
movq %r14, %rcx
callq 0x8670
movq (%r14), %r14
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
testq %r14, %r14
je 0x14ee8
xorl %eax, %eax
movsd 0x10(%rsp,%rax,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rax
cmpq %rax, %r14
jne 0x14ed2
ucomisd %xmm1, %xmm0
jb 0x14ef4
sqrtsd %xmm0, %xmm0
jmp 0x14ef9
callq 0x8cd0
testq %r14, %r14
je 0x14f18
xorl %eax, %eax
movsd 0x10(%rsp,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0x14f00
movq 0x8(%rsp), %rcx
movl 0x4(%rsp), %r8d
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %rcx, %rdx
callq 0x82e0
addq $0x38, %rsp
popq %rbx
popq %r14
retq