LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/funcs.c
// Function: Clamp
static int Clamp(lua_State *L)
    {
    if(lua_isnumber(L,1)) return num_Clamp(L);
    if(isvec(L,1)) return vec_Clamp(L);
    if(ismat(L,1)) return mat_Clamp(L);
    return badarg(L, 1);
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x8560
testl %eax, %eax
je 0xc9a4
movq %rbx, %rdi
popq %rbx
jmp 0x8a90
leaq 0xaa1f(%rip), %rdx      # 0x173ca
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8170
testl %eax, %eax
je 0xc9c5
movq %rbx, %rdi
popq %rbx
jmp 0x8ad0
leaq 0xa9c9(%rip), %rdx      # 0x17395
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8170
testl %eax, %eax
je 0xc9e6
movq %rbx, %rdi
popq %rbx
jmp 0x8af0
leaq 0xa9b7(%rip), %rdx      # 0x173a4
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
jmp 0x81b0
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/funcs.c
// Function: Mix
static int Mix(lua_State *L)
    {
    if(lua_isnumber(L,1)) return num_Mix(L);
    if(isvec(L,1)) return vec_Mix(L);
    if(ismat(L,1)) return mat_Mix(L);
    if(isquat(L,1)) return quat_Mix(L);
    return badarg(L, 1);
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x8560
testl %eax, %eax
je 0xca16
movq %rbx, %rdi
popq %rbx
jmp 0x8110
leaq 0xa9ad(%rip), %rdx      # 0x173ca
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8170
testl %eax, %eax
je 0xca37
movq %rbx, %rdi
popq %rbx
jmp 0x8910
leaq 0xa957(%rip), %rdx      # 0x17395
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8170
testl %eax, %eax
je 0xca58
movq %rbx, %rdi
popq %rbx
jmp 0x8100
leaq 0xa95b(%rip), %rdx      # 0x173ba
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8170
testl %eax, %eax
je 0xca79
movq %rbx, %rdi
popq %rbx
jmp 0x80b0
leaq 0xa924(%rip), %rdx      # 0x173a4
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
jmp 0x81b0
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/funcs.c
// Function: Step
static int Step(lua_State *L)
    {
    if(lua_isnumber(L,1)) return num_Step(L);
    if(isvec(L,1)) return vec_Step(L);
    if(ismat(L,1)) return mat_Step(L);
    return badarg(L, 1);
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x8560
testl %eax, %eax
je 0xcae0
movq %rbx, %rdi
popq %rbx
jmp 0x89b0
leaq 0xa8e3(%rip), %rdx      # 0x173ca
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8170
testl %eax, %eax
je 0xcb01
movq %rbx, %rdi
popq %rbx
jmp 0x83a0
leaq 0xa88d(%rip), %rdx      # 0x17395
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8170
testl %eax, %eax
je 0xcb22
movq %rbx, %rdi
popq %rbx
jmp 0x8d80
leaq 0xa87b(%rip), %rdx      # 0x173a4
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
jmp 0x81b0
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/funcs.c
// Function: Smoothstep
static int Smoothstep(lua_State *L)
    {
    if(lua_isnumber(L,1)) return num_Smoothstep(L);
    if(isvec(L,1)) return vec_Smoothstep(L);
    if(ismat(L,1)) return mat_Smoothstep(L);
    return badarg(L, 1);
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x8560
testl %eax, %eax
je 0xcb52
movq %rbx, %rdi
popq %rbx
jmp 0x84e0
leaq 0xa871(%rip), %rdx      # 0x173ca
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8170
testl %eax, %eax
je 0xcb73
movq %rbx, %rdi
popq %rbx
jmp 0x89d0
leaq 0xa81b(%rip), %rdx      # 0x17395
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8170
testl %eax, %eax
je 0xcb94
movq %rbx, %rdi
popq %rbx
jmp 0x8830
leaq 0xa809(%rip), %rdx      # 0x173a4
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
jmp 0x81b0
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/funcs.c
// Function: Fade
static int Fade(lua_State *L)
    {
    if(lua_isnumber(L,1)) return num_Fade(L);
    if(isvec(L,1)) return vec_Fade(L);
    if(ismat(L,1)) return mat_Fade(L);
    return badarg(L, 1);
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x8560
testl %eax, %eax
je 0xcbc4
movq %rbx, %rdi
popq %rbx
jmp 0x8d70
leaq 0xa7ff(%rip), %rdx      # 0x173ca
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8170
testl %eax, %eax
je 0xcbe5
movq %rbx, %rdi
popq %rbx
jmp 0x8890
leaq 0xa7a9(%rip), %rdx      # 0x17395
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8170
testl %eax, %eax
je 0xcc06
movq %rbx, %rdi
popq %rbx
jmp 0x8360
leaq 0xa797(%rip), %rdx      # 0x173a4
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
jmp 0x81b0
nop
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/hostmem.c
// Function: Write
static int Write(lua_State *L)
    {
    int t = lua_type(L, 3);
    if(t == LUA_TSTRING) return WritePack(L);
    if(t == LUA_TNIL) return WriteData(L);
    return luaL_argerror(L, 3, errstring(ERR_TYPE));    
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x3, %esi
callq 0x8c40
testl %eax, %eax
je 0xcd66
cmpl $0x4, %eax
jne 0xcde6
leaq 0xa6d1(%rip), %rcx      # 0x173d9
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x80e0
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x86e0
movq %rax, %r12
movq %rbx, %rdi
movl $0x1, %esi
movl $0x3, %edx
callq 0x8050
movq 0x8(%r15), %r8
subq %r12, %r8
jbe 0xce0d
addq (%r15), %r12
movq %rbx, %rdi
movl $0x4, %esi
movl %eax, %edx
movq %r12, %rcx
callq 0x81c0
jmp 0xce3f
leaq 0xa66c(%rip), %rcx      # 0x173d9
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x80e0
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x86e0
movq %rax, %r12
leaq 0x8(%rsp), %r13
movq %rbx, %rdi
movl $0x4, %esi
movq %r13, %rdx
callq 0x85c0
movq (%r13), %rdx
testq %rdx, %rdx
je 0xce3f
movq 0x8(%r15), %rcx
subq %r12, %rcx
seta %sil
cmpq %rcx, %rdx
setbe %cl
testb %cl, %sil
jne 0xce31
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
callq 0x8510
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x8a80
movl %eax, %r14d
jmp 0xce3f
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
callq 0x8510
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x81b0
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
callq 0x8510
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x8a80
addq (%r15), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x8760
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/hostmem.c
// Function: Copy
static int Copy(lua_State *L)
    {
    int t = lua_type(L, 4);
    if(t == LUA_TLIGHTUSERDATA) return CopyPtr(L);
    if(t == LUA_TUSERDATA) return CopyHostmem(L);
    return luaL_argerror(L, 4, errstring(ERR_TYPE));    
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x4, %esi
callq 0x8c40
cmpl $0x7, %eax
je 0xcee6
cmpl $0x2, %eax
jne 0xcfa0
leaq 0xa55e(%rip), %rcx      # 0x173d9
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x80e0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x86e0
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x86e0
movq %rax, %r12
movq %rbx, %rdi
movl $0x4, %esi
callq 0x8bb0
testq %r12, %r12
je 0xcfe9
movq 0x8(%r14), %rcx
subq %r15, %rcx
setbe %dl
cmpq %rcx, %r12
seta %cl
orb %dl, %cl
cmpb $0x1, %cl
je 0xcf80
addq (%r14), %r15
jmp 0xcfdb
leaq 0xa4ec(%rip), %r13      # 0x173d9
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
movq %r13, %rcx
callq 0x80e0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x86e0
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x86e0
movq %rax, %r12
movq %rbx, %rdi
movl $0x4, %esi
xorl %edx, %edx
movq %r13, %rcx
callq 0x80e0
movq %rax, %r13
movq %rbx, %rdi
movl $0x5, %esi
callq 0x86e0
cmpq %r13, %r14
je 0xcfb7
testq %r12, %r12
je 0xcfe9
movq 0x8(%r14), %rcx
subq %r15, %rcx
setbe %dl
cmpq %rcx, %r12
seta %cl
orb %dl, %cl
cmpb $0x1, %cl
je 0xcf80
movq 0x8(%r13), %rcx
subq %rax, %rcx
setbe %dl
cmpq %rcx, %r12
seta %cl
orb %dl, %cl
cmpb $0x1, %cl
jne 0xcfd4
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
callq 0x8510
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x8a80
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
callq 0x8510
movq %rbx, %rdi
movl $0x4, %esi
movq %rax, %rdx
jmp 0xcfc6
leaq 0xa451(%rip), %rdx      # 0x1740f
movq %rbx, %rdi
movl $0x4, %esi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x81b0
addq (%r14), %r15
addq (%r13), %rax
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x8760
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/hostmem.c
// Function: Clear
static int Clear(lua_State *L)
/* clear(offset, size, c) 
 */
    {
    size_t len;
    const char *s;
    char c;
    hostmem_t* hostmem = checkhostmem(L, 1, NULL);
    size_t offset = luaL_checkinteger(L, 2);
    size_t size = luaL_checkinteger(L, 3);

    if(lua_type(L, 4) == LUA_TSTRING)
        {
        s = luaL_checklstring(L, 4, &len);
        if(len != 1)
            return luaL_argerror(L, 4, "invalid length"); /* must be 1 */
        c = s[0];
        }
    else
        c = luaL_optinteger(L, 4, 0);
    
    if((offset >= hostmem->size) || (size > hostmem->size - offset))
        return luaL_error(L, errstring(ERR_BOUNDARIES));
    if(size == 0)
        return 0;
    memset(hostmem->ptr + offset, c, size);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xa3cd(%rip), %rcx      # 0x173d9
movl $0x1, %esi
xorl %edx, %edx
callq 0x80e0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x86e0
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x86e0
movq %rax, %r12
movq %rbx, %rdi
movl $0x4, %esi
callq 0x8c40
cmpl $0x4, %eax
jne 0xd06d
leaq 0x8(%rsp), %r13
movq %rbx, %rdi
movl $0x4, %esi
movq %r13, %rdx
callq 0x85c0
cmpq $0x1, (%r13)
jne 0xd0c6
movb (%rax), %al
jmp 0xd07c
movq %rbx, %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0x8840
movq 0x8(%r14), %rcx
subq %r15, %rcx
setbe %dl
cmpq %rcx, %r12
seta %cl
orb %dl, %cl
cmpb $0x1, %cl
jne 0xd0ac
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
callq 0x8510
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x8a80
jmp 0xd0da
xorl %ebx, %ebx
testq %r12, %r12
je 0xd0dc
addq (%r14), %r15
movzbl %al, %esi
movq %r15, %rdi
movq %r12, %rdx
callq 0x84f0
jmp 0xd0dc
leaq 0xa36e(%rip), %rdx      # 0x1743b
movq %rbx, %rdi
movl $0x4, %esi
callq 0x81b0
movl %eax, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/hostmem.c
// Function: Read
static int Read(lua_State *L)
    {
    int type;
    hostmem_t* hostmem = checkhostmem(L, 1, NULL);
    size_t offset = luaL_optinteger(L, 2, 0);
    size_t size = luaL_optinteger(L, 3, hostmem->size - offset);
    if((offset >= hostmem->size) || (size > hostmem->size - offset))
        return luaL_error(L, errstring(ERR_BOUNDARIES));
    if(lua_type(L, 4) == LUA_TSTRING) /* unpack according to 'type' */
        {
        type = checktype(L, 4);
        if(size == 0)
            { lua_newtable(L); return 1; }
        return pushdata(L, type, hostmem->ptr + offset, size);
        }
    if(size == 0)
        lua_pushstring(L, ""); 
    else
        lua_pushlstring(L, hostmem->ptr + offset, size);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa2db(%rip), %rcx      # 0x173d9
movl $0x1, %esi
xorl %edx, %edx
callq 0x80e0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x8840
movq %rax, %r15
movq 0x8(%r14), %rdx
subq %rax, %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x8840
movq %rax, %r12
movq 0x8(%r14), %rax
subq %r15, %rax
setbe %cl
cmpq %rax, %r12
seta %al
orb %cl, %al
cmpb $0x1, %al
jne 0xd16e
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
callq 0x8510
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8a80
movq %rbx, %rdi
movl $0x4, %esi
callq 0x8c40
cmpl $0x4, %eax
jne 0xd1b5
movq %rbx, %rdi
movl $0x1, %esi
movl $0x4, %edx
callq 0x8050
testq %r12, %r12
je 0xd1cd
addq (%r14), %r15
movq %rbx, %rdi
movl %eax, %esi
movq %r15, %rdx
movq %r12, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x86c0
testq %r12, %r12
je 0xd1db
addq (%r14), %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x8960
jmp 0xd1ea
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x82f0
jmp 0xd1ea
leaq 0xa558(%rip), %rsi      # 0x1773a
movq %rbx, %rdi
callq 0x8d00
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/hostmem.c
// Function: Ptr
static int Ptr(lua_State *L)
    {
    hostmem_t* hostmem = checkhostmem(L, 1, NULL);
    size_t offset = luaL_optinteger(L, 2, 0);
    size_t size = luaL_optinteger(L, 3, 0);
    if((offset >= hostmem->size) || (size > hostmem->size - offset))
        return luaL_error(L, errstring(ERR_BOUNDARIES));
    lua_pushlightuserdata(L, hostmem->ptr + offset);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xa1cf(%rip), %rcx      # 0x173d9
movl $0x1, %esi
xorl %edx, %edx
callq 0x80e0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x8840
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x8840
movq 0x8(%r14), %rcx
subq %r15, %rcx
jbe 0xd261
cmpq %rcx, %rax
ja 0xd261
addq (%r14), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x88e0
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
movl $0xfffffff6, %edi       # imm = 0xFFFFFFF6
callq 0x8510
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x8a80
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/hostmem.c
// Function: Size
static int Size(lua_State *L)
    {
    size_t offset;
    char *ptr;
    hostmem_t* hostmem = checkhostmem(L, 1, NULL);
    if(lua_isnoneornil(L, 2))
        lua_pushinteger(L, hostmem->size);
    else if(lua_isinteger(L, 2))
        {
        offset = luaL_checkinteger(L, 2);
        if(offset >= hostmem->size)
            lua_pushinteger(L, 0);
        else
            lua_pushinteger(L, hostmem->size - offset);
        }
    else
        {
        ptr = (char*)checklightuserdata(L, 2);
        if((ptr < hostmem->ptr) || (ptr > (hostmem->ptr + hostmem->size)))
            lua_pushinteger(L, 0);
        else
            lua_pushinteger(L, hostmem->ptr + hostmem->size - ptr);
        }
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa14e(%rip), %rcx      # 0x173d9
movl $0x1, %esi
xorl %edx, %edx
callq 0x80e0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8c40
testl %eax, %eax
jle 0xd2d8
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8df0
movq %rbx, %rdi
movl $0x2, %esi
testl %eax, %eax
je 0xd2de
callq 0x86e0
movq 0x8(%r14), %rcx
xorl %esi, %esi
subq %rax, %rcx
cmovaeq %rcx, %rsi
jmp 0xd2fb
movq 0x8(%r14), %rsi
jmp 0xd2fb
callq 0x8bb0
movq (%r14), %rsi
cmpq %rsi, %rax
jb 0xd2f4
addq 0x8(%r14), %rsi
cmpq %rsi, %rax
jbe 0xd2f8
xorl %esi, %esi
jmp 0xd2fb
subq %rax, %rsi
movq %rbx, %rdi
callq 0x8500
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/hostmem.c
// Function: CreateHostmem
static int CreateHostmem(lua_State *L)
    {
    size_t size;
    const char *ptr;
    hostmem_t* hostmem;

    if(lua_type(L, 1) == LUA_TSTRING)
        {
        ptr = lua_tolstring(L, 1, &size);
        }
    else
        {
        size = luaL_checkinteger(L, 1);
        ptr = (char*)checklightuserdata(L, 2);
        }

    if(size == 0)
        return luaL_argerror(L, 1, errstring(ERR_LENGTH));

    hostmem = (hostmem_t*)MallocNoErr(L, sizeof(hostmem_t));
    if(!hostmem)
        {
        Free(L, hostmem);
        return luaL_error(L, errstring(ERR_MEMORY));
        }

    hostmem->ptr = (char*)ptr;
    hostmem->size = size;
    newhostmem(L, hostmem);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x8c40
cmpl $0x4, %eax
jne 0xd366
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x8290
jmp 0xd384
movq %rbx, %rdi
movl $0x1, %esi
callq 0x86e0
movq %rax, (%rsp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8bb0
movq %rax, %r14
cmpq $0x0, (%rsp)
je 0xd3d6
movl $0x10, %esi
movq %rbx, %rdi
callq 0x89f0
testq %rax, %rax
je 0xd3f2
movq %r14, (%rax)
movq (%rsp), %rcx
movq %rcx, 0x8(%rax)
leaq 0xa027(%rip), %rdx      # 0x173d9
leaq 0xa02b(%rip), %rcx      # 0x173e4
movq %rbx, %rdi
movq %rax, %rsi
callq 0x83d0
leaq 0x28f(%rip), %rcx       # 0xd65a
movq %rcx, 0x8(%rax)
movl $0x1, %eax
jmp 0xd413
movl $0xfffffff8, %edi       # imm = 0xFFFFFFF8
callq 0x8510
movq %rbx, %rdi
movl $0x1, %esi
movq %rax, %rdx
callq 0x81b0
jmp 0xd413
movq %rbx, %rdi
xorl %esi, %esi
callq 0x85f0
movl $0xfffffffa, %edi       # imm = 0xFFFFFFFA
callq 0x8510
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x8a80
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/hostmem.c
// Function: Create
static int Create(lua_State *L, int arg, size_t alignment)
    {
    const char *data = NULL;
    char *ptr;
    size_t size;
    (void)alignment;

    if(lua_type(L, arg) == LUA_TSTRING)
        {
        if(!lua_isnoneornil(L, arg+1))
            return CreatePack(L, arg, alignment);
    
        data = luaL_checklstring(L, arg, &size);
        if(size == 0) 
            return luaL_argerror(L, arg, errstring(ERR_LENGTH));
        }
    else
        {
        size = luaL_checkinteger(L, arg);
        if(size == 0) 
            return luaL_argerror(L, arg, errstring(ERR_VALUE));
        }
#if defined(MACOS) /* @@TODO */
    ptr = (char*)Malloc(L, size);
#else
    ptr = (char*)AlignedAlloc(alignment, size);
#endif
    if(!ptr)
        return luaL_error(L, "failed to allocate page aligned memory");
            
    if(data)
        memcpy(ptr, data, size);
    else
        memset(ptr, 0, size);

    CreateAllocated(L, ptr, size);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
callq 0x8c40
cmpl $0x4, %eax
jne 0xd4d1
leal 0x1(%r15), %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8c40
testl %eax, %eax
jle 0xd4ea
movq %rbx, %rdi
movl $0x1, %esi
movl %r15d, %edx
callq 0x8050
movl %eax, %r12d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8490
movslq %eax, %r13
movl %r12d, %edi
callq 0x8220
movq %rax, %r15
imulq %r13, %r15
testq %r15, %r15
je 0xd55a
movq %r14, %rdi
movq %r15, %rsi
callq 0x8ca0
testq %rax, %rax
je 0xd5ab
movq %rax, %r14
movq %rbx, %rdi
movl %r12d, %esi
movq %r13, %rdx
movq %rax, %rcx
movq %r15, %r8
callq 0x85b0
testl %eax, %eax
je 0xd589
movl %eax, %r12d
movq %r14, %rdi
callq 0x8090
movl %r12d, %edi
jmp 0xd55f
movq %rbx, %rdi
movl %r15d, %esi
callq 0x86e0
movq %rax, (%rsp)
testq %rax, %rax
je 0xd535
xorl %r12d, %r12d
jmp 0xd509
movq %rsp, %r13
movq %rbx, %rdi
movl %r15d, %esi
movq %r13, %rdx
callq 0x85c0
cmpq $0x0, (%r13)
je 0xd5ca
movq %rax, %r12
movq (%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x8ca0
testq %rax, %rax
je 0xd547
movq %rax, %r14
movq %rax, %rdi
testq %r12, %r12
je 0xd57f
movq %r12, %rsi
movq %r15, %rdx
callq 0x8760
jmp 0xd589
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x8510
movq %rbx, %rdi
movl %r15d, %esi
jmp 0xd569
leaq 0x9f0f(%rip), %rsi      # 0x1745d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x8a80
jmp 0xd59c
movl $0xfffffff8, %edi       # imm = 0xFFFFFFF8
callq 0x8510
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x81b0
xorl %esi, %esi
movq %r15, %rdx
callq 0x84f0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xd5e4
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9eab(%rip), %rsi      # 0x1745d
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8a80
movl $0xfffffff8, %edi       # imm = 0xFFFFFFF8
callq 0x8510
movq %rbx, %rdi
movl %r15d, %esi
movq %rax, %rdx
callq 0x81b0
jmp 0xd59c
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/hostmem.c
// Function: CreateAllocated
static int CreateAllocated(lua_State *L, char *ptr, size_t size)
    {
    ud_t *ud;
    hostmem_t* hostmem;
    hostmem = (hostmem_t*)MallocNoErr(L, sizeof(hostmem_t));
    if(!hostmem)
        {
        free(ptr);
        return luaL_error(L, errstring(ERR_MEMORY));
        }
    hostmem->ptr = ptr;
    hostmem->size = size;
    ud = newhostmem(L, hostmem);
    MarkAllocated(ud);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl $0x10, %esi
callq 0x89f0
testq %rax, %rax
je 0xd636
movq %r14, (%rax)
movq %r15, 0x8(%rax)
leaq 0x9dca(%rip), %rdx      # 0x173d9
leaq 0x9dce(%rip), %rcx      # 0x173e4
movq %rbx, %rdi
movq %rax, %rsi
callq 0x83d0
leaq 0x32(%rip), %rcx        # 0xd65a
movq %rcx, 0x8(%rax)
orb $0x2, 0x18(%rax)
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x8090
movl $0xfffffffa, %edi       # imm = 0xFFFFFFFA
callq 0x8510
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x8a80
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/hostmem.c
// Function: freehostmem
static int freehostmem(lua_State *L, ud_t *ud)
    {
    hostmem_t* hostmem = (hostmem_t*)ud->handle;
    int allocated = IsAllocated(ud);
    if(!freeuserdata(L, ud, "hostmem")) return 0;
    if(allocated)
        AlignedFree(hostmem->ptr);
    Free(L, hostmem);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq (%rsi), %rbx
movl 0x18(%rsi), %ebp
leaq 0x9d76(%rip), %rdx      # 0x173e4
callq 0x8ab0
testl %eax, %eax
je 0xd690
testb $0x2, %bpl
je 0xd685
movq (%rbx), %rdi
callq 0x8090
movq %r14, %rdi
movq %rbx, %rsi
callq 0x85f0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/mat.c
// Function: moonglmath_pushmat
int pushmat(lua_State *L, mat_t m, size_t mr, size_t mc, size_t nr, size_t nc)
/* mr, mc = no. of valid colums/rows in m
 */
    {
    size_t i, j;
    checkmatsize(L, nr, nc);
    lua_newtable(L);
    setmetatable(L, MAT_MT);
    for(i=0; i<nr; i++)
        {
        lua_newtable(L); /* row i+1 */
        for(j=0; j<nc; j++)
            {
            lua_pushnumber(L, (i < mr) && (j < mc) ? m[i][j] : 0);
            lua_seti(L, -2, j+1);
            }
        lua_seti(L, -2, i+1);
        }
    for(i=nr; i<4; i++)
        {
        lua_newtable(L); /* empty rows */
        lua_seti(L, -2, i+1);
        }
    lua_pushinteger(L, nr);
    lua_setfield(L, -2, "rows");
    lua_pushinteger(L, nc);
    lua_setfield(L, -2, "columns");
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r12
movq %rdi, %rbx
leaq -0x5(%r8), %rax
cmpq $-0x4, %rax
setae %al
movq %r9, 0x8(%rsp)
leaq -0x5(%r9), %rcx
cmpq $-0x4, %rcx
setae %cl
testb %cl, %al
jne 0xdbaa
leaq 0x9a3b(%rip), %rsi      # 0x175cd
movq %rbx, %rdi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8a80
movq %r8, %r14
movq %rdx, %r13
movq %rsi, %rbp
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x82f0
leaq 0x97cf(%rip), %rsi      # 0x17395
movq %rbx, %rdi
callq 0x8950
movq %r14, 0x10(%rsp)
testq %r14, %r14
je 0xdc4c
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x82f0
cmpq $0x0, 0x8(%rsp)
je 0xdc2e
xorl %r14d, %r14d
cmpq %r13, %r15
setae %al
cmpq %r12, %r14
setae %cl
xorps %xmm0, %xmm0
orb %al, %cl
jne 0xdc0c
movsd (%rbp,%r14,8), %xmm0
movq %rbx, %rdi
callq 0x87d0
incq %r14
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r14, %rdx
callq 0x8640
cmpq %r14, 0x8(%rsp)
jne 0xdbf2
incq %r15
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r15, %rdx
callq 0x8640
addq $0x20, %rbp
cmpq 0x10(%rsp), %r15
jne 0xdbdb
movq 0x10(%rsp), %r15
cmpq $0x3, %r15
ja 0xdc80
leaq 0x1(%r15), %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x82f0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r14, %rdx
callq 0x8640
incq %r14
cmpq $0x5, %r14
jne 0xdc5b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8500
leaq 0x992e(%rip), %rdx      # 0x175c0
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x84b0
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq 0x8500
leaq 0x9912(%rip), %rdx      # 0x175c5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x84b0
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/mat.c
// Function: moonglmath_mat_unm
void mat_unm(mat_t dst, mat_t m, size_t nr, size_t nc)
    {
    size_t i, j;
    for(i = 0; i < nr; i++)
        for(j = 0; j < nc; j++)
            dst[i][j] = -m[i][j];
    }

// Assembly:
testq %rdx, %rdx
je 0xdeda
xorl %eax, %eax
movaps 0x9224(%rip), %xmm0     # 0x170d0
testq %rcx, %rcx
je 0xdeca
xorl %r8d, %r8d
movsd (%rsi,%r8,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%rdi,%r8,8)
incq %r8
cmpq %r8, %rcx
jne 0xdeb4
incq %rax
addq $0x20, %rdi
addq $0x20, %rsi
cmpq %rdx, %rax
jne 0xdeac
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/mat.c
// Function: moonglmath_mat_transpose
void mat_transpose(mat_t dst, mat_t m, size_t nr, size_t nc)
    {
    size_t i, j;
    for(i = 0; i < nr; i++)
        for(j = 0; j < nc; j++)
            dst[i][j] = m[j][i];
    }

// Assembly:
testq %rdx, %rdx
je 0xdf14
xorl %eax, %eax
testq %rcx, %rcx
je 0xdf04
movq %rsi, %r8
xorl %r9d, %r9d
movsd (%r8), %xmm0
movsd %xmm0, (%rdi,%r9,8)
incq %r9
addq $0x20, %r8
cmpq %r9, %rcx
jne 0xdeed
incq %rax
addq $0x20, %rdi
addq $0x8, %rsi
cmpq %rdx, %rax
jne 0xdee2
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/mat.c
// Function: moonglmath_mat_add
void mat_add(mat_t dst, mat_t m1, mat_t m2, size_t nr, size_t nc)
    {
    size_t i, j;
    for(i = 0; i < nr; i++)
        for(j = 0; j < nc; j++)
            dst[i][j] = m1[i][j] + m2[i][j];
    }

// Assembly:
testq %rcx, %rcx
je 0xdf52
xorl %eax, %eax
testq %r8, %r8
je 0xdf3e
xorl %r9d, %r9d
movsd (%rsi,%r9,8), %xmm0
addsd (%rdx,%r9,8), %xmm0
movsd %xmm0, (%rdi,%r9,8)
incq %r9
cmpq %r9, %r8
jne 0xdf24
incq %rax
addq $0x20, %rdi
addq $0x20, %rdx
addq $0x20, %rsi
cmpq %rcx, %rax
jne 0xdf1c
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/mat.c
// Function: moonglmath_mat_div
void mat_div(mat_t dst, mat_t m, double s, size_t nr, size_t nc)
    {
    size_t i, j;
    for(i = 0; i < nr; i++)
        for(j = 0; j < nc; j++)
            dst[i][j] = m[i][j]/s;
    }

// Assembly:
testq %rdx, %rdx
je 0xdfc8
xorl %eax, %eax
testq %rcx, %rcx
je 0xdfb8
xorl %r8d, %r8d
movsd (%rsi,%r8,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rdi,%r8,8)
incq %r8
cmpq %r8, %rcx
jne 0xdfa0
incq %rax
addq $0x20, %rdi
addq $0x20, %rsi
cmpq %rdx, %rax
jne 0xdf98
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/mat.c
// Function: moonglmath_mat_mul
void mat_mul(mat_t dst, mat_t m1, mat_t m2, size_t nr1, size_t nc1, size_t nc2) /* nr1=nc1 */
/* dst = m1 * m2  
 * (nr1 x nc2) = (nr1 x nc1) *(nc1 x nc2)
 */
    {
    size_t i, j, k;
    double s;
    for(i=0; i < nr1; i++)
        for(j=0; j < nc2; j++)
            {
            s = 0;
            for(k=0; k < nc1; k++)
                s += m1[i][k] * m2[k][j];
            dst[i][j] = s;
            }
    }

// Assembly:
testq %rcx, %rcx
je 0xe06e
pushq %r15
pushq %r14
pushq %rbx
xorl %eax, %eax
testq %r9, %r9
je 0xe05d
movq %rax, %r10
shlq $0x5, %r10
addq %rdi, %r10
movq %rdx, %r11
xorl %ebx, %ebx
xorpd %xmm0, %xmm0
testq %r8, %r8
je 0xe04b
movq %r11, %r14
xorl %r15d, %r15d
movsd (%rsi,%r15,8), %xmm1
mulsd (%r14), %xmm1
addsd %xmm1, %xmm0
incq %r15
addq $0x20, %r14
cmpq %r15, %r8
jne 0xe030
movsd %xmm0, (%r10,%rbx,8)
incq %rbx
addq $0x8, %r11
cmpq %r9, %rbx
jne 0xe021
incq %rax
addq $0x20, %rsi
cmpq %rcx, %rax
jne 0xe00d
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/mat.c
// Function: moonglmath_mat_mulby
void mat_mulby(mat_t m1, mat_t m2, size_t nr1, size_t nc1, size_t nc2) /* nr1=nc1 */
/* m1 = m1 * m2  (in place)
 * (nr1 x nc2) = (nr1 x nc1) *(nc1 x nc2)
 */
    {
    size_t i, j, k;
    double s;
    mat_t tmp;
    mat_copy(tmp, m1);
    for(i=0; i < nr1; i++)
        for(j=0; j < nc2; j++)
            {
            s = 0;
            for(k=0; k < nc1; k++)
                s += tmp[i][k] * m2[k][j];
            m1[i][j] = s;
            }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rax
movq %rsi, %r9
movq %rdi, %r10
leaq -0x80(%rsp), %r11
movl $0x10, %ecx
movq %r11, %rdi
movq %r10, %rsi
rep  movsq (%rsi), %es:(%rdi)
testq %rdx, %rdx
je 0xe0f2
xorl %ecx, %ecx
testq %r8, %r8
je 0xe0e6
movq %rcx, %rsi
shlq $0x5, %rsi
addq %r10, %rsi
movq %r9, %rdi
xorl %ebx, %ebx
xorpd %xmm0, %xmm0
testq %rax, %rax
je 0xe0d5
movq %rdi, %r14
xorl %r15d, %r15d
movsd (%r11,%r15,8), %xmm1
mulsd (%r14), %xmm1
addsd %xmm1, %xmm0
incq %r15
addq $0x20, %r14
cmpq %r15, %rax
jne 0xe0ba
movsd %xmm0, (%rsi,%rbx,8)
incq %rbx
addq $0x8, %rdi
cmpq %r8, %rbx
jne 0xe0ab
incq %rcx
addq $0x20, %r11
cmpq %rdx, %rcx
jne 0xe097
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/mat.c
// Function: moonglmath_mat_mxv
void mat_mxv(vec_t dst, mat_t m, vec_t v, size_t nr, size_t nc)
/* m is an nr x nc matrix
 * v is an nc column vector
 * dst is an nr column vector  (nr x nc) * (nc x 1) = (nr x 1)
 */
    {
    size_t i, j;
    double s;
    for(i=0; i < nr; i++)
        {
        s = 0;
        for(j=0; j < nc; j++)
            s += (m[i][j] * v[j]);
        dst[i] = s;
        }
    }

// Assembly:
testq %rcx, %rcx
je 0xe134
xorl %eax, %eax
xorpd %xmm0, %xmm0
testq %r8, %r8
je 0xe123
xorl %r9d, %r9d
movsd (%rsi,%r9,8), %xmm1
mulsd (%rdx,%r9,8), %xmm1
addsd %xmm1, %xmm0
incq %r9
cmpq %r9, %r8
jne 0xe10b
movsd %xmm0, (%rdi,%rax,8)
incq %rax
addq $0x20, %rsi
cmpq %rcx, %rax
jne 0xe0ff
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/mat.c
// Function: moonglmath_mat_vxm
void mat_vxm(vec_t dst, vec_t v, mat_t m, size_t nr, size_t nc)
/* v is an nr row vector
 * m is an nr x nc matrix
 * dst is an nc row vector  (1 x nr) x (nr x nc) = (1 x nc)
 */
    {
    size_t i, j;
    double s;
    for(i=0; i < nc; i++)
        {
        s = 0;
        for(j=0; j < nr; j++)
            s += (v[j] * m[j][i]);
        dst[i] = s;
        }
    }

// Assembly:
testq %r8, %r8
je 0xe177
xorl %eax, %eax
xorpd %xmm0, %xmm0
testq %rcx, %rcx
je 0xe166
movq %rdx, %r9
xorl %r10d, %r10d
movsd (%rsi,%r10,8), %xmm1
mulsd (%r9), %xmm1
addsd %xmm1, %xmm0
incq %r10
addq $0x20, %r9
cmpq %r10, %rcx
jne 0xe14b
movsd %xmm0, (%rdi,%rax,8)
incq %rax
addq $0x8, %rdx
cmpq %r8, %rax
jne 0xe13c
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/mat.c
// Function: moonglmath_mat_inv
int mat_inv(mat_t dst, mat_t m, size_t n)
    {
    size_t i, j;
    double d;
    if(n==2)
        d = det2(m);
    else if(n==3)
        d = det3(m);
    else //if(n==4)
        d = det4(m);
    if(d == 0.0)
        return 0;
    mat_adj(dst, m, n);
    for(i=0; i<n; i++)
        for(j=0; j<n; j++)
            dst[i][j] /= d;
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movsd (%rsi), %xmm8
movsd 0x28(%rsi), %xmm0
cmpq $0x3, %rdx
je 0xe97f
cmpq $0x2, %rbx
jne 0xe9e2
movsd 0x8(%rsi), %xmm1
mulsd 0x20(%rsi), %xmm1
mulsd %xmm0, %xmm8
subsd %xmm1, %xmm8
jmp 0xeb3e
movsd 0x50(%rsi), %xmm1
movsd 0x48(%rsi), %xmm2
movsd 0x20(%rsi), %xmm3
movsd 0x30(%rsi), %xmm4
movapd %xmm4, %xmm5
mulsd %xmm2, %xmm5
movapd %xmm0, %xmm6
mulsd %xmm1, %xmm6
subsd %xmm5, %xmm6
movsd 0x40(%rsi), %xmm5
mulsd %xmm5, %xmm4
mulsd %xmm3, %xmm1
subsd %xmm4, %xmm1
mulsd 0x8(%rsi), %xmm1
mulsd %xmm6, %xmm8
subsd %xmm1, %xmm8
mulsd %xmm5, %xmm0
mulsd %xmm2, %xmm3
subsd %xmm0, %xmm3
mulsd 0x10(%rsi), %xmm3
addsd %xmm3, %xmm8
jmp 0xeb3e
movsd 0x50(%rsi), %xmm10
movsd 0x78(%rsi), %xmm4
movsd 0x70(%rsi), %xmm1
movsd 0x58(%rsi), %xmm12
movapd %xmm12, %xmm2
mulsd %xmm1, %xmm2
movapd %xmm10, %xmm11
mulsd %xmm4, %xmm11
subsd %xmm2, %xmm11
movsd 0x30(%rsi), %xmm5
movsd 0x48(%rsi), %xmm7
movsd 0x68(%rsi), %xmm2
movapd %xmm12, %xmm3
mulsd %xmm2, %xmm3
movapd %xmm2, %xmm14
movsd %xmm2, (%rsp)
movapd %xmm7, %xmm6
mulsd %xmm4, %xmm6
subsd %xmm3, %xmm6
movapd %xmm6, %xmm3
mulsd %xmm5, %xmm3
movapd %xmm5, %xmm2
movapd %xmm0, %xmm9
mulsd %xmm11, %xmm9
subsd %xmm3, %xmm9
movsd 0x38(%rsi), %xmm3
movapd %xmm10, %xmm13
mulsd %xmm14, %xmm13
movapd %xmm7, %xmm5
mulsd %xmm1, %xmm5
subsd %xmm13, %xmm5
movapd %xmm3, %xmm14
mulsd %xmm5, %xmm14
addsd %xmm9, %xmm14
movsd 0x40(%rsi), %xmm9
movsd 0x60(%rsi), %xmm13
mulsd %xmm13, %xmm12
mulsd %xmm9, %xmm4
subsd %xmm12, %xmm4
movapd %xmm4, %xmm15
mulsd %xmm2, %xmm15
movsd 0x20(%rsi), %xmm12
mulsd %xmm12, %xmm11
subsd %xmm15, %xmm11
mulsd %xmm13, %xmm10
mulsd %xmm9, %xmm1
subsd %xmm10, %xmm1
movapd %xmm3, %xmm10
mulsd %xmm1, %xmm10
addsd %xmm11, %xmm10
mulsd %xmm14, %xmm8
mulsd 0x8(%rsi), %xmm10
subsd %xmm10, %xmm8
mulsd %xmm0, %xmm4
mulsd %xmm12, %xmm6
subsd %xmm4, %xmm6
mulsd %xmm13, %xmm7
mulsd (%rsp), %xmm9
subsd %xmm7, %xmm9
mulsd %xmm9, %xmm3
addsd %xmm6, %xmm3
mulsd 0x10(%rsi), %xmm3
addsd %xmm8, %xmm3
mulsd %xmm0, %xmm1
mulsd %xmm12, %xmm5
subsd %xmm1, %xmm5
mulsd %xmm2, %xmm9
addsd %xmm5, %xmm9
mulsd 0x18(%rsi), %xmm9
subsd %xmm9, %xmm3
movapd %xmm3, %xmm8
xorl %eax, %eax
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm8
jne 0xeb4d
jnp 0xeb95
movsd %xmm8, (%rsp)
movq %r14, %rdi
movq %rbx, %rdx
callq 0x8470
movl $0x1, %eax
testq %rbx, %rbx
je 0xeb95
xorl %ecx, %ecx
movsd (%rsp), %xmm1
xorl %edx, %edx
movsd (%r14,%rdx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%r14,%rdx,8)
incq %rdx
cmpq %rdx, %rbx
jne 0xeb71
incq %rcx
addq $0x20, %r14
cmpq %rbx, %rcx
jne 0xeb6f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/mat.c
// Function: moonglmath_mat_clamp
int mat_clamp(mat_t dst, mat_t m, mat_t minm, mat_t maxm, size_t nr, size_t nc)
    {
    size_t i, j;
    for(i = 0; i < nr; i++)
        for(j = 0; j < nc; j++)
            dst[i][j] = clamp(m[i][j], minm[i][j], maxm[i][j]);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x8(%rsp)
testq %r8, %r8
je 0xec19
movq %r9, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
xorl %eax, %eax
movq %rax, 0x10(%rsp)
testq %rbx, %rbx
je 0xebfa
xorl %r14d, %r14d
movsd (%r13,%r14,8), %xmm0
movsd (%r12,%r14,8), %xmm1
movsd (%r15,%r14,8), %xmm2
callq 0x8390
movsd %xmm0, (%rbp,%r14,8)
incq %r14
cmpq %r14, %rbx
jne 0xebd3
movq 0x10(%rsp), %rax
incq %rax
addq $0x20, %rbp
addq $0x20, %r15
addq $0x20, %r12
addq $0x20, %r13
cmpq 0x8(%rsp), %rax
jne 0xebc6
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/mat.c
// Function: moonglmath_mat_mix
int mat_mix(mat_t dst, mat_t m1, mat_t m2, size_t nr, size_t nc, double k)
    {
    size_t i, j;
    for(i = 0; i < nr; i++)
        for(j = 0; j < nc; j++)
            dst[i][j] = mix(m1[i][j], m2[i][j], k);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x8(%rsp)
testq %rcx, %rcx
je 0xec9d
movq %r8, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
xorl %ebp, %ebp
movsd %xmm0, 0x10(%rsp)
testq %rbx, %rbx
je 0xec87
xorl %r14d, %r14d
movsd (%r12,%r14,8), %xmm0
movsd (%r15,%r14,8), %xmm1
movsd 0x10(%rsp), %xmm2
callq 0x8780
movsd %xmm0, (%r13,%r14,8)
incq %r14
cmpq %r14, %rbx
jne 0xec61
incq %rbp
addq $0x20, %r13
addq $0x20, %r15
addq $0x20, %r12
cmpq 0x8(%rsp), %rbp
jne 0xec59
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/mat.c
// Function: moonglmath_mat_step
int mat_step(mat_t dst, mat_t m, mat_t edge, size_t nr, size_t nc)
    {
    size_t i, j;
    for(i = 0; i < nr; i++)
        for(j = 0; j < nc; j++)
            dst[i][j] = step(m[i][j], edge[i][j]);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
testq %rcx, %rcx
je 0xed10
movq %r8, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
xorl %ebp, %ebp
testq %rbx, %rbx
je 0xecfb
xorl %r14d, %r14d
movsd (%r12,%r14,8), %xmm0
movsd (%r15,%r14,8), %xmm1
callq 0x8860
movsd %xmm0, (%r13,%r14,8)
incq %r14
cmpq %r14, %rbx
jne 0xecdb
incq %rbp
addq $0x20, %r13
addq $0x20, %r15
addq $0x20, %r12
cmpq (%rsp), %rbp
jne 0xecd3
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/mat.c
// Function: moonglmath_mat_smoothstep
int mat_smoothstep(mat_t dst, mat_t m, mat_t edge0, mat_t edge1, size_t nr, size_t nc)
    {
    size_t i, j;
    for(i = 0; i < nr; i++)
        for(j = 0; j < nc; j++)
            dst[i][j] = smoothstep(m[i][j], edge0[i][j], edge1[i][j]);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x8(%rsp)
testq %r8, %r8
je 0xeda0
movq %r9, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
xorl %eax, %eax
movq %rax, 0x10(%rsp)
testq %rbx, %rbx
je 0xed81
xorl %r14d, %r14d
movsd (%r13,%r14,8), %xmm0
movsd (%r12,%r14,8), %xmm1
movsd (%r15,%r14,8), %xmm2
callq 0x8690
movsd %xmm0, (%rbp,%r14,8)
incq %r14
cmpq %r14, %rbx
jne 0xed5a
movq 0x10(%rsp), %rax
incq %rax
addq $0x20, %rbp
addq $0x20, %r15
addq $0x20, %r12
addq $0x20, %r13
cmpq 0x8(%rsp), %rax
jne 0xed4d
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/mat.c
// Function: moonglmath_mat_fade
int mat_fade(mat_t dst, mat_t m, mat_t edge0, mat_t edge1, size_t nr, size_t nc)
    {
    size_t i, j;
    for(i = 0; i < nr; i++)
        for(j = 0; j < nc; j++)
            dst[i][j] = fade(m[i][j], edge0[i][j], edge1[i][j]);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x8(%rsp)
testq %r8, %r8
je 0xee30
movq %r9, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
xorl %eax, %eax
movq %rax, 0x10(%rsp)
testq %rbx, %rbx
je 0xee11
xorl %r14d, %r14d
movsd (%r13,%r14,8), %xmm0
movsd (%r12,%r14,8), %xmm1
movsd (%r15,%r14,8), %xmm2
callq 0x8790
movsd %xmm0, (%rbp,%r14,8)
incq %r14
cmpq %r14, %rbx
jne 0xedea
movq 0x10(%rsp), %rax
incq %rax
addq $0x20, %rbp
addq $0x20, %r15
addq $0x20, %r12
addq $0x20, %r13
cmpq 0x8(%rsp), %rax
jne 0xeddd
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/mat.c
// Function: moonglmath_mat_Det
int mat_Det(lua_State *L)
    {
    size_t nr, nc;
    mat_t m;
    checkmat(L, 1, m, &nr, &nc);
    if(nr != nc)
        return luaL_argerror(L, 1, "not a square matrix");
    if(nr==2)
        lua_pushnumber(L, det2(m));
    else if(nr==3)
        lua_pushnumber(L, det3(m));
    else //if(nr==4)
        lua_pushnumber(L, det4(m));
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdx
leaq 0x98(%rsp), %r14
leaq 0x90(%rsp), %r15
movl $0x1, %esi
movq %r14, %rcx
movq %r15, %r8
callq 0x8520
movq (%r14), %rax
cmpq (%r15), %rax
jne 0xeeba
movsd 0x10(%rsp), %xmm0
movsd 0x38(%rsp), %xmm9
cmpq $0x3, %rax
je 0xeed3
cmpq $0x2, %rax
jne 0xef3d
movsd 0x18(%rsp), %xmm1
mulsd 0x30(%rsp), %xmm1
mulsd %xmm9, %xmm0
subsd %xmm1, %xmm0
movq %rbx, %rdi
jmp 0xf0ae
leaq 0x8731(%rip), %rdx      # 0x175f2
movq %rbx, %rdi
movl $0x1, %esi
callq 0x81b0
jmp 0xf0b8
movsd 0x60(%rsp), %xmm3
movsd 0x58(%rsp), %xmm4
movsd 0x30(%rsp), %xmm1
movsd 0x40(%rsp), %xmm5
movapd %xmm5, %xmm6
mulsd %xmm4, %xmm6
movapd %xmm9, %xmm7
mulsd %xmm3, %xmm7
subsd %xmm6, %xmm7
movsd 0x50(%rsp), %xmm6
mulsd %xmm6, %xmm5
mulsd %xmm1, %xmm3
subsd %xmm5, %xmm3
mulsd 0x18(%rsp), %xmm3
mulsd %xmm7, %xmm0
subsd %xmm3, %xmm0
mulsd %xmm6, %xmm9
mulsd %xmm4, %xmm1
subsd %xmm9, %xmm1
mulsd 0x20(%rsp), %xmm1
addsd %xmm0, %xmm1
jmp 0xf0a7
movsd 0x60(%rsp), %xmm11
movsd 0x88(%rsp), %xmm2
movsd 0x80(%rsp), %xmm3
movsd 0x68(%rsp), %xmm13
movapd %xmm13, %xmm1
mulsd %xmm3, %xmm1
movapd %xmm11, %xmm12
mulsd %xmm2, %xmm12
subsd %xmm1, %xmm12
movsd 0x40(%rsp), %xmm5
movsd 0x58(%rsp), %xmm8
movsd 0x78(%rsp), %xmm4
movapd %xmm13, %xmm1
mulsd %xmm4, %xmm1
movapd %xmm4, %xmm6
movsd %xmm4, 0x8(%rsp)
movapd %xmm8, %xmm7
mulsd %xmm2, %xmm7
subsd %xmm1, %xmm7
movapd %xmm7, %xmm1
mulsd %xmm5, %xmm1
movapd %xmm5, %xmm4
movapd %xmm9, %xmm10
mulsd %xmm12, %xmm10
subsd %xmm1, %xmm10
movsd 0x48(%rsp), %xmm1
movapd %xmm11, %xmm14
mulsd %xmm6, %xmm14
movapd %xmm8, %xmm6
mulsd %xmm3, %xmm6
subsd %xmm14, %xmm6
movapd %xmm1, %xmm15
mulsd %xmm6, %xmm15
addsd %xmm10, %xmm15
movsd 0x50(%rsp), %xmm10
movsd 0x70(%rsp), %xmm14
mulsd %xmm14, %xmm13
mulsd %xmm10, %xmm2
subsd %xmm13, %xmm2
movapd %xmm2, %xmm5
mulsd %xmm4, %xmm5
movsd 0x30(%rsp), %xmm13
mulsd %xmm13, %xmm12
subsd %xmm5, %xmm12
mulsd %xmm14, %xmm11
mulsd %xmm10, %xmm3
subsd %xmm11, %xmm3
movapd %xmm1, %xmm5
mulsd %xmm3, %xmm5
addsd %xmm12, %xmm5
mulsd %xmm15, %xmm0
mulsd 0x18(%rsp), %xmm5
subsd %xmm5, %xmm0
mulsd %xmm9, %xmm2
mulsd %xmm13, %xmm7
subsd %xmm2, %xmm7
mulsd %xmm14, %xmm8
mulsd 0x8(%rsp), %xmm10
subsd %xmm8, %xmm10
mulsd %xmm10, %xmm1
addsd %xmm7, %xmm1
mulsd 0x20(%rsp), %xmm1
addsd %xmm0, %xmm1
mulsd %xmm9, %xmm3
mulsd %xmm13, %xmm6
subsd %xmm3, %xmm6
mulsd %xmm4, %xmm10
addsd %xmm6, %xmm10
mulsd 0x28(%rsp), %xmm10
subsd %xmm10, %xmm1
movq %rbx, %rdi
movapd %xmm1, %xmm0
callq 0x87d0
movl $0x1, %eax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/mat.c
// Function: moonglmath_mat_Adj
int mat_Adj(lua_State *L)
    {
    size_t nr, nc;
    mat_t m, adj;
    checkmat(L, 1, m, &nr, &nc);
    if(nr != nc)
        return luaL_argerror(L, 1, "not a square matrix");
    mat_adj(adj, m, nr);
    return pushmat(L, adj, nr, nr, nr, nr);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdi, %rbx
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %r14
movq %rsp, %r15
movl $0x1, %esi
movq %r14, %rcx
movq %r15, %r8
callq 0x8520
movq (%r14), %r14
cmpq (%r15), %r14
jne 0xf12a
leaq 0x90(%rsp), %r15
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x8470
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r14, %rcx
movq %r14, %r8
movq %r14, %r9
callq 0x84d0
jmp 0xf13e
leaq 0x84c1(%rip), %rdx      # 0x175f2
movq %rbx, %rdi
movl $0x1, %esi
callq 0x81b0
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/mat.c
// Function: moonglmath_mat_Inv
int mat_Inv(lua_State *L)
    {
    size_t nr, nc;
    mat_t m, inv;
    checkmat(L, 1, m, &nr, &nc);
    if(nr != nc)
        return luaL_argerror(L, 1, "not a square matrix");
    if(!mat_inv(inv, m, nr))
        return luaL_argerror(L, 1, "singular matrix");
    return pushmat(L, inv, nr, nr, nr, nr);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdi, %rbx
leaq 0x90(%rsp), %rdx
leaq 0x8(%rsp), %r14
movq %rsp, %r15
movl $0x1, %esi
movq %r14, %rcx
movq %r15, %r8
callq 0x8520
movq (%r14), %r14
cmpq (%r15), %r14
jne 0xf1b6
leaq 0x10(%rsp), %rdi
leaq 0x90(%rsp), %rsi
movq %r14, %rdx
callq 0x82b0
testl %eax, %eax
je 0xf1bf
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
movq %r14, %rcx
movq %r14, %r8
movq %r14, %r9
callq 0x84d0
jmp 0xf1d3
leaq 0x8435(%rip), %rdx      # 0x175f2
jmp 0xf1c6
leaq 0x8440(%rip), %rdx      # 0x17606
movq %rbx, %rdi
movl $0x1, %esi
callq 0x81b0
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/mat.c
// Function: moonglmath_mat_Trace
int mat_Trace(lua_State *L)
    {
    size_t nr, nc, i;
    mat_t m;
    double res = 0;
    checkmat(L, 1, m, &nr, &nc);
    if(nr != nc)
        return luaL_argerror(L, 1, "not a square matrix");
    for(i = 0; i < nr; i++)
        res += m[i][i];
    lua_pushnumber(L, res);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %rsp, %r12
movl $0x1, %esi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x8520
movq (%r15), %rax
cmpq (%r12), %rax
jne 0xf240
xorpd %xmm0, %xmm0
testq %rax, %rax
je 0xf231
addsd (%r14), %xmm0
addq $0x28, %r14
decq %rax
jne 0xf223
movq %rbx, %rdi
callq 0x87d0
movl $0x1, %eax
jmp 0xf254
leaq 0x83ab(%rip), %rdx      # 0x175f2
movq %rbx, %rdi
movl $0x1, %esi
callq 0x81b0
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/mat.c
// Function: moonglmath_mat_Transpose
int mat_Transpose(lua_State *L)
    {
    size_t i, j, nr, nc;
    mat_t m, m1;
    checkmat(L, 1, m, &nr, &nc);
    for(i = 0; i < nr; i++)
        for(j = 0; j < nc; j++)
            m1[j][i] = m[i][j];
    return pushmat(L, m1, nc, nr, nc, nr);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdi, %rbx
leaq 0x90(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %rsp, %r8
movl $0x1, %esi
movq %r14, %rdx
movq %r15, %rcx
callq 0x8520
movq (%r15), %rcx
testq %rcx, %rcx
je 0xf2d6
leaq 0x10(%rsp), %rax
movq (%rsp), %rdx
xorl %esi, %esi
testq %rdx, %rdx
je 0xf2c6
movq %rax, %rdi
xorl %r8d, %r8d
movsd (%r14,%r8,8), %xmm0
movsd %xmm0, (%rdi)
incq %r8
addq $0x20, %rdi
cmpq %r8, %rdx
jne 0xf2b0
incq %rsi
addq $0x20, %r14
addq $0x8, %rax
cmpq %rcx, %rsi
jne 0xf2a5
movq (%rsp), %rdx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %rdx, %r8
movq %rcx, %r9
callq 0x84d0
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/mat.c
// Function: moonglmath_mat_Column
int mat_Column(lua_State *L)
    {
    mat_t m;
    vec_t v;
    size_t i, j, nr, nc;
    checkmat(L, 1, m, &nr, &nc);
    j = luaL_checkinteger(L, 2);
    if(j < 1 || j > nc)
        return luaL_argerror(L, 2, "invalid column index");
    j--;
    for(i = 0; i < nr; i++)
        v[i] = m[i][j];
    return pushvec(L, v, nr, nr, 0);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %rdx
movq %rsp, %rcx
leaq 0x8(%rsp), %r14
movl $0x1, %esi
movq %r14, %r8
callq 0x8520
movq %rbx, %rdi
movl $0x2, %esi
callq 0x86e0
leaq -0x1(%rax), %rcx
cmpq (%r14), %rcx
jae 0xf375
movq (%rsp), %rcx
testq %rcx, %rcx
je 0xf360
leaq (%rsp,%rax,8), %rax
addq $0x28, %rax
xorl %edx, %edx
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp,%rdx,8)
incq %rdx
addq $0x20, %rax
cmpq %rdx, %rcx
jne 0xf34a
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %rcx, %rdx
xorl %r8d, %r8d
callq 0x82e0
jmp 0xf389
leaq 0x829a(%rip), %rdx      # 0x17616
movq %rbx, %rdi
movl $0x2, %esi
callq 0x81b0
addq $0xb8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonglmath/src/mat.c
// Function: moonglmath_mat_Row
int mat_Row(lua_State *L)
    {
    mat_t m;
    vec_t v;
    size_t i, j, nr, nc;
    checkmat(L, 1, m, &nr, &nc);
    i = luaL_checkinteger(L, 2);
    if(i < 1 || i > nr)
        return luaL_argerror(L, 2, "invalid row index");
    i--;
    for(j = 0; j < nc; j++)
        v[j] = m[i][j];
    return pushvec(L, v, nc, nc, 1);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %rdx
leaq 0x8(%rsp), %r14
movq %rsp, %r8
movl $0x1, %esi
movq %r14, %rcx
callq 0x8520
movq %rbx, %rdi
movl $0x2, %esi
callq 0x86e0
leaq -0x1(%rax), %rcx
cmpq (%r14), %rcx
jae 0xf413
movq (%rsp), %r14
testq %r14, %r14
je 0xf3f8
shlq $0x5, %rax
leaq (%rsp,%rax), %rsi
addq $0x10, %rsi
leaq (,%r14,8), %rdx
leaq 0x10(%rsp), %rdi
callq 0x8760
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
movq %r14, %rcx
movl $0x1, %r8d
callq 0x82e0
jmp 0xf427
leaq 0x8211(%rip), %rdx      # 0x1762b
movq %rbx, %rdi
movl $0x2, %esi
callq 0x81b0
addq $0xb8, %rsp
popq %rbx
popq %r14
retq