LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x7649(%rip), %rsi      # 0x10231
movq %rax, %rdi
callq 0x6410
testl %eax, %eax
je 0x8d96
leaq 0x847f(%rip), %rsi      # 0x1107e
movq %r15, %rdi
callq 0x6410
testl %eax, %eax
je 0x8d38
leaq 0x8482(%rip), %rsi      # 0x11098
movq %r15, %rdi
callq 0x6410
testl %eax, %eax
je 0x8d40
leaq 0x845e(%rip), %rsi      # 0x1108b
movq %r15, %rdi
callq 0x6410
testl %eax, %eax
je 0x8d48
leaq 0x8462(%rip), %rsi      # 0x110a6
movq %r15, %rdi
callq 0x6410
testl %eax, %eax
je 0x8d50
leaq 0x7ab3(%rip), %rsi      # 0x1070e
movq %r15, %rdi
callq 0x6410
testl %eax, %eax
je 0x8d58
leaq 0x773d(%rip), %rsi      # 0x103af
movq %r15, %rdi
callq 0x6410
testl %eax, %eax
je 0x8d60
leaq 0x83b5(%rip), %rsi      # 0x1103e
movq %r15, %rdi
callq 0x6410
testl %eax, %eax
je 0x8d68
leaq 0x8380(%rip), %rsi      # 0x11020
movq %r15, %rdi
callq 0x6410
testl %eax, %eax
je 0x8d70
leaq 0x7a5e(%rip), %rsi      # 0x10715
movq %r15, %rdi
callq 0x6410
testl %eax, %eax
je 0x8d78
leaq 0x7a54(%rip), %rsi      # 0x10722
movq %r15, %rdi
callq 0x6410
testl %eax, %eax
je 0x8d80
leaq 0x7a46(%rip), %rsi      # 0x1072b
movq %r15, %rdi
callq 0x6410
testl %eax, %eax
je 0x8d88
leaq 0x7a3a(%rip), %rsi      # 0x10736
movq %r15, %rdi
callq 0x6410
testl %eax, %eax
je 0x8d90
leaq 0x750b(%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 0x8d96
movl $0x2, %r12d
jmp 0x8d96
movl $0x3, %r12d
jmp 0x8d96
movl $0x4, %r12d
jmp 0x8d96
movl $0x5, %r12d
jmp 0x8d96
movl $0x6, %r12d
jmp 0x8d96
movl $0x7, %r12d
jmp 0x8d96
movl $0x8, %r12d
jmp 0x8d96
movl $0x9, %r12d
jmp 0x8d96
movl $0xa, %r12d
jmp 0x8d96
movl $0xb, %r12d
jmp 0x8d96
movl $0x12, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8dff
movl %esi, %eax
leaq 0x7838(%rip), %rcx      # 0x105ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x746d(%rip), %rsi      # 0x10231
jmp 0x8e4f
leaq 0x7952(%rip), %rsi      # 0x10722
jmp 0x8e4f
leaq 0x82cd(%rip), %rsi      # 0x110a6
jmp 0x8e4f
leaq 0x7954(%rip), %rsi      # 0x10736
jmp 0x8e4f
leaq 0x7923(%rip), %rsi      # 0x1070e
jmp 0x8e4f
leaq 0x7937(%rip), %rsi      # 0x1072b
jmp 0x8e4f
leaq 0x828e(%rip), %rsi      # 0x1108b
jmp 0x8e4f
leaq 0x73b0(%rip), %rsi      # 0x101b6
leaq 0x788a(%rip), %rdx      # 0x10697
movl $0xd7, %ecx
xorl %eax, %eax
popq %r8
jmp 0x67a0
leaq 0x8276(%rip), %rsi      # 0x11098
jmp 0x8e4f
leaq 0x8253(%rip), %rsi      # 0x1107e
jmp 0x8e4f
leaq 0x757b(%rip), %rsi      # 0x103af
jmp 0x8e4f
leaq 0x8201(%rip), %rsi      # 0x1103e
jmp 0x8e4f
leaq 0x78cf(%rip), %rsi      # 0x10715
jmp 0x8e4f
leaq 0x81d1(%rip), %rsi      # 0x11020
callq 0x6920
movl $0x1, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %r12d, %r12d
xorl %edx, %edx
callq 0x6370
movq %rax, %r15
leaq 0x78c2(%rip), %rsi      # 0x1073e
movq %rax, %rdi
callq 0x6410
testl %eax, %eax
je 0x8f3d
leaq 0x78ae(%rip), %rsi      # 0x10741
movq %r15, %rdi
callq 0x6410
testl %eax, %eax
je 0x8f17
leaq 0x78a2(%rip), %rsi      # 0x10748
movq %r15, %rdi
callq 0x6410
testl %eax, %eax
je 0x8f1f
leaq 0x7898(%rip), %rsi      # 0x10751
movq %r15, %rdi
callq 0x6410
testl %eax, %eax
je 0x8f27
leaq 0x7889(%rip), %rsi      # 0x10755
movq %r15, %rdi
callq 0x6410
testl %eax, %eax
je 0x8f2f
leaq 0x787c(%rip), %rsi      # 0x1075b
movq %r15, %rdi
callq 0x6410
testl %eax, %eax
je 0x8f37
leaq 0x732c(%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 0x8f3d
movl $0x2, %r12d
jmp 0x8f3d
movl $0x3, %r12d
jmp 0x8f3d
movl $0x4, %r12d
jmp 0x8f3d
movl $0x5, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8fa4
pushq %rax
movl %esi, %eax
leaq 0x76dd(%rip), %rcx      # 0x10638
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x77d3(%rip), %rsi      # 0x1073e
jmp 0x8f98
leaq 0x77e1(%rip), %rsi      # 0x10755
jmp 0x8f98
leaq 0x77cb(%rip), %rsi      # 0x10748
jmp 0x8f98
leaq 0x77cb(%rip), %rsi      # 0x10751
jmp 0x8f98
leaq 0x77b2(%rip), %rsi      # 0x10741
jmp 0x8f98
leaq 0x77c3(%rip), %rsi      # 0x1075b
callq 0x6920
movl $0x1, %eax
popq %rcx
retq
leaq 0x720b(%rip), %rsi      # 0x101b6
leaq 0x76e5(%rip), %rdx      # 0x10697
movl $0xfc, %ecx
xorl %eax, %eax
jmp 0x67a0
// File: /workspace/github_c_makefile_star2_O1/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 0x7782(%rip), %rsi      # 0x10761
movq %rax, %rdi
callq 0x6410
testl %eax, %eax
je 0x9066
leaq 0x7774(%rip), %rsi      # 0x10766
movq %r15, %rdi
callq 0x6410
testl %eax, %eax
je 0x9050
leaq 0x7767(%rip), %rsi      # 0x1076c
movq %r15, %rdi
callq 0x6410
testl %eax, %eax
je 0x9058
leaq 0x775a(%rip), %rsi      # 0x10772
movq %r15, %rdi
callq 0x6410
testl %eax, %eax
je 0x9060
leaq 0x71f3(%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 0x9066
movl $0x3, %r12d
jmp 0x9066
movl $0x2, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x90bb
pushq %rax
movl %esi, %eax
leaq 0x75cc(%rip), %rcx      # 0x10650
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x76cd(%rip), %rsi      # 0x10761
jmp 0x90af
leaq 0x76d5(%rip), %rsi      # 0x10772
jmp 0x90af
leaq 0x76c6(%rip), %rsi      # 0x1076c
jmp 0x90af
leaq 0x76b7(%rip), %rsi      # 0x10766
callq 0x6920
movl $0x1, %eax
popq %rcx
retq
leaq 0x70f4(%rip), %rsi      # 0x101b6
leaq 0x75ce(%rip), %rdx      # 0x10697
movl $0x11e, %ecx            # imm = 0x11E
xorl %eax, %eax
jmp 0x67a0
// File: /workspace/github_c_makefile_star2_O1/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 0x7683(%rip), %rsi      # 0x10779
movq %rax, %rdi
callq 0x6410
testl %eax, %eax
je 0x91b7
leaq 0x7697(%rip), %rsi      # 0x107a4
movq %r15, %rdi
callq 0x6410
testl %eax, %eax
je 0x9191
leaq 0x7662(%rip), %rsi      # 0x10782
movq %r15, %rdi
callq 0x6410
testl %eax, %eax
je 0x9199
leaq 0x7658(%rip), %rsi      # 0x1078b
movq %r15, %rdi
callq 0x6410
testl %eax, %eax
je 0x91a1
leaq 0x764c(%rip), %rsi      # 0x10792
movq %r15, %rdi
callq 0x6410
testl %eax, %eax
je 0x91a9
leaq 0x7644(%rip), %rsi      # 0x1079d
movq %r15, %rdi
callq 0x6410
testl %eax, %eax
je 0x91b1
leaq 0x70b2(%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 0x91b7
movl $0x2, %r12d
jmp 0x91b7
movl $0x3, %r12d
jmp 0x91b7
movl $0x4, %r12d
jmp 0x91b7
movl $0x5, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x921e
pushq %rax
movl %esi, %eax
leaq 0x748b(%rip), %rcx      # 0x10660
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x7594(%rip), %rsi      # 0x10779
jmp 0x9212
leaq 0x75a4(%rip), %rsi      # 0x10792
jmp 0x9212
leaq 0x758b(%rip), %rsi      # 0x10782
jmp 0x9212
leaq 0x758b(%rip), %rsi      # 0x1078b
jmp 0x9212
leaq 0x759b(%rip), %rsi      # 0x107a4
jmp 0x9212
leaq 0x758b(%rip), %rsi      # 0x1079d
callq 0x6920
movl $0x1, %eax
popq %rcx
retq
leaq 0x6f91(%rip), %rsi      # 0x101b6
leaq 0x746b(%rip), %rdx      # 0x10697
movl $0x143, %ecx            # imm = 0x143
xorl %eax, %eax
jmp 0x67a0
// File: /workspace/github_c_makefile_star2_O1/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 0x754f(%rip), %rsi      # 0x107a8
movq %rax, %rdi
callq 0x6410
testl %eax, %eax
je 0x92e0
leaq 0x7546(%rip), %rsi      # 0x107b2
movq %r15, %rdi
callq 0x6410
testl %eax, %eax
je 0x92ca
leaq 0x6fb7(%rip), %rsi      # 0x10236
movq %r15, %rdi
callq 0x6410
testl %eax, %eax
je 0x92d2
leaq 0x752c(%rip), %rsi      # 0x107be
movq %r15, %rdi
callq 0x6410
testl %eax, %eax
je 0x92da
leaq 0x6f79(%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 0x92e0
movl $0x2, %r12d
jmp 0x92e0
movl $0x3, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9335
pushq %rax
movl %esi, %eax
leaq 0x737a(%rip), %rcx      # 0x10678
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x749a(%rip), %rsi      # 0x107a8
jmp 0x9329
leaq 0x6f1f(%rip), %rsi      # 0x10236
jmp 0x9329
leaq 0x749e(%rip), %rsi      # 0x107be
jmp 0x9329
leaq 0x7489(%rip), %rsi      # 0x107b2
callq 0x6920
movl $0x1, %eax
popq %rcx
retq
leaq 0x6e7a(%rip), %rsi      # 0x101b6
leaq 0x7354(%rip), %rdx      # 0x10697
movl $0x164, %ecx            # imm = 0x164
xorl %eax, %eax
jmp 0x67a0
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x7462(%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_O1/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 0x9418
cmpl $0x0, (%rbx)
je 0x9418
movl (%rbx), %eax
testl %ebp, %ebp
je 0x93e5
testl %eax, %eax
je 0x9418
xorl %r15d, %r15d
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 0x6460
movl (%rbx), %eax
cmpq %rax, %r15
jb 0x93b9
jmp 0x9418
testl %eax, %eax
je 0x9418
xorl %r15d, %r15d
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 0x6460
movl (%rbx), %eax
cmpq %rax, %r15
jb 0x93ec
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
leaq 0x7336(%rip), %rdx      # 0x107c3
movl $0x1, %esi
callq 0x66f0
movq %rax, %r14
xorl %eax, %eax
cmpq $0x0, 0x8(%r14)
je 0x94d9
movl (%r14), %esi
testl %esi, %esi
je 0x94d9
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6550
movl (%r14), %eax
testl %eax, %eax
je 0x94d9
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movl (%rax,%r15,4), %esi
movq %rbx, %rdi
callq 0x64d0
incq %r15
movl (%r14), %eax
cmpq %rax, %r15
jb 0x94be
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
leaq 0x72d5(%rip), %rdx      # 0x107c3
movl $0x1, %esi
callq 0x66f0
movq %rax, %r14
xorl %eax, %eax
cmpq $0x0, 0x8(%r14)
je 0x953a
movl (%r14), %esi
testl %esi, %esi
je 0x953a
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6550
movl (%r14), %eax
testl %eax, %eax
je 0x953a
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movl (%rax,%r15,4), %esi
movq %rbx, %rdi
callq 0x6300
incq %r15
movl (%r14), %eax
cmpq %rax, %r15
jb 0x951f
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movb $0x0, (%r14)
movl $0x0, -0x4(%r14)
leaq 0x4(%rsp), %rdi
callq 0x6320
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6920
movl $0x1, %eax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x6370
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x6260
movq %r14, %rdi
movl %eax, %esi
callq 0x63a0
movq %rbx, %rdi
testq %rax, %rax
je 0x9614
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x65e0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x64a0
// File: /workspace/github_c_makefile_star2_O1/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 0x967f
movq %rax, %rsi
callq 0x65e0
jmp 0x9684
callq 0x64a0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7251(%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 0x96d8
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x65e0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x64a0
// File: /workspace/github_c_makefile_star2_O1/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 0x71f9(%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 0x789b(%rip), %rdx      # 0x10fd2
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x62e0
movl 0x4(%r14), %esi
movq %rbx, %rdi
callq 0x6300
leaq 0x6c41(%rip), %rdx      # 0x10398
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x62e0
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x6300
leaq 0x6bb0(%rip), %rdx      # 0x10327
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x62e0
movl 0xc(%r14), %esi
movq %rbx, %rdi
callq 0x6300
leaq 0x7168(%rip), %rdx      # 0x108ff
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x62e0
movl 0x10(%r14), %esi
movq %rbx, %rdi
callq 0x6300
leaq 0x7d9c(%rip), %rdx      # 0x11553
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x62e0
movl 0x14(%r14), %esi
movq %rbx, %rdi
callq 0x6300
leaq 0x7d8b(%rip), %rdx      # 0x11562
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x62e0
movl 0x18(%r14), %esi
movq %rbx, %rdi
callq 0x6300
leaq 0x7d77(%rip), %rdx      # 0x1156e
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x62e0
movl 0x1c(%r14), %esi
movq %rbx, %rdi
callq 0x6300
leaq 0x70ee(%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_O1/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 0x9863
movl %eax, %ebp
cmpl $0x1, %eax
jne 0x98c4
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x6370
movq %rax, %rsi
jmp 0x98c6
movq %rbx, %rdi
movl $0x2, %esi
callq 0x68d0
cmpl $0x6, %eax
jne 0x9915
movq %rbx, %rdi
callq 0x99c9
movq %rbx, %rdi
movl $0x2, %esi
callq 0x63c0
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x6240
movl %eax, 0xec47(%rip)      # 0x184e8
leaq 0x15e(%rip), %rax       # 0x9a06
movq %rax, 0xec51(%rip)      # 0x18500
leaq 0xec4a(%rip), %rdi      # 0x18500
movq %rbx, 0xec4b(%rip)      # 0x18508
callq 0x6990
jmp 0x98f5
xorl %esi, %esi
movl %ebp, %edi
callq 0x6850
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
testq %rax, %rax
je 0x98fe
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x6990
cmpl $0x1, %ebp
jne 0x98f5
movq %rbx, 0xec03(%rip)      # 0x184f8
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
leaq 0x7006(%rip), %rsi      # 0x1090b
movq %rbx, %rdi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x67a0
leaq 0x7010(%rip), %rdx      # 0x1092c
movq %rbx, %rdi
movl $0x2, %esi
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x61c0
// File: /workspace/github_c_makefile_star2_O1/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 0x9954
testl %eax, %eax
jne 0x9972
movq %rbx, %rdi
callq 0x99c9
jmp 0x9991
movq 0xeb9d(%rip), %rdi      # 0x184f8
testq %rdi, %rdi
je 0x9991
callq 0x6740
movq $0x0, 0xeb88(%rip) # 0x184f8
jmp 0x9991
movl %eax, %edi
xorl %esi, %esi
callq 0x6850
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
testq %rax, %rax
je 0x9999
movq %rsp, %rdi
callq 0x6740
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x6f6b(%rip), %rsi      # 0x1090b
movq %rbx, %rdi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
jmp 0x67a0
// File: /workspace/github_c_makefile_star2_O1/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 0x99c9
callq 0x61f0
movq $0x0, 0xeb33(%rip) # 0x184f8
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xead1(%rip), %rdx      # 0x184e8
movq %rsi, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x62b0
movl $0x7e, %ecx
cmpl $0x6, %eax
jne 0x9a59
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 0x9a78
leaq 0x6756(%rip), %rsi      # 0x101b6
leaq 0x6ed7(%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_O1/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 0x6eb2(%rip), %rdi      # 0x10947
movq %rdx, %rsi
xorl %eax, %eax
callq 0x6710
leaq 0x6eb4(%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_O1/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:
pushq %rbx
movq %rdi, %rbx
callq 0x61d0
movl %eax, %esi
movq %rbx, %rdi
callq 0x6300
callq 0x6790
movl %eax, %esi
movq %rbx, %rdi
callq 0x6300
callq 0x60e0
movl %eax, %esi
movq %rbx, %rdi
callq 0x6300
movl $0x3, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa3f6
leaq 0x6a65(%rip), %rsi      # 0x10e4e
movq %rbx, %rdi
callq 0x6920
movl $0x1, %ebp
testb $0x2, %r14b
je 0xa40d
leaq 0x6a52(%rip), %rsi      # 0x10e55
movq %rbx, %rdi
callq 0x6920
incl %ebp
testb $0x4, %r14b
je 0xa424
leaq 0x6a43(%rip), %rsi      # 0x10e5d
movq %rbx, %rdi
callq 0x6920
incl %ebp
testb $0x8, %r14b
je 0xa43b
leaq 0x6a32(%rip), %rsi      # 0x10e63
movq %rbx, %rdi
callq 0x6920
incl %ebp
testb $0x10, %r14b
je 0xa452
leaq 0x6a23(%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_O1/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 0x69f1(%rip), %rdi      # 0x10e7a
movq %rdx, %rsi
xorl %eax, %eax
callq 0x6710
leaq 0x69f6(%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_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x67d1(%rip), %rdx      # 0x10e90
movl $0x1, %esi
callq 0x66f0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x6750
movq %r14, %rdi
movl %eax, %esi
callq 0x67b0
movl %eax, %esi
movq %rbx, %rdi
callq 0x6300
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6788(%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 0x69a3(%rip), %rdx      # 0x110db
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %ecx
movl %eax, %r8d
popq %rbx
popq %r14
popq %rbp
jmp 0xb287
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6733(%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 0x6958(%rip), %rsi      # 0x110e5
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 0xa7ba
movl 0x4(%rsp), %esi
movq %rbx, %rdi
callq 0x64d0
movl $0x1, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x66b7(%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 0x68e8(%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 0xa836
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_O1/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 0x663b(%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 0x6874(%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 0xa8b2
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_O1/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 0x65c2(%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 0x6808(%rip), %rdx      # 0x11106
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %ecx
movl %eax, %r8d
popq %rbx
popq %r14
popq %rbp
jmp 0xb365
// File: /workspace/github_c_makefile_star2_O1/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 0x656d(%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 0x67bb(%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 0xa978
movq %rbx, %rdi
callq 0x6800
jmp 0xa984
movl 0x4(%rsp), %esi
movq %rbx, %rdi
callq 0x66b0
leaq 0x6794(%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 0xa9ae
movq %rbx, %rdi
callq 0x6800
jmp 0xa9ba
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_O1/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 0x64b4(%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 0x6717(%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 0xaa44
cmpl $0xc, (%rsp)
jne 0xaa44
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_O1/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 0x6431(%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 0x669f(%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 0xaaca
cmpl $0x14, 0x8(%rsp)
jne 0xaaca
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_O1/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 0x63ab(%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 0x6619(%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 0xab50
cmpl $0x14, 0x8(%rsp)
jne 0xab50
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_O1/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 0x6325(%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 0x6593(%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 0xabda
cmpl $0x14, 0x8(%rsp)
jne 0xabda
cvtss2sd 0x1c(%rsp), %xmm0
movq %rbx, %rdi
callq 0x64f0
movl $0x1, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x629b(%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 0x6522(%rip), %rsi      # 0x11147
leaq 0xc(%rsp), %r8
movq %r14, %rdi
movl %ebp, %edx
movl %eax, %ecx
xorl %r9d, %r9d
callq 0x6290
testl %eax, %eax
je 0xac45
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x6200
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb2bc
leaq 0x5be4(%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 0x6450
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0xb2fa
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