LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/animation.c
// Function: moonassimp_freeanimation
int freeanimation(lua_State *L, animation_t *animation)
    {
    unsigned int i;
    if(animation->mChannels != NULL && animation->mNumChannels > 0)
        {
        for(i = 0; i < animation->mNumChannels; i++)
            freenodeanim(L, animation->mChannels[i]);
        TRACE_DELETE_N(i, "nodeanims");
        }
    if(animation->mMeshChannels != NULL && animation->mNumMeshChannels > 0)
        {
        for(i = 0; i < animation->mNumMeshChannels; i++)
            freemeshanim(L, animation->mMeshChannels[i]);
        TRACE_DELETE_N(i, "meshanims");
        }
    TRACE_DELETE(animation, "animation");

    freeuserdata(L, animation);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x420(%rax)
je 0x6f15
movq 0x8(%rsp), %rax
cmpl $0x0, 0x418(%rax)
jbe 0x6f15
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x418(%rcx), %eax
jae 0x6eff
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x420(%rax), %rax
movl 0x4(%rsp), %ecx
movq (%rax,%rcx,8), %rsi
callq 0x6850
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x6ec3
jmp 0x6f01
movl 0x4(%rsp), %esi
leaq 0xf17d(%rip), %rdi      # 0x16089
movb $0x0, %al
callq 0x6720
jmp 0x6f15
movq 0x8(%rsp), %rax
cmpq $0x0, 0x430(%rax)
je 0x6f8c
movq 0x8(%rsp), %rax
cmpl $0x0, 0x428(%rax)
jbe 0x6f8c
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x428(%rcx), %eax
jae 0x6f76
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x430(%rax), %rax
movl 0x4(%rsp), %ecx
movq (%rax,%rcx,8), %rsi
callq 0x6980
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x6f3a
jmp 0x6f78
movl 0x4(%rsp), %esi
leaq 0xf11b(%rip), %rdi      # 0x1609e
movb $0x0, %al
callq 0x6720
jmp 0x6f8c
jmp 0x6f8e
movq 0x8(%rsp), %rsi
leaq 0xf119(%rip), %rdi      # 0x160b3
movb $0x0, %al
callq 0x6720
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x6400
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/animation.c
// Function: Name
static int Name(lua_State *L)
    {
    animation_t *animation = checkanimation(L, 1);
    if(animation->mName.length == 0)
        return 0;
    lua_pushstring(L, animation->mName.data);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0xf05a(%rip), %rdx      # 0x16074
callq 0x6700
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x0, (%rax)
jne 0x7036
movl $0x0, 0x14(%rsp)
jmp 0x7050
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
addq $0x4, %rsi
callq 0x6930
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/animation.c
// Function: Channel
static int Channel(lua_State *L)
/* nodeanim = animation:node_anim(node_name) */
    {
    unsigned int i;
    animation_t *animation = checkanimation(L, 1);
    const char *name = luaL_checkstring(L, 2);
    if(animation->mChannels == NULL || animation->mNumChannels == 0) return 0;
    for(i = 0; i < animation->mNumChannels; i++)
        {
#define nodename animation->mChannels[i]->mNodeName
        if(strncmp(name, nodename.data, nodename.length) == 0) /* found */
            {
            pushnodeanim(L, animation->mChannels[i]);
            return 1;
            }
#undef nodename
        }
    return 0; /* not found */
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0xef0a(%rip), %rdx      # 0x16074
callq 0x6700
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x6380
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x420(%rax)
je 0x71a8
movq 0x8(%rsp), %rax
cmpl $0x0, 0x418(%rax)
jne 0x71b5
movl $0x0, 0x24(%rsp)
jmp 0x724e
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x418(%rcx), %eax
jae 0x7246
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x420(%rax), %rax
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rsi
addq $0x4, %rsi
movq 0x8(%rsp), %rax
movq 0x420(%rax), %rax
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl (%rax), %eax
movl %eax, %edx
callq 0x6120
cmpl $0x0, %eax
jne 0x7234
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x420(%rax), %rax
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rsi
callq 0x6390
movl $0x1, 0x24(%rsp)
jmp 0x724e
jmp 0x7236
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x71bd
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/animation.c
// Function: Channels
static int Channels(lua_State *L)
    {
    unsigned int i;
    animation_t *animation = checkanimation(L, 1);
    lua_newtable(L);
    if(animation->mChannels == NULL || animation->mNumChannels == 0) return 1;
    for(i = 0; i < animation->mNumChannels; i++)
        {
        pushnodeanim(L, animation->mChannels[i]);
        lua_rawseti(L, -2, i+1);
        }
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0xedfa(%rip), %rdx      # 0x16074
callq 0x6700
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6250
movq 0x8(%rsp), %rax
cmpq $0x0, 0x420(%rax)
je 0x72af
movq 0x8(%rsp), %rax
cmpl $0x0, 0x418(%rax)
jne 0x72b9
movl $0x1, 0x24(%rsp)
jmp 0x731f
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x418(%rcx), %eax
jae 0x7317
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x420(%rax), %rax
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rsi
callq 0x6390
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6470
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x72c1
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/animation.c
// Function: MeshChannels
static int MeshChannels(lua_State *L)
    {
    unsigned int i;
    animation_t *animation = checkanimation(L, 1);
    const char *name = luaL_optstring(L, 2, NULL);
    lua_newtable(L);
    if(animation->mMeshChannels == NULL || animation->mNumMeshChannels == 0) return 1;
    for(i = 0; i < animation->mNumMeshChannels; i++)
        {
#define maname animation->mMeshChannels[i]->mName
        if(!name || (strncmp(name, maname.data, maname.length) == 0))
            {
            pushmeshanim(L, animation->mMeshChannels[i]);
            lua_rawseti(L, -2, i+1);
            }
#undef maname
        }
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0xecda(%rip), %rdx      # 0x16074
callq 0x6700
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x6270
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6250
movq 0x8(%rsp), %rax
cmpq $0x0, 0x430(%rax)
je 0x73e9
movq 0x8(%rsp), %rax
cmpl $0x0, 0x428(%rax)
jne 0x73f6
movl $0x1, 0x24(%rsp)
jmp 0x74aa
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x428(%rcx), %eax
jae 0x74a2
cmpq $0x0, (%rsp)
je 0x7458
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x430(%rax), %rax
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rsi
addq $0x4, %rsi
movq 0x8(%rsp), %rax
movq 0x430(%rax), %rax
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl (%rax), %eax
movl %eax, %edx
callq 0x6120
cmpl $0x0, %eax
jne 0x7490
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x430(%rax), %rax
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rsi
callq 0x6390
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6470
jmp 0x7492
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x73fe
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/animmesh.c
// Function: moonassimp_newanimmesh
int newanimmesh(lua_State *L, scene_t *scene, mesh_t *mesh, animmesh_t *animmesh)
    {
    ud_t *ud;
//  TRACE_CREATE(animmesh, "animmesh");
    ud = newuserdata(L, (void*)animmesh, ANIMMESH_MT);
    ud->scene = scene;
    ud->mesh = mesh;
    return 1;   
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0xec47(%rip), %rdx      # 0x16130
callq 0x68d0
movq %rax, (%rsp)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movl $0x1, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/animmesh.c
// Function: Mesh
static int Mesh(lua_State *L)
    {
    animmesh_t *animmesh = checkanimmesh(L, 1);
    ud_t *ud = userdata(animmesh);
    mesh_t *mesh = ud->mesh;
    return pushmesh(L, mesh);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0xeb86(%rip), %rdx      # 0x16130
callq 0x6700
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x6780
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x6390
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/animmesh.c
// Function: HasColors
static int HasColors(lua_State *L)
    {
    animmesh_t *animmesh = checkanimmesh(L, 1);
    unsigned int i = checkindex(L, 2);
    if( i >= AI_MAX_NUMBER_OF_COLOR_SETS )
        lua_pushboolean(L, 0);
    else
        lua_pushboolean(L, animmesh->mColors[i] != NULL);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0xea36(%rip), %rdx      # 0x16130
callq 0x6700
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x6320
movl %eax, 0x4(%rsp)
cmpl $0x8, 0x4(%rsp)
jb 0x772c
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x6540
jmp 0x7750
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x4(%rsp), %ecx
cmpq $0x0, 0x428(%rax,%rcx,8)
setne %al
andb $0x1, %al
movzbl %al, %esi
callq 0x6540
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/animmesh.c
// Function: HasTextureCoords
static int HasTextureCoords(lua_State *L)
    {
    animmesh_t *animmesh = checkanimmesh(L, 1);
    unsigned int i = checkindex(L, 2);
    if( i >= AI_MAX_NUMBER_OF_TEXTURECOORDS )
        lua_pushboolean(L, 0);
    else
        lua_pushboolean(L, animmesh->mTextureCoords[i] != NULL);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0xe9b6(%rip), %rdx      # 0x16130
callq 0x6700
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x6320
movl %eax, 0x4(%rsp)
cmpl $0x8, 0x4(%rsp)
jb 0x77ac
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x6540
jmp 0x77d0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x4(%rsp), %ecx
cmpq $0x0, 0x468(%rax,%rcx,8)
setne %al
andb $0x1, %al
movzbl %al, %esi
callq 0x6540
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/animmesh.c
// Function: Color
static int Color(lua_State *L)
    {
    animmesh_t *animmesh = checkanimmesh(L, 1);
    unsigned int chan = checkindex(L, 2);
    unsigned int i = checkindex(L, 3);
    if( chan >= AI_MAX_NUMBER_OF_COLOR_SETS || animmesh->mColors[chan] == NULL)
        return luaL_argerror(L, 2, "out of range");
    if( i >= animmesh->mNumVertices)
        return luaL_argerror(L, 3, "out of range");
    return pushcolor4(L, &(animmesh->mColors[chan][i]), 0);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0xe676(%rip), %rdx      # 0x16130
callq 0x6700
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x6320
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movl $0x3, %esi
callq 0x6320
movl %eax, 0x8(%rsp)
cmpl $0x8, 0xc(%rsp)
jae 0x7b05
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
cmpq $0x0, 0x428(%rax,%rcx,8)
jne 0x7b21
movq 0x18(%rsp), %rdi
movl $0x2, %esi
leaq 0xe693(%rip), %rdx      # 0x161a9
callq 0x61c0
movl %eax, 0x24(%rsp)
jmp 0x7b7a
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x4a8(%rcx), %eax
jb 0x7b4e
movq 0x18(%rsp), %rdi
movl $0x3, %esi
leaq 0xe666(%rip), %rdx      # 0x161a9
callq 0x61c0
movl %eax, 0x24(%rsp)
jmp 0x7b7a
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movq 0x428(%rax,%rcx,8), %rsi
movl 0x8(%rsp), %eax
shlq $0x4, %rax
addq %rax, %rsi
xorl %edx, %edx
callq 0x62d0
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/animmesh.c
// Function: TextureCoords
static int TextureCoords(lua_State *L)
    {
    vector3_t *coords;
    vector2_t vec2;
    unsigned int ncomp;
    animmesh_t *animmesh = checkanimmesh(L, 1);
    ud_t *ud = userdata(animmesh);
    mesh_t *mesh = ud->mesh;
    unsigned int chan = checkindex(L, 2);
    unsigned int i = checkindex(L, 3);
    if( chan >= AI_MAX_NUMBER_OF_TEXTURECOORDS || animmesh->mTextureCoords[chan] == NULL)
        return luaL_argerror(L, 2, "out of range");
    if( i >= animmesh->mNumVertices)
        return luaL_argerror(L, 3, "out of range");
    ncomp = mesh->mNumUVComponents[chan]; /* no. of components */
    coords =  &(animmesh->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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0xe586(%rip), %rdx      # 0x16130
callq 0x6700
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x6780
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl $0x2, %esi
callq 0x6320
movl %eax, 0x4(%rsp)
movq 0x38(%rsp), %rdi
movl $0x3, %esi
callq 0x6320
movl %eax, (%rsp)
cmpl $0x8, 0x4(%rsp)
jae 0x7c11
movq 0x18(%rsp), %rax
movl 0x4(%rsp), %ecx
cmpq $0x0, 0x468(%rax,%rcx,8)
jne 0x7c30
movq 0x38(%rsp), %rdi
movl $0x2, %esi
leaq 0xe587(%rip), %rdx      # 0x161a9
callq 0x61c0
movl %eax, 0x44(%rsp)
jmp 0x7d3c
movl (%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x4a8(%rcx), %eax
jb 0x7c5f
movq 0x38(%rsp), %rdi
movl $0x3, %esi
leaq 0xe558(%rip), %rdx      # 0x161a9
callq 0x61c0
movl %eax, 0x44(%rsp)
jmp 0x7d3c
movq 0x8(%rsp), %rax
movl 0x4(%rsp), %ecx
movl 0xb0(%rax,%rcx,4), %eax
movl %eax, 0x24(%rsp)
movq 0x18(%rsp), %rax
movl 0x4(%rsp), %ecx
movq 0x468(%rax,%rcx,8), %rax
movl (%rsp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
cmpl $0x3, 0x24(%rsp)
jne 0x7cb4
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
xorl %edx, %edx
callq 0x6610
movl %eax, 0x44(%rsp)
jmp 0x7d3c
cmpl $0x2, 0x24(%rsp)
jne 0x7cf1
movq 0x30(%rsp), %rax
movss (%rax), %xmm0
movss %xmm0, 0x28(%rsp)
movq 0x30(%rsp), %rax
movss 0x4(%rax), %xmm0
movss %xmm0, 0x2c(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
xorl %edx, %edx
callq 0x6170
movl %eax, 0x44(%rsp)
jmp 0x7d3c
cmpl $0x1, 0x24(%rsp)
jne 0x7d19
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movl $0x1, 0x44(%rsp)
jmp 0x7d3c
movq 0x38(%rsp), %rdi
leaq 0xe491(%rip), %rsi      # 0x161b6
leaq 0xe4a4(%rip), %rdx      # 0x161d0
movl $0xa5, %ecx
movb $0x0, %al
callq 0x67b0
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/bitfields.c
// Function: moonassimp_checktextureflags
unsigned int checktextureflags(lua_State *L, int arg)
/* Accepts an integer or a list of strings starting from index=arg */
    {
    unsigned int flags = 0;
    const char *s;
    
    if(lua_type(L, arg) == LUA_TNUMBER)
        return (unsigned int)luaL_checkinteger(L, arg);

    while(lua_isstring(L, arg))
        {
        s = lua_tostring(L, arg++);
#define CASE(CODE,str) if((strcmp(s, str)==0)) do { flags |= CODE; goto done; } while(0)
    CASE(aiTextureFlags_Invert, "invert");
    CASE(aiTextureFlags_UseAlpha, "use alpha");
    CASE(aiTextureFlags_IgnoreAlpha, "ignore alpha");
#undef CASE
        return (unsigned int)luaL_argerror(L, --arg, badvalue(L,s));
        done: ;
        }
    return flags;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x68e0
cmpl $0x3, %eax
jne 0x7d8f
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x6440
movl %eax, 0x34(%rsp)
jmp 0x7e8f
jmp 0x7d91
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x69c0
cmpl $0x0, %eax
je 0x7e87
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x61e0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0xe42c(%rip), %rsi      # 0x16200
callq 0x6420
cmpl $0x0, %eax
jne 0x7df0
jmp 0x7de0
movl 0x20(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x7e82
movq 0x18(%rsp), %rdi
leaq 0xe40b(%rip), %rsi      # 0x16207
callq 0x6420
cmpl $0x0, %eax
jne 0x7e15
jmp 0x7e08
movl 0x20(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x20(%rsp)
jmp 0x7e82
movq 0x18(%rsp), %rdi
leaq 0xe3f0(%rip), %rsi      # 0x16211
callq 0x6420
cmpl $0x0, %eax
jne 0x7e3a
jmp 0x7e2d
movl 0x20(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x20(%rsp)
jmp 0x7e82
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rsp)
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0xe3ba(%rip), %rsi      # 0x1621e
movb $0x0, %al
callq 0x63e0
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movq %rax, %rdx
callq 0x61c0
movl %eax, 0x34(%rsp)
jmp 0x7e8f
jmp 0x7d91
movl 0x20(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/bitfields.c
// Function: moonassimp_pushtextureflags
int pushtextureflags(lua_State *L, unsigned int flags, int pushcode)
/* Pushes an integer followed by a list of strings */
    {
    int n = 0;
    if(pushcode)
        { lua_pushinteger(L, flags); return 1; }

#define CASE(CODE,str) do { if( flags & CODE) { lua_pushstring(L, str); n++; } } while(0)
    CASE(aiTextureFlags_Invert, "invert");
    CASE(aiTextureFlags_UseAlpha, "use alpha");
    CASE(aiTextureFlags_IgnoreAlpha, "ignore alpha");
#undef CASE
    if(flags==0) { lua_pushstring(L, "none"); n++; }
    return n;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x0, 0x10(%rsp)
je 0x7edd
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x6310
movl $0x1, 0x24(%rsp)
jmp 0x7f8c
jmp 0x7edf
movl 0x14(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x7f07
movq 0x18(%rsp), %rdi
leaq 0xe309(%rip), %rsi      # 0x16200
callq 0x6930
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x7f09
jmp 0x7f0b
movl 0x14(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x7f33
movq 0x18(%rsp), %rdi
leaq 0xe2e4(%rip), %rsi      # 0x16207
callq 0x6930
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x7f35
jmp 0x7f37
movl 0x14(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x7f5f
movq 0x18(%rsp), %rdi
leaq 0xe2c2(%rip), %rsi      # 0x16211
callq 0x6930
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x7f61
cmpl $0x0, 0x14(%rsp)
jne 0x7f84
movq 0x18(%rsp), %rdi
leaq 0xe2bd(%rip), %rsi      # 0x16231
callq 0x6930
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/bitfields.c
// Function: moonassimp_checkprimitivetype
unsigned int checkprimitivetype(lua_State *L, int arg)
/* Accepts an integer or a list of strings starting from index=arg */
    {
    unsigned int flags = 0;
    const char *s;
    
    if(lua_type(L, arg) == LUA_TNUMBER)
        return (unsigned int)luaL_checkinteger(L, arg);

    while(lua_isstring(L, arg))
        {
        s = lua_tostring(L, arg++);
#define CASE(CODE,str) if((strcmp(s, str)==0)) do { flags |= CODE; goto done; } while(0)
    CASE(aiPrimitiveType_POINT, "point");
    CASE(aiPrimitiveType_LINE, "line");
    CASE(aiPrimitiveType_TRIANGLE, "triangle");
    CASE(aiPrimitiveType_POLYGON, "polygon");
#undef CASE
        return (unsigned int)luaL_argerror(L, --arg, badvalue(L,s));
        done: ;
        }
    return flags;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x68e0
cmpl $0x3, %eax
jne 0x7fdf
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x6440
movl %eax, 0x34(%rsp)
jmp 0x8107
jmp 0x7fe1
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x69c0
cmpl $0x0, %eax
je 0x80ff
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x61e0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0xe212(%rip), %rsi      # 0x16236
callq 0x6420
cmpl $0x0, %eax
jne 0x8040
jmp 0x8030
movl 0x20(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x80fa
movq 0x18(%rsp), %rdi
leaq 0xe1f0(%rip), %rsi      # 0x1623c
callq 0x6420
cmpl $0x0, %eax
jne 0x8068
jmp 0x8058
movl 0x20(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x20(%rsp)
jmp 0x80fa
movq 0x18(%rsp), %rdi
leaq 0xe1cd(%rip), %rsi      # 0x16241
callq 0x6420
cmpl $0x0, %eax
jne 0x808d
jmp 0x8080
movl 0x20(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x20(%rsp)
jmp 0x80fa
movq 0x18(%rsp), %rdi
leaq 0xe1b1(%rip), %rsi      # 0x1624a
callq 0x6420
cmpl $0x0, %eax
jne 0x80b2
jmp 0x80a5
movl 0x20(%rsp), %eax
orl $0x8, %eax
movl %eax, 0x20(%rsp)
jmp 0x80fa
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rsp)
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0xe142(%rip), %rsi      # 0x1621e
movb $0x0, %al
callq 0x63e0
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movq %rax, %rdx
callq 0x61c0
movl %eax, 0x34(%rsp)
jmp 0x8107
jmp 0x7fe1
movl 0x20(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/bitfields.c
// Function: moonassimp_pushprimitivetype
int pushprimitivetype(lua_State *L, unsigned int flags, int pushcode)
/* Pushes an integer followed by a list of strings */
    {
    int n = 0;
    if(pushcode)
        { lua_pushinteger(L, flags); return 1; }

#define CASE(CODE,str) do { if( flags & CODE) { lua_pushstring(L, str); n++; } } while(0)
    CASE(aiPrimitiveType_POINT, "point");
    CASE(aiPrimitiveType_LINE, "line");
    CASE(aiPrimitiveType_TRIANGLE, "triangle");
    CASE(aiPrimitiveType_POLYGON, "polygon");
#undef CASE
    if(flags==0) { lua_pushstring(L, "none"); n++; }
    return n;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x0, 0x10(%rsp)
je 0x814d
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x6310
movl $0x1, 0x24(%rsp)
jmp 0x8228
jmp 0x814f
movl 0x14(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x8177
movq 0x18(%rsp), %rdi
leaq 0xe0cf(%rip), %rsi      # 0x16236
callq 0x6930
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x8179
jmp 0x817b
movl 0x14(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x81a3
movq 0x18(%rsp), %rdi
leaq 0xe0a9(%rip), %rsi      # 0x1623c
callq 0x6930
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x81a5
jmp 0x81a7
movl 0x14(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x81cf
movq 0x18(%rsp), %rdi
leaq 0xe082(%rip), %rsi      # 0x16241
callq 0x6930
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x81d1
jmp 0x81d3
movl 0x14(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x81fb
movq 0x18(%rsp), %rdi
leaq 0xe05f(%rip), %rsi      # 0x1624a
callq 0x6930
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x81fd
cmpl $0x0, 0x14(%rsp)
jne 0x8220
movq 0x18(%rsp), %rdi
leaq 0xe021(%rip), %rsi      # 0x16231
callq 0x6930
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/bitfields.c
// Function: moonassimp_checksceneflags
unsigned int checksceneflags(lua_State *L, int arg)
/* Accepts an integer or a list of strings starting from index=arg */
    {
    unsigned int flags = 0;
    const char *s;
    
    if(lua_type(L, arg) == LUA_TNUMBER)
        return (unsigned int)luaL_checkinteger(L, arg);

    while(lua_isstring(L, arg))
        {
        s = lua_tostring(L, arg++);
#define CASE(CODE,str) if((strcmp(s, str)==0)) do { flags |= CODE; goto done; } while(0)
        CASE(0, "none");
        CASE(AI_SCENE_FLAGS_INCOMPLETE, "incomplete");
        CASE(AI_SCENE_FLAGS_VALIDATED, "validated");
        CASE(AI_SCENE_FLAGS_VALIDATION_WARNING, "validation warning");
        CASE(AI_SCENE_FLAGS_NON_VERBOSE_FORMAT, "non verbose format");
        CASE(AI_SCENE_FLAGS_TERRAIN, "terrain");
#undef CASE
        return (unsigned int)luaL_argerror(L, --arg, badvalue(L,s));
        done: ;
        }
    return flags;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x68e0
cmpl $0x3, %eax
jne 0x827f
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x6440
movl %eax, 0x34(%rsp)
jmp 0x83f7
jmp 0x8281
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x69c0
cmpl $0x0, %eax
je 0x83ef
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
xorl %eax, %eax
movl %eax, %edx
callq 0x61e0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0xdf6d(%rip), %rsi      # 0x16231
callq 0x6420
cmpl $0x0, %eax
jne 0x82e0
jmp 0x82d0
movl 0x20(%rsp), %eax
orl $0x0, %eax
movl %eax, 0x20(%rsp)
jmp 0x83ea
movq 0x18(%rsp), %rdi
leaq 0xdf66(%rip), %rsi      # 0x16252
callq 0x6420
cmpl $0x0, %eax
jne 0x8308
jmp 0x82f8
movl 0x20(%rsp), %eax
orl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x83ea
movq 0x18(%rsp), %rdi
leaq 0xdf49(%rip), %rsi      # 0x1625d
callq 0x6420
cmpl $0x0, %eax
jne 0x8330
jmp 0x8320
movl 0x20(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x20(%rsp)
jmp 0x83ea
movq 0x18(%rsp), %rdi
leaq 0xdf2b(%rip), %rsi      # 0x16267
callq 0x6420
cmpl $0x0, %eax
jne 0x8358
jmp 0x8348
movl 0x20(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x20(%rsp)
jmp 0x83ea
movq 0x18(%rsp), %rdi
leaq 0xdf16(%rip), %rsi      # 0x1627a
callq 0x6420
cmpl $0x0, %eax
jne 0x837d
jmp 0x8370
movl 0x20(%rsp), %eax
orl $0x8, %eax
movl %eax, 0x20(%rsp)
jmp 0x83ea
movq 0x18(%rsp), %rdi
leaq 0xdf04(%rip), %rsi      # 0x1628d
callq 0x6420
cmpl $0x0, %eax
jne 0x83a2
jmp 0x8395
movl 0x20(%rsp), %eax
orl $0x10, %eax
movl %eax, 0x20(%rsp)
jmp 0x83ea
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rsp)
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0xde52(%rip), %rsi      # 0x1621e
movb $0x0, %al
callq 0x63e0
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movq %rax, %rdx
callq 0x61c0
movl %eax, 0x34(%rsp)
jmp 0x83f7
jmp 0x8281
movl 0x20(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/bitfields.c
// Function: moonassimp_pushsceneflags
int pushsceneflags(lua_State *L, unsigned int flags, int pushcode)
/* Pushes an integer followed by a list of strings */
    {
    int n = 0;
    if(pushcode)
        { lua_pushinteger(L, flags); return 1; }

#define CASE(CODE,str) do { if( flags & CODE) { lua_pushstring(L, str); n++; } } while(0)
        CASE(AI_SCENE_FLAGS_INCOMPLETE, "incomplete");
        CASE(AI_SCENE_FLAGS_VALIDATED, "validated");
        CASE(AI_SCENE_FLAGS_VALIDATION_WARNING, "validation warning");
        CASE(AI_SCENE_FLAGS_NON_VERBOSE_FORMAT, "non verbose format");
        CASE(AI_SCENE_FLAGS_TERRAIN, "terrain");
#undef CASE
    if(flags==0) { lua_pushstring(L, "none"); n++; }
    return n;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x0, 0x10(%rsp)
je 0x843d
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x6310
movl $0x1, 0x24(%rsp)
jmp 0x8544
jmp 0x843f
movl 0x14(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x8467
movq 0x18(%rsp), %rdi
leaq 0xddfb(%rip), %rsi      # 0x16252
callq 0x6930
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x8469
jmp 0x846b
movl 0x14(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x8493
movq 0x18(%rsp), %rdi
leaq 0xddda(%rip), %rsi      # 0x1625d
callq 0x6930
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x8495
jmp 0x8497
movl 0x14(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x84bf
movq 0x18(%rsp), %rdi
leaq 0xddb8(%rip), %rsi      # 0x16267
callq 0x6930
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x84c1
jmp 0x84c3
movl 0x14(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x84eb
movq 0x18(%rsp), %rdi
leaq 0xdd9f(%rip), %rsi      # 0x1627a
callq 0x6930
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x84ed
jmp 0x84ef
movl 0x14(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x8517
movq 0x18(%rsp), %rdi
leaq 0xdd86(%rip), %rsi      # 0x1628d
callq 0x6930
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x8519
cmpl $0x0, 0x14(%rsp)
jne 0x853c
movq 0x18(%rsp), %rdi
leaq 0xdd05(%rip), %rsi      # 0x16231
callq 0x6930
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/bone.c
// Function: moonassimp_newbone
int newbone(lua_State *L, scene_t *scene, mesh_t *mesh, bone_t *bone)
    {
    ud_t *ud;
    TRACE_CREATE(bone, "bone");
    ud = newuserdata(L, (void*)bone, BONE_MT);
    ud->scene = scene;
    ud->mesh = mesh;
    return 1;   
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x8(%rsp), %rsi
leaq 0xd48c(%rip), %rdi      # 0x16470
movb $0x0, %al
callq 0x6720
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0xd486(%rip), %rdx      # 0x16482
callq 0x68d0
movq %rax, (%rsp)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movl $0x1, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/bone.c
// Function: Name
static int Name(lua_State *L)
    {
    bone_t *bone = checkbone(L, 1);
    if(bone->mName.length == 0)
        return 0;
    lua_pushstring(L, bone->mName.data);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0xd3b8(%rip), %rdx      # 0x16482
callq 0x6700
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x0, (%rax)
jne 0x90e6
movl $0x0, 0x14(%rsp)
jmp 0x9100
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
addq $0x4, %rsi
callq 0x6930
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/bone.c
// Function: Weights
static int Weights(lua_State *L)
/* returns a (possibly sparse) table t 
 * where t[i] is the weight for the vertex i 
 * (i= 1-based index in the mesh's vertices list)
 */
    {
    unsigned int i;
    bone_t *bone = checkbone(L, 1);
    lua_newtable(L);
    if(bone->mWeights == NULL || bone->mNumWeights == 0) return 0;
    for(i = 0; i < bone->mNumWeights; i++)
        {
#define w bone->mWeights[i]
        lua_pushnumber(L, w.mWeight);
        lua_rawseti(L, -2, w.mVertexId+1);
#undef w
        }
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0xd308(%rip), %rdx      # 0x16482
callq 0x6700
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6250
movq 0x8(%rsp), %rax
cmpq $0x0, 0x418(%rax)
je 0x91af
movq 0x8(%rsp), %rax
cmpl $0x0, 0x404(%rax)
jne 0x91b9
movl $0x0, 0x24(%rsp)
jmp 0x9234
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x404(%rcx), %eax
jae 0x922c
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x418(%rax), %rax
movl 0x14(%rsp), %ecx
movss 0x4(%rax,%rcx,8), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x418(%rax), %rax
movl 0x14(%rsp), %ecx
movl (%rax,%rcx,8), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6470
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x91c1
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/bone.c
// Function: OrderedWeights
static int OrderedWeights(lua_State *L)
/* returns a table t of elements { vertex=i, weight=val }
 */
    {
    unsigned int i;
    bone_t *bone = checkbone(L, 1);
    lua_newtable(L);
    if(bone->mWeights == NULL || bone->mNumWeights == 0) return 0;
    for(i = 0; i < bone->mNumWeights; i++)
        {
#define w bone->mWeights[i]
        lua_newtable(L);
        lua_pushinteger(L, w.mVertexId+1);
        lua_setfield(L, -2, "vertex");
        lua_pushnumber(L, w.mWeight);
        lua_setfield(L, -2, "weight");
        lua_rawseti(L, -2, i+1);
#undef w
        }
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0xd228(%rip), %rdx      # 0x16482
callq 0x6700
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6250
movq 0x8(%rsp), %rax
cmpq $0x0, 0x418(%rax)
je 0x928f
movq 0x8(%rsp), %rax
cmpl $0x0, 0x404(%rax)
jne 0x929c
movl $0x0, 0x24(%rsp)
jmp 0x936d
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x404(%rcx), %eax
jae 0x9365
movq 0x18(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6250
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x418(%rax), %rax
movl 0x14(%rsp), %ecx
movl (%rax,%rcx,8), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x6310
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0xd1d2(%rip), %rdx      # 0x164ce
callq 0x62e0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x418(%rax), %rax
movl 0x14(%rsp), %ecx
movss 0x4(%rax,%rcx,8), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x6500
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0xd19f(%rip), %rdx      # 0x164d5
callq 0x62e0
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6470
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x92a4
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/camera.c
// Function: moonassimp_newcamera
int newcamera(lua_State *L, scene_t *scene, camera_t *camera)
    {
    ud_t *ud;
    TRACE_CREATE(camera, "camera");
    ud = newuserdata(L, (void*)camera, CAMERA_MT);
    ud->scene = scene;
    return 1;   
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rsi
leaq 0xd111(%rip), %rdi      # 0x16500
movb $0x0, %al
callq 0x6720
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0xd10d(%rip), %rdx      # 0x16514
callq 0x68d0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movl $0x1, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/camera.c
// Function: Name
static int Name(lua_State *L)
    {
    camera_t *camera = checkcamera(L, 1);
    if(camera->mName.length == 0)
        return 0;
    lua_pushstring(L, camera->mName.data);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0xd04a(%rip), %rdx      # 0x16514
callq 0x6700
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x0, (%rax)
jne 0x94e6
movl $0x0, 0x14(%rsp)
jmp 0x9500
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
addq $0x4, %rsi
callq 0x6930
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/enums.c
// Function: moonassimp_checkanimbehaviour
unsigned int checkanimbehaviour(lua_State *L, int arg)
    {
    const char *s = luaL_checkstring(L, arg);
#define CASE(CODE,str) if((strcmp(s, str)==0)) return CODE
    CASE(aiAnimBehaviour_DEFAULT, "default");
    CASE(aiAnimBehaviour_CONSTANT, "constant");
    CASE(aiAnimBehaviour_LINEAR, "linear");
    CASE(aiAnimBehaviour_REPEAT, "repeat");
#undef CASE
    return (unsigned int)luaL_argerror(L, arg, badvalue(L,s));
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x6380
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0xcf18(%rip), %rsi      # 0x16688
callq 0x6420
cmpl $0x0, %eax
jne 0x9787
movl $0x0, 0x34(%rsp)
jmp 0x9826
movq 0x18(%rsp), %rdi
leaq 0xd203(%rip), %rsi      # 0x16996
callq 0x6420
cmpl $0x0, %eax
jne 0x97a7
movl $0x1, 0x34(%rsp)
jmp 0x9826
movq 0x18(%rsp), %rdi
leaq 0xd1f8(%rip), %rsi      # 0x169ab
callq 0x6420
cmpl $0x0, %eax
jne 0x97c7
movl $0x2, 0x34(%rsp)
jmp 0x9826
movq 0x18(%rsp), %rdi
leaq 0xcebd(%rip), %rsi      # 0x16690
callq 0x6420
cmpl $0x0, %eax
jne 0x97e7
movl $0x3, 0x34(%rsp)
jmp 0x9826
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0xca14(%rip), %rsi      # 0x1621e
movb $0x0, %al
callq 0x63e0
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movq %rax, %rdx
callq 0x61c0
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/enums.c
// Function: moonassimp_pushanimbehaviour
int pushanimbehaviour(lua_State *L, unsigned int value)
    {
    switch(value)
        {
#define CASE(CODE,str) case CODE: lua_pushstring(L, str); break
    CASE(aiAnimBehaviour_DEFAULT, "default");
    CASE(aiAnimBehaviour_CONSTANT, "constant");
    CASE(aiAnimBehaviour_LINEAR, "linear");
    CASE(aiAnimBehaviour_REPEAT, "repeat");
#undef CASE
        default:
            return unexpected(L);
        }
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq %rax, 0x8(%rsp)
subq $0x3, %rax
ja 0x98ad
movq 0x8(%rsp), %rax
leaq 0xcd48(%rip), %rcx      # 0x165a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rdi
leaq 0xce1b(%rip), %rsi      # 0x16688
callq 0x6930
jmp 0x98d2
movq 0x18(%rsp), %rdi
leaq 0xd116(%rip), %rsi      # 0x16996
callq 0x6930
jmp 0x98d2
movq 0x18(%rsp), %rdi
leaq 0xd118(%rip), %rsi      # 0x169ab
callq 0x6930
jmp 0x98d2
movq 0x18(%rsp), %rdi
leaq 0xcdea(%rip), %rsi      # 0x16690
callq 0x6930
jmp 0x98d2
movq 0x18(%rsp), %rdi
leaq 0xc8fd(%rip), %rsi      # 0x161b6
leaq 0xcdd7(%rip), %rdx      # 0x16697
movl $0x38, %ecx
movb $0x0, %al
callq 0x67b0
movl %eax, 0x24(%rsp)
jmp 0x98da
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/enums.c
// Function: moonassimp_checklogstream
unsigned int checklogstream(lua_State *L, int arg)
    {
    const char *s = luaL_checkstring(L, arg);
#define CASE(CODE,str) if((strcmp(s, str)==0)) return CODE
    CASE(0, "user"); // user Lua callback
    CASE(aiDefaultLogStream_FILE, "file");
    CASE(aiDefaultLogStream_STDOUT, "stdout");
    CASE(aiDefaultLogStream_STDERR, "stderr");
    //CASE(aiDefaultLogStream_DEBUGGER, "debugger");
#undef CASE
    return (unsigned int)luaL_argerror(L, arg, badvalue(L,s));
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x6380
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0xcd7f(%rip), %rsi      # 0x1669f
callq 0x6420
cmpl $0x0, %eax
jne 0x9937
movl $0x0, 0x34(%rsp)
jmp 0x99d6
movq 0x18(%rsp), %rdi
leaq 0xd79d(%rip), %rsi      # 0x170e0
callq 0x6420
cmpl $0x0, %eax
jne 0x9957
movl $0x1, 0x34(%rsp)
jmp 0x99d6
movq 0x18(%rsp), %rdi
leaq 0xcd41(%rip), %rsi      # 0x166a4
callq 0x6420
cmpl $0x0, %eax
jne 0x9977
movl $0x2, 0x34(%rsp)
jmp 0x99d6
movq 0x18(%rsp), %rdi
leaq 0xcd28(%rip), %rsi      # 0x166ab
callq 0x6420
cmpl $0x0, %eax
jne 0x9997
movl $0x4, 0x34(%rsp)
jmp 0x99d6
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0xc864(%rip), %rsi      # 0x1621e
movb $0x0, %al
callq 0x63e0
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movq %rax, %rdx
callq 0x61c0
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/enums.c
// Function: moonassimp_pushlogstream
int pushlogstream(lua_State *L, unsigned int value)
    {
    switch(value)
        {
#define CASE(CODE,str) case CODE: lua_pushstring(L, str); break
    CASE(0, "user"); // user Lua callback
    CASE(aiDefaultLogStream_FILE, "file");
    CASE(aiDefaultLogStream_STDOUT, "stdout");
    CASE(aiDefaultLogStream_STDERR, "stderr");
    //CASE(aiDefaultLogStream_DEBUGGER, "debugger");
#undef CASE
        default:
            return unexpected(L);
        }
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq %rax, 0x8(%rsp)
subq $0x4, %rax
ja 0x9a5d
movq 0x8(%rsp), %rax
leaq 0xcba8(%rip), %rcx      # 0x165b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rdi
leaq 0xcc82(%rip), %rsi      # 0x1669f
callq 0x6930
jmp 0x9a82
movq 0x18(%rsp), %rdi
leaq 0xd6b0(%rip), %rsi      # 0x170e0
callq 0x6930
jmp 0x9a82
movq 0x18(%rsp), %rdi
leaq 0xcc61(%rip), %rsi      # 0x166a4
callq 0x6930
jmp 0x9a82
movq 0x18(%rsp), %rdi
leaq 0xcc55(%rip), %rsi      # 0x166ab
callq 0x6930
jmp 0x9a82
movq 0x18(%rsp), %rdi
leaq 0xc74d(%rip), %rsi      # 0x161b6
leaq 0xcc27(%rip), %rdx      # 0x16697
movl $0x5b, %ecx
movb $0x0, %al
callq 0x67b0
movl %eax, 0x24(%rsp)
jmp 0x9a8a
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/enums.c
// Function: moonassimp_checkblendmode
unsigned int checkblendmode(lua_State *L, int arg)
    {
    const char *s = luaL_checkstring(L, arg);
#define CASE(CODE,str) if((strcmp(s, str)==0)) return CODE
    CASE(aiBlendMode_Default, "default");
    CASE(aiBlendMode_Additive, "additive");
#undef CASE
    return (unsigned int)luaL_argerror(L, arg, badvalue(L,s));
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x6380
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0xcbb8(%rip), %rsi      # 0x16688
callq 0x6420
cmpl $0x0, %eax
jne 0x9ae4
movl $0x0, 0x34(%rsp)
jmp 0x9b43
movq 0x18(%rsp), %rdi
leaq 0xcbc2(%rip), %rsi      # 0x166b2
callq 0x6420
cmpl $0x0, %eax
jne 0x9b04
movl $0x1, 0x34(%rsp)
jmp 0x9b43
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0xc6f7(%rip), %rsi      # 0x1621e
movb $0x0, %al
callq 0x63e0
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movq %rax, %rdx
callq 0x61c0
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/enums.c
// Function: moonassimp_pushblendmode
int pushblendmode(lua_State *L, unsigned int value)
    {
    switch(value)
        {
#define CASE(CODE,str) case CODE: lua_pushstring(L, str); break
    CASE(aiBlendMode_Default, "default");
    CASE(aiBlendMode_Additive, "additive");
#undef CASE
        default:
            return unexpected(L);
        }
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, (%rsp)
testl %eax, %eax
je 0x9b74
jmp 0x9b6a
movl (%rsp), %eax
subl $0x1, %eax
je 0x9b87
jmp 0x9b9a
movq 0x8(%rsp), %rdi
leaq 0xcb08(%rip), %rsi      # 0x16688
callq 0x6930
jmp 0x9bbf
movq 0x8(%rsp), %rdi
leaq 0xcb1f(%rip), %rsi      # 0x166b2
callq 0x6930
jmp 0x9bbf
movq 0x8(%rsp), %rdi
leaq 0xc610(%rip), %rsi      # 0x161b6
leaq 0xcaea(%rip), %rdx      # 0x16697
movl $0x77, %ecx
movb $0x0, %al
callq 0x67b0
movl %eax, 0x14(%rsp)
jmp 0x9bc7
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/enums.c
// Function: moonassimp_checkshadingmode
unsigned int checkshadingmode(lua_State *L, int arg)
    {
    const char *s = luaL_checkstring(L, arg);
#define CASE(CODE,str) if((strcmp(s, str)==0)) return CODE
    CASE(aiShadingMode_Flat, "flat");
    CASE(aiShadingMode_Gouraud, "gouraud");
    CASE(aiShadingMode_Phong, "phong");
    CASE(aiShadingMode_Blinn, "blinn");
    CASE(aiShadingMode_Toon, "toon");
    CASE(aiShadingMode_OrenNayar, "oren nayar");
    CASE(aiShadingMode_Minnaert, "minnaert");
    CASE(aiShadingMode_CookTorrance, "cook torrance");
    CASE(aiShadingMode_NoShading, "no shading");
    CASE(aiShadingMode_Fresnel, "fresnel");
#undef CASE
    return (unsigned int)luaL_argerror(L, arg, badvalue(L,s));
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x6380
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0xcabb(%rip), %rsi      # 0x166bb
callq 0x6420
cmpl $0x0, %eax
jne 0x9c17
movl $0x1, 0x34(%rsp)
jmp 0x9d88
movq 0x18(%rsp), %rdi
leaq 0xca9d(%rip), %rsi      # 0x166c0
callq 0x6420
cmpl $0x0, %eax
jne 0x9c3a
movl $0x2, 0x34(%rsp)
jmp 0x9d88
movq 0x18(%rsp), %rdi
leaq 0xca82(%rip), %rsi      # 0x166c8
callq 0x6420
cmpl $0x0, %eax
jne 0x9c5d
movl $0x3, 0x34(%rsp)
jmp 0x9d88
movq 0x18(%rsp), %rdi
leaq 0xca65(%rip), %rsi      # 0x166ce
callq 0x6420
cmpl $0x0, %eax
jne 0x9c80
movl $0x4, 0x34(%rsp)
jmp 0x9d88
movq 0x18(%rsp), %rdi
leaq 0xca48(%rip), %rsi      # 0x166d4
callq 0x6420
cmpl $0x0, %eax
jne 0x9ca3
movl $0x5, 0x34(%rsp)
jmp 0x9d88
movq 0x18(%rsp), %rdi
leaq 0xca2a(%rip), %rsi      # 0x166d9
callq 0x6420
cmpl $0x0, %eax
jne 0x9cc6
movl $0x6, 0x34(%rsp)
jmp 0x9d88
movq 0x18(%rsp), %rdi
leaq 0xca12(%rip), %rsi      # 0x166e4
callq 0x6420
cmpl $0x0, %eax
jne 0x9ce9
movl $0x7, 0x34(%rsp)
jmp 0x9d88
movq 0x18(%rsp), %rdi
leaq 0xc9f8(%rip), %rsi      # 0x166ed
callq 0x6420
cmpl $0x0, %eax
jne 0x9d09
movl $0x8, 0x34(%rsp)
jmp 0x9d88
movq 0x18(%rsp), %rdi
leaq 0xc9e6(%rip), %rsi      # 0x166fb
callq 0x6420
cmpl $0x0, %eax
jne 0x9d29
movl $0x9, 0x34(%rsp)
jmp 0x9d88
movq 0x18(%rsp), %rdi
leaq 0xc9d1(%rip), %rsi      # 0x16706
callq 0x6420
cmpl $0x0, %eax
jne 0x9d49
movl $0xa, 0x34(%rsp)
jmp 0x9d88
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0xc4b2(%rip), %rsi      # 0x1621e
movb $0x0, %al
callq 0x63e0
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movq %rax, %rdx
callq 0x61c0
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)