LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %edx, %edx
callq 0x6370
movq %rax, %r15
leaq 0x7d69(%rip), %rsi      # 0x106bb
movq %rax, %rdi
callq 0x6420
testl %eax, %eax
je 0x8a4b
leaq 0x7d57(%rip), %rsi      # 0x106c0
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8a52
leaq 0x7d48(%rip), %rsi      # 0x106c8
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8a59
leaq 0x7d37(%rip), %rsi      # 0x106ce
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8a60
leaq 0x7d26(%rip), %rsi      # 0x106d4
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8a67
leaq 0x7d14(%rip), %rsi      # 0x106d9
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8a6e
leaq 0x7d08(%rip), %rsi      # 0x106e4
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8a75
leaq 0x7cfa(%rip), %rsi      # 0x106ed
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8a7c
leaq 0x7cf5(%rip), %rsi      # 0x106fb
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8a83
leaq 0x7ced(%rip), %rsi      # 0x10706
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8a8a
leaq 0x77f2(%rip), %rsi      # 0x1021e
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x63d0
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x61c0
movl $0x1, %eax
jmp 0x8a8f
movl $0x2, %eax
jmp 0x8a8f
movl $0x3, %eax
jmp 0x8a8f
movl $0x4, %eax
jmp 0x8a8f
movl $0x5, %eax
jmp 0x8a8f
movl $0x6, %eax
jmp 0x8a8f
movl $0x7, %eax
jmp 0x8a8f
movl $0x8, %eax
jmp 0x8a8f
movl $0x9, %eax
jmp 0x8a8f
movl $0xa, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
decl %esi
cmpl $0x9, %esi
ja 0x8afe
pushq %rax
leaq 0x7b20(%rip), %rax      # 0x105c4
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x7c07(%rip), %rsi      # 0x106bb
jmp 0x8b1f
leaq 0x7c17(%rip), %rsi      # 0x106d4
jmp 0x8b1f
leaq 0x7c40(%rip), %rsi      # 0x10706
jmp 0x8b1f
leaq 0x7bf9(%rip), %rsi      # 0x106c8
jmp 0x8b1f
leaq 0x7bf6(%rip), %rsi      # 0x106ce
jmp 0x8b1f
leaq 0x7c0c(%rip), %rsi      # 0x106ed
jmp 0x8b1f
leaq 0x7bd6(%rip), %rsi      # 0x106c0
jmp 0x8b1f
leaq 0x7be6(%rip), %rsi      # 0x106d9
jmp 0x8b1f
leaq 0x7be8(%rip), %rsi      # 0x106e4
jmp 0x8b1f
leaq 0x76b1(%rip), %rsi      # 0x101b6
leaq 0x7b8b(%rip), %rdx      # 0x10697
movl $0xa4, %ecx
xorl %eax, %eax
jmp 0x67a0
leaq 0x7bdc(%rip), %rsi      # 0x106fb
callq 0x6920
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/enums.c
// Function: moonassimp_checktexturetype
unsigned int checktexturetype(lua_State *L, int arg)
    {
    const char *s = luaL_checkstring(L, arg);
#define CASE(CODE,str) if((strcmp(s, str)==0)) return CODE
    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
    return (unsigned int)luaL_argerror(L, arg, badvalue(L,s));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %r12d, %r12d
xorl %edx, %edx
callq 0x6370
movq %rax, %r15
leaq 0x76e5(%rip), %rsi      # 0x10231
movq %rax, %rdi
callq 0x6420
testl %eax, %eax
je 0x8cfa
leaq 0x851b(%rip), %rsi      # 0x1107e
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8c9c
leaq 0x851e(%rip), %rsi      # 0x11098
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8ca4
leaq 0x84fa(%rip), %rsi      # 0x1108b
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8cac
leaq 0x84fe(%rip), %rsi      # 0x110a6
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8cb4
leaq 0x7b4f(%rip), %rsi      # 0x1070e
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8cbc
leaq 0x77d9(%rip), %rsi      # 0x103af
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8cc4
leaq 0x8451(%rip), %rsi      # 0x1103e
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8ccc
leaq 0x841c(%rip), %rsi      # 0x11020
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8cd4
leaq 0x7afa(%rip), %rsi      # 0x10715
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8cdc
leaq 0x7af0(%rip), %rsi      # 0x10722
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8ce4
leaq 0x7ae2(%rip), %rsi      # 0x1072b
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8cec
leaq 0x7ad6(%rip), %rsi      # 0x10736
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8cf4
leaq 0x75a7(%rip), %rsi      # 0x1021e
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x63d0
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x61c0
movl $0x1, %r12d
jmp 0x8cfa
movl $0x2, %r12d
jmp 0x8cfa
movl $0x3, %r12d
jmp 0x8cfa
movl $0x4, %r12d
jmp 0x8cfa
movl $0x5, %r12d
jmp 0x8cfa
movl $0x6, %r12d
jmp 0x8cfa
movl $0x7, %r12d
jmp 0x8cfa
movl $0x8, %r12d
jmp 0x8cfa
movl $0x9, %r12d
jmp 0x8cfa
movl $0xa, %r12d
jmp 0x8cfa
movl $0xb, %r12d
jmp 0x8cfa
movl $0x12, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rax
cmpl $0x12, %esi
ja 0x8d63
movl %esi, %eax
leaq 0x78d4(%rip), %rcx      # 0x105ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x7509(%rip), %rsi      # 0x10231
jmp 0x8db3
leaq 0x79ee(%rip), %rsi      # 0x10722
jmp 0x8db3
leaq 0x8369(%rip), %rsi      # 0x110a6
jmp 0x8db3
leaq 0x79f0(%rip), %rsi      # 0x10736
jmp 0x8db3
leaq 0x79bf(%rip), %rsi      # 0x1070e
jmp 0x8db3
leaq 0x79d3(%rip), %rsi      # 0x1072b
jmp 0x8db3
leaq 0x832a(%rip), %rsi      # 0x1108b
jmp 0x8db3
leaq 0x744c(%rip), %rsi      # 0x101b6
leaq 0x7926(%rip), %rdx      # 0x10697
movl $0xd7, %ecx
xorl %eax, %eax
popq %r8
jmp 0x67a0
leaq 0x8312(%rip), %rsi      # 0x11098
jmp 0x8db3
leaq 0x82ef(%rip), %rsi      # 0x1107e
jmp 0x8db3
leaq 0x7617(%rip), %rsi      # 0x103af
jmp 0x8db3
leaq 0x829d(%rip), %rsi      # 0x1103e
jmp 0x8db3
leaq 0x796b(%rip), %rsi      # 0x10715
jmp 0x8db3
leaq 0x826d(%rip), %rsi      # 0x11020
callq 0x6920
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %edx, %edx
callq 0x6370
movq %rax, %r15
cmpb $0x75, (%rax)
jne 0x8dea
cmpb $0x76, 0x1(%r15)
jne 0x8dea
cmpb $0x0, 0x2(%r15)
je 0x8e84
leaq 0x7950(%rip), %rsi      # 0x10741
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8e6f
leaq 0x7944(%rip), %rsi      # 0x10748
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8e76
leaq 0x793a(%rip), %rsi      # 0x10751
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8e7d
leaq 0x792b(%rip), %rsi      # 0x10755
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8e88
leaq 0x791e(%rip), %rsi      # 0x1075b
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8e8f
leaq 0x73ce(%rip), %rsi      # 0x1021e
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x63d0
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x61c0
movl $0x1, %eax
jmp 0x8e94
movl $0x2, %eax
jmp 0x8e94
movl $0x3, %eax
jmp 0x8e94
xorl %eax, %eax
jmp 0x8e94
movl $0x4, %eax
jmp 0x8e94
movl $0x5, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpl $0x5, %esi
ja 0x8ef2
pushq %rax
movl %esi, %eax
leaq 0x778f(%rip), %rcx      # 0x10638
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x7885(%rip), %rsi      # 0x1073e
jmp 0x8ee6
leaq 0x7893(%rip), %rsi      # 0x10755
jmp 0x8ee6
leaq 0x787d(%rip), %rsi      # 0x10748
jmp 0x8ee6
leaq 0x787d(%rip), %rsi      # 0x10751
jmp 0x8ee6
leaq 0x7864(%rip), %rsi      # 0x10741
jmp 0x8ee6
leaq 0x7875(%rip), %rsi      # 0x1075b
callq 0x6920
movl $0x1, %eax
popq %rcx
retq
leaq 0x72bd(%rip), %rsi      # 0x101b6
leaq 0x7797(%rip), %rdx      # 0x10697
movl $0xfc, %ecx
xorl %eax, %eax
jmp 0x67a0
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %r12d, %r12d
xorl %edx, %edx
callq 0x6370
movq %rax, %r15
leaq 0x7834(%rip), %rsi      # 0x10761
movq %rax, %rdi
callq 0x6420
testl %eax, %eax
je 0x8fb4
leaq 0x7826(%rip), %rsi      # 0x10766
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8f9e
leaq 0x7819(%rip), %rsi      # 0x1076c
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8fa6
leaq 0x780c(%rip), %rsi      # 0x10772
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8fae
leaq 0x72a5(%rip), %rsi      # 0x1021e
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x63d0
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x61c0
movl $0x1, %r12d
jmp 0x8fb4
movl $0x3, %r12d
jmp 0x8fb4
movl $0x2, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpl $0x3, %esi
ja 0x9009
pushq %rax
movl %esi, %eax
leaq 0x767e(%rip), %rcx      # 0x10650
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x777f(%rip), %rsi      # 0x10761
jmp 0x8ffd
leaq 0x7787(%rip), %rsi      # 0x10772
jmp 0x8ffd
leaq 0x7778(%rip), %rsi      # 0x1076c
jmp 0x8ffd
leaq 0x7769(%rip), %rsi      # 0x10766
callq 0x6920
movl $0x1, %eax
popq %rcx
retq
leaq 0x71a6(%rip), %rsi      # 0x101b6
leaq 0x7680(%rip), %rdx      # 0x10697
movl $0x11e, %ecx            # imm = 0x11E
xorl %eax, %eax
jmp 0x67a0
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %r12d, %r12d
xorl %edx, %edx
callq 0x6370
movq %rax, %r15
leaq 0x7735(%rip), %rsi      # 0x10779
movq %rax, %rdi
callq 0x6420
testl %eax, %eax
je 0x9105
leaq 0x7749(%rip), %rsi      # 0x107a4
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x90df
leaq 0x7714(%rip), %rsi      # 0x10782
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x90e7
leaq 0x770a(%rip), %rsi      # 0x1078b
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x90ef
leaq 0x76fe(%rip), %rsi      # 0x10792
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x90f7
leaq 0x76f6(%rip), %rsi      # 0x1079d
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x90ff
leaq 0x7164(%rip), %rsi      # 0x1021e
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x63d0
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x61c0
movl $0x1, %r12d
jmp 0x9105
movl $0x2, %r12d
jmp 0x9105
movl $0x3, %r12d
jmp 0x9105
movl $0x4, %r12d
jmp 0x9105
movl $0x5, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpl $0x5, %esi
ja 0x916c
pushq %rax
movl %esi, %eax
leaq 0x753d(%rip), %rcx      # 0x10660
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x7646(%rip), %rsi      # 0x10779
jmp 0x9160
leaq 0x7656(%rip), %rsi      # 0x10792
jmp 0x9160
leaq 0x763d(%rip), %rsi      # 0x10782
jmp 0x9160
leaq 0x763d(%rip), %rsi      # 0x1078b
jmp 0x9160
leaq 0x764d(%rip), %rsi      # 0x107a4
jmp 0x9160
leaq 0x763d(%rip), %rsi      # 0x1079d
callq 0x6920
movl $0x1, %eax
popq %rcx
retq
leaq 0x7043(%rip), %rsi      # 0x101b6
leaq 0x751d(%rip), %rdx      # 0x10697
movl $0x143, %ecx            # imm = 0x143
xorl %eax, %eax
jmp 0x67a0
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %r12d, %r12d
xorl %edx, %edx
callq 0x6370
movq %rax, %r15
leaq 0x7601(%rip), %rsi      # 0x107a8
movq %rax, %rdi
callq 0x6420
testl %eax, %eax
je 0x922e
leaq 0x75f8(%rip), %rsi      # 0x107b2
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x9218
leaq 0x7069(%rip), %rsi      # 0x10236
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x9220
leaq 0x75de(%rip), %rsi      # 0x107be
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x9228
leaq 0x702b(%rip), %rsi      # 0x1021e
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x63d0
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x61c0
movl $0x1, %r12d
jmp 0x922e
movl $0x2, %r12d
jmp 0x922e
movl $0x3, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpl $0x3, %esi
ja 0x9283
pushq %rax
movl %esi, %eax
leaq 0x742c(%rip), %rcx      # 0x10678
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x754c(%rip), %rsi      # 0x107a8
jmp 0x9277
leaq 0x6fd1(%rip), %rsi      # 0x10236
jmp 0x9277
leaq 0x7550(%rip), %rsi      # 0x107be
jmp 0x9277
leaq 0x753b(%rip), %rsi      # 0x107b2
callq 0x6920
movl $0x1, %eax
popq %rcx
retq
leaq 0x6f2c(%rip), %rsi      # 0x101b6
leaq 0x7406(%rip), %rdx      # 0x10697
movl $0x164, %ecx            # imm = 0x164
xorl %eax, %eax
jmp 0x67a0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x7512(%rip), %rdx      # 0x107c3
movq %rcx, %rsi
callq 0x68c0
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
cmpq $0x0, 0x8(%rbx)
je 0x935b
cmpl $0x0, (%rbx)
je 0x935b
xorl %r15d, %r15d
testl %ebp, %ebp
je 0x932f
movq 0x8(%rbx), %rax
movl (%rax,%r15,4), %esi
movq %r14, %rdi
callq 0x6300
incq %r15
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r15, %rdx
callq 0x6470
movl (%rbx), %eax
cmpq %rax, %r15
jb 0x9303
jmp 0x935b
movq 0x8(%rbx), %rax
movl (%rax,%r15,4), %esi
incl %esi
movq %r14, %rdi
callq 0x6300
incq %r15
movq %r14, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r15, %rdx
callq 0x6470
movl (%rbx), %eax
cmpq %rax, %r15
jb 0x932f
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x73f0(%rip), %rdx      # 0x107c3
movl $0x1, %esi
callq 0x66f0
xorl %r15d, %r15d
cmpq $0x0, 0x8(%rax)
je 0x9421
movq %rax, %r14
movl (%rax), %esi
testl %esi, %esi
je 0x9421
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6560
cmpl $0x0, (%r14)
je 0x9421
xorl %r12d, %r12d
movq 0x8(%r14), %rax
movl (%rax,%r12,4), %esi
movq %rbx, %rdi
callq 0x64e0
incq %r12
movl (%r14), %r15d
cmpq %r15, %r12
jb 0x9406
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7381(%rip), %rdx      # 0x107c3
movl $0x1, %esi
callq 0x66f0
xorl %r15d, %r15d
cmpq $0x0, 0x8(%rax)
je 0x9490
movq %rax, %r14
movl (%rax), %esi
testl %esi, %esi
je 0x9490
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6560
cmpl $0x0, (%r14)
je 0x9490
xorl %r12d, %r12d
movq 0x8(%r14), %rax
movl (%rax,%r12,4), %esi
movq %rbx, %rdi
callq 0x6300
incq %r12
movl (%r14), %r15d
cmpq %r15, %r12
jb 0x9475
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x6370
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x6260
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x6270
movl (%r14), %esi
movq %r15, %rdi
movl %ebp, %edx
movq %rax, %rcx
callq 0x6780
movq %rbx, %rdi
testq %rax, %rax
je 0x95df
movq %rax, %rsi
callq 0x65e0
jmp 0x95e4
callq 0x64b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x72f1(%rip), %rdx      # 0x108ee
movl $0x1, %esi
callq 0x66f0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x6260
movq %r14, %rdi
movl %eax, %esi
callq 0x66e0
movq %rbx, %rdi
testq %rax, %rax
je 0x9638
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x65e0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x64b0
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x7299(%rip), %rdx      # 0x108ee
movl $0x1, %esi
callq 0x66f0
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movaps %xmm0, 0x10(%r14)
movq %rax, %rdi
movq %r14, %rsi
callq 0x6110
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
movl (%r14), %esi
movq %rbx, %rdi
callq 0x6300
leaq 0x793b(%rip), %rdx      # 0x10fd2
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x62e0
movl 0x4(%r14), %esi
movq %rbx, %rdi
callq 0x6300
leaq 0x6ce1(%rip), %rdx      # 0x10398
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x62e0
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x6300
leaq 0x6c50(%rip), %rdx      # 0x10327
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x62e0
movl 0xc(%r14), %esi
movq %rbx, %rdi
callq 0x6300
leaq 0x7208(%rip), %rdx      # 0x108ff
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x62e0
movl 0x10(%r14), %esi
movq %rbx, %rdi
callq 0x6300
leaq 0x7e3c(%rip), %rdx      # 0x11553
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x62e0
movl 0x14(%r14), %esi
movq %rbx, %rdi
callq 0x6300
leaq 0x7e2b(%rip), %rdx      # 0x11562
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x62e0
movl 0x18(%r14), %esi
movq %rbx, %rdi
callq 0x6300
leaq 0x7e17(%rip), %rdx      # 0x1156e
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x62e0
movl 0x1c(%r14), %esi
movq %rbx, %rdi
callq 0x6300
leaq 0x718e(%rip), %rdx      # 0x10905
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x62e0
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x67e0
testl %eax, %eax
je 0x97c3
movl %eax, %ebp
cmpl $0x1, %eax
jne 0x9824
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x6370
movq %rax, %rsi
jmp 0x9826
movq %rbx, %rdi
movl $0x2, %esi
callq 0x68d0
cmpl $0x6, %eax
jne 0x9875
movq %rbx, %rdi
callq 0x9929
movq %rbx, %rdi
movl $0x2, %esi
callq 0x63c0
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x6240
movl %eax, 0xece7(%rip)      # 0x184e8
leaq 0x15e(%rip), %rax       # 0x9966
movq %rax, 0xecf1(%rip)      # 0x18500
leaq 0xecea(%rip), %rdi      # 0x18500
movq %rbx, 0xeceb(%rip)      # 0x18508
callq 0x6990
jmp 0x9855
xorl %esi, %esi
movl %ebp, %edi
callq 0x6850
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
testq %rax, %rax
je 0x985e
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x6990
cmpl $0x1, %ebp
jne 0x9855
movq %rbx, 0xeca3(%rip)      # 0x184f8
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
leaq 0x70a6(%rip), %rsi      # 0x1090b
movq %rbx, %rdi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x67a0
leaq 0x70b0(%rip), %rdx      # 0x1092c
movq %rbx, %rdi
movl $0x2, %esi
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x61c0
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x1, %esi
callq 0x67e0
cmpl $0x1, %eax
je 0x98b4
testl %eax, %eax
jne 0x98d2
movq %rbx, %rdi
callq 0x9929
jmp 0x98f1
movq 0xec3d(%rip), %rdi      # 0x184f8
testq %rdi, %rdi
je 0x98f1
callq 0x6740
movq $0x0, 0xec28(%rip) # 0x184f8
jmp 0x98f1
movl %eax, %edi
xorl %esi, %esi
callq 0x6850
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
testq %rax, %rax
je 0x98f9
movq %rsp, %rdi
callq 0x6740
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x700b(%rip), %rsi      # 0x1090b
movq %rbx, %rdi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
jmp 0x67a0
// File: /workspace/github_c_makefile_star2_O3/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
callq 0x9929
callq 0x61f0
movq $0x0, 0xebd3(%rip) # 0x184f8
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq 0xeb71(%rip), %rdx      # 0x184e8
movq %rsi, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x62b0
movl $0x7e, %ecx
cmpl $0x6, %eax
jne 0x99b9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6920
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x6980
movl $0x81, %ecx
testl %eax, %eax
je 0x99d8
leaq 0x67f6(%rip), %rsi      # 0x101b6
leaq 0x6f77(%rip), %rdx      # 0x1093e
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x67a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x6f52(%rip), %rdi      # 0x10947
movq %rdx, %rsi
xorl %eax, %eax
callq 0x6710
leaq 0x6f54(%rip), %rdx      # 0x1095a
movq %r15, %rdi
movq %rbx, %rsi
callq 0x68c0
movq %r14, 0x10(%rax)
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x6940
movl %eax, %r14d
xorl %ebp, %ebp
testb $0x1, %r14b
je 0xa356
leaq 0x6b05(%rip), %rsi      # 0x10e4e
movq %rbx, %rdi
callq 0x6920
movl $0x1, %ebp
testb $0x2, %r14b
je 0xa36d
leaq 0x6af2(%rip), %rsi      # 0x10e55
movq %rbx, %rdi
callq 0x6920
incl %ebp
testb $0x4, %r14b
je 0xa384
leaq 0x6ae3(%rip), %rsi      # 0x10e5d
movq %rbx, %rdi
callq 0x6920
incl %ebp
testb $0x8, %r14b
je 0xa39b
leaq 0x6ad2(%rip), %rsi      # 0x10e63
movq %rbx, %rdi
callq 0x6920
incl %ebp
testb $0x10, %r14b
je 0xa3b2
leaq 0x6ac3(%rip), %rsi      # 0x10e6b
movq %rbx, %rdi
callq 0x6920
incl %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x6a91(%rip), %rdi      # 0x10e7a
movq %rdx, %rsi
xorl %eax, %eax
callq 0x6710
leaq 0x6a96(%rip), %rdx      # 0x10e90
movq %r15, %rdi
movq %rbx, %rsi
callq 0x68c0
movq %r14, 0x10(%rax)
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x6828(%rip), %rdx      # 0x10e90
movl $0x1, %esi
callq 0x66f0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x6750
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x6310
leaq 0x6a43(%rip), %rdx      # 0x110db
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %ecx
movl %eax, %r8d
popq %rbx
popq %r14
popq %rbp
jmp 0xb1fa
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/material.c
// Function: Texture_op
static int Texture_op(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_TEXOP_BASE, type, index, &val, NULL) 
        != AI_SUCCESS) return 0;
    pushtextureop(L, val);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6757(%rip), %rdx      # 0x10e90
movl $0x1, %esi
callq 0x66f0
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x6750
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x6310
leaq 0x6988(%rip), %rsi      # 0x110f1
xorl %r14d, %r14d
leaq 0x4(%rsp), %r8
movq %r15, %rdi
movl %ebp, %edx
movl %eax, %ecx
xorl %r9d, %r9d
callq 0x6290
testl %eax, %eax
jne 0xa796
movl 0x4(%rsp), %esi
movq %rbx, %rdi
callq 0x6360
movl $0x1, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/material.c
// Function: Texture_mapping
static int Texture_mapping(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_MAPPING_BASE, type, index, &val, NULL) 
        != AI_SUCCESS) return 0;
    pushtexturemapping(L, val);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x66db(%rip), %rdx      # 0x10e90
movl $0x1, %esi
callq 0x66f0
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x6750
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x6310
leaq 0x6914(%rip), %rsi      # 0x110f9
xorl %r14d, %r14d
leaq 0x4(%rsp), %r8
movq %r15, %rdi
movl %ebp, %edx
movl %eax, %ecx
xorl %r9d, %r9d
callq 0x6290
testl %eax, %eax
jne 0xa812
movl 0x4(%rsp), %esi
movq %rbx, %rdi
callq 0x6930
movl $0x1, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/material.c
// Function: Texture_blend
static int Texture_blend(lua_State *L)
    {
    material_t *material = checkmaterial(L, 1);
    unsigned int type = checktexturetype(L, 2);
    unsigned int index = checkindex(L, 3);
    return GetFloat(L, material, _AI_MATKEY_TEXBLEND_BASE, type, index);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x6662(%rip), %rdx      # 0x10e90
movl $0x1, %esi
callq 0x66f0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x6750
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x6310
leaq 0x68a8(%rip), %rdx      # 0x11106
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %ecx
movl %eax, %r8d
popq %rbx
popq %r14
popq %rbp
jmp 0xb2d8
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/material.c
// Function: Texture_mapmode
static int Texture_mapmode(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_MAPPINGMODE_U_BASE, type, index, &val, NULL) 
        != AI_SUCCESS) lua_pushnil(L); else pushtexturemapmode(L, val);
    if(aiGetMaterialIntegerArray(material, _AI_MATKEY_MAPPINGMODE_V_BASE, type, index, &val, NULL) 
        != AI_SUCCESS) lua_pushnil(L); else pushtexturemapmode(L, val);
    return 2;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x660d(%rip), %rdx      # 0x10e90
movl $0x1, %esi
callq 0x66f0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x6750
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x6310
movl %eax, %r15d
leaq 0x685b(%rip), %rsi      # 0x11111
leaq 0x4(%rsp), %r8
movq %r14, %rdi
movl %ebp, %edx
movl %eax, %ecx
xorl %r9d, %r9d
callq 0x6290
testl %eax, %eax
je 0xa8d8
movq %rbx, %rdi
callq 0x6800
jmp 0xa8e4
movl 0x4(%rsp), %esi
movq %rbx, %rdi
callq 0x66b0
leaq 0x6834(%rip), %rsi      # 0x1111f
leaq 0x4(%rsp), %r8
movq %r14, %rdi
movl %ebp, %edx
movl %r15d, %ecx
xorl %r9d, %r9d
callq 0x6290
testl %eax, %eax
je 0xa90e
movq %rbx, %rdi
callq 0x6800
jmp 0xa91a
movl 0x4(%rsp), %esi
movq %rbx, %rdi
callq 0x66b0
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/material.c
// Function: Texture_axis
static int Texture_axis(lua_State *L)
    {
    vector3_t vec;
    material_t *material = checkmaterial(L, 1);
    unsigned int type = checktexturetype(L, 2);
    unsigned int index = checkindex(L, 3);
    unsigned int max = sizeof(vector3_t);
    if(AI_SUCCESS != 
        aiGetMaterialFloatArray(material, _AI_MATKEY_TEXMAP_AXIS_BASE, type, index,
        (float*)&vec, &max) || sizeof(vector3_t) != max) return 0;
    return pushvector3(L, &vec, 0);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x6554(%rip), %rdx      # 0x10e90
movl $0x1, %esi
callq 0x66f0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x6750
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x6310
movq %rsp, %r9
movl $0xc, (%r9)
leaq 0x67b7(%rip), %rsi      # 0x1112d
leaq 0x4(%rsp), %r8
movq %r14, %rdi
movl %ebp, %edx
movl %eax, %ecx
callq 0x67c0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0xa9a4
cmpl $0xc, (%rsp)
jne 0xa9a4
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6600
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/material.c
// Function: Texture_uvtranslation
static int Texture_uvtranslation(lua_State *L)
    {
    struct aiUVTransform trafo;
    material_t *material = checkmaterial(L, 1);
    unsigned int type = checktexturetype(L, 2);
    unsigned int index = checkindex(L, 3);
    unsigned int max = sizeof(struct aiUVTransform);
    if(AI_SUCCESS != 
        aiGetMaterialFloatArray(material, _AI_MATKEY_UVTRANSFORM_BASE, type, index,
        (float*)&trafo, &max) || sizeof(struct aiUVTransform) != max) return 0;
    return pushvector2(L, &(trafo.mTranslation), 0);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x64d1(%rip), %rdx      # 0x10e90
movl $0x1, %esi
callq 0x66f0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x6750
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x6310
leaq 0x8(%rsp), %r9
movl $0x14, (%r9)
leaq 0x673f(%rip), %rsi      # 0x1113a
leaq 0xc(%rsp), %r8
movq %r14, %rdi
movl %ebp, %edx
movl %eax, %ecx
callq 0x67c0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0xaa2a
cmpl $0x14, 0x8(%rsp)
jne 0xaa2a
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6170
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/material.c
// Function: Texture_uvscaling
static int Texture_uvscaling(lua_State *L)
    {
    struct aiUVTransform trafo;
    material_t *material = checkmaterial(L, 1);
    unsigned int type = checktexturetype(L, 2);
    unsigned int index = checkindex(L, 3);
    unsigned int max = sizeof(struct aiUVTransform);
    if(AI_SUCCESS != 
        aiGetMaterialFloatArray(material, _AI_MATKEY_UVTRANSFORM_BASE, type, index,
        (float*)&trafo, &max) || sizeof(struct aiUVTransform) != max) return 0;
    return pushvector2(L, &(trafo.mScaling), 0);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x644b(%rip), %rdx      # 0x10e90
movl $0x1, %esi
callq 0x66f0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x6750
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x6310
leaq 0x8(%rsp), %r9
movl $0x14, (%r9)
leaq 0x66b9(%rip), %rsi      # 0x1113a
leaq 0xc(%rsp), %r8
movq %r14, %rdi
movl %ebp, %edx
movl %eax, %ecx
callq 0x67c0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0xaab0
cmpl $0x14, 0x8(%rsp)
jne 0xaab0
leaq 0x14(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6170
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/material.c
// Function: Texture_uvrotation
static int Texture_uvrotation(lua_State *L)
    {
    struct aiUVTransform trafo;
    material_t *material = checkmaterial(L, 1);
    unsigned int type = checktexturetype(L, 2);
    unsigned int index = checkindex(L, 3);
    unsigned int max = sizeof(struct aiUVTransform);
    if(AI_SUCCESS != 
        aiGetMaterialFloatArray(material, _AI_MATKEY_UVTRANSFORM_BASE, type, index,
        (float*)&trafo, &max) || sizeof(struct aiUVTransform) != max) return 0;
    lua_pushnumber(L, trafo.mRotation);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x63c5(%rip), %rdx      # 0x10e90
movl $0x1, %esi
callq 0x66f0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x6750
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x6310
leaq 0x8(%rsp), %r9
movl $0x14, (%r9)
leaq 0x6633(%rip), %rsi      # 0x1113a
leaq 0xc(%rsp), %r8
movq %r14, %rdi
movl %ebp, %edx
movl %eax, %ecx
callq 0x67c0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0xab3a
cmpl $0x14, 0x8(%rsp)
jne 0xab3a
cvtss2sd 0x1c(%rsp), %xmm0
movq %rbx, %rdi
callq 0x6500
movl $0x1, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/material.c
// Function: Texture_flags
static int Texture_flags(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_TEXFLAGS_BASE, type, index, &val, NULL) 
        != AI_SUCCESS) val = 0;
    return pushtextureflags(L, val, 1);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x633c(%rip), %rdx      # 0x10e90
movl $0x1, %esi
callq 0x66f0
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x6750
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x6310
leaq 0x65c3(%rip), %rsi      # 0x11147
xorl %r14d, %r14d
leaq 0x4(%rsp), %r8
movq %r15, %rdi
movl %ebp, %edx
movl %eax, %ecx
xorl %r9d, %r9d
callq 0x6290
testl %eax, %eax
je 0xaba9
movl $0x0, 0x4(%rsp)
jmp 0xabae
movl 0x4(%rsp), %r14d
movq %rbx, %rdi
movl %r14d, %esi
movl $0x1, %edx
callq 0x6200
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/material.c
// Function: GetString
static int GetString(lua_State *L, material_t *material, const char* pKey, unsigned int type, unsigned int index)
    {
    aistring_t s;
    if(!material) material = checkmaterial(L, 1);
    s.data[0]='\0';
    s.length = 0;
    if(aiGetMaterialString(material, pKey, type, index, &s) != AI_SUCCESS) return 0;
    lua_pushlstring(L, s.data, s.length);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movq %rdi, %rbx
testq %rsi, %rsi
jne 0xb22f
leaq 0x5c71(%rip), %rdx      # 0x10e90
movq %rbx, %rdi
movl $0x1, %esi
callq 0x66f0
movq %rax, %rsi
leaq 0x4(%rsp), %r8
movb $0x0, 0x4(%r8)
movl $0x0, (%r8)
movq %rsi, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
callq 0x6460
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0xb26d
leaq 0x8(%rsp), %rsi
movl -0x4(%rsi), %edx
movq %rbx, %rdi
callq 0x6670
movl $0x1, %eax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
retq