LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/mesh.c
// Function: moonassimp_newmesh
int newmesh(lua_State *L, scene_t *scene, mesh_t *mesh)
    {
    unsigned int i;
    ud_t *ud;
    TRACE_CREATE(mesh, "mesh");
    if(mesh->mFaces != NULL && mesh->mNumFaces > 0)
        {
        for(i = 0; i < mesh->mNumFaces; i++)
            { newface(L, scene, mesh, &(mesh->mFaces[i])); lua_pop(L, 1); }
        TRACE_CREATE_N(i, "faces");
        }
    if(mesh->mBones != NULL && mesh->mNumBones > 0)
        {
        for(i = 0; i < mesh->mNumBones; i++)
            { newbone(L, scene, mesh, mesh->mBones[i]); lua_pop(L, 1); }
        TRACE_CREATE_N(i, "bones");
        }
    if(mesh->mAnimMeshes != NULL && mesh->mNumAnimMeshes > 0)
        {
        for(i = 0; i < mesh->mNumAnimMeshes; i++)
            { newanimmesh(L, scene, mesh, mesh->mAnimMeshes[i]); lua_pop(L, 1); }
        TRACE_CREATE_N(i, "animmeshes");
        }
    ud = newuserdata(L, (void*)mesh, MESH_MT);
    ud->scene = scene;
    return 1;   
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x5d21(%rip), %rdi      # 0x11190
movq %rdx, %rsi
xorl %eax, %eax
callq 0x6710
cmpq $0x0, 0xd0(%r14)
je 0xb4db
movl 0x8(%r14), %eax
testl %eax, %eax
je 0xb4db
xorl %r13d, %r13d
pushq $-0x2
popq %rbp
xorl %r12d, %r12d
movl %eax, %eax
cmpq %rax, %r12
jae 0xb4ca
movq 0xd0(%r14), %rcx
addq %r13, %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x6080
movq %r15, %rdi
movl %ebp, %esi
callq 0x60c0
incq %r12
movl 0x8(%r14), %eax
addq $0x10, %r13
jmp 0xb494
leaq 0x5cd1(%rip), %rdi      # 0x111a2
movl %r12d, %esi
xorl %eax, %eax
callq 0x6710
cmpq $0x0, 0xe0(%r14)
je 0xb53d
movl 0xd8(%r14), %eax
testl %eax, %eax
je 0xb53d
xorl %r12d, %r12d
pushq $-0x2
popq %rbp
movl %eax, %eax
cmpq %rax, %r12
jae 0xb52c
movq 0xe0(%r14), %rax
movq (%rax,%r12,8), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x6230
movq %r15, %rdi
movl %ebp, %esi
callq 0x60c0
incq %r12
movl 0xd8(%r14), %eax
jmp 0xb4f6
leaq 0x5c80(%rip), %rdi      # 0x111b3
movl %r12d, %esi
xorl %eax, %eax
callq 0x6710
cmpq $0x0, 0x4f8(%r14)
je 0xb59f
movl 0x4f0(%r14), %eax
testl %eax, %eax
je 0xb59f
xorl %r12d, %r12d
pushq $-0x2
popq %rbp
movl %eax, %eax
cmpq %rax, %r12
jae 0xb58e
movq 0x4f8(%r14), %rax
movq (%rax,%r12,8), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x6160
movq %r15, %rdi
movl %ebp, %esi
callq 0x60c0
incq %r12
movl 0x4f0(%r14), %eax
jmp 0xb558
leaq 0x5c2f(%rip), %rdi      # 0x111c4
movl %r12d, %esi
xorl %eax, %eax
callq 0x6710
leaq 0x5c34(%rip), %rdx      # 0x111da
movq %r15, %rdi
movq %r14, %rsi
callq 0x68c0
movq %rbx, 0x10(%rax)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/mesh.c
// Function: moonassimp_freemesh
int freemesh(lua_State *L, mesh_t *mesh)
    {
    unsigned int i;
    if(mesh->mFaces != NULL && mesh->mNumFaces > 0)
        {
        for(i = 0; i < mesh->mNumFaces; i++)
            freeface(L, &(mesh->mFaces[i]));
        TRACE_DELETE_N(i, "faces");
        }
    if(mesh->mBones != NULL && mesh->mNumBones > 0)
        {
        for(i = 0; i < mesh->mNumBones; i++)
            freebone(L, mesh->mBones[i]);
        TRACE_DELETE_N(i, "bones");
        }
    if(mesh->mAnimMeshes != NULL && mesh->mNumAnimMeshes > 0)
        {
        for(i = 0; i < mesh->mNumAnimMeshes; i++)
            freeanimmesh(L, mesh->mAnimMeshes[i]);
        TRACE_DELETE_N(i, "animmeshes");
        }
    TRACE_DELETE(mesh, "mesh");
    freeuserdata(L, mesh);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0xd0(%rsi)
je 0xb622
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0xb622
xorl %r12d, %r12d
xorl %r15d, %r15d
movl %eax, %eax
cmpq %rax, %r15
jae 0xb611
movq 0xd0(%rbx), %rsi
addq %r12, %rsi
movq %r14, %rdi
callq 0x69a0
incq %r15
movl 0x8(%rbx), %eax
addq $0x10, %r12
jmp 0xb5ec
leaq 0x5bd2(%rip), %rdi      # 0x111ea
movl %r15d, %esi
xorl %eax, %eax
callq 0x6710
cmpq $0x0, 0xe0(%rbx)
je 0xb66f
movl 0xd8(%rbx), %eax
testl %eax, %eax
je 0xb66f
xorl %r15d, %r15d
movl %eax, %eax
cmpq %rax, %r15
jae 0xb65e
movq 0xe0(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x67d0
incq %r15
movl 0xd8(%rbx), %eax
jmp 0xb639
leaq 0x5b96(%rip), %rdi      # 0x111fb
movl %r15d, %esi
xorl %eax, %eax
callq 0x6710
cmpq $0x0, 0x4f8(%rbx)
je 0xb6bc
movl 0x4f0(%rbx), %eax
testl %eax, %eax
je 0xb6bc
xorl %r15d, %r15d
movl %eax, %eax
cmpq %rax, %r15
jae 0xb6ab
movq 0x4f8(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x6530
incq %r15
movl 0x4f0(%rbx), %eax
jmp 0xb686
leaq 0x5b5a(%rip), %rdi      # 0x1120c
movl %r15d, %esi
xorl %eax, %eax
callq 0x6710
leaq 0x5b5f(%rip), %rdi      # 0x11222
movq %rbx, %rsi
xorl %eax, %eax
callq 0x6710
movq %r14, %rdi
movq %rbx, %rsi
callq 0x63f0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/mesh.c
// Function: HasTangents
static int HasTangents(lua_State *L) /* and bitangents */
    {
    mesh_t *mesh = checkmesh(L, 1);
    lua_pushboolean(L, mesh->mTangents != NULL && mesh->mBitangents != NULL &&
                        mesh->mNumVertices > 0);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x59bb(%rip), %rdx      # 0x111da
pushq $0x1
popq %rsi
callq 0x66f0
xorl %esi, %esi
cmpq $0x0, 0x20(%rax)
je 0xb841
cmpq $0x0, 0x28(%rax)
je 0xb841
xorl %esi, %esi
cmpl $0x0, 0x4(%rax)
setne %sil
movq %rbx, %rdi
callq 0x6540
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/mesh.c
// Function: HasColors
static int HasColors(lua_State *L)
    {
    mesh_t *mesh = checkmesh(L, 1);
    unsigned int i = checkindex(L, 2);
    if( i >= AI_MAX_NUMBER_OF_COLOR_SETS)
        lua_pushboolean(L, 0);
    else
        lua_pushboolean(L, mesh->mColors[i] != NULL && mesh->mNumVertices > 0);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x597e(%rip), %rdx      # 0x111da
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x6310
xorl %esi, %esi
cmpl $0x7, %eax
ja 0xb88e
movl %eax, %eax
cmpq $0x0, 0x30(%r14,%rax,8)
je 0xb88e
xorl %esi, %esi
cmpl $0x0, 0x4(%r14)
setne %sil
movq %rbx, %rdi
callq 0x6540
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/mesh.c
// Function: HasTextureCoords
static int HasTextureCoords(lua_State *L)
    {
    mesh_t *mesh = checkmesh(L, 1);
    unsigned int i = checkindex(L, 2);
    if( i >= AI_MAX_NUMBER_OF_TEXTURECOORDS)
        lua_pushboolean(L, 0);
    else
        lua_pushboolean(L, mesh->mTextureCoords[i] != NULL && mesh->mNumVertices > 0);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x592b(%rip), %rdx      # 0x111da
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x6310
xorl %esi, %esi
cmpl $0x7, %eax
ja 0xb8e1
movl %eax, %eax
cmpq $0x0, 0x70(%r14,%rax,8)
je 0xb8e1
xorl %esi, %esi
cmpl $0x0, 0x4(%r14)
setne %sil
movq %rbx, %rdi
callq 0x6540
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/mesh.c
// Function: NumTextureCoordsChannels
static int NumTextureCoordsChannels(lua_State *L)
    {
    unsigned int n = 0;
    mesh_t *mesh = checkmesh(L, 1);
    while (n < AI_MAX_NUMBER_OF_TEXTURECOORDS && mesh->mTextureCoords[n]) ++n;
    lua_pushinteger(L, n);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x57a6(%rip), %rdx      # 0x111da
pushq $0x1
popq %rsi
callq 0x66f0
xorl %esi, %esi
cmpq $0x8, %rsi
je 0xba51
cmpq $0x0, 0x70(%rax,%rsi,8)
je 0xba51
incq %rsi
jmp 0xba3e
movq %rbx, %rdi
callq 0x6300
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/mesh.c
// Function: NumTextureCoordsComponents
static int NumTextureCoordsComponents(lua_State *L)
    {
    mesh_t *mesh = checkmesh(L, 1);
    unsigned int chan = checkindex(L, 2);
    if( chan >= AI_MAX_NUMBER_OF_TEXTURECOORDS || mesh->mTextureCoords[chan] == NULL)
        return luaL_argerror(L, 2, "out of range");
    lua_pushinteger(L, mesh->mNumUVComponents[chan]);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x576e(%rip), %rdx      # 0x111da
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x6310
cmpl $0x7, %eax
ja 0xbaac
movl %eax, %eax
cmpq $0x0, 0x70(%r14,%rax,8)
je 0xbaac
movl 0xb0(%r14,%rax,4), %esi
movq %rbx, %rdi
callq 0x6300
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x46f6(%rip), %rdx      # 0x101a9
pushq $0x2
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x61c0
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/mesh.c
// Function: NumColorChannels
static int NumColorChannels(lua_State *L)
    {
    unsigned int n = 0;
    mesh_t *mesh = checkmesh(L, 1);
    while (n < AI_MAX_NUMBER_OF_COLOR_SETS && mesh->mColors[n]) ++n;
    lua_pushinteger(L, n);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x570a(%rip), %rdx      # 0x111da
pushq $0x1
popq %rsi
callq 0x66f0
xorl %esi, %esi
cmpq $0x8, %rsi
je 0xbaed
cmpq $0x0, 0x30(%rax,%rsi,8)
je 0xbaed
incq %rsi
jmp 0xbada
movq %rbx, %rdi
callq 0x6300
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/mesh.c
// Function: Color
static int Color(lua_State *L)
    {
    mesh_t *mesh = checkmesh(L, 1);
    unsigned int chan = checkindex(L, 2);
    unsigned int i = checkindex(L, 3);
    if( chan >= AI_MAX_NUMBER_OF_COLOR_SETS || mesh->mColors[chan] == NULL)
        return luaL_argerror(L, 2, "out of range");
    if( i >= mesh->mNumVertices)
        return luaL_argerror(L, 3, "out of range");
    return pushcolor4(L, &(mesh->mColors[chan][i]), 0);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x5336(%rip), %rdx      # 0x111da
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x6310
movl %eax, %ebp
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x6310
cmpl $0x7, %ebp
ja 0xbef5
movl %ebp, %ecx
movq 0x30(%r14,%rcx,8), %rsi
testq %rsi, %rsi
je 0xbef5
cmpl 0x4(%r14), %eax
jae 0xbf0b
movl %eax, %eax
shlq $0x4, %rax
addq %rax, %rsi
movq %rbx, %rdi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x62d0
leaq 0x42ad(%rip), %rdx      # 0x101a9
pushq $0x2
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x61c0
leaq 0x4297(%rip), %rdx      # 0x101a9
pushq $0x3
jmp 0xbefe
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/mesh.c
// Function: AllColors
static int AllColors(lua_State *L)
    {
    mesh_t *mesh = checkmesh(L, 1);
    unsigned int chan;
    unsigned int i;
    lua_newtable(L);
    for(chan = 0; chan < AI_MAX_NUMBER_OF_COLOR_SETS; chan++)
        {
        if(mesh->mColors[chan] == NULL) break;
        lua_newtable(L);
        for(i=0; i < mesh->mNumVertices; i++)
            {
            pushcolor4(L, &(mesh->mColors[chan][i]), 1);
            lua_rawseti(L, -2, i+1);
            }
        lua_rawseti(L, -2, chan+1);
        }
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x52af(%rip), %rdx      # 0x111da
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
pushq $-0x2
popq %r12
cmpq $0x8, %r15
je 0xbfae
cmpq $0x0, 0x30(%r14,%r15,8)
je 0xbfae
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
xorl %ebp, %ebp
xorl %r13d, %r13d
movl 0x4(%r14), %eax
cmpq %rax, %r13
jae 0xbf9b
movq 0x30(%r14,%r15,8), %rsi
addq %rbp, %rsi
movq %rbx, %rdi
pushq $0x1
popq %rdx
callq 0x62d0
incq %r13
movq %rbx, %rdi
movl %r12d, %esi
movq %r13, %rdx
callq 0x6470
addq $0x10, %rbp
jmp 0xbf68
incq %r15
movq %rbx, %rdi
movl %r12d, %esi
movq %r15, %rdx
callq 0x6470
jmp 0xbf49
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/mesh.c
// Function: TextureCoords
static int TextureCoords(lua_State *L)
    {
    vector3_t *coords;
    vector2_t vec2;
    unsigned int ncomp;
    mesh_t *mesh = checkmesh(L, 1);
    unsigned int chan = checkindex(L, 2);
    unsigned int i = checkindex(L, 3);
    if( chan >= AI_MAX_NUMBER_OF_TEXTURECOORDS || mesh->mTextureCoords[chan] == NULL)
        return luaL_argerror(L, 2, "out of range");
    if( i >= mesh->mNumVertices)
        return luaL_argerror(L, 3, "out of range");
    ncomp = mesh->mNumUVComponents[chan]; /* no. of components */
    coords =  &(mesh->mTextureCoords[chan][i]);
    if(ncomp == 3)
        return pushvector3(L, coords, 0);
    if(ncomp == 2)
        {
        vec2.x = coords->x;
        vec2.y = coords->y;
        return pushvector2(L, &vec2, 0);
        }
    if(ncomp == 1)
        {
        lua_pushnumber(L, coords->x);
        return 1;
        }
    return unexpected(L); /* 4 components are currently not supported */
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5209(%rip), %rdx      # 0x111da
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x66f0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x6310
movl %eax, %r15d
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x6310
cmpl $0x7, %r15d
ja 0xc044
movl %r15d, %ecx
movq 0x70(%r14,%rcx,8), %rsi
testq %rsi, %rsi
je 0xc044
cmpl 0x4(%r14), %eax
jae 0xc060
movl 0xb0(%r14,%rcx,4), %ecx
movl %eax, %eax
imulq $0xc, %rax, %rax
addq %rax, %rsi
cmpl $0x1, %ecx
je 0xc084
cmpl $0x2, %ecx
je 0xc06b
cmpl $0x3, %ecx
jne 0xc09d
movq %rbx, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6600
leaq 0x415e(%rip), %rdx      # 0x101a9
pushq $0x2
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x61c0
leaq 0x4142(%rip), %rdx      # 0x101a9
pushq $0x3
jmp 0xc04d
movsd (%rsi), %xmm0
movq %rsp, %rsi
movsd %xmm0, (%rsi)
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6170
movl %eax, %ebp
jmp 0xc090
cvtss2sd (%rsi), %xmm0
movq %rbx, %rdi
callq 0x6500
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4112(%rip), %rsi      # 0x101b6
leaq 0x4129(%rip), %rdx      # 0x101d4
movq %rbx, %rdi
movl $0x12c, %ecx            # imm = 0x12C
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x67a0
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/mesh.c
// Function: AllTextureCoords
static int AllTextureCoords(lua_State *L)
    {
    vector3_t *coords;
    vector2_t vec2;
    unsigned int ncomp;
    mesh_t *mesh = checkmesh(L, 1);
    unsigned int chan;
    unsigned int i;

    lua_newtable(L);
    for(chan = 0; chan < AI_MAX_NUMBER_OF_TEXTURECOORDS; chan++)
        {
        if(mesh->mTextureCoords[chan] == NULL) break;
        ncomp = mesh->mNumUVComponents[chan]; /* no. of components */
        lua_newtable(L);
        for(i=0; i<mesh->mNumVertices; i++)
            {
            coords =  &(mesh->mTextureCoords[chan][i]);
            switch(ncomp)
                {
                case 3: pushvector3(L, coords, 1); break;
                case 2: {
                        vec2.x = coords->x;
                        vec2.y = coords->y;
                        pushvector2(L, &vec2, 1);
                        break;
                        }
                case 1: {
                        lua_newtable(L);
                        lua_pushnumber(L, coords->x);
                        lua_rawseti(L, -2, 1);
                        break;
                        }
                default:
                    return unexpected(L); /* 4 components are currently not supported */
                }
            lua_rawseti(L, -2, i+1);
            }
        lua_rawseti(L, -2, chan+1);
        }
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x50fe(%rip), %rdx      # 0x111da
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, 0x8(%rsp)
xorl %ebx, %ebx
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
cmpq $0x8, %rbx
je 0xc1fe
movq 0x8(%rsp), %rax
cmpq $0x0, 0x70(%rax,%rbx,8)
je 0xc1fe
movl 0xb0(%rax,%rbx,4), %ebp
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x8(%rsp), %rcx
movl 0x4(%rcx), %eax
cmpq %rax, %r13
jae 0xc1c9
movq %rbx, %r15
movq 0x70(%rcx,%rbx,8), %rbx
addq %r12, %rbx
cmpl $0x1, %ebp
je 0xc186
cmpl $0x2, %ebp
je 0xc16a
cmpl $0x3, %ebp
jne 0xc1df
movq %r14, %rdi
movq %rbx, %rsi
pushq $0x1
popq %rdx
callq 0x6600
jmp 0xc1ac
movsd (%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0x6170
jmp 0xc1ac
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
cvtss2sd (%rbx), %xmm0
movq %r14, %rdi
callq 0x6500
movq %r14, %rdi
pushq $-0x2
popq %rsi
pushq $0x1
popq %rdx
callq 0x6470
incq %r13
movq %r14, %rdi
pushq $-0x2
popq %rsi
movq %r13, %rdx
callq 0x6470
addq $0xc, %r12
movq %r15, %rbx
jmp 0xc12b
incq %rbx
movq %r14, %rdi
pushq $-0x2
popq %rsi
movq %rbx, %rdx
callq 0x6470
jmp 0xc0f7
leaq 0x3fd0(%rip), %rsi      # 0x101b6
leaq 0x3fe7(%rip), %rdx      # 0x101d4
movq %r14, %rdi
movl $0x152, %ecx            # imm = 0x152
xorl %eax, %eax
callq 0x67a0
jmp 0xc201
pushq $0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/mesh.c
// Function: Material
static int Material(lua_State *L)
    {
#define scene ud->scene
    mesh_t *mesh = checkmesh(L, 1);
    ud_t *ud = userdata(mesh);
    if(mesh->mMaterialIndex >= scene->mNumMaterials)
        return unexpected(L);   
    pushmaterial(L, scene->mMaterials[mesh->mMaterialIndex]);
    return 1;
#undef scene
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4fbc(%rip), %rdx      # 0x111da
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
movq %rax, %rdi
callq 0x6770
movl 0xe8(%r14), %ecx
movq 0x10(%rax), %rax
cmpl 0x20(%rax), %ecx
jae 0xc25c
movq 0x28(%rax), %rax
movq (%rax,%rcx,8), %rsi
movq %rbx, %rdi
callq 0x6380
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3f53(%rip), %rsi      # 0x101b6
leaq 0x3f6a(%rip), %rdx      # 0x101d4
movq %rbx, %rdi
movl $0x8c, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x67a0
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/mesh.c
// Function: Face
static int Face(lua_State *L)
    {
    mesh_t *mesh = checkmesh(L, 1);
    unsigned int i = checkindex(L, 2);
    if(mesh->mFaces == NULL || mesh->mNumFaces == 0 || i >= mesh->mNumFaces)
        return luaL_argerror(L, 2, "out of range");
    return pushface(L, &(mesh->mFaces[i]));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4f4c(%rip), %rdx      # 0x111da
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x6310
movq 0xd0(%r14), %rsi
testq %rsi, %rsi
je 0xc2da
movl 0x8(%r14), %ecx
testl %ecx, %ecx
setne %dl
cmpl %ecx, %eax
setb %cl
testb %cl, %dl
je 0xc2da
movl %eax, %eax
shlq $0x4, %rax
addq %rax, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6380
leaq 0x3ec8(%rip), %rdx      # 0x101a9
pushq $0x2
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x61c0
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/mesh.c
// Function: AllIndices
static int AllIndices(lua_State *L)
    {
    mesh_t *mesh = checkmesh(L, 1);
    int zero_based = optboolean(L, 2, 0);
    unsigned int i;

    lua_newtable(L);
    if(mesh->mFaces == NULL || mesh->mNumFaces == 0)
        return 1;
    for(i = 0; i < mesh->mNumFaces; i++)
        {
        pushfaceindices(L, &(mesh->mFaces[i]), zero_based);
        lua_rawseti(L, -2, i+1);
        }
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4ed2(%rip), %rdx      # 0x111da
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x60b0
movl %eax, %ebp
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
cmpq $0x0, 0xd0(%r14)
je 0xc380
movl 0x8(%r14), %eax
testl %eax, %eax
je 0xc380
xorl %r13d, %r13d
pushq $-0x2
popq %r15
xorl %r12d, %r12d
movl %eax, %eax
cmpq %rax, %r12
jae 0xc380
movq 0xd0(%r14), %rsi
addq %r13, %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x62a0
incq %r12
movq %rbx, %rdi
movl %r15d, %esi
movq %r12, %rdx
callq 0x6470
movl 0x8(%r14), %eax
addq $0x10, %r13
jmp 0xc34a
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/mesh.c
// Function: Bone
static int Bone(lua_State *L)
    {
    mesh_t *mesh = checkmesh(L, 1);
    unsigned int i = checkindex(L, 2);
    if(mesh->mBones == NULL || mesh->mNumBones == 0 || i >= mesh->mNumBones)
        return luaL_argerror(L, 2, "out of range");
    return pushbone(L, mesh->mBones[i]);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4e3a(%rip), %rdx      # 0x111da
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x6310
movq 0xe0(%r14), %rcx
testq %rcx, %rcx
je 0xc3ee
movl 0xd8(%r14), %edx
testl %edx, %edx
setne %sil
cmpl %edx, %eax
setb %dl
testb %dl, %sil
je 0xc3ee
movl %eax, %eax
movq (%rcx,%rax,8), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6380
leaq 0x3db4(%rip), %rdx      # 0x101a9
pushq $0x2
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x61c0
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/mesh.c
// Function: AnimMesh
static int AnimMesh(lua_State *L)
    {
    mesh_t *mesh = checkmesh(L, 1);
    unsigned int i = checkindex(L, 2);
    if(mesh->mAnimMeshes == NULL || mesh->mNumAnimMeshes == 0 || i >= mesh->mNumAnimMeshes)
        return luaL_argerror(L, 2, "out of range");
    return pushanimmesh(L, mesh->mAnimMeshes[i]);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4dc5(%rip), %rdx      # 0x111da
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x6310
movq 0x4f8(%r14), %rcx
testq %rcx, %rcx
je 0xc463
movl 0x4f0(%r14), %edx
testl %edx, %edx
setne %sil
cmpl %edx, %eax
setb %dl
testb %dl, %sil
je 0xc463
movl %eax, %eax
movq (%rcx,%rax,8), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6380
leaq 0x3d3f(%rip), %rdx      # 0x101a9
pushq $0x2
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x61c0
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/mesh.c
// Function: Faces
static int Faces(lua_State *L)
    {
    unsigned int i;
    mesh_t *mesh = checkmesh(L, 1);
    lua_newtable(L);
    if(mesh->mFaces == NULL || mesh->mNumFaces == 0) return 1;
    for(i = 0; i < mesh->mNumFaces; i++)
        {
        pushface(L, &(mesh->mFaces[i]));
        lua_rawseti(L, -2, i+1);
        }
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x4d4c(%rip), %rdx      # 0x111da
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
cmpq $0x0, 0xd0(%r14)
je 0xc4f3
movl 0x8(%r14), %eax
testl %eax, %eax
je 0xc4f3
xorl %r12d, %r12d
pushq $-0x2
popq %rbp
xorl %r15d, %r15d
movl %eax, %eax
cmpq %rax, %r15
jae 0xc4f3
movq 0xd0(%r14), %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x6380
incq %r15
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x6470
movl 0x8(%r14), %eax
addq $0x10, %r12
jmp 0xc4c0
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/mesh.c
// Function: Bones
static int Bones(lua_State *L)
    {
    unsigned int i;
    mesh_t *mesh = checkmesh(L, 1);
    lua_newtable(L);
    if(mesh->mBones == NULL || mesh->mNumBones == 0) return 1;
    for(i = 0; i < mesh->mNumBones; i++)
        {
        pushbone(L, mesh->mBones[i]);
        lua_rawseti(L, -2, i+1);
        }
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4cca(%rip), %rdx      # 0x111da
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
cmpq $0x0, 0xe0(%r14)
je 0xc575
movl 0xd8(%r14), %eax
testl %eax, %eax
je 0xc575
xorl %r15d, %r15d
pushq $-0x2
popq %rbp
movl %eax, %eax
cmpq %rax, %r15
jae 0xc575
movq 0xe0(%r14), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x6380
incq %r15
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x6470
movl 0xd8(%r14), %eax
jmp 0xc542
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/mesh.c
// Function: AnimMeshes
static int AnimMeshes(lua_State *L)
    {
    unsigned int i;
    mesh_t *mesh = checkmesh(L, 1);
    lua_newtable(L);
    if(mesh->mAnimMeshes == NULL || mesh->mNumAnimMeshes == 0) return 1;
    for(i = 0; i < mesh->mNumAnimMeshes; i++)
        {
        pushanimmesh(L, mesh->mAnimMeshes[i]);
        lua_rawseti(L, -2, i+1);
        }
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4c46(%rip), %rdx      # 0x111da
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
cmpq $0x0, 0x4f8(%r14)
je 0xc5f9
movl 0x4f0(%r14), %eax
testl %eax, %eax
je 0xc5f9
xorl %r15d, %r15d
pushq $-0x2
popq %rbp
movl %eax, %eax
cmpq %rax, %r15
jae 0xc5f9
movq 0x4f8(%r14), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x6380
incq %r15
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x6470
movl 0x4f0(%r14), %eax
jmp 0xc5c6
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/meshanim.c
// Function: moonassimp_newmeshanim
int newmeshanim(lua_State *L, scene_t *scene, animation_t *animation, meshanim_t *meshanim)
    {
    ud_t *ud;
//  TRACE_CREATE(meshanim, "meshanim");
    ud = newuserdata(L, (void*)meshanim, MESHANIM_MT);
    ud->scene = scene;
    ud->animation = animation;
    return 1;   
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x4d57(%rip), %rdx      # 0x11370
movq %rcx, %rsi
callq 0x68c0
movq %r14, 0x10(%rax)
movq %rbx, 0x28(%rax)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/meshanim.c
// Function: Keys
static int Keys(lua_State *L)
/* { key1, key2, ... }
 *
 * key1 = { time = 123.456, value = index }
 */
    {
    unsigned int i;
    meshanim_t *meshanim = checkmeshanim(L, 1);
    lua_newtable(L);
    for(i = 0; i < meshanim->mNumKeys; i++)
        {
#define key meshanim->mKeys[i]
        lua_newtable(L);
        lua_pushnumber(L, key.mTime);
        lua_setfield(L, -2, "time");
        pushindex(L, key.mValue);
        lua_setfield(L, -2, "value");
        lua_rawseti(L, -2, i+1);
#undef key
        }
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4c85(%rip), %rdx      # 0x11370
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
pushq $-0x2
popq %rbp
leaq 0x4c8d(%rip), %r12      # 0x1139c
xorl %r13d, %r13d
movl 0x404(%r14), %eax
cmpq %rax, %r13
jae 0xc787
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
movq 0x408(%r14), %rax
movsd (%rax,%r15), %xmm0
movq %rbx, %rdi
callq 0x6500
movq %rbx, %rdi
movl %ebp, %esi
leaq 0x4c4c(%rip), %rdx      # 0x11397
callq 0x62e0
movq 0x408(%r14), %rax
movl 0x8(%rax,%r15), %esi
movq %rbx, %rdi
callq 0x64e0
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x62e0
incq %r13
movq %rbx, %rdi
movl %ebp, %esi
movq %r13, %rdx
callq 0x6470
addq $0x10, %r15
jmp 0xc712
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/node.c
// Function: moonassimp_newnode
int newnode(lua_State *L, scene_t *scene, node_t *node)
/* recursively creates the userdata for the node and its children */
    {
    ud_t *ud;
    unsigned int i;
    TRACE_CREATE(node, "node");
    for(i = 0; i < node->mNumChildren; i++)
        {
        newnode(L, scene, node->mChildren[i]);
        lua_pop(L, 1);
        }
    ud = newuserdata(L, (void*)node, NODE_MT);
    ud->scene = scene;
    return 1;   
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x4c1c(%rip), %rdi      # 0x113d0
xorl %r12d, %r12d
movq %rdx, %rsi
xorl %eax, %eax
callq 0x6710
pushq $-0x2
popq %rbp
movl 0x450(%r14), %eax
cmpq %rax, %r12
jae 0xc7f5
movq 0x458(%r14), %rax
movq (%rax,%r12,8), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6480
movq %r15, %rdi
movl %ebp, %esi
callq 0x60c0
incq %r12
jmp 0xc7c4
leaq 0x4be6(%rip), %rdx      # 0x113e2
movq %r15, %rdi
movq %r14, %rsi
callq 0x68c0
movq %rbx, 0x10(%rax)
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/node.c
// Function: moonassimp_freenode
int freenode(lua_State *L, node_t *node)
/* recursively deletes the userdata for the node and its children */
    {
    unsigned int i;
    for(i = 0; i < node->mNumChildren; i++)
        freenode(L, node->mChildren[i]);
    TRACE_DELETE(node, "node");
    freeuserdata(L, node);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movl 0x450(%rbx), %eax
cmpq %rax, %r15
jae 0xc848
movq 0x458(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x63b0
incq %r15
jmp 0xc825
leaq 0x4ba3(%rip), %rdi      # 0x113f2
movq %rbx, %rsi
xorl %eax, %eax
callq 0x6710
movq %r14, %rdi
movq %rbx, %rsi
callq 0x63f0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/node.c
// Function: Child
static int Child(lua_State *L)
    { 
    node_t *node = checknode(L, 1);
    unsigned int i = checkindex(L, 2);
    if(i >= node->mNumChildren)
        return luaL_argerror(L, 2, "out of range");
    return pushnode(L, node->mChildren[i]);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4a68(%rip), %rdx      # 0x113e2
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x6310
cmpl 0x450(%r14), %eax
jae 0xc9b5
movq 0x458(%r14), %rcx
movl %eax, %eax
movq (%rcx,%rax,8), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6380
leaq 0x37ed(%rip), %rdx      # 0x101a9
pushq $0x2
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x61c0
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/node.c
// Function: Children
static int Children(lua_State *L)
    {
    unsigned int i;
    node_t *node = checknode(L, 1);
    lua_newtable(L);
    for(i = 0; i < node->mNumChildren; i++)
        {
        pushnode(L, node->mChildren[i]);
        lua_rawseti(L, -2, i+1);
        }
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4a03(%rip), %rdx      # 0x113e2
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
pushq $-0x2
popq %rbp
movl 0x450(%r14), %eax
cmpq %rax, %r15
jae 0xca2d
movq 0x458(%r14), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x6380
incq %r15
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x6470
jmp 0xc9fc
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/node.c
// Function: Mesh
static int Mesh(lua_State *L)
    {
#define scene ud->scene
    unsigned int index;
    node_t *node = checknode(L, 1);
    unsigned int i = checkindex(L, 2);
    ud_t *ud = userdata(node);
    if(i >= node->mNumMeshes)
        return luaL_argerror(L, 2, "out of range");
    index = node->mMeshes[i];
    if(index >= scene->mNumMeshes)
        return unexpected(L);   
    return pushmesh(L, scene->mMeshes[index]);
#undef scene
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x4999(%rip), %rdx      # 0x113e2
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x6310
movl %eax, %ebp
movq %r14, %rdi
callq 0x6770
cmpl 0x460(%r14), %ebp
jae 0xca9b
movq 0x468(%r14), %rcx
movl %ebp, %edx
movl (%rcx,%rdx,4), %ecx
movq 0x10(%rax), %rax
cmpl 0x10(%rax), %ecx
jae 0xcab1
movq 0x18(%rax), %rax
movq (%rax,%rcx,8), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x6380
leaq 0x3707(%rip), %rdx      # 0x101a9
pushq $0x2
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x61c0
leaq 0x36fe(%rip), %rsi      # 0x101b6
leaq 0x4972(%rip), %rdx      # 0x11431
movq %rbx, %rdi
movl $0x8d, %ecx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x67a0
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/node.c
// Function: Meshes
static int Meshes(lua_State *L)
    {
#define scene ud->scene
    unsigned int i, index;
    node_t *node = checknode(L, 1);
    ud_t *ud = userdata(node);
    lua_newtable(L);
    for(i = 0; i < node->mNumMeshes; i++)
        {
        index = node->mMeshes[i];
        if(index >= scene->mNumMeshes)
            return unexpected(L);   
        pushmesh(L, scene->mMeshes[index]);
        lua_rawseti(L, -2, i+1);
        }
    return 1;
#undef scene
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x48fe(%rip), %rdx      # 0x113e2
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
movq %rax, %rdi
callq 0x6770
movq %rax, %r15
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
pushq $-0x2
popq %rbp
movl 0x460(%r14), %eax
cmpq %rax, %r12
jae 0xcb4e
movq 0x468(%r14), %rax
movl (%rax,%r12,4), %eax
movq 0x10(%r15), %rcx
cmpl 0x10(%rcx), %eax
jae 0xcb5a
movq 0x18(%rcx), %rcx
movq (%rcx,%rax,8), %rsi
movq %rbx, %rdi
callq 0x6380
incq %r12
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x6470
jmp 0xcb0c
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3655(%rip), %rsi      # 0x101b6
leaq 0x48c9(%rip), %rdx      # 0x11431
pushq $0x7a
popq %rcx
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x67a0
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/nodeanim.c
// Function: moonassimp_newnodeanim
int newnodeanim(lua_State *L, scene_t *scene, animation_t *animation, nodeanim_t *nodeanim)
    {
    ud_t *ud;
//  TRACE_CREATE(nodeanim, "nodeanim");
    ud = newuserdata(L, (void*)nodeanim, NODEANIM_MT);
    ud->scene = scene;
    ud->animation = animation;
    return 1;   
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x48ab(%rip), %rdx      # 0x11460
movq %rcx, %rsi
callq 0x68c0
movq %r14, 0x10(%rax)
movq %rbx, 0x28(%rax)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/nodeanim.c
// Function: PositionKeys
static int PositionKeys(lua_State *L)
/* { key1, key2, ... }
 *
 * key1 = { time = 123.456, value = { x, y, z } }
 */
    {
    unsigned int i;
    nodeanim_t *nodeanim = checknodeanim(L, 1);
    lua_newtable(L);
    for(i = 0; i < nodeanim->mNumPositionKeys; i++)
        {
#define key nodeanim->mPositionKeys[i]
        lua_newtable(L);
        lua_pushnumber(L, key.mTime);
        lua_setfield(L, -2, "time");
        pushvector3(L, &(key.mValue), 1);
        lua_setfield(L, -2, "value");
        lua_rawseti(L, -2, i+1);
#undef key
        }
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x477d(%rip), %rdx      # 0x11460
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
pushq $0x8
popq %r12
pushq $-0x2
popq %r13
leaq 0x4690(%rip), %rbp      # 0x1139c
movl 0x404(%r14), %eax
cmpq %rax, %r15
jae 0xcd86
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
movq 0x408(%r14), %rax
movsd -0x8(%rax,%r12), %xmm0
movq %rbx, %rdi
callq 0x6500
movq %rbx, %rdi
movl %r13d, %esi
leaq 0x4650(%rip), %rdx      # 0x11397
callq 0x62e0
movq 0x408(%r14), %rsi
addq %r12, %rsi
movq %rbx, %rdi
pushq $0x1
popq %rdx
callq 0x6600
movq %rbx, %rdi
movl %r13d, %esi
movq %rbp, %rdx
callq 0x62e0
incq %r15
movq %rbx, %rdi
movl %r13d, %esi
movq %r15, %rdx
callq 0x6470
addq $0x18, %r12
jmp 0xcd0c
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/nodeanim.c
// Function: RotationKeys
static int RotationKeys(lua_State *L)
/* { key1, key2, ... }
 *
 * key1 = { time = 123.456, value = { w, x, y, z } }
 */
    {
    unsigned int i;
    nodeanim_t *nodeanim = checknodeanim(L, 1);
    lua_newtable(L);
    for(i = 0; i < nodeanim->mNumRotationKeys; i++)
        {
#define key nodeanim->mRotationKeys[i]
        lua_newtable(L);
        lua_pushnumber(L, key.mTime);
        lua_setfield(L, -2, "time");
        pushquaternion(L, &(key.mValue), 1);
        lua_setfield(L, -2, "value");
        lua_rawseti(L, -2, i+1);
#undef key
        }
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x46b3(%rip), %rdx      # 0x11460
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
pushq $0x8
popq %r12
pushq $-0x2
popq %r13
leaq 0x45c6(%rip), %rbp      # 0x1139c
movl 0x410(%r14), %eax
cmpq %rax, %r15
jae 0xce50
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
movq 0x418(%r14), %rax
movsd -0x8(%rax,%r12), %xmm0
movq %rbx, %rdi
callq 0x6500
movq %rbx, %rdi
movl %r13d, %esi
leaq 0x4586(%rip), %rdx      # 0x11397
callq 0x62e0
movq 0x418(%r14), %rsi
addq %r12, %rsi
movq %rbx, %rdi
pushq $0x1
popq %rdx
callq 0x6090
movq %rbx, %rdi
movl %r13d, %esi
movq %rbp, %rdx
callq 0x62e0
incq %r15
movq %rbx, %rdi
movl %r13d, %esi
movq %r15, %rdx
callq 0x6470
addq $0x18, %r12
jmp 0xcdd6
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/nodeanim.c
// Function: ScalingKeys
static int ScalingKeys(lua_State *L)
/* { key1, key2, ... }
 *
 * key1 = { time = 123.456, value = { x, y, z } }
 */
    {
    unsigned int i;
    nodeanim_t *nodeanim = checknodeanim(L, 1);
    lua_newtable(L);
    for(i = 0; i < nodeanim->mNumScalingKeys; i++)
        {
#define key nodeanim->mScalingKeys[i]
        lua_newtable(L);
        lua_pushnumber(L, key.mTime);
        lua_setfield(L, -2, "time");
        pushvector3(L, &(key.mValue), 1);
        lua_setfield(L, -2, "value");
        lua_rawseti(L, -2, i+1);
#undef key
        }
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x45e9(%rip), %rdx      # 0x11460
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
pushq $0x8
popq %r12
pushq $-0x2
popq %r13
leaq 0x44fc(%rip), %rbp      # 0x1139c
movl 0x420(%r14), %eax
cmpq %rax, %r15
jae 0xcf1a
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
movq 0x428(%r14), %rax
movsd -0x8(%rax,%r12), %xmm0
movq %rbx, %rdi
callq 0x6500
movq %rbx, %rdi
movl %r13d, %esi
leaq 0x44bc(%rip), %rdx      # 0x11397
callq 0x62e0
movq 0x428(%r14), %rsi
addq %r12, %rsi
movq %rbx, %rdi
pushq $0x1
popq %rdx
callq 0x6600
movq %rbx, %rdi
movl %r13d, %esi
movq %rbp, %rdx
callq 0x62e0
incq %r15
movq %rbx, %rdi
movl %r13d, %esi
movq %r15, %rdx
callq 0x6470
addq $0x18, %r12
jmp 0xcea0
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/scene.c
// Function: moonassimp_newscene
int newscene(lua_State *L, scene_t *scene)
/* recursively creates the userdata for the scene,
 * the root node and its children, and all other nested objects */
    {
    unsigned int i;
    TRACE_CREATE(scene, "scene");
    if(scene->mRootNode)
        {
        newnode(L, scene, scene->mRootNode);
        lua_pop(L, 1);
        }
#define New(what, newfunc) do {                     \
    for(i=0; i< scene->mNum##what; i++)             \
        { newfunc(L, scene, scene->m##what[i]); lua_pop(L, 1);  } } while(0)
    New(Meshes, newmesh);
    New(Materials, newmaterial);
    New(Lights, newlight);
    New(Textures, newtexture);
    New(Cameras, newcamera);
    New(Animations, newanimation);
#undef New
    newuserdata(L, (void*)scene, SCENE_MT);
    return 1;   
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x456c(%rip), %rdi      # 0x114f0
xorl %eax, %eax
callq 0x6710
movq 0x8(%rbx), %rdx
testq %rdx, %rdx
je 0xcfaa
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6480
pushq $-0x2
popq %rsi
movq %r14, %rdi
callq 0x60c0
xorl %r15d, %r15d
pushq $-0x2
popq %rbp
movl 0x10(%rbx), %eax
cmpq %rax, %r15
jae 0xcfda
movq 0x18(%rbx), %rax
movq (%rax,%r15,8), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6140
movq %r14, %rdi
movl %ebp, %esi
callq 0x60c0
incq %r15
jmp 0xcfb0
xorl %r15d, %r15d
pushq $-0x2
popq %rbp
movl 0x20(%rbx), %eax
cmpq %rax, %r15
jae 0xd00a
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6700
movq %r14, %rdi
movl %ebp, %esi
callq 0x60c0
incq %r15
jmp 0xcfe0
xorl %r15d, %r15d
pushq $-0x2
popq %rbp
movl 0x50(%rbx), %eax
cmpq %rax, %r15
jae 0xd03a
movq 0x58(%rbx), %rax
movq (%rax,%r15,8), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6220
movq %r14, %rdi
movl %ebp, %esi
callq 0x60c0
incq %r15
jmp 0xd010
xorl %r15d, %r15d
pushq $-0x2
popq %rbp
movl 0x40(%rbx), %eax
cmpq %rax, %r15
jae 0xd06a
movq 0x48(%rbx), %rax
movq (%rax,%r15,8), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6150
movq %r14, %rdi
movl %ebp, %esi
callq 0x60c0
incq %r15
jmp 0xd040
xorl %r15d, %r15d
pushq $-0x2
popq %rbp
movl 0x60(%rbx), %eax
cmpq %rax, %r15
jae 0xd09a
movq 0x68(%rbx), %rax
movq (%rax,%r15,8), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x68e0
movq %r14, %rdi
movl %ebp, %esi
callq 0x60c0
incq %r15
jmp 0xd070
xorl %r15d, %r15d
pushq $-0x2
popq %rbp
movl 0x30(%rbx), %eax
cmpq %rax, %r15
jae 0xd0ca
movq 0x38(%rbx), %rax
movq (%rax,%r15,8), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6890
movq %r14, %rdi
movl %ebp, %esi
callq 0x60c0
incq %r15
jmp 0xd0a0
leaq 0x381d(%rip), %rdx      # 0x108ee
movq %r14, %rdi
movq %rbx, %rsi
callq 0x68c0
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/scene.c
// Function: Mesh
static int Mesh(lua_State *L)
    {
    scene_t *scene = checkscene(L, 1);
    unsigned int i = checkindex(L, 2); /* 1-based */
    if(i > scene->mNumMeshes)
        return luaL_argerror(L, 2, "out of range");
    pushmesh(L, scene->mMeshes[i]);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3308(%rip), %rdx      # 0x108ee
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x6310
cmpl 0x10(%r14), %eax
jbe 0xd61b
leaq 0x2ba0(%rip), %rdx      # 0x101a9
pushq $0x2
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x61c0
movq 0x18(%r14), %rcx
movl %eax, %eax
movq (%rcx,%rax,8), %rsi
movq %rbx, %rdi
callq 0x6380
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/scene.c
// Function: Meshes
static int Meshes(lua_State *L)
    {
    unsigned int i;
    scene_t *scene = checkscene(L, 1);
    lua_newtable(L);
    for(i = 0; i < scene->mNumMeshes; i++)
        {
        pushmesh(L, scene->mMeshes[i]);
        lua_rawseti(L, -2, i+1);
        }
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x32a5(%rip), %rdx      # 0x108ee
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
pushq $-0x2
popq %rbp
movl 0x10(%r14), %eax
cmpq %rax, %r15
jae 0xd691
movq 0x18(%r14), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x6380
incq %r15
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x6470
jmp 0xd666
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/scene.c
// Function: Delete
static int Delete(lua_State *L)
    {
    unsigned int i;
    scene_t *scene = testscene(L, 1);
    if(!scene) return 0; /* already deleted */
    /* first, release all userdata */
#define Free(what, freefunc) do {                   \
    if(scene->mNum##what > 0)                       \
        {                                           \
        for(i=0; i < scene->mNum##what; i++)        \
            freefunc(L, scene->m##what[i]);         \
        }                                           \
} while(0)
    Free(Meshes, freemesh);
    Free(Materials, freematerial);
    Free(Lights, freelight);
    Free(Textures, freetexture);
    Free(Cameras, freecamera);
    Free(Animations, freeanimation);
#undef Free
    if(scene->mRootNode)
        freenode(L, scene->mRootNode);
    TRACE_DELETE(scene, "scene");
    freeuserdata(L, scene);
    /* finally, release the scene */
    aiReleaseImport(scene);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x307b(%rip), %rdx      # 0x108ee
pushq $0x1
popq %rsi
callq 0x65b0
testq %rax, %rax
je 0xd9bd
movq %rax, %r14
movl 0x10(%rax), %eax
testl %eax, %eax
je 0xd8b1
xorl %r15d, %r15d
movl %eax, %eax
cmpq %rax, %r15
jae 0xd8b1
movq 0x18(%r14), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x6510
incq %r15
movl 0x10(%r14), %eax
jmp 0xd891
movl 0x20(%r14), %eax
testl %eax, %eax
je 0xd8dc
xorl %r15d, %r15d
movl %eax, %eax
cmpq %rax, %r15
jae 0xd8dc
movq 0x28(%r14), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x6690
incq %r15
movl 0x20(%r14), %eax
jmp 0xd8bc
movl 0x50(%r14), %eax
testl %eax, %eax
je 0xd907
xorl %r15d, %r15d
movl %eax, %eax
cmpq %rax, %r15
jae 0xd907
movq 0x58(%r14), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x6880
incq %r15
movl 0x50(%r14), %eax
jmp 0xd8e7
movl 0x40(%r14), %eax
testl %eax, %eax
je 0xd932
xorl %r15d, %r15d
movl %eax, %eax
cmpq %rax, %r15
jae 0xd932
movq 0x48(%r14), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x67f0
incq %r15
movl 0x40(%r14), %eax
jmp 0xd912
movl 0x60(%r14), %eax
testl %eax, %eax
je 0xd95d
xorl %r15d, %r15d
movl %eax, %eax
cmpq %rax, %r15
jae 0xd95d
movq 0x68(%r14), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x66d0
incq %r15
movl 0x60(%r14), %eax
jmp 0xd93d
movl 0x30(%r14), %eax
testl %eax, %eax
je 0xd988
xorl %r15d, %r15d
movl %eax, %eax
cmpq %rax, %r15
jae 0xd988
movq 0x38(%r14), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x60d0
incq %r15
movl 0x30(%r14), %eax
jmp 0xd968
movq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0xd999
movq %rbx, %rdi
callq 0x63b0
leaq 0x3bff(%rip), %rdi      # 0x1159f
movq %r14, %rsi
xorl %eax, %eax
callq 0x6710
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63f0
movq %r14, %rdi
callq 0x6060
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)