LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/enums.c
// Function: moonassimp_pushshadingmode
int pushshadingmode(lua_State *L, unsigned int value)
    {
    switch(value)
        {
#define CASE(CODE,str) case CODE: lua_pushstring(L, str); break
    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
        default:
            return unexpected(L);
        }
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl 0x14(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x9, %eax
ja 0x9ea5
movq 0x8(%rsp), %rax
leaq 0xc7f5(%rip), %rcx      # 0x165c4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rdi
leaq 0xc8d7(%rip), %rsi      # 0x166bb
callq 0x6930
jmp 0x9eca
movq 0x18(%rsp), %rdi
leaq 0xc8c6(%rip), %rsi      # 0x166c0
callq 0x6930
jmp 0x9eca
movq 0x18(%rsp), %rdi
leaq 0xc8b8(%rip), %rsi      # 0x166c8
callq 0x6930
jmp 0x9eca
movq 0x18(%rsp), %rdi
leaq 0xc8a8(%rip), %rsi      # 0x166ce
callq 0x6930
jmp 0x9eca
movq 0x18(%rsp), %rdi
leaq 0xc898(%rip), %rsi      # 0x166d4
callq 0x6930
jmp 0x9eca
movq 0x18(%rsp), %rdi
leaq 0xc887(%rip), %rsi      # 0x166d9
callq 0x6930
jmp 0x9eca
movq 0x18(%rsp), %rdi
leaq 0xc87f(%rip), %rsi      # 0x166e4
callq 0x6930
jmp 0x9eca
movq 0x18(%rsp), %rdi
leaq 0xc875(%rip), %rsi      # 0x166ed
callq 0x6930
jmp 0x9eca
movq 0x18(%rsp), %rdi
leaq 0xc870(%rip), %rsi      # 0x166fb
callq 0x6930
jmp 0x9eca
movq 0x18(%rsp), %rdi
leaq 0xc868(%rip), %rsi      # 0x16706
callq 0x6930
jmp 0x9eca
movq 0x18(%rsp), %rdi
leaq 0xc305(%rip), %rsi      # 0x161b6
leaq 0xc7df(%rip), %rdx      # 0x16697
movl $0xa4, %ecx
movb $0x0, %al
callq 0x67b0
movl %eax, 0x24(%rsp)
jmp 0x9ed2
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/enums.c
// Function: moonassimp_pushtexturetype
int pushtexturetype(lua_State *L, unsigned int value)
    {
    switch(value)
        {
#define CASE(CODE,str) case CODE: lua_pushstring(L, str); break
    CASE(aiTextureType_NONE, "none");
    CASE(aiTextureType_DIFFUSE, "diffuse");
    CASE(aiTextureType_SPECULAR, "specular");
    CASE(aiTextureType_AMBIENT, "ambient");
    CASE(aiTextureType_EMISSIVE, "emissive");
    CASE(aiTextureType_HEIGHT, "height");
    CASE(aiTextureType_NORMALS, "normals");
    CASE(aiTextureType_SHININESS, "shininess");
    CASE(aiTextureType_OPACITY, "opacity");
    CASE(aiTextureType_DISPLACEMENT, "displacement");
    CASE(aiTextureType_LIGHTMAP, "lightmap");
    CASE(aiTextureType_REFLECTION, "reflection");
    CASE(aiTextureType_UNKNOWN, "unknown");
#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 $0x12, %rax
ja 0xa254
movq 0x8(%rsp), %rax
leaq 0xc4b0(%rip), %rcx      # 0x165ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rdi
leaq 0xc0e0(%rip), %rsi      # 0x16231
callq 0x6930
jmp 0xa279
movq 0x18(%rsp), %rdi
leaq 0xcf17(%rip), %rsi      # 0x1707e
callq 0x6930
jmp 0xa279
movq 0x18(%rsp), %rdi
leaq 0xcf1b(%rip), %rsi      # 0x17098
callq 0x6930
jmp 0xa279
movq 0x18(%rsp), %rdi
leaq 0xcef8(%rip), %rsi      # 0x1708b
callq 0x6930
jmp 0xa279
movq 0x18(%rsp), %rdi
leaq 0xcefd(%rip), %rsi      # 0x170a6
callq 0x6930
jmp 0xa279
movq 0x18(%rsp), %rdi
leaq 0xc54f(%rip), %rsi      # 0x1670e
callq 0x6930
jmp 0xa279
movq 0x18(%rsp), %rdi
leaq 0xc1da(%rip), %rsi      # 0x163af
callq 0x6930
jmp 0xa279
movq 0x18(%rsp), %rdi
leaq 0xce53(%rip), %rsi      # 0x1703e
callq 0x6930
jmp 0xa279
movq 0x18(%rsp), %rdi
leaq 0xce1f(%rip), %rsi      # 0x17020
callq 0x6930
jmp 0xa279
movq 0x18(%rsp), %rdi
leaq 0xc501(%rip), %rsi      # 0x16715
callq 0x6930
jmp 0xa279
movq 0x18(%rsp), %rdi
leaq 0xc4fb(%rip), %rsi      # 0x16722
callq 0x6930
jmp 0xa279
movq 0x18(%rsp), %rdi
leaq 0xc4f1(%rip), %rsi      # 0x1672b
callq 0x6930
jmp 0xa279
movq 0x18(%rsp), %rdi
leaq 0xc4e9(%rip), %rsi      # 0x16736
callq 0x6930
jmp 0xa279
movq 0x18(%rsp), %rdi
leaq 0xbf56(%rip), %rsi      # 0x161b6
leaq 0xc430(%rip), %rdx      # 0x16697
movl $0xd7, %ecx
movb $0x0, %al
callq 0x67b0
movl %eax, 0x24(%rsp)
jmp 0xa281
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/enums.c
// Function: moonassimp_checktexturemapping
unsigned int checktexturemapping(lua_State *L, int arg)
    {
    const char *s = luaL_checkstring(L, arg);
#define CASE(CODE,str) if((strcmp(s, str)==0)) return CODE
    CASE(aiTextureMapping_UV, "uv");
    CASE(aiTextureMapping_SPHERE, "sphere");
    CASE(aiTextureMapping_CYLINDER, "cylinder");
    CASE(aiTextureMapping_BOX, "box");
    CASE(aiTextureMapping_PLANE, "plane");
    CASE(aiTextureMapping_OTHER, "other");
#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 0xc47e(%rip), %rsi      # 0x1673e
callq 0x6420
cmpl $0x0, %eax
jne 0xa2d7
movl $0x0, 0x34(%rsp)
jmp 0xa3bc
movq 0x18(%rsp), %rdi
leaq 0xc45e(%rip), %rsi      # 0x16741
callq 0x6420
cmpl $0x0, %eax
jne 0xa2fa
movl $0x1, 0x34(%rsp)
jmp 0xa3bc
movq 0x18(%rsp), %rdi
leaq 0xc442(%rip), %rsi      # 0x16748
callq 0x6420
cmpl $0x0, %eax
jne 0xa31d
movl $0x2, 0x34(%rsp)
jmp 0xa3bc
movq 0x18(%rsp), %rdi
leaq 0xc428(%rip), %rsi      # 0x16751
callq 0x6420
cmpl $0x0, %eax
jne 0xa33d
movl $0x3, 0x34(%rsp)
jmp 0xa3bc
movq 0x18(%rsp), %rdi
leaq 0xc40c(%rip), %rsi      # 0x16755
callq 0x6420
cmpl $0x0, %eax
jne 0xa35d
movl $0x4, 0x34(%rsp)
jmp 0xa3bc
movq 0x18(%rsp), %rdi
leaq 0xc3f2(%rip), %rsi      # 0x1675b
callq 0x6420
cmpl $0x0, %eax
jne 0xa37d
movl $0x5, 0x34(%rsp)
jmp 0xa3bc
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 0xbe7e(%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)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/enums.c
// Function: moonassimp_pushtexturemapping
int pushtexturemapping(lua_State *L, unsigned int value)
    {
    switch(value)
        {
#define CASE(CODE,str) case CODE: lua_pushstring(L, str); break
    CASE(aiTextureMapping_UV, "uv");
    CASE(aiTextureMapping_SPHERE, "sphere");
    CASE(aiTextureMapping_CYLINDER, "cylinder");
    CASE(aiTextureMapping_BOX, "box");
    CASE(aiTextureMapping_PLANE, "plane");
    CASE(aiTextureMapping_OTHER, "other");
#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 $0x5, %rax
ja 0xa47a
movq 0x8(%rsp), %rax
leaq 0xc23c(%rip), %rcx      # 0x16638
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rdi
leaq 0xc32d(%rip), %rsi      # 0x1673e
callq 0x6930
jmp 0xa49f
movq 0x18(%rsp), %rdi
leaq 0xc31a(%rip), %rsi      # 0x16741
callq 0x6930
jmp 0xa49f
movq 0x18(%rsp), %rdi
leaq 0xc30e(%rip), %rsi      # 0x16748
callq 0x6930
jmp 0xa49f
movq 0x18(%rsp), %rdi
leaq 0xc304(%rip), %rsi      # 0x16751
callq 0x6930
jmp 0xa49f
movq 0x18(%rsp), %rdi
leaq 0xc2f5(%rip), %rsi      # 0x16755
callq 0x6930
jmp 0xa49f
movq 0x18(%rsp), %rdi
leaq 0xc2e8(%rip), %rsi      # 0x1675b
callq 0x6930
jmp 0xa49f
movq 0x18(%rsp), %rdi
leaq 0xbd30(%rip), %rsi      # 0x161b6
leaq 0xc20a(%rip), %rdx      # 0x16697
movl $0xfc, %ecx
movb $0x0, %al
callq 0x67b0
movl %eax, 0x24(%rsp)
jmp 0xa4a7
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/enums.c
// Function: moonassimp_checktexturemapmode
unsigned int checktexturemapmode(lua_State *L, int arg)
    {
    const char *s = luaL_checkstring(L, arg);
#define CASE(CODE,str) if((strcmp(s, str)==0)) return CODE
    CASE(aiTextureMapMode_Wrap, "wrap");
    CASE(aiTextureMapMode_Clamp, "clamp");
    CASE(aiTextureMapMode_Decal, "decal");
    CASE(aiTextureMapMode_Mirror, "mirror");
#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 0xc281(%rip), %rsi      # 0x16761
callq 0x6420
cmpl $0x0, %eax
jne 0xa4f7
movl $0x0, 0x34(%rsp)
jmp 0xa596
movq 0x18(%rsp), %rdi
leaq 0xc263(%rip), %rsi      # 0x16766
callq 0x6420
cmpl $0x0, %eax
jne 0xa517
movl $0x1, 0x34(%rsp)
jmp 0xa596
movq 0x18(%rsp), %rdi
leaq 0xc249(%rip), %rsi      # 0x1676c
callq 0x6420
cmpl $0x0, %eax
jne 0xa537
movl $0x3, 0x34(%rsp)
jmp 0xa596
movq 0x18(%rsp), %rdi
leaq 0xc22f(%rip), %rsi      # 0x16772
callq 0x6420
cmpl $0x0, %eax
jne 0xa557
movl $0x2, 0x34(%rsp)
jmp 0xa596
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 0xbca4(%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_pushtexturemapmode
int pushtexturemapmode(lua_State *L, unsigned int value)
    {
    switch(value)
        {
#define CASE(CODE,str) case CODE: lua_pushstring(L, str); break
    CASE(aiTextureMapMode_Wrap, "wrap");
    CASE(aiTextureMapMode_Clamp, "clamp");
    CASE(aiTextureMapMode_Decal, "decal");
    CASE(aiTextureMapMode_Mirror, "mirror");
#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 0xa61d
movq 0x8(%rsp), %rax
leaq 0xc088(%rip), %rcx      # 0x16650
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rdi
leaq 0xc184(%rip), %rsi      # 0x16761
callq 0x6930
jmp 0xa642
movq 0x18(%rsp), %rdi
leaq 0xc176(%rip), %rsi      # 0x16766
callq 0x6930
jmp 0xa642
movq 0x18(%rsp), %rdi
leaq 0xc169(%rip), %rsi      # 0x1676c
callq 0x6930
jmp 0xa642
movq 0x18(%rsp), %rdi
leaq 0xc15c(%rip), %rsi      # 0x16772
callq 0x6930
jmp 0xa642
movq 0x18(%rsp), %rdi
leaq 0xbb8d(%rip), %rsi      # 0x161b6
leaq 0xc067(%rip), %rdx      # 0x16697
movl $0x11e, %ecx            # imm = 0x11E
movb $0x0, %al
callq 0x67b0
movl %eax, 0x24(%rsp)
jmp 0xa64a
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_checktextureop
unsigned int checktextureop(lua_State *L, int arg)
    {
    const char *s = luaL_checkstring(L, arg);
#define CASE(CODE,str) if((strcmp(s, str)==0)) return CODE
    CASE(aiTextureOp_Multiply, "multiply");
    CASE(aiTextureOp_Add, "add");
    CASE(aiTextureOp_Subtract, "subtract");
    CASE(aiTextureOp_Divide, "divide");
    CASE(aiTextureOp_SmoothAdd, "smooth add");
    CASE(aiTextureOp_SignedAdd, "signed add");
#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 0xc0e9(%rip), %rsi      # 0x16779
callq 0x6420
cmpl $0x0, %eax
jne 0xa6a7
movl $0x0, 0x34(%rsp)
jmp 0xa78c
movq 0x18(%rsp), %rdi
leaq 0xc0f1(%rip), %rsi      # 0x167a4
callq 0x6420
cmpl $0x0, %eax
jne 0xa6ca
movl $0x1, 0x34(%rsp)
jmp 0xa78c
movq 0x18(%rsp), %rdi
leaq 0xc0ac(%rip), %rsi      # 0x16782
callq 0x6420
cmpl $0x0, %eax
jne 0xa6ed
movl $0x2, 0x34(%rsp)
jmp 0xa78c
movq 0x18(%rsp), %rdi
leaq 0xc092(%rip), %rsi      # 0x1678b
callq 0x6420
cmpl $0x0, %eax
jne 0xa70d
movl $0x3, 0x34(%rsp)
jmp 0xa78c
movq 0x18(%rsp), %rdi
leaq 0xc079(%rip), %rsi      # 0x16792
callq 0x6420
cmpl $0x0, %eax
jne 0xa72d
movl $0x4, 0x34(%rsp)
jmp 0xa78c
movq 0x18(%rsp), %rdi
leaq 0xc064(%rip), %rsi      # 0x1679d
callq 0x6420
cmpl $0x0, %eax
jne 0xa74d
movl $0x5, 0x34(%rsp)
jmp 0xa78c
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 0xbaae(%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)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/enums.c
// Function: moonassimp_pushtextureop
int pushtextureop(lua_State *L, unsigned int value)
    {
    switch(value)
        {
#define CASE(CODE,str) case CODE: lua_pushstring(L, str); break
    CASE(aiTextureOp_Multiply, "multiply");
    CASE(aiTextureOp_Add, "add");
    CASE(aiTextureOp_Subtract, "subtract");
    CASE(aiTextureOp_Divide, "divide");
    CASE(aiTextureOp_SmoothAdd, "smooth add");
    CASE(aiTextureOp_SignedAdd, "signed add");
#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 $0x5, %rax
ja 0xa84a
movq 0x8(%rsp), %rax
leaq 0xbe94(%rip), %rcx      # 0x16660
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rdi
leaq 0xbf98(%rip), %rsi      # 0x16779
callq 0x6930
jmp 0xa86f
movq 0x18(%rsp), %rdi
leaq 0xbfad(%rip), %rsi      # 0x167a4
callq 0x6930
jmp 0xa86f
movq 0x18(%rsp), %rdi
leaq 0xbf78(%rip), %rsi      # 0x16782
callq 0x6930
jmp 0xa86f
movq 0x18(%rsp), %rdi
leaq 0xbf6e(%rip), %rsi      # 0x1678b
callq 0x6930
jmp 0xa86f
movq 0x18(%rsp), %rdi
leaq 0xbf62(%rip), %rsi      # 0x16792
callq 0x6930
jmp 0xa86f
movq 0x18(%rsp), %rdi
leaq 0xbf5a(%rip), %rsi      # 0x1679d
callq 0x6930
jmp 0xa86f
movq 0x18(%rsp), %rdi
leaq 0xb960(%rip), %rsi      # 0x161b6
leaq 0xbe3a(%rip), %rdx      # 0x16697
movl $0x143, %ecx            # imm = 0x143
movb $0x0, %al
callq 0x67b0
movl %eax, 0x24(%rsp)
jmp 0xa877
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/enums.c
// Function: moonassimp_checklightsourcetype
unsigned int checklightsourcetype(lua_State *L, int arg)
    {
    const char *s = luaL_checkstring(L, arg);
#define CASE(CODE,str) if((strcmp(s, str)==0)) return CODE
    CASE(aiLightSource_UNDEFINED, "undefined");
    CASE(aiLightSource_DIRECTIONAL, "directional");
    CASE(aiLightSource_POINT, "point");
    CASE(aiLightSource_SPOT, "spot");
#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 0xbef8(%rip), %rsi      # 0x167a8
callq 0x6420
cmpl $0x0, %eax
jne 0xa8c7
movl $0x0, 0x34(%rsp)
jmp 0xa966
movq 0x18(%rsp), %rdi
leaq 0xbedf(%rip), %rsi      # 0x167b2
callq 0x6420
cmpl $0x0, %eax
jne 0xa8e7
movl $0x1, 0x34(%rsp)
jmp 0xa966
movq 0x18(%rsp), %rdi
leaq 0xb943(%rip), %rsi      # 0x16236
callq 0x6420
cmpl $0x0, %eax
jne 0xa907
movl $0x2, 0x34(%rsp)
jmp 0xa966
movq 0x18(%rsp), %rdi
leaq 0xbeab(%rip), %rsi      # 0x167be
callq 0x6420
cmpl $0x0, %eax
jne 0xa927
movl $0x3, 0x34(%rsp)
jmp 0xa966
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 0xb8d4(%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_pushlightsourcetype
int pushlightsourcetype(lua_State *L, unsigned int value)
    {
    switch(value)
        {
#define CASE(CODE,str) case CODE: lua_pushstring(L, str); break
    CASE(aiLightSource_UNDEFINED, "undefined");
    CASE(aiLightSource_DIRECTIONAL, "directional");
    CASE(aiLightSource_POINT, "point");
    CASE(aiLightSource_SPOT, "spot");
#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 0xa9ed
movq 0x8(%rsp), %rax
leaq 0xbce0(%rip), %rcx      # 0x16678
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rdi
leaq 0xbdfb(%rip), %rsi      # 0x167a8
callq 0x6930
jmp 0xaa12
movq 0x18(%rsp), %rdi
leaq 0xbdf2(%rip), %rsi      # 0x167b2
callq 0x6930
jmp 0xaa12
movq 0x18(%rsp), %rdi
leaq 0xb863(%rip), %rsi      # 0x16236
callq 0x6930
jmp 0xaa12
movq 0x18(%rsp), %rdi
leaq 0xbdd8(%rip), %rsi      # 0x167be
callq 0x6930
jmp 0xaa12
movq 0x18(%rsp), %rdi
leaq 0xb7bd(%rip), %rsi      # 0x161b6
leaq 0xbc97(%rip), %rdx      # 0x16697
movl $0x164, %ecx            # imm = 0x164
movb $0x0, %al
callq 0x67b0
movl %eax, 0x24(%rsp)
jmp 0xaa1a
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/face.c
// Function: moonassimp_newface
int newface(lua_State *L, scene_t *scene, mesh_t *mesh, face_t *face)
    {
    ud_t *ud;
//  TRACE_CREATE(face, "face");
    ud = newuserdata(L, (void*)face, FACE_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 0xbd6a(%rip), %rdx      # 0x167c3
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/face.c
// Function: moonassimp_pushfaceindices
int pushfaceindices(lua_State *L, face_t *face, int zero_based)
/* pushes a table with the face indices */
    {
    unsigned int i;
    lua_newtable(L);
    if(face->mIndices == NULL || face->mNumIndices == 0)
        return 1;
    if(zero_based)
        {
        for(i=0; i < face->mNumIndices; i++)
            {
            lua_pushinteger(L, face->mIndices[i]);
            lua_rawseti(L, -2, i+1);
            }
        }
    else
        {
        for(i=0; i < face->mNumIndices; i++)
            {
            lua_pushinteger(L, face->mIndices[i] + 1);
            lua_rawseti(L, -2, i+1);
            }
        }
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x18(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6250
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0xaaf6
movq 0x10(%rsp), %rax
cmpl $0x0, (%rax)
jne 0xab03
movl $0x1, 0x24(%rsp)
jmp 0xabcb
cmpl $0x0, 0xc(%rsp)
je 0xab64
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jae 0xab62
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, %esi
callq 0x6310
movq 0x18(%rsp), %rdi
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6470
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xab12
jmp 0xabc3
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jae 0xabc1
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rsp), %ecx
movl (%rax,%rcx,4), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x6310
movq 0x18(%rsp), %rdi
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6470
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xab6c
jmp 0xabc3
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/face.c
// Function: Indices
static int Indices(lua_State *L)
    {
    unsigned int i;
    face_t * face = checkface(L, 1);
    if(face->mIndices == NULL || face->mNumIndices == 0)
        return 0;
    luaL_checkstack(L, face->mNumIndices, NULL);
    for(i=0; i < face->mNumIndices; i++)
        pushindex(L, face->mIndices[i]);
    return face->mNumIndices;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0xbb39(%rip), %rdx      # 0x167c3
callq 0x6700
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0xacaa
movq 0x8(%rsp), %rax
cmpl $0x0, (%rax)
jne 0xacb4
movl $0x0, 0x24(%rsp)
jmp 0xad10
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movl (%rax), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x6560
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl (%rcx), %eax
jae 0xad05
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x14(%rsp), %ecx
movl (%rax,%rcx,4), %esi
callq 0x64e0
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xacd1
movq 0x8(%rsp), %rax
movl (%rax), %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/face.c
// Function: ZeroBasedIndices
static int ZeroBasedIndices(lua_State *L)
    {
    unsigned int i;
    face_t * face = checkface(L, 1);
    if(face->mIndices == NULL || face->mNumIndices == 0)
        return 0;
    luaL_checkstack(L, face->mNumIndices, NULL);
    for(i=0; i < face->mNumIndices; i++)
        lua_pushinteger(L, face->mIndices[i]);
    return face->mNumIndices;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0xba89(%rip), %rdx      # 0x167c3
callq 0x6700
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0xad5a
movq 0x8(%rsp), %rax
cmpl $0x0, (%rax)
jne 0xad64
movl $0x0, 0x24(%rsp)
jmp 0xadc2
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movl (%rax), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x6560
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl (%rcx), %eax
jae 0xadb7
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x14(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, %esi
callq 0x6310
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xad81
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/import.c
// Function: GetExtensionList
static int GetExtensionList(lua_State *L)
    {
    struct aiString out;
    out.data[0]='\0';
    out.length = 0;
    aiGetExtensionList(&out);
    lua_pushstring(L, out.data);
    return 1;
    }

// Assembly:
subq $0x418, %rsp            # imm = 0x418
movq %rdi, 0x410(%rsp)
movb $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
leaq 0xc(%rsp), %rdi
callq 0x6330
movq 0x410(%rsp), %rdi
leaq 0xc(%rsp), %rsi
addq $0x4, %rsi
callq 0x6930
movl $0x1, %eax
addq $0x418, %rsp            # imm = 0x418
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/import.c
// Function: ImportFile
static int ImportFile(lua_State *L)
    {
    const char *file = luaL_checkstring(L, 1);
    unsigned int flags = checkpostprocessflags(L, 2);
    const scene_t* scene = aiImportFile(file, flags);

    if(!scene)
        return nilerrmsg(L);
    
    return newscene(L, (scene_t*)scene);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x6380
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x6260
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x63b0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0xaf0d
movq 0x18(%rsp), %rdi
callq 0x64b0
movl %eax, 0x24(%rsp)
jmp 0xaf1f
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
callq 0x65f0
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/import.c
// Function: ImportFileFromMemory
static int ImportFileFromMemory(lua_State *L)
    {
    size_t len;
    const char *buffer = luaL_checklstring(L, 1, &len);
    unsigned int flags = checkpostprocessflags(L, 2);
    const char *hint = luaL_optstring(L, 3, NULL);
    const scene_t* scene = aiImportFileFromMemory(buffer, (unsigned int)len, flags, hint);

    if(!scene)
        return nilerrmsg(L);
    
    return newscene(L, (scene_t*)scene);
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x20(%rsp), %rdx
callq 0x6380
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x6260
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x6270
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movl %eax, %esi
movl 0x14(%rsp), %edx
movq 0x8(%rsp), %rcx
callq 0x6790
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0xafb5
movq 0x28(%rsp), %rdi
callq 0x64b0
movl %eax, 0x34(%rsp)
jmp 0xafc7
movq 0x28(%rsp), %rdi
movq (%rsp), %rsi
callq 0x65f0
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/import.c
// Function: ApplyPostProcessing
static int ApplyPostProcessing(lua_State *L)
    {
    const scene_t *scene;
    const scene_t *orig = checkscene(L, 1);
    unsigned int flags = checkpostprocessflags(L, 2);
    
    scene = aiApplyPostProcessing(orig, flags);
    if(!scene)
        return nilerrmsg(L);

    return newscene(L, (scene_t*)scene);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0xb904(%rip), %rdx      # 0x168ee
callq 0x6700
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x6260
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x66f0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xb032
movq 0x18(%rsp), %rdi
callq 0x64b0
movl %eax, 0x24(%rsp)
jmp 0xb045
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x65f0
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/import.c
// Function: GetMemoryRequirements
static int GetMemoryRequirements(lua_State *L)
    {
    struct aiMemoryInfo mem;
    const scene_t *scene = checkscene(L, 1);
    memset(&mem, 0, sizeof(mem));
    aiGetMemoryRequirements(scene, &mem);
    lua_newtable(L);
#define SET(what)   do { lua_pushinteger(L, mem.what); lua_setfield(L, -2, #what); } while(0)
    SET(textures);
    SET(materials);
    SET(meshes);
    SET(nodes);
    SET(animations);
    SET(cameras);
    SET(lights);
    SET(total);
#undef SET
    return 1;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movl $0x1, %esi
leaq 0xb884(%rip), %rdx      # 0x168ee
callq 0x6700
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x6300
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x6110
movq 0x30(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6250
movq 0x30(%rsp), %rdi
movl 0x10(%rsp), %eax
movl %eax, %esi
callq 0x6310
movq 0x30(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0xbf0f(%rip), %rdx      # 0x16fd2
callq 0x62e0
jmp 0xb0ca
movq 0x30(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x6310
movq 0x30(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0xb2ad(%rip), %rdx      # 0x16398
callq 0x62e0
jmp 0xb0f2
movq 0x30(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0x6310
movq 0x30(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0xb214(%rip), %rdx      # 0x16327
callq 0x62e0
jmp 0xb11a
movq 0x30(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x6310
movq 0x30(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0xb7c4(%rip), %rdx      # 0x168ff
callq 0x62e0
jmp 0xb142
movq 0x30(%rsp), %rdi
movl 0x20(%rsp), %eax
movl %eax, %esi
callq 0x6310
movq 0x30(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0xc3f0(%rip), %rdx      # 0x17553
callq 0x62e0
jmp 0xb16a
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0x6310
movq 0x30(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0xc3d7(%rip), %rdx      # 0x17562
callq 0x62e0
jmp 0xb192
movq 0x30(%rsp), %rdi
movl 0x28(%rsp), %eax
movl %eax, %esi
callq 0x6310
movq 0x30(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0xc3bb(%rip), %rdx      # 0x1756e
callq 0x62e0
jmp 0xb1ba
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x6310
movq 0x30(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0xb72a(%rip), %rdx      # 0x16905
callq 0x62e0
movl $0x1, %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/import.c
// Function: Attach_log_stream
static int Attach_log_stream(lua_State *L)
    {
    struct aiLogStream c;
    const char *filename = NULL;
    unsigned int t = checklogstream(L, 1);
    if(t==0)
        return AttachUserLogStream(L);
    if(t==aiDefaultLogStream_FILE)
        filename = luaL_checkstring(L, 2);

    c = aiGetPredefinedLogStream((enum aiDefaultLogStream)t, filename);
    if(!c.callback)
        return luaL_error(L, "cannot get predefined log stream");
    aiAttachLogStream(&c);

    if(t==aiDefaultLogStream_FILE)
        FileLogStream = &c;
    return 0;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
callq 0x67f0
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
jne 0xb22f
movq 0x38(%rsp), %rdi
callq 0xb3e0
movl %eax, 0x44(%rsp)
jmp 0xb2c0
cmpl $0x1, 0x1c(%rsp)
jne 0xb24e
movq 0x38(%rsp), %rdi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x6380
movq %rax, 0x20(%rsp)
movl 0x1c(%rsp), %edi
movq 0x20(%rsp), %rsi
callq 0x6860
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0xb29b
movq 0x38(%rsp), %rdi
leaq 0xb67d(%rip), %rsi      # 0x1690b
movb $0x0, %al
callq 0x67b0
movl %eax, 0x44(%rsp)
jmp 0xb2c0
leaq 0x28(%rsp), %rdi
callq 0x69a0
cmpl $0x1, 0x1c(%rsp)
jne 0xb2b8
leaq 0x28(%rsp), %rax
movq %rax, 0x12248(%rip)     # 0x1d500
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/import.c
// Function: Detach_log_stream
static int Detach_log_stream(lua_State *L)
    {
    struct aiLogStream c;
    unsigned int t = checklogstream(L, 1);

    if(t==0)
        return DetachUserLogStream(L);

    if(t==aiDefaultLogStream_FILE)
        {
        if(FileLogStream == NULL) return 0; /* nothing to do */
        aiDetachLogStream(FileLogStream);
        FileLogStream = NULL;
        return 0;
        }
    
    c = aiGetPredefinedLogStream((enum aiDefaultLogStream)t, NULL);
    if(!c.callback)
        return luaL_error(L, "cannot get predefined log stream");
    aiDetachLogStream(&c);
    return 0;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x67f0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0xb306
movq 0x28(%rsp), %rdi
callq 0xb480
movl %eax, 0x34(%rsp)
jmp 0xb39e
cmpl $0x1, 0x14(%rsp)
jne 0xb342
cmpq $0x0, 0x121eb(%rip)     # 0x1d500
jne 0xb321
movl $0x0, 0x34(%rsp)
jmp 0xb39e
movq 0x121d8(%rip), %rdi     # 0x1d500
callq 0x6750
movq $0x0, 0x121c8(%rip) # 0x1d500
movl $0x0, 0x34(%rsp)
jmp 0xb39e
movl 0x14(%rsp), %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x6860
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xb38c
movq 0x28(%rsp), %rdi
leaq 0xb58c(%rip), %rsi      # 0x1690b
movb $0x0, %al
callq 0x67b0
movl %eax, 0x34(%rsp)
jmp 0xb39e
leaq 0x18(%rsp), %rdi
callq 0x6750
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/import.c
// Function: Detach_all_log_streams
static int Detach_all_log_streams(lua_State *L)
    {
    DetachUserLogStream(L);
    aiDetachAllLogStreams();
    FileLogStream = NULL;
    return 0;
    }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0xb480
callq 0x61f0
movq $0x0, 0x12132(%rip) # 0x1d500
xorl %eax, %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/import.c
// Function: AttachUserLogStream
static int AttachUserLogStream(lua_State *L)
    {
    if(lua_type(L, 2) != LUA_TFUNCTION)
        return luaL_argerror(L, 2, "function expected");
    DetachUserLogStream(L); /* the previous attached one, if any */
    reference(L, CallbackRef, 2);
    LogStream.callback = LogStreamCallback;
    LogStream.user = (char*)L;
    aiAttachLogStream(&LogStream);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x68e0
cmpl $0x6, %eax
je 0xb419
movq 0x8(%rsp), %rdi
movl $0x2, %esi
leaq 0xb51e(%rip), %rdx      # 0x1692c
callq 0x61c0
movl %eax, 0x14(%rsp)
jmp 0xb475
movq 0x8(%rsp), %rdi
callq 0xb480
movq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x63d0
movq 0x8(%rsp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x6240
movl %eax, 0x120a9(%rip)     # 0x1d4f0
leaq 0xa2(%rip), %rax        # 0xb4f0
movq %rax, 0x120b3(%rip)     # 0x1d508
movq 0x8(%rsp), %rax
movq %rax, 0x120af(%rip)     # 0x1d510
leaq 0x120a0(%rip), %rdi     # 0x1d508
callq 0x69a0
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/import.c
// Function: DetachUserLogStream
static int DetachUserLogStream(lua_State *L)
    {
    if(CallbackRef == LUA_NOREF) return 0; /* nothing to do */
    aiDetachLogStream(&LogStream);
    unreference(L, CallbackRef);    
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpl $-0x2, 0x12060(%rip)    # 0x1d4f0
jne 0xb49c
movl $0x0, 0x14(%rsp)
jmp 0xb4da
leaq 0x12065(%rip), %rdi     # 0x1d508
callq 0x6750
cmpl $-0x2, 0x12041(%rip)    # 0x1d4f0
je 0xb4d0
movq 0x8(%rsp), %rdi
movl 0x12034(%rip), %edx     # 0x1d4f0
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x6920
movl $0xfffffffe, 0x12020(%rip) # imm = 0xFFFFFFFE
jmp 0xb4d2
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/import.c
// Function: LogStreamCallback
static void LogStreamCallback(const char* message, char* user)
    {
#define L ((lua_State*)user)
    if(pushvalue(L, CallbackRef) != LUA_TFUNCTION)
        { unexpected(L); return; }
    lua_pushstring(L, message);
    if(lua_pcall(L, 1, 0, 0) != LUA_OK)
        { unexpected(L); return; }
#undef L
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movslq 0x11fe6(%rip), %rdx     # 0x1d4f0
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x62b0
cmpl $0x6, %eax
je 0xb53a
movq 0x8(%rsp), %rdi
leaq 0xac91(%rip), %rsi      # 0x161b6
leaq 0xb412(%rip), %rdx      # 0x1693e
movl $0x7e, %ecx
movb $0x0, %al
callq 0x67b0
jmp 0xb588
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x6930
movq 0x8(%rsp), %rdi
movl $0x1, %esi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %edx
movq %r9, %r8
callq 0x6990
cmpl $0x0, %eax
je 0xb588
movq 0x8(%rsp), %rdi
leaq 0xac41(%rip), %rsi      # 0x161b6
leaq 0xb3c2(%rip), %rdx      # 0x1693e
movl $0x81, %ecx
movb $0x0, %al
callq 0x67b0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/light.c
// Function: moonassimp_newlight
int newlight(lua_State *L, scene_t *scene, light_t *light)
    {
    ud_t *ud;
    TRACE_CREATE(light, "light");
    ud = newuserdata(L, (void*)light, LIGHT_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 0xb398(%rip), %rdi      # 0x16947
movb $0x0, %al
callq 0x6720
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0xb393(%rip), %rdx      # 0x1695a
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/light.c
// Function: Name
static int Name(lua_State *L)
    {
    light_t *light = checklight(L, 1);
    if(light->mName.length == 0)
        return 0;
    lua_pushstring(L, light->mName.data);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
leaq 0xb2d0(%rip), %rdx      # 0x1695a
callq 0x6700
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x0, (%rax)
jne 0xb6a6
movl $0x0, 0x14(%rsp)
jmp 0xb6c0
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/main.c
// Function: luaopen_moonassimp
int luaopen_moonassimp(lua_State *L)
/* Lua calls this function to load the module */
    {
    lua_newtable(L); /* the ai table */
    AddVersions(L);
    AddConstants(L);
    atexit(AtExit);

    /* add assimp functions: */
    luaL_setfuncs(L, Functions, 0);
    moonassimp_open_import(L);
    moonassimp_open_scene(L);
    moonassimp_open_node(L);
    moonassimp_open_mesh(L);
    moonassimp_open_animmesh(L);
    moonassimp_open_material(L);
    moonassimp_open_animation(L);
    moonassimp_open_texture(L);
    moonassimp_open_light(L);
    moonassimp_open_camera(L);
    moonassimp_open_face(L);
    moonassimp_open_bone(L);
    moonassimp_open_nodeanim(L);
    moonassimp_open_meshanim(L);
    moonassimp_open_additional(L);

    return 1;
    }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6250
movq (%rsp), %rdi
callq 0xbb10
movq (%rsp), %rdi
callq 0xbbb0
leaq 0x715(%rip), %rdi       # 0xc180
callq 0x15640
movq (%rsp), %rdi
leaq 0x10a95(%rip), %rsi     # 0x1c510
xorl %edx, %edx
callq 0x61a0
movq (%rsp), %rdi
callq 0x64a0
movq (%rsp), %rdi
callq 0x65d0
movq (%rsp), %rdi
callq 0x6660
movq (%rsp), %rdi
callq 0x62f0
movq (%rsp), %rdi
callq 0x68b0
movq (%rsp), %rdi
callq 0x6570
movq (%rsp), %rdi
callq 0x6590
movq (%rsp), %rdi
callq 0x6030
movq (%rsp), %rdi
callq 0x6650
movq (%rsp), %rdi
callq 0x65e0
movq (%rsp), %rdi
callq 0x6840
movq (%rsp), %rdi
callq 0x6600
movq (%rsp), %rdi
callq 0x6360
movq (%rsp), %rdi
callq 0x6640
movq (%rsp), %rdi
callq 0x6830
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/main.c
// Function: AddVersions
static void AddVersions(lua_State *L)
/* Add version strings to the ai table */
    {
    lua_pushstring(L, "_VERSION");
    lua_pushstring(L, "MoonAssimp "MOONASSIMP_VERSION);
    lua_settable(L, -3);

    lua_pushstring(L, "_ASSIMP_VERSION");
    lua_pushfstring(L, "Assimp %d.%d.%d", 
            aiGetVersionMajor(),
            aiGetVersionMinor(),
            aiGetVersionRevision());
    lua_settable(L, -3);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0xaf31(%rip), %rsi      # 0x16a56
callq 0x6930
movq 0x10(%rsp), %rdi
leaq 0xaf0a(%rip), %rsi      # 0x16a40
callq 0x6930
movq 0x10(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x6520
movq 0x10(%rsp), %rdi
leaq 0xaef9(%rip), %rsi      # 0x16a4f
callq 0x6930
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
callq 0x61d0
movl %eax, 0x8(%rsp)
callq 0x67a0
movl %eax, 0xc(%rsp)
callq 0x60e0
movq (%rsp), %rdi
movl 0x8(%rsp), %edx
movl 0xc(%rsp), %ecx
movl %eax, %r8d
leaq 0xaece(%rip), %rsi      # 0x16a5f
movb $0x0, %al
callq 0x63e0
movq 0x10(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x6520
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/main.c
// Function: GetVersion
static int GetVersion(lua_State *L)
    {
    lua_pushinteger(L, aiGetVersionMajor());
    lua_pushinteger(L, aiGetVersionMinor());
    lua_pushinteger(L, aiGetVersionRevision());
    return 3;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x61d0
movq 0x8(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x6310
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x67a0
movq 0x10(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x6310
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x60e0
movq 0x18(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x6310
movl $0x3, %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/main.c
// Function: GetCompileFlags
static int GetCompileFlags(lua_State *L)
    {
    int n = 0;
    unsigned int flags = aiGetCompileFlags();
#define ADD(F, f) if(flags & ASSIMP_CFLAGS_##F) { lua_pushstring(L, f); n++; }
    ADD(SHARED, "shared")
    ADD(STLPORT, "stlport")
    ADD(DEBUG, "debug")
    ADD(NOBOOST, "noboost")
    ADD(SINGLETHREADED, "singlethreaded")
#undef ADD
    return n;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
callq 0x6950
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xc272
movq 0x10(%rsp), %rdi
leaq 0xabec(%rip), %rsi      # 0x16e4e
callq 0x6930
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0x8(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xc29a
movq 0x10(%rsp), %rdi
leaq 0xabcb(%rip), %rsi      # 0x16e55
callq 0x6930
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0x8(%rsp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xc2c2
movq 0x10(%rsp), %rdi
leaq 0xabab(%rip), %rsi      # 0x16e5d
callq 0x6930
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0x8(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xc2ea
movq 0x10(%rsp), %rdi
leaq 0xab89(%rip), %rsi      # 0x16e63
callq 0x6930
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0x8(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xc312
movq 0x10(%rsp), %rdi
leaq 0xab69(%rip), %rsi      # 0x16e6b
callq 0x6930
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/material.c
// Function: moonassimp_newmaterial
int newmaterial(lua_State *L, scene_t *scene, material_t *material)
    {
    ud_t *ud;
    TRACE_CREATE(material, "material");
    ud = newuserdata(L, (void*)material, MATERIAL_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 0xab0b(%rip), %rdi      # 0x16e7a
movb $0x0, %al
callq 0x6720
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0xab09(%rip), %rdx      # 0x16e90
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/material.c
// Function: Shading
static int Shading(lua_State *L)
    {
    int val;
    material_t *material = checkmaterial(L, 1);
    if(aiGetMaterialIntegerArray(material, AI_MATKEY_SHADING_MODEL, &val, NULL) != AI_SUCCESS) 
        return 0;
    return pushshadingmode(L, val);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0xa9e6(%rip), %rdx      # 0x16e90
callq 0x6700
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0xab33(%rip), %rsi      # 0x16ff3
xorl %ecx, %ecx
leaq 0x14(%rsp), %r8
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %edx
callq 0x6290
cmpl $0x0, %eax
je 0xc4e2
movl $0x0, 0x24(%rsp)
jmp 0xc4f4
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x6960
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/material.c
// Function: Blend
static int Blend(lua_State *L)
    {
    int val;
    material_t *material = checkmaterial(L, 1);
    if(aiGetMaterialIntegerArray(material, AI_MATKEY_BLEND_FUNC, &val, NULL) != AI_SUCCESS) 
        return 0;
    return pushblendmode(L, val);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0xa946(%rip), %rdx      # 0x16e90
callq 0x6700
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0xaab0(%rip), %rsi      # 0x17010
xorl %ecx, %ecx
leaq 0x14(%rsp), %r8
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %edx
callq 0x6290
cmpl $0x0, %eax
je 0xc582
movl $0x0, 0x24(%rsp)
jmp 0xc594
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x68c0
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/material.c
// Function: TextureCount
static int TextureCount(lua_State *L)
    {
    material_t *material = checkmaterial(L, 1);
    unsigned int type = checktexturetype(L, 2);
    unsigned int count = aiGetMaterialTextureCount(material, (enum aiTextureType)type);
    lua_pushinteger(L, count);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0xa666(%rip), %rdx      # 0x16e90
callq 0x6700
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x6760
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x67c0
movl %eax, (%rsp)
movq 0x10(%rsp), %rdi
movl (%rsp), %eax
movl %eax, %esi
callq 0x6310
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/material.c
// Function: Texture_path
static int Texture_path(lua_State *L)
    {
    material_t *material = checkmaterial(L, 1);
    unsigned int type = checktexturetype(L, 2);
    unsigned int index = checkindex(L, 3);
    return GetString(L, material, _AI_MATKEY_TEXTURE_BASE, type, index);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0xa5f6(%rip), %rdx      # 0x16e90
callq 0x6700
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x6760
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x6320
movl %eax, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %ecx
movl (%rsp), %r8d
leaq 0xa7f9(%rip), %rdx      # 0x170db
callq 0xd8c0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonassimp/src/material.c
// Function: Texture_uvwsrc
static int Texture_uvwsrc(lua_State *L)
    {
    int val;
    material_t *material = checkmaterial(L, 1);
    unsigned int type = checktexturetype(L, 2);
    unsigned int index = checkindex(L, 3);
    if(aiGetMaterialIntegerArray(material, _AI_MATKEY_UVWSRC_BASE, type, index, &val, NULL) 
        != AI_SUCCESS) return 0;
    pushindex(L, val);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0xa586(%rip), %rdx      # 0x16e90
callq 0x6700
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x6760
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rdi
movl $0x3, %esi
callq 0x6320
movl %eax, (%rsp)
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %edx
movl (%rsp), %ecx
leaq 0xa799(%rip), %rsi      # 0x170e5
leaq 0x14(%rsp), %r8
xorl %eax, %eax
movl %eax, %r9d
callq 0x6290
cmpl $0x0, %eax
je 0xc96a
movl $0x0, 0x24(%rsp)
jmp 0xc980
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x64e0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)