LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x7762(%rip), %rsi      # 0x10231
movq %rax, %rdi
callq 0x6420
testl %eax, %eax
je 0x8c43
leaq 0x8598(%rip), %rsi      # 0x1107e
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8c13
leaq 0x859b(%rip), %rsi      # 0x11098
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8c17
leaq 0x8577(%rip), %rsi      # 0x1108b
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8c1b
leaq 0x857b(%rip), %rsi      # 0x110a6
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8c1f
leaq 0x7bcc(%rip), %rsi      # 0x1070e
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8c23
leaq 0x7856(%rip), %rsi      # 0x103af
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8c27
leaq 0x84ce(%rip), %rsi      # 0x1103e
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8c2b
leaq 0x8499(%rip), %rsi      # 0x11020
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8c2f
leaq 0x7b77(%rip), %rsi      # 0x10715
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8c33
leaq 0x7b6d(%rip), %rsi      # 0x10722
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8c37
leaq 0x7b63(%rip), %rsi      # 0x1072b
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8c3b
leaq 0x7b5b(%rip), %rsi      # 0x10736
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8c3f
leaq 0x7630(%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
pushq $0x1
jmp 0x8c41
pushq $0x2
jmp 0x8c41
pushq $0x3
jmp 0x8c41
pushq $0x4
jmp 0x8c41
pushq $0x5
jmp 0x8c41
pushq $0x6
jmp 0x8c41
pushq $0x7
jmp 0x8c41
pushq $0x8
jmp 0x8c41
pushq $0x9
jmp 0x8c41
pushq $0xa
jmp 0x8c41
pushq $0xb
jmp 0x8c41
pushq $0x12
popq %r12
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8cac
movl %esi, %eax
leaq 0x798b(%rip), %rcx      # 0x105ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x75c0(%rip), %rsi      # 0x10231
jmp 0x8cfc
leaq 0x7aa5(%rip), %rsi      # 0x10722
jmp 0x8cfc
leaq 0x8420(%rip), %rsi      # 0x110a6
jmp 0x8cfc
leaq 0x7aa7(%rip), %rsi      # 0x10736
jmp 0x8cfc
leaq 0x7a76(%rip), %rsi      # 0x1070e
jmp 0x8cfc
leaq 0x7a8a(%rip), %rsi      # 0x1072b
jmp 0x8cfc
leaq 0x83e1(%rip), %rsi      # 0x1108b
jmp 0x8cfc
leaq 0x7503(%rip), %rsi      # 0x101b6
leaq 0x79dd(%rip), %rdx      # 0x10697
movl $0xd7, %ecx
xorl %eax, %eax
popq %r8
jmp 0x67a0
leaq 0x83c9(%rip), %rsi      # 0x11098
jmp 0x8cfc
leaq 0x83a6(%rip), %rsi      # 0x1107e
jmp 0x8cfc
leaq 0x76ce(%rip), %rsi      # 0x103af
jmp 0x8cfc
leaq 0x8354(%rip), %rsi      # 0x1103e
jmp 0x8cfc
leaq 0x7a22(%rip), %rsi      # 0x10715
jmp 0x8cfc
leaq 0x8324(%rip), %rsi      # 0x11020
callq 0x6920
pushq $0x1
popq %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8d31
cmpb $0x76, 0x1(%r15)
jne 0x8d31
cmpb $0x0, 0x2(%r15)
je 0x8dc2
leaq 0x7a09(%rip), %rsi      # 0x10741
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8db6
leaq 0x79fd(%rip), %rsi      # 0x10748
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8dba
leaq 0x79f3(%rip), %rsi      # 0x10751
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8dbe
leaq 0x79e4(%rip), %rsi      # 0x10755
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8dc6
leaq 0x79d7(%rip), %rsi      # 0x1075b
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8dca
leaq 0x7487(%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
pushq $0x1
jmp 0x8dcc
pushq $0x2
jmp 0x8dcc
pushq $0x3
jmp 0x8dcc
xorl %eax, %eax
jmp 0x8dcd
pushq $0x4
jmp 0x8dcc
pushq $0x5
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8e29
pushq %rax
movl %esi, %eax
leaq 0x7856(%rip), %rcx      # 0x10638
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x794c(%rip), %rsi      # 0x1073e
jmp 0x8e1f
leaq 0x795a(%rip), %rsi      # 0x10755
jmp 0x8e1f
leaq 0x7944(%rip), %rsi      # 0x10748
jmp 0x8e1f
leaq 0x7944(%rip), %rsi      # 0x10751
jmp 0x8e1f
leaq 0x792b(%rip), %rsi      # 0x10741
jmp 0x8e1f
leaq 0x793c(%rip), %rsi      # 0x1075b
callq 0x6920
pushq $0x1
popq %rax
popq %rcx
retq
leaq 0x7386(%rip), %rsi      # 0x101b6
leaq 0x7860(%rip), %rdx      # 0x10697
movl $0xfc, %ecx
xorl %eax, %eax
jmp 0x67a0
// File: /workspace/github_c_makefile_star2_O2/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 0x78fd(%rip), %rsi      # 0x10761
movq %rax, %rdi
callq 0x6420
testl %eax, %eax
je 0x8ee1
leaq 0x78ef(%rip), %rsi      # 0x10766
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8ed5
leaq 0x78e2(%rip), %rsi      # 0x1076c
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8ed9
leaq 0x78d5(%rip), %rsi      # 0x10772
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x8edd
leaq 0x736e(%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
pushq $0x1
jmp 0x8edf
pushq $0x3
jmp 0x8edf
pushq $0x2
popq %r12
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8f34
pushq %rax
movl %esi, %eax
leaq 0x7751(%rip), %rcx      # 0x10650
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x7852(%rip), %rsi      # 0x10761
jmp 0x8f2a
leaq 0x785a(%rip), %rsi      # 0x10772
jmp 0x8f2a
leaq 0x784b(%rip), %rsi      # 0x1076c
jmp 0x8f2a
leaq 0x783c(%rip), %rsi      # 0x10766
callq 0x6920
pushq $0x1
popq %rax
popq %rcx
retq
leaq 0x727b(%rip), %rsi      # 0x101b6
leaq 0x7755(%rip), %rdx      # 0x10697
movl $0x11e, %ecx            # imm = 0x11E
xorl %eax, %eax
jmp 0x67a0
// File: /workspace/github_c_makefile_star2_O2/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 0x780a(%rip), %rsi      # 0x10779
movq %rax, %rdi
callq 0x6420
testl %eax, %eax
je 0x901e
leaq 0x781e(%rip), %rsi      # 0x107a4
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x900a
leaq 0x77e9(%rip), %rsi      # 0x10782
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x900e
leaq 0x77df(%rip), %rsi      # 0x1078b
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x9012
leaq 0x77d3(%rip), %rsi      # 0x10792
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x9016
leaq 0x77cb(%rip), %rsi      # 0x1079d
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x901a
leaq 0x7239(%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
pushq $0x1
jmp 0x901c
pushq $0x2
jmp 0x901c
pushq $0x3
jmp 0x901c
pushq $0x4
jmp 0x901c
pushq $0x5
popq %r12
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9083
pushq %rax
movl %esi, %eax
leaq 0x7624(%rip), %rcx      # 0x10660
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x772d(%rip), %rsi      # 0x10779
jmp 0x9079
leaq 0x773d(%rip), %rsi      # 0x10792
jmp 0x9079
leaq 0x7724(%rip), %rsi      # 0x10782
jmp 0x9079
leaq 0x7724(%rip), %rsi      # 0x1078b
jmp 0x9079
leaq 0x7734(%rip), %rsi      # 0x107a4
jmp 0x9079
leaq 0x7724(%rip), %rsi      # 0x1079d
callq 0x6920
pushq $0x1
popq %rax
popq %rcx
retq
leaq 0x712c(%rip), %rsi      # 0x101b6
leaq 0x7606(%rip), %rdx      # 0x10697
movl $0x143, %ecx            # imm = 0x143
xorl %eax, %eax
jmp 0x67a0
// File: /workspace/github_c_makefile_star2_O2/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 0x76ea(%rip), %rsi      # 0x107a8
movq %rax, %rdi
callq 0x6420
testl %eax, %eax
je 0x913b
leaq 0x76e1(%rip), %rsi      # 0x107b2
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x912f
leaq 0x7152(%rip), %rsi      # 0x10236
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x9133
leaq 0x76c7(%rip), %rsi      # 0x107be
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x9137
leaq 0x7114(%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
pushq $0x1
jmp 0x9139
pushq $0x2
jmp 0x9139
pushq $0x3
popq %r12
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x918e
pushq %rax
movl %esi, %eax
leaq 0x751f(%rip), %rcx      # 0x10678
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x763f(%rip), %rsi      # 0x107a8
jmp 0x9184
leaq 0x70c4(%rip), %rsi      # 0x10236
jmp 0x9184
leaq 0x7643(%rip), %rsi      # 0x107be
jmp 0x9184
leaq 0x762e(%rip), %rsi      # 0x107b2
callq 0x6920
pushq $0x1
popq %rax
popq %rcx
retq
leaq 0x7021(%rip), %rsi      # 0x101b6
leaq 0x74fb(%rip), %rdx      # 0x10697
movl $0x164, %ecx            # imm = 0x164
xorl %eax, %eax
jmp 0x67a0
// File: /workspace/github_c_makefile_star2_O2/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 0x760a(%rip), %rdx      # 0x107c3
movq %rcx, %rsi
callq 0x68c0
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9268
movl (%rbx), %eax
testl %eax, %eax
je 0x9268
xorl %r15d, %r15d
testl %ebp, %ebp
je 0x9238
pushq $-0x2
popq %rbp
movl %eax, %eax
cmpq %rax, %r15
jae 0x9268
movq 0x8(%rbx), %rax
movl (%rax,%r15,4), %esi
movq %r14, %rdi
callq 0x6300
incq %r15
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x6470
movl (%rbx), %eax
jmp 0x920d
pushq $-0x2
popq %rbp
movl %eax, %eax
cmpq %rax, %r15
jae 0x9268
movq 0x8(%rbx), %rax
movl (%rax,%r15,4), %esi
incl %esi
movq %r14, %rdi
callq 0x6300
incq %r15
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x6470
movl (%rbx), %eax
jmp 0x923b
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/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 0x74e4(%rip), %rdx      # 0x107c3
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
xorl %eax, %eax
cmpq $0x0, 0x8(%r14)
je 0x9324
movl (%r14), %esi
testl %esi, %esi
je 0x9324
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6560
movl (%r14), %eax
cmpq %rax, %r15
jae 0x9324
movq 0x8(%r14), %rax
movl (%rax,%r15,4), %esi
movq %rbx, %rdi
callq 0x64e0
incq %r15
jmp 0x9307
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x748a(%rip), %rdx      # 0x107c3
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
xorl %eax, %eax
cmpq $0x0, 0x8(%r14)
je 0x937e
movl (%r14), %esi
testl %esi, %esi
je 0x937e
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6560
movl (%r14), %eax
cmpq %rax, %r15
jae 0x937e
movq 0x8(%r14), %rax
movl (%rax,%r15,4), %esi
movq %rbx, %rdi
callq 0x6300
incq %r15
jmp 0x9361
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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)
andl $0x0, -0x4(%r14)
leaq 0x4(%rsp), %rdi
callq 0x6320
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6920
pushq $0x1
popq %rax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x6370
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x6260
movq %r14, %rdi
movl %eax, %esi
callq 0x63a0
movq %rbx, %rdi
testq %rax, %rax
je 0x9451
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_O2/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
pushq $0x1
popq %rsi
movq %rsp, %r14
movq %r14, %rdx
callq 0x6370
movq %rax, %r15
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x6260
movl %eax, %ebp
pushq $0x3
popq %rsi
movq %rbx, %rdi
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 0x94b6
movq %rax, %rsi
callq 0x65e0
jmp 0x94bb
callq 0x64b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x741a(%rip), %rdx      # 0x108ee
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x6260
movq %r14, %rdi
movl %eax, %esi
callq 0x66e0
movq %rbx, %rdi
testq %rax, %rax
je 0x950b
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_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x73c3(%rip), %rdx      # 0x108ee
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x66f0
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
movaps %xmm0, 0x10(%r15)
movq %rax, %rdi
movq %r15, %rsi
callq 0x6110
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
movl (%r15), %esi
movq %r14, %rdi
callq 0x6300
leaq 0x7a65(%rip), %rdx      # 0x10fd2
pushq $-0x2
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
callq 0x62e0
movl 0x4(%r15), %esi
movq %r14, %rdi
callq 0x6300
leaq 0x6e0b(%rip), %rdx      # 0x10398
movq %r14, %rdi
movl %ebp, %esi
callq 0x62e0
movl 0x8(%r15), %esi
movq %r14, %rdi
callq 0x6300
leaq 0x6d7d(%rip), %rdx      # 0x10327
movq %r14, %rdi
movl %ebp, %esi
callq 0x62e0
movl 0xc(%r15), %esi
movq %r14, %rdi
callq 0x6300
leaq 0x7338(%rip), %rdx      # 0x108ff
movq %r14, %rdi
movl %ebp, %esi
callq 0x62e0
movl 0x10(%r15), %esi
movq %r14, %rdi
callq 0x6300
leaq 0x7f6f(%rip), %rdx      # 0x11553
movq %r14, %rdi
movl %ebp, %esi
callq 0x62e0
movl 0x14(%r15), %esi
movq %r14, %rdi
callq 0x6300
leaq 0x7f61(%rip), %rdx      # 0x11562
movq %r14, %rdi
movl %ebp, %esi
callq 0x62e0
movl 0x18(%r15), %esi
movq %r14, %rdi
callq 0x6300
leaq 0x7f50(%rip), %rdx      # 0x1156e
movq %r14, %rdi
movl %ebp, %esi
callq 0x62e0
movl 0x1c(%r15), %esi
movq %r14, %rdi
callq 0x6300
leaq 0x72ca(%rip), %rdx      # 0x10905
movq %r14, %rdi
movl %ebp, %esi
callq 0x62e0
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x67e0
testl %eax, %eax
je 0x9680
movl %eax, %ebp
cmpl $0x1, %eax
jne 0x96dd
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6370
movq %rax, %rsi
jmp 0x96df
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x68d0
cmpl $0x6, %eax
jne 0x972e
movq %rbx, %rdi
callq 0x97d8
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x63c0
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x6240
movl %eax, 0xfe2e(%rip)      # 0x194e8
leaq 0x154(%rip), %rax       # 0x9815
movq %rax, 0xfe38(%rip)      # 0x19500
leaq 0xfe31(%rip), %rdi      # 0x19500
movq %rbx, 0xfe32(%rip)      # 0x19508
callq 0x6990
jmp 0x970e
xorl %esi, %esi
movl %ebp, %edi
callq 0x6850
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
testq %rax, %rax
je 0x9717
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x6990
cmpl $0x1, %ebp
jne 0x970e
movq %rbx, 0xfdea(%rip)      # 0x194f8
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
leaq 0x71ed(%rip), %rsi      # 0x1090b
movq %rbx, %rdi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x67a0
leaq 0x71f7(%rip), %rdx      # 0x1092c
pushq $0x2
popq %rsi
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x61c0
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x67e0
cmpl $0x1, %eax
je 0x9769
testl %eax, %eax
jne 0x9784
movq %rbx, %rdi
callq 0x97d8
jmp 0x97a3
movq 0xfd88(%rip), %rdi      # 0x194f8
testq %rdi, %rdi
je 0x97a3
callq 0x6740
andq $0x0, 0xfd76(%rip)      # 0x194f8
jmp 0x97a3
movl %eax, %edi
xorl %esi, %esi
callq 0x6850
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
testq %rax, %rax
je 0x97ab
movq %rsp, %rdi
callq 0x6740
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x7159(%rip), %rsi      # 0x1090b
movq %rbx, %rdi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
jmp 0x67a0
// File: /workspace/github_c_makefile_star2_O2/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 0x97d8
callq 0x61f0
andq $0x0, 0xfd24(%rip)      # 0x194f8
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfcc2(%rip), %rdx      # 0x194e8
movq %rsi, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x62b0
cmpl $0x6, %eax
jne 0x9869
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6920
pushq $0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x6980
movl $0x81, %ecx
testl %eax, %eax
jne 0x986c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x7e
popq %rcx
leaq 0x6943(%rip), %rsi      # 0x101b6
leaq 0x70c4(%rip), %rdx      # 0x1093e
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x67a0
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x70a6(%rip), %rdi      # 0x10947
movq %rdx, %rsi
xorl %eax, %eax
callq 0x6710
leaq 0x70a8(%rip), %rdx      # 0x1095a
movq %r15, %rdi
movq %rbx, %rsi
callq 0x68c0
movq %r14, 0x10(%rax)
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x3
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa18b
leaq 0x6cce(%rip), %rsi      # 0x10e4e
movq %rbx, %rdi
callq 0x6920
pushq $0x1
popq %rbp
testb $0x2, %r14b
je 0xa1a2
leaq 0x6cbd(%rip), %rsi      # 0x10e55
movq %rbx, %rdi
callq 0x6920
incl %ebp
testb $0x4, %r14b
je 0xa1b9
leaq 0x6cae(%rip), %rsi      # 0x10e5d
movq %rbx, %rdi
callq 0x6920
incl %ebp
testb $0x8, %r14b
je 0xa1d0
leaq 0x6c9d(%rip), %rsi      # 0x10e63
movq %rbx, %rdi
callq 0x6920
incl %ebp
testb $0x10, %r14b
je 0xa1e7
leaq 0x6c8e(%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_O2/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 0x6c61(%rip), %rdi      # 0x10e7a
movq %rdx, %rsi
xorl %eax, %eax
callq 0x6710
leaq 0x6c66(%rip), %rdx      # 0x10e90
movq %r15, %rdi
movq %rbx, %rsi
callq 0x68c0
movq %r14, 0x10(%rax)
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x6a47(%rip), %rdx      # 0x10e90
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x66f0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x6750
movq %r14, %rdi
movl %eax, %esi
callq 0x67b0
movl %eax, %esi
movq %rbx, %rdi
callq 0x6300
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6a06(%rip), %rdx      # 0x10e90
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x6750
movl %eax, %ebp
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x6310
leaq 0x6c27(%rip), %rdx      # 0x110db
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %ecx
movl %eax, %r8d
popq %rbx
popq %r14
popq %rbp
jmp 0xaf8a
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x69b2(%rip), %rdx      # 0x10e90
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x66f0
movq %rax, %r12
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x6750
movl %eax, %ebp
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x6310
leaq 0x6bdb(%rip), %rsi      # 0x110e5
xorl %r15d, %r15d
leaq 0xc(%rsp), %r8
movq %r12, %rdi
movl %ebp, %edx
movl %eax, %ecx
xorl %r9d, %r9d
callq 0x6290
testl %eax, %eax
jne 0xa534
movl 0xc(%rsp), %esi
movq %r14, %rdi
callq 0x64e0
movl %ebx, %r15d
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x6936(%rip), %rdx      # 0x10e90
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x66f0
movq %rax, %r12
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x6750
movl %eax, %ebp
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x6310
leaq 0x6b6b(%rip), %rsi      # 0x110f1
xorl %r15d, %r15d
leaq 0xc(%rsp), %r8
movq %r12, %rdi
movl %ebp, %edx
movl %eax, %ecx
xorl %r9d, %r9d
callq 0x6290
testl %eax, %eax
jne 0xa5b0
movl 0xc(%rsp), %esi
movq %r14, %rdi
callq 0x6360
movl %ebx, %r15d
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x68ba(%rip), %rdx      # 0x10e90
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x66f0
movq %rax, %r12
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x6750
movl %eax, %ebp
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x6310
leaq 0x6af7(%rip), %rsi      # 0x110f9
xorl %r15d, %r15d
leaq 0xc(%rsp), %r8
movq %r12, %rdi
movl %ebp, %edx
movl %eax, %ecx
xorl %r9d, %r9d
callq 0x6290
testl %eax, %eax
jne 0xa62c
movl 0xc(%rsp), %esi
movq %r14, %rdi
callq 0x6930
movl %ebx, %r15d
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6846(%rip), %rdx      # 0x10e90
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x6750
movl %eax, %ebp
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x6310
leaq 0x6a92(%rip), %rdx      # 0x11106
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %ecx
movl %eax, %r8d
popq %rbx
popq %r14
popq %rbp
jmp 0xb05f
// File: /workspace/github_c_makefile_star2_O2/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 0x67f7(%rip), %rdx      # 0x10e90
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x6750
movl %eax, %ebp
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x6310
movl %eax, %r15d
leaq 0x6a4b(%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 0xa6e8
movq %rbx, %rdi
callq 0x6800
jmp 0xa6f4
movl 0x4(%rsp), %esi
movq %rbx, %rdi
callq 0x66b0
leaq 0x6a24(%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 0xa71e
movq %rbx, %rdi
callq 0x6800
jmp 0xa72a
movl 0x4(%rsp), %esi
movq %rbx, %rdi
callq 0x66b0
pushq $0x2
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/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 0x6746(%rip), %rdx      # 0x10e90
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x6750
movl %eax, %ebp
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x6310
movq %rsp, %r9
movl $0xc, (%r9)
leaq 0x69af(%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 0xa7ac
cmpl $0xc, (%rsp)
jne 0xa7ac
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_O2/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 0x66c9(%rip), %rdx      # 0x10e90
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x6750
movl %eax, %ebp
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x6310
leaq 0x8(%rsp), %r9
movl $0x14, (%r9)
leaq 0x693d(%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 0xa82c
cmpl $0x14, 0x8(%rsp)
jne 0xa82c
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_O2/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 0x6649(%rip), %rdx      # 0x10e90
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x6750
movl %eax, %ebp
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x6310
leaq 0x8(%rsp), %r9
movl $0x14, (%r9)
leaq 0x68bd(%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 0xa8ac
cmpl $0x14, 0x8(%rsp)
jne 0xa8ac
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_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x65c7(%rip), %rdx      # 0x10e90
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x66f0
movq %rax, %r15
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x6750
movl %eax, %ebp
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x6310
movq %rsp, %r9
movl $0x14, (%r9)
leaq 0x683b(%rip), %rsi      # 0x1113a
leaq 0x4(%rsp), %r8
movq %r15, %rdi
movl %ebp, %edx
movl %eax, %ecx
callq 0x67c0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0xa92e
cmpl $0x14, (%rsp)
jne 0xa92e
cvtss2sd 0x14(%rsp), %xmm0
movq %r14, %rdi
callq 0x6500
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6546(%rip), %rdx      # 0x10e90
pushq $0x1
popq %rsi
callq 0x66f0
movq %rax, %r15
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x6750
movl %eax, %ebp
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x6310
leaq 0x67d3(%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 0xa996
andl $0x0, 0x4(%rsp)
jmp 0xa99b
movl 0x4(%rsp), %r14d
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x6200
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xafbd
leaq 0x5ee1(%rip), %rdx      # 0x10e90
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x66f0
movq %rax, %rsi
leaq 0x4(%rsp), %r8
movb $0x0, 0x4(%r8)
andl $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 0xaff6
leaq 0x8(%rsp), %rsi
movl -0x4(%rsi), %edx
movq %rbx, %rdi
callq 0x6670
pushq $0x1
popq %rax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
retq