LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x14318
leaq 0x3799(%rip), %rdi      # 0x17aa2
callq 0x8180
movsd 0x3612(%rip), %xmm0     # 0x17928
jmp 0x14332
cvtsi2sdq 0x8(%rsp), %xmm1
cvtsi2sdq 0x10(%rsp), %xmm0
mulsd 0x3602(%rip), %xmm0     # 0x17930
addsd %xmm1, %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3576(%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_O3/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 0x14431
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 0x14433
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x144ac
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x81a0
testq %r14, %r14
je 0x144df
leaq 0x3465(%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_O3/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, %ebp
movq %rdi, %r14
testq %rdx, %rdx
je 0x1455b
xorl %ecx, %ecx
callq 0x8330
jmp 0x14562
xorl %edx, %edx
callq 0x85c0
movq %rax, %r15
movq (%r12), %rdi
xorl %r13d, %r13d
testq %rdi, %rdi
je 0x14593
xorl %ebx, %ebx
movq %r15, %rsi
callq 0x86a0
testl %eax, %eax
je 0x1466d
movq 0x8(%r12,%r13,4), %rdi
incl %ebx
addq $0x2, %r13
testq %rdi, %rdi
jne 0x14573
movq %r14, %rdi
movl %r13d, %esi
callq 0x8030
testl %eax, %eax
je 0x1463e
movq (%r12), %rdx
testq %rdx, %rdx
je 0x1463e
movl %ebp, 0x4(%rsp)
addq $0x8, %r12
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x3334(%rip), %r13      # 0x178fb
leaq 0x339a(%rip), %rbx      # 0x17968
movq %r14, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x8610
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8d00
movq (%r12), %rdx
addl $0x2, %ebp
addq $0x8, %r12
testq %rdx, %rdx
jne 0x145ce
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x80c0
movq %r14, %rdi
movl %ebp, %esi
callq 0x8bc0
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x8290
testq %rax, %rax
movl 0x4(%rsp), %ebp
je 0x1463e
leaq 0x333e(%rip), %rsi      # 0x1796a
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x8610
jmp 0x14652
leaq 0x3350(%rip), %rsi      # 0x17995
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x8610
movq %r14, %rdi
movl %ebp, %esi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x81b0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x146d4
movq %r15, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x8290
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x146d4
movq %rax, %r15
addq $0x8, %rbx
movq %r15, %rsi
callq 0x86a0
testl %eax, %eax
je 0x146ce
movq (%rbx), %rdi
addq $0x8, %rbx
testq %rdi, %rdi
jne 0x146b4
jmp 0x146d4
movl $0x1, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r12
movq %rcx, %r15
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x2bca(%rip), %rdx      # 0x173ca
callq 0x8170
testl %eax, %eax
je 0x14895
leaq 0x31fd(%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 0x32b6(%rip), %rdx      # 0x17afb
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8da0
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x86e0
movq %rax, %r13
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x80c0
leaq -0x5(%r13), %rax
cmpq $-0x5, %rax
ja 0x1489a
leaq 0x326f(%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 0x1490d
testq %r12, %r12
je 0x148a7
movl 0x4(%rsp), %eax
movl %eax, (%r12)
testq %r15, %r15
je 0x148af
movq %r13, (%r15)
movl $0x1, %r15d
testq %r14, %r14
je 0x1490d
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
negq %r13
movl $0x1, %r12d
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x8d30
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x8320
movsd %xmm0, -0x8(%r14,%r12,8)
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x80c0
leaq (%r12,%r13), %rax
incq %rax
incq %r12
cmpq $0x1, %rax
jne 0x148cf
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_O3/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 0x149a1
leaq 0x3163(%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
xorl %r13d, %r13d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x82f0
leaq 0x2a07(%rip), %rsi      # 0x173ca
movq %rbx, %rdi
callq 0x8950
xorps %xmm0, %xmm0
cmpq %r15, %r13
jae 0x149d9
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 0x149cb
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8500
leaq 0x30f0(%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 0x2fe6(%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_O3/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 0x14a78
xorl %eax, %eax
movaps 0x266c(%rip), %xmm0     # 0x170d0
movsd (%rsi,%rax,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%rdi,%rax,8)
incq %rax
cmpq %rax, %rdx
jne 0x14a64
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x14aa4
xorl %eax, %eax
movsd (%rsi,%rax,8), %xmm0
addsd (%rdx,%rax,8), %xmm0
movsd %xmm0, (%rdi,%rax,8)
incq %rax
cmpq %rax, %rcx
jne 0x14a8d
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x14af5
xorl %eax, %eax
movsd (%rdi,%rax,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rax
cmpq %rax, %rsi
jne 0x14ae0
ucomisd %xmm1, %xmm0
jb 0x8cd0
sqrtsd %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x14b24
xorl %eax, %eax
movsd (%rdi,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq %rax, %rsi
jne 0x14b0f
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x14bb1
xorl %eax, %eax
movsd (%rsi,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rdi,%rax,8)
incq %rax
cmpq %rax, %rdx
jne 0x14b9b
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x14bd3
xorl %eax, %eax
movsd (%rdi,%rax,8), %xmm1
mulsd (%rsi,%rax,8), %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq %rax, %rdx
jne 0x14bbd
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x14c21
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 0x14bfc
incq %rax
addq $0x20, %rdi
cmpq %rcx, %rax
jne 0x14bf9
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x14e6b
xorl %ecx, %ecx
movsd 0x10(%rsp,%rcx,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x14e55
ucomisd %xmm1, %xmm0
jb 0x14e77
sqrtsd %xmm0, %xmm0
jmp 0x14e7c
callq 0x8cd0
movq %rbx, %rdi
callq 0x87d0
movl $0x1, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x14ed9
xorl %ecx, %ecx
movsd 0x10(%rsp,%rcx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x14ec3
movq %rbx, %rdi
callq 0x87d0
movl $0x1, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %r14, %r14
je 0x14f48
xorpd %xmm0, %xmm0
xorl %eax, %eax
movsd 0x10(%rsp,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq %rax, %r14
jne 0x14f22
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x14f4c
sqrtsd %xmm0, %xmm0
jmp 0x14f51
xorl %ecx, %ecx
jmp 0x14f70
callq 0x8cd0
xorl %eax, %eax
movsd 0x10(%rsp,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0x14f53
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
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglmath/src/vec.c
// Function: moonglmath_vec_Clamp
int vec_Clamp(lua_State *L)
    {
    vec_t dst, v, minv, maxv;
    size_t size, size1;
    unsigned int isrow, isrow1;
    checkvec(L, 1, v, &size, &isrow);
    checkvec(L, 2, minv, &size1, &isrow1);
    if(size1 != size || isrow1 != isrow)
        return luaL_error(L, OPERANDS_ERROR);
    checkvec(L, 3, maxv, &size1, &isrow1);
    if(size1 != size || isrow1 != isrow)
        return luaL_error(L, OPERANDS_ERROR);
    vec_clamp(dst, v, minv, maxv, size);
    return pushvec(L, dst, size, size, isrow);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
leaq 0x60(%rsp), %rdx
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %r8
movl $0x1, %esi
movq %r14, %rcx
callq 0x8670
leaq 0x40(%rsp), %rdx
leaq 0x18(%rsp), %r15
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rcx
callq 0x8670
movq (%r15), %rax
cmpq (%r14), %rax
jne 0x150b7
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jne 0x150b7
leaq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %r14
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movl $0x3, %esi
movq %r14, %rcx
callq 0x8670
movq (%r14), %r14
cmpq 0x10(%rsp), %r14
jne 0x150e1
movl 0x8(%rsp), %r8d
cmpl 0xc(%rsp), %r8d
jne 0x150e1
testq %r14, %r14
je 0x150f9
xorl %r15d, %r15d
movsd 0x60(%rsp,%r15,8), %xmm0
movsd 0x40(%rsp,%r15,8), %xmm1
movsd 0x20(%rsp,%r15,8), %xmm2
callq 0x8390
movsd %xmm0, 0x80(%rsp,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x1507f
movq 0x10(%rsp), %rcx
movl 0xc(%rsp), %r8d
jmp 0x150fb
leaq 0x257f(%rip), %rsi      # 0x1763d
leaq 0x2a3b(%rip), %rdx      # 0x17b00
movq %rbx, %rdi
movl $0x234, %ecx            # imm = 0x234
xorl %eax, %eax
callq 0x8a80
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2555(%rip), %rsi      # 0x1763d
leaq 0x2a11(%rip), %rdx      # 0x17b00
movq %rbx, %rdi
movl $0x237, %ecx            # imm = 0x237
jmp 0x150cd
xorl %ecx, %ecx
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
movq %rcx, %rdx
callq 0x82e0
jmp 0x150d4
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglmath/src/vec.c
// Function: moonglmath_vec_Mix
int vec_Mix(lua_State *L)
    {
    vec_t dst, v1, v2;
    double k;
    size_t size, size1;
    unsigned int isrow, isrow1;
    checkvec(L, 1, v1, &size, &isrow);
    checkvec(L, 2, v2, &size1, &isrow1);
    if(size1 != size || isrow1 != isrow)
        return luaL_error(L, OPERANDS_ERROR);
    k = luaL_checknumber(L, 3);
    vec_mix(dst, v1, v2, size, k);
    return pushvec(L, dst, size, size, isrow);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x40(%rsp), %rdx
leaq 0x8(%rsp), %r14
movq %rsp, %r8
movl $0x1, %esi
movq %r14, %rcx
callq 0x8670
leaq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %r15
leaq 0x4(%rsp), %r8
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %rcx
callq 0x8670
movq (%r15), %rax
cmpq (%r14), %rax
jne 0x151b8
movl 0x4(%rsp), %eax
cmpl (%rsp), %eax
jne 0x151b8
movq %rbx, %rdi
movl $0x3, %esi
callq 0x8320
movq 0x8(%rsp), %r14
testq %r14, %r14
je 0x151d7
xorl %r15d, %r15d
movsd %xmm0, 0x10(%rsp)
movsd 0x40(%rsp,%r15,8), %xmm0
movsd 0x20(%rsp,%r15,8), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0x8780
movsd %xmm0, 0x60(%rsp,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x15189
movq 0x8(%rsp), %rcx
jmp 0x151d9
leaq 0x247e(%rip), %rsi      # 0x1763d
leaq 0x293a(%rip), %rdx      # 0x17b00
movq %rbx, %rdi
movl $0x245, %ecx            # imm = 0x245
xorl %eax, %eax
callq 0x8a80
jmp 0x151ed
xorl %ecx, %ecx
movl (%rsp), %r8d
leaq 0x60(%rsp), %rsi
movq %rbx, %rdi
movq %rcx, %rdx
callq 0x82e0
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglmath/src/vec.c
// Function: moonglmath_vec_Step
int vec_Step(lua_State *L)
    {
    vec_t dst, v1, edge;
    double k;
    size_t size, size1;
    unsigned int isrow, isrow1;
    checkvec(L, 1, v1, &size, &isrow);
    if(lua_isnumber(L, 2))
        {
        k = lua_tonumber(L, 2);
        edge[0]=edge[1]=edge[2]=edge[3]=k;
        }
    else
        {
        checkvec(L, 2, edge, &size1, &isrow1);
        if(size1 != size || isrow1 != isrow)
            return luaL_error(L, OPERANDS_ERROR);
        }
    vec_step(dst, v1, edge, size);
    return pushvec(L, dst, size, size, isrow);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq 0x50(%rsp), %rdx
leaq 0x10(%rsp), %rcx
leaq 0xc(%rsp), %r8
movl $0x1, %esi
callq 0x8670
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8560
testl %eax, %eax
je 0x15285
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x8630
movlhps %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq 0x10(%rsp), %r14
testq %r14, %r14
je 0x152d7
xorl %r15d, %r15d
movsd 0x50(%rsp,%r15,8), %xmm0
movsd 0x20(%rsp,%r15,8), %xmm1
callq 0x8860
movsd %xmm0, 0x70(%rsp,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x1525c
movq 0x10(%rsp), %rcx
jmp 0x152d9
leaq 0x20(%rsp), %rdx
leaq 0x48(%rsp), %r14
leaq 0x1c(%rsp), %r8
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rcx
callq 0x8670
movq (%r14), %r14
cmpq 0x10(%rsp), %r14
jne 0x152b8
movl 0x1c(%rsp), %eax
cmpl 0xc(%rsp), %eax
je 0x15254
leaq 0x237e(%rip), %rsi      # 0x1763d
leaq 0x283a(%rip), %rdx      # 0x17b00
movq %rbx, %rdi
movl $0x25b, %ecx            # imm = 0x25B
xorl %eax, %eax
callq 0x8a80
jmp 0x152ee
xorl %ecx, %ecx
movl 0xc(%rsp), %r8d
leaq 0x70(%rsp), %rsi
movq %rbx, %rdi
movq %rcx, %rdx
callq 0x82e0
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglmath/src/vec.c
// Function: moonglmath_vec_Smoothstep
int vec_Smoothstep(lua_State *L)
    {
    vec_t dst, v, edge0, edge1;
    double k;
    size_t size, size1;
    unsigned int isrow, isrow1;
    checkvec(L, 1, v, &size, &isrow);
    if(lua_isnumber(L, 2))
        {
        k = lua_tonumber(L, 2);
        edge0[0]=edge0[1]=edge0[2]=edge0[3]=k;
        }
    else
        {
        checkvec(L, 2, edge0, &size1, &isrow1);
        if(size1 != size || isrow1 != isrow)
            return luaL_error(L, OPERANDS_ERROR);
        }
    if(lua_isnumber(L, 3))
        {
        k = lua_tonumber(L, 3);
        edge1[0]=edge1[1]=edge1[2]=edge1[3]=k;
        }
    else
        {
        checkvec(L, 3, edge1, &size1, &isrow1);
        if(size1 != size || isrow1 != isrow)
            return luaL_error(L, OPERANDS_ERROR);
        }
    vec_smoothstep(dst, v, edge0, edge1, size);
    return pushvec(L, dst, size, size, isrow);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
leaq 0x60(%rsp), %rdx
leaq 0x10(%rsp), %rcx
leaq 0xc(%rsp), %r8
movl $0x1, %esi
callq 0x8670
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8560
testl %eax, %eax
je 0x153cc
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x8630
movlhps %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x8560
testl %eax, %eax
je 0x1541b
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x8630
movlhps %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq 0x10(%rsp), %r14
testq %r14, %r14
je 0x15471
xorl %r15d, %r15d
movsd 0x60(%rsp,%r15,8), %xmm0
movsd 0x40(%rsp,%r15,8), %xmm1
movsd 0x20(%rsp,%r15,8), %xmm2
callq 0x8690
movsd %xmm0, 0x80(%rsp,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x15396
movq 0x10(%rsp), %rcx
jmp 0x15473
leaq 0x40(%rsp), %rdx
leaq 0x18(%rsp), %r14
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rcx
callq 0x8670
movq (%r14), %rax
cmpq 0x10(%rsp), %rax
jne 0x15403
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
je 0x15354
leaq 0x2233(%rip), %rsi      # 0x1763d
leaq 0x26ef(%rip), %rdx      # 0x17b00
movq %rbx, %rdi
movl $0x272, %ecx            # imm = 0x272
jmp 0x15468
leaq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %r14
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movl $0x3, %esi
movq %r14, %rcx
callq 0x8670
movq (%r14), %r14
cmpq 0x10(%rsp), %r14
jne 0x15452
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
je 0x1538a
leaq 0x21e4(%rip), %rsi      # 0x1763d
leaq 0x26a0(%rip), %rdx      # 0x17b00
movq %rbx, %rdi
movl $0x27d, %ecx            # imm = 0x27D
xorl %eax, %eax
callq 0x8a80
jmp 0x1548b
xorl %ecx, %ecx
movl 0xc(%rsp), %r8d
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
movq %rcx, %rdx
callq 0x82e0
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglmath/src/vec.c
// Function: moonglmath_vec_Fade
int vec_Fade(lua_State *L)
    {
    vec_t dst, v, edge0, edge1;
    double k;
    size_t size, size1;
    unsigned int isrow, isrow1;
    checkvec(L, 1, v, &size, &isrow);
    if(lua_isnumber(L, 2))
        {
        k = lua_tonumber(L, 2);
        edge0[0]=edge0[1]=edge0[2]=edge0[3]=k;
        }
    else
        {
        checkvec(L, 2, edge0, &size1, &isrow1);
        if(size1 != size || isrow1 != isrow)
            return luaL_error(L, OPERANDS_ERROR);
        }
    if(lua_isnumber(L, 3))
        {
        k = lua_tonumber(L, 3);
        edge1[0]=edge1[1]=edge1[2]=edge1[3]=k;
        }
    else
        {
        checkvec(L, 3, edge1, &size1, &isrow1);
        if(size1 != size || isrow1 != isrow)
            return luaL_error(L, OPERANDS_ERROR);
        }
    vec_fade(dst, v, edge0, edge1, size);
    return pushvec(L, dst, size, size, isrow);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
leaq 0x60(%rsp), %rdx
leaq 0x10(%rsp), %rcx
leaq 0xc(%rsp), %r8
movl $0x1, %esi
callq 0x8670
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8560
testl %eax, %eax
je 0x15569
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x8630
movlhps %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x8560
testl %eax, %eax
je 0x155b8
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x8630
movlhps %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq 0x10(%rsp), %r14
testq %r14, %r14
je 0x1560e
xorl %r15d, %r15d
movsd 0x60(%rsp,%r15,8), %xmm0
movsd 0x40(%rsp,%r15,8), %xmm1
movsd 0x20(%rsp,%r15,8), %xmm2
callq 0x8790
movsd %xmm0, 0x80(%rsp,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x15533
movq 0x10(%rsp), %rcx
jmp 0x15610
leaq 0x40(%rsp), %rdx
leaq 0x18(%rsp), %r14
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rcx
callq 0x8670
movq (%r14), %rax
cmpq 0x10(%rsp), %rax
jne 0x155a0
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
je 0x154f1
leaq 0x2096(%rip), %rsi      # 0x1763d
leaq 0x2552(%rip), %rdx      # 0x17b00
movq %rbx, %rdi
movl $0x293, %ecx            # imm = 0x293
jmp 0x15605
leaq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %r14
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movl $0x3, %esi
movq %r14, %rcx
callq 0x8670
movq (%r14), %r14
cmpq 0x10(%rsp), %r14
jne 0x155ef
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
je 0x15527
leaq 0x2047(%rip), %rsi      # 0x1763d
leaq 0x2503(%rip), %rdx      # 0x17b00
movq %rbx, %rdi
movl $0x29e, %ecx            # imm = 0x29E
xorl %eax, %eax
callq 0x8a80
jmp 0x15628
xorl %ecx, %ecx
movl 0xc(%rsp), %r8d
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
movq %rcx, %rdx
callq 0x82e0
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglmath/src/vec.c
// Function: Concat
static int Concat(lua_State *L)
    {
    vec_t v;
    size_t size;
    unsigned int isrow;
    if(testvec(L, 1, v, &size, &isrow))
        {
        ToString_(L, v, size, isrow);
        lua_pushvalue(L, 2);
        }
    else if(testvec(L, 2, v, &size, &isrow))
        {
        lua_pushvalue(L, 1);
        ToString_(L, v, size, isrow);
        }
    else 
        return unexpected(L);
    lua_concat(L, 2);
    return 1;
    }

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
leaq 0x4(%rsp), %r8
movl $0x1, %esi
callq 0x8a50
testl %eax, %eax
je 0x15714
movq 0x8(%rsp), %rdx
movl 0x4(%rsp), %ecx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x15d34
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8600
jmp 0x15757
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
leaq 0x4(%rsp), %r8
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8a50
testl %eax, %eax
je 0x1576f
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8600
movq 0x8(%rsp), %rdx
movl 0x4(%rsp), %ecx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x15d34
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8bc0
movl $0x1, %eax
addq $0x30, %rsp
popq %rbx
retq
leaq 0x18fe(%rip), %rsi      # 0x17074
leaq 0x2383(%rip), %rdx      # 0x17b00
movq %rbx, %rdi
movl $0xe4, %ecx
xorl %eax, %eax
callq 0x8a80
jmp 0x15769
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglmath/src/vec.c
// Function: Unm
static int Unm(lua_State *L)
    {
    vec_t v; 
    size_t size, i; 
    unsigned int isrow;
    checkvec(L, 1, v, &size, &isrow);
    for(i=0; i < 4; i++)    
        v[i] = -v[i];
    return pushvec(L, v, size, size, isrow);
    }

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
leaq 0x4(%rsp), %r8
movl $0x1, %esi
callq 0x8670
xorl %eax, %eax
movaps 0x1918(%rip), %xmm0     # 0x170d0
movaps 0x10(%rsp,%rax,8), %xmm1
xorps %xmm0, %xmm1
movaps %xmm1, 0x10(%rsp,%rax,8)
addq $0x2, %rax
cmpq $0x4, %rax
jne 0x157b8
movq 0x8(%rsp), %rcx
movl 0x4(%rsp), %r8d
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %rcx, %rdx
callq 0x82e0
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglmath/src/vec.c
// Function: Add
static int Add(lua_State *L)
    {
    vec_t v, v1; 
    size_t size, size1, i; 
    unsigned int isrow, isrow1;
    checkvec(L, 1, v, &size, &isrow);
    checkvec(L, 2, v1, &size1, &isrow1);
    if((isrow != isrow1) || (size != size1))
        return luaL_error(L, OPERANDS_ERROR);
    for(i=0; i < size; i++) 
        v[i] += v1[i];
    return pushvec(L, v, size, size, isrow);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdx
leaq 0x10(%rsp), %rcx
leaq 0x1c(%rsp), %r14
movl $0x1, %esi
movq %r14, %r8
callq 0x8670
leaq 0x40(%rsp), %rdx
leaq 0x8(%rsp), %rcx
leaq 0x18(%rsp), %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %r8
callq 0x8670
movl (%r14), %r8d
cmpl (%r15), %r8d
jne 0x1587d
movq 0x10(%rsp), %rcx
cmpq 0x8(%rsp), %rcx
jne 0x1587d
testq %rcx, %rcx
je 0x1586b
xorl %eax, %eax
movsd 0x40(%rsp,%rax,8), %xmm0
addsd 0x20(%rsp,%rax,8), %xmm0
movsd %xmm0, 0x20(%rsp,%rax,8)
incq %rax
cmpq %rax, %rcx
jne 0x15851
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
movq %rcx, %rdx
callq 0x82e0
jmp 0x1589a
leaq 0x1db9(%rip), %rsi      # 0x1763d
leaq 0x2275(%rip), %rdx      # 0x17b00
movq %rbx, %rdi
movl $0x18b, %ecx            # imm = 0x18B
xorl %eax, %eax
callq 0x8a80
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglmath/src/vec.c
// Function: Div
static int Div(lua_State *L)
    {
    vec_t v; 
    size_t size, i; 
    unsigned int isrow;
    double s;
    checkvec(L, 1, v, &size, &isrow);
    s = luaL_checknumber(L, 2);
    for(i=0; i < size; i++) 
        v[i] /= s;
    return pushvec(L, v, size, size, isrow);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %r14
leaq 0xc(%rsp), %r8
movl $0x1, %esi
movq %r14, %rcx
callq 0x8670
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8320
movq (%r14), %rcx
testq %rcx, %rcx
je 0x15bfc
xorl %eax, %eax
movsd 0x10(%rsp,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp,%rax,8)
incq %rax
cmpq %rax, %rcx
jne 0x15be4
movl 0xc(%rsp), %r8d
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %rcx, %rdx
callq 0x82e0
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglmath/src/vec.c
// Function: Cross
static int Cross(lua_State *L)
/* always return a size=3 vector */
//@@ TODO?: v % scalar = component-wise mod
    {
    vec_t v1, v2, v;
    size_t size1, size2; 
    unsigned int isrow1, isrow2;
    checkvec(L, 1, v1, &size1, &isrow1);
    checkvec(L, 2, v2, &size2, &isrow2);
    if((isrow1 != isrow2) || (size1 != size2))
        return luaL_error(L, OPERANDS_ERROR);
    if(size1==2)
        v1[2] = v2[2] = 0;
    vec_cross(v, v1, v2);
    return pushvec(L, v, 3, 3, isrow1);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x40(%rsp), %rdx
leaq 0x10(%rsp), %rcx
leaq 0x1c(%rsp), %r14
movl $0x1, %esi
movq %r14, %r8
callq 0x8670
leaq 0x20(%rsp), %rdx
leaq 0x8(%rsp), %rcx
leaq 0x18(%rsp), %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r15, %r8
callq 0x8670
movl (%r14), %r8d
cmpl (%r15), %r8d
jne 0x15c8f
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jne 0x15c8f
cmpq $0x2, %rax
jne 0x15cae
xorl %eax, %eax
movq %rax, 0x30(%rsp)
movq %rax, 0x50(%rsp)
xorpd %xmm0, %xmm0
jmp 0x15cba
leaq 0x19a7(%rip), %rsi      # 0x1763d
leaq 0x1e63(%rip), %rdx      # 0x17b00
movq %rbx, %rdi
movl $0x1fb, %ecx            # imm = 0x1FB
xorl %eax, %eax
callq 0x8a80
jmp 0x15d27
movapd 0x30(%rsp), %xmm0
movhpd 0x50(%rsp), %xmm0       # xmm0 = xmm0[0],mem[0]
movsd 0x40(%rsp), %xmm1
movsd 0x48(%rsp), %xmm2
movsd 0x20(%rsp), %xmm3
movsd 0x28(%rsp), %xmm4
movapd %xmm0, %xmm5
shufpd $0x1, %xmm1, %xmm5      # xmm5 = xmm5[1],xmm1[0]
mulsd %xmm4, %xmm1
unpcklpd %xmm0, %xmm4            # xmm4 = xmm4[0],xmm0[0]
mulpd %xmm5, %xmm4
movapd %xmm2, %xmm5
unpcklpd %xmm3, %xmm5            # xmm5 = xmm5[0],xmm3[0]
mulpd %xmm0, %xmm5
subpd %xmm4, %xmm5
leaq 0x60(%rsp), %rsi
movapd %xmm5, (%rsi)
mulsd %xmm2, %xmm3
subsd %xmm3, %xmm1
movsd %xmm1, 0x10(%rsi)
movq $0x0, 0x18(%rsi)
movl $0x3, %edx
movl $0x3, %ecx
movq %rbx, %rdi
callq 0x82e0
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglmath/src/vec.c
// Function: ToString_
static int ToString_(lua_State *L, vec_t v, size_t size, unsigned int isrow)
/* 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;
    switch(size)
        {
#define T isrow==1 ? "" : "'"
        case 2: p = snprintf(str, space, "{ "FMT", "FMT" }%s", v[0], v[1], T ); break;
        case 3: p = snprintf(str, space, "{ "FMT", "FMT", "FMT" }%s", 
                                                v[0], v[1], v[2], T); break;
        case 4: p = snprintf(str, space, "{ "FMT", "FMT", "FMT", "FMT" }%s", 
                                                v[0], v[1], v[2], v[3], T); break;
        default:
            return luaL_error(L, UNEXPECTED_ERROR);
        }
    if(space<0)
        { 
        /* truncate */
        p = SZ - 5; 
        p+=snprintf(str+p, space, " ...");
        lua_pushlstring(L, str, p);
        return 1;
        }
    lua_pushlstring(L, str, p);
    return 1;
#undef space
#undef SZ
    }

// Assembly:
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdi, %rbx
cmpq $0x4, %rdx
je 0x15dca
cmpq $0x3, %rdx
je 0x15d8f
cmpq $0x2, %rdx
jne 0x15e46
movsd (%rsi), %xmm0
movsd 0x8(%rsi), %xmm1
cmpl $0x1, %ecx
leaq 0x19ce(%rip), %rax      # 0x1773a
leaq 0x1b8b(%rip), %rcx      # 0x178fe
cmoveq %rax, %rcx
leaq 0x1d8e(%rip), %rdx      # 0x17b0c
movq %rsp, %rdi
movl $0x200, %esi            # imm = 0x200
movb $0x2, %al
callq 0x83f0
jmp 0x15e08
movsd (%rsi), %xmm0
movsd 0x8(%rsi), %xmm1
movsd 0x10(%rsi), %xmm2
cmpl $0x1, %ecx
leaq 0x1993(%rip), %rax      # 0x1773a
leaq 0x1b50(%rip), %rcx      # 0x178fe
cmoveq %rax, %rcx
leaq 0x1d60(%rip), %rdx      # 0x17b19
movq %rsp, %rdi
movl $0x200, %esi            # imm = 0x200
movb $0x3, %al
callq 0x83f0
jmp 0x15e08
movsd (%rsi), %xmm0
movsd 0x8(%rsi), %xmm1
movsd 0x10(%rsi), %xmm2
movsd 0x18(%rsi), %xmm3
cmpl $0x1, %ecx
leaq 0x1953(%rip), %rax      # 0x1773a
leaq 0x1b10(%rip), %rcx      # 0x178fe
cmoveq %rax, %rcx
leaq 0x1d31(%rip), %rdx      # 0x17b2a
movq %rsp, %rdi
movl $0x200, %esi            # imm = 0x200
movb $0x4, %al
callq 0x83f0
cmpl $0x201, %eax            # imm = 0x201
jl 0x15e2a
movq %rsp, %rsi
movb $0x0, 0x1ff(%rsi)
movl $0x2e2e2e20, 0x1fb(%rsi) # imm = 0x2E2E2E20
movl $0x1ff, %edx            # imm = 0x1FF
jmp 0x15e30
movslq %eax, %rdx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x8960
movl $0x1, %eax
addq $0x200, %rsp            # imm = 0x200
popq %rbx
retq
leaq 0x1227(%rip), %rsi      # 0x17074
leaq 0x1cac(%rip), %rdx      # 0x17b00
movq %rbx, %rdi
movl $0xba, %ecx
xorl %eax, %eax
addq $0x200, %rsp            # imm = 0x200
popq %rbx
jmp 0x8a80
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglmath/src/vec.c
// Function: Vxs
static int Vxs(lua_State *L, int sarg, int varg)
    {
    vec_t v; 
    size_t size, i; 
    unsigned int isrow;
    double s = luaL_checknumber(L, sarg);
    checkvec(L, varg, v, &size, &isrow);
    for(i=0; i < size; i++) 
        v[i] *= s;
    return pushvec(L, v, size, size, isrow);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebp
movq %rdi, %rbx
callq 0x8320
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rdx
leaq 0x38(%rsp), %r14
leaq 0x4(%rsp), %r8
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rcx
callq 0x8670
movsd 0x8(%rsp), %xmm1
movq (%r14), %rcx
testq %rcx, %rcx
je 0x15ec7
xorl %eax, %eax
movsd 0x10(%rsp,%rax,8), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp,%rax,8)
incq %rax
cmpq %rax, %rcx
jne 0x15eaf
movl 0x4(%rsp), %r8d
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %rcx, %rdx
callq 0x82e0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglmath/src/vec.c
// Function: Vec
static int Vec(lua_State *L, size_t size, unsigned int isrow)
/* creates a vector of size 'size', from a vector or a list of values 
 * the size is adapted by discarding exceeding values or adding zeros
 * in lieu of missing values.
 * vecN(v)
 * vecN([x1 ,[x2,...[,xN]]])
 */
    {
    vec_t v;
    size_t vsize, i, arg;
    arg = 1;
    if(testvec(L, arg, v, &vsize, NULL))
        return pushvec(L, v, vsize, size, isrow);
    checkvecsize(L, size);
    for(i = 0; i < size; i++)
        v[i] = luaL_optnumber(L, arg++, 0);
    return pushvec(L, v, size, size, isrow);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movl $0x1, %esi
xorl %r8d, %r8d
callq 0x8a50
testl %eax, %eax
je 0x15fee
movq 0x8(%rsp), %rdx
jmp 0x1601d
movq %r14, %rdx
testq %r14, %r14
je 0x1601d
xorl %r13d, %r13d
leaq 0x1(%r13), %r12
xorps %xmm0, %xmm0
movq %r15, %rdi
movl %r12d, %esi
callq 0x8340
movsd %xmm0, 0x10(%rsp,%r13,8)
movq %r12, %r13
cmpq %r12, %r14
jne 0x15ff9
movq %r14, %rdx
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
movq %r14, %rcx
movl %ebx, %r8d
callq 0x82e0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglmath/src/viewing.c
// Function: moonglmath_ortho
int ortho(mat_t dst, double l, double r, double b, double t, double near, double far)
/* ortho(left, right, bottom, top, near,  far)
 * near=-1 and far=1 give a 2D projection
 *
 * Rfr. RTR3/4.6.1
 *
 * The viewing parallelepiped is: 
 * x: left .. right
 * y: bottom .. up
 * z: -near .. -far
 *
 * The camera is positioned at the origin, pointing to the -z axis (x=right, y=up)
 * and the projection plane is the x-y plane (or, equivalently, any plane parallel
 * to x-y, since the projectors are parallel to the z axis).
 *
 * M =  |2/(r-l)  0    0     0| |1 0 0 -(l+r)/2| = |2/(r-l)  0     0    -(r+l)/(r-l)|
 *      |  0   2/(t-b) 0     0|*|0 1 0 -(t+b)/2|   |  0   2/(t-b)  0    -(t+b)/(t-b)|
 *      |  0      0  2/(f-n) 0| |0 0 1 -(f+n)/2|   |  0     0   2/(f-n) -(f+n)/(f-n)|
 *      |  0      0    0     1| |0 0 0     1   |   |  0     0      0         1      |
 *           scaling               translation
 */
    {
    double n, f;
    n = -near;
    f = -far;
    mat_clear(dst);
    dst[0][0] = 2.0/(r-l);
    dst[0][3] = -(r+l)/(r-l);
    dst[1][1] = 2.0/(t-b);
    dst[1][3] = -(t+b)/(t-b);
    dst[2][2] = 2.0/(f-n);
    dst[2][3] = -(f+n)/(f-n);
    dst[3][3] = 1.0;
    return 0;
    }

// Assembly:
movapd 0xef4(%rip), %xmm7      # 0x170d0
movapd %xmm4, %xmm6
xorpd %xmm7, %xmm6
xorps %xmm8, %xmm8
movups %xmm8, 0x18(%rdi)
movups %xmm8, 0x28(%rdi)
movups %xmm8, 0x38(%rdi)
movups %xmm8, 0x58(%rdi)
movups %xmm8, 0x48(%rdi)
movups %xmm8, 0x68(%rdi)
movups %xmm8, 0x8(%rdi)
movapd %xmm1, %xmm8
subsd %xmm0, %xmm8
movsd 0x1582(%rip), %xmm9     # 0x177a0
movapd %xmm9, %xmm10
divsd %xmm8, %xmm10
movsd %xmm10, (%rdi)
addsd %xmm1, %xmm0
xorpd %xmm7, %xmm0
divsd %xmm8, %xmm0
movsd %xmm0, 0x18(%rdi)
movapd %xmm3, %xmm0
subsd %xmm2, %xmm0
divsd %xmm0, %xmm9
movsd %xmm9, 0x28(%rdi)
addsd %xmm3, %xmm2
xorpd %xmm7, %xmm2
divsd %xmm0, %xmm2
movsd %xmm2, 0x38(%rdi)
subsd %xmm5, %xmm4
subsd %xmm5, %xmm6
xorpd %xmm7, %xmm6
movapd 0x18f9(%rip), %xmm0     # 0x17b70
unpcklpd %xmm6, %xmm0            # xmm0 = xmm0[0],xmm6[0]
unpcklpd %xmm4, %xmm4            # xmm4 = xmm4[0,0]
divpd %xmm4, %xmm0
movupd %xmm0, 0x50(%rdi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x78(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglmath/src/viewing.c
// Function: moonglmath_frustum
int frustum(mat_t dst, double l, double r, double b, double t, double n, double f)
    {
    mat_clear(dst);
    dst[0][0] = 2.0*n/(r-l);
    dst[0][2] = (r+l)/(r-l);
    dst[1][1] = 2.0*n/(t-b);
    dst[1][2] = (t+b)/(t-b);
    dst[2][2] = -(f+n)/(f-n);
    dst[2][3] = -2.0*f*n/(f-n);
    dst[3][2] = -1.0;
    return 0;
    }

// Assembly:
xorps %xmm6, %xmm6
movups %xmm6, 0x8(%rdi)
movups %xmm6, 0x58(%rdi)
movups %xmm6, 0x48(%rdi)
movups %xmm6, 0x68(%rdi)
movups %xmm6, 0x38(%rdi)
movups %xmm6, 0x18(%rdi)
movq $0x0, 0x78(%rdi)
movapd %xmm4, %xmm6
addsd %xmm5, %xmm6
movapd %xmm5, %xmm7
subsd %xmm4, %xmm7
mulsd 0x18ac(%rip), %xmm5     # 0x17b80
mulsd %xmm4, %xmm5
unpcklpd %xmm2, %xmm4            # xmm4 = xmm4[0],xmm2[0]
movapd 0x188b(%rip), %xmm8     # 0x17b70
unpcklpd %xmm3, %xmm8            # xmm8 = xmm8[0],xmm3[0]
movapd %xmm4, %xmm9
mulpd %xmm8, %xmm9
addpd %xmm4, %xmm8
movsd %xmm9, %xmm8            # xmm8 = xmm9[0],xmm8[1]
movapd %xmm1, %xmm4
subsd %xmm0, %xmm4
divsd %xmm4, %xmm9
movsd %xmm9, (%rdi)
addsd %xmm1, %xmm0
divsd %xmm4, %xmm0
movsd %xmm0, 0x10(%rdi)
subsd %xmm2, %xmm3
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
divpd %xmm3, %xmm8
xorpd 0xd9e(%rip), %xmm6      # 0x170d0
movupd %xmm8, 0x28(%rdi)
unpcklpd %xmm5, %xmm6            # xmm6 = xmm6[0],xmm5[0]
unpcklpd %xmm7, %xmm7            # xmm7 = xmm7[0,0]
divpd %xmm7, %xmm6
movupd %xmm6, 0x50(%rdi)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x70(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglmath/src/viewing.c
// Function: moonglmath_perspective
int perspective(mat_t dst, double fovy, double aspect, double n, double f)
    {
    double t = tan(fovy/2) * n; /* top */
    double r = t * aspect; /* right */
    mat_clear(dst);
    dst[0][0] = n/r;
    dst[1][1] = n/t;
    dst[2][2] = -(f+n)/(f-n);
    dst[2][3] = -2.0*f*n/(f-n);
    dst[3][2] = -1.0;
    return 0;
    }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movaps %xmm3, 0x10(%rsp)
movsd %xmm2, (%rsp)
movsd %xmm1, 0x8(%rsp)
movq %rdi, %rbx
mulsd 0x141e(%rip), %xmm0     # 0x17798
callq 0x88a0
movsd (%rsp), %xmm3
mulsd %xmm3, %xmm0
movsd 0x8(%rsp), %xmm2
mulsd %xmm0, %xmm2
xorps %xmm1, %xmm1
movups %xmm1, 0x28(%rbx)
movups %xmm1, 0x48(%rbx)
movups %xmm1, 0x58(%rbx)
movups %xmm1, 0x68(%rbx)
movups %xmm1, 0x8(%rbx)
movups %xmm1, 0x18(%rbx)
movups %xmm1, 0x38(%rbx)
movq $0x0, 0x78(%rbx)
movapd %xmm3, %xmm1
divsd %xmm2, %xmm1
movsd %xmm1, (%rbx)
movapd %xmm3, %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x28(%rbx)
movapd %xmm3, %xmm0
movapd 0x10(%rsp), %xmm2
addsd %xmm2, %xmm0
xorpd 0xce8(%rip), %xmm0      # 0x170d0
movapd %xmm2, %xmm1
subsd %xmm3, %xmm1
mulsd 0x1788(%rip), %xmm2     # 0x17b80
mulsd %xmm3, %xmm2
unpcklpd %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0]
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
divpd %xmm1, %xmm0
movupd %xmm0, 0x50(%rbx)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x70(%rbx)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonglmath/src/viewing.c
// Function: Ortho
static int Ortho(lua_State *L)
    {
    mat_t m;
    double l = luaL_checknumber(L, 1); /* left */
    double r = luaL_checknumber(L, 2); /* right */
    double b = luaL_checknumber(L, 3); /* bottom */
    double t = luaL_checknumber(L, 4); /* top */
    double n = luaL_optnumber(L, 5, -1.0); /* near */
    double f = luaL_optnumber(L, 6, 1.0); /* far */
    ortho(m, l, r, b, t, n, f);
    return pushmat(L, m, 4, 4, 4, 4);
    }

// Assembly:
pushq %rbx
subq $0xc0, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x8320
movaps %xmm0, 0x20(%rsp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8320
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x8320
movaps %xmm0, 0x30(%rsp)
movq %rbx, %rdi
movl $0x4, %esi
callq 0x8320
movsd %xmm0, 0x8(%rsp)
movsd 0x13fa(%rip), %xmm0     # 0x17928
movq %rbx, %rdi
movl $0x5, %esi
callq 0x8340
movaps %xmm0, 0x10(%rsp)
movsd 0xb78(%rip), %xmm0      # 0x170c0
movq %rbx, %rdi
movl $0x6, %esi
callq 0x8340
movapd 0xb73(%rip), %xmm2      # 0x170d0
movapd 0x10(%rsp), %xmm8
movapd %xmm8, %xmm1
xorpd %xmm2, %xmm1
xorps %xmm3, %xmm3
leaq 0x40(%rsp), %rsi
movups %xmm3, 0x18(%rsi)
movups %xmm3, 0x28(%rsi)
movups %xmm3, 0x38(%rsi)
movups %xmm3, 0x48(%rsi)
movups %xmm3, 0x58(%rsi)
movups %xmm3, 0x8(%rsi)
movups %xmm3, 0x68(%rsi)
movsd (%rsp), %xmm7
movapd %xmm7, %xmm3
movapd 0x20(%rsp), %xmm6
subsd %xmm6, %xmm3
movsd 0x11f4(%rip), %xmm4     # 0x177a0
movapd %xmm4, %xmm5
divsd %xmm3, %xmm5
movsd %xmm5, (%rsi)
addsd %xmm7, %xmm6
xorpd %xmm2, %xmm6
divsd %xmm3, %xmm6
movsd %xmm6, 0x18(%rsi)
movsd 0x8(%rsp), %xmm6
movapd %xmm6, %xmm3
movapd 0x30(%rsp), %xmm5
subsd %xmm5, %xmm3
divsd %xmm3, %xmm4
movsd %xmm4, 0x28(%rsi)
addsd %xmm6, %xmm5
xorpd %xmm2, %xmm5
divsd %xmm3, %xmm5
movsd %xmm5, 0x38(%rsi)
movapd %xmm8, %xmm3
subsd %xmm0, %xmm3
subsd %xmm0, %xmm1
xorpd %xmm2, %xmm1
movapd 0x1560(%rip), %xmm0     # 0x17b70
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
divpd %xmm3, %xmm0
movapd %xmm0, 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 $0xc0, %rsp
popq %rbx
retq