LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_12/detab.c
// Function: is_arg_list_valid
int is_arg_list_valid(int argc, char *argv[])
{
  for (size_t i = 1; i < argc; ++i)
  {
    if (argv[i][0] == '-' || argv[i][0] == '+')
    {
      if (argc > 3 || !is_str_uint(argv[i] + 1))
      {
        return 0;
      }
      continue;
    }

    if (!is_str_uint(argv[i]) || (i > 1 && atoi(argv[i - 1]) > atoi(argv[i])))
    {
      return 0;
    }
  }
  return 1;
}

// Assembly:
movl $0x1, %eax
cmpl $0x2, %edi
jb 0x13c7
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movslq %edi, %r13
movl $0x1, %r15d
xorl %r12d, %r12d
movq (%rbx,%r15,8), %r14
movzbl (%r14), %eax
cmpl $0x2d, %eax
je 0x1362
cmpl $0x2b, %eax
jne 0x1378
cmpl $0x3, %ebp
jg 0x13b2
incq %r14
movq %r14, %rdi
callq 0x13c8
testl %eax, %eax
jne 0x13a6
jmp 0x13b2
movq %r14, %rdi
callq 0x13c8
testl %eax, %eax
je 0x13b2
cmpq $0x2, %r15
jb 0x13a6
movq -0x8(%rbx,%r15,8), %rdi
callq 0x1070
movl %eax, 0x4(%rsp)
movq %r14, %rdi
callq 0x1070
cmpl %eax, 0x4(%rsp)
jg 0x13b2
incq %r15
cmpq %r13, %r15
setae %r12b
jne 0x1350
movzbl %r12b, %eax
andl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_12/detab.c
// Function: is_str_uint
int is_str_uint(char *str)
{
  for (size_t i = 0; i < strlen(str); ++i)
  {
    if (!isdigit(str[i]))
    {
      return 0;
    }
  }
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1050
testq %rax, %rax
je 0x1418
movq %rax, %r14
callq 0x1080
movq (%rax), %rcx
movsbq (%rbx), %rdx
xorl %eax, %eax
testb $0x8, 0x1(%rcx,%rdx,2)
je 0x141d
movl $0x1, %eax
movq %rax, %rdx
cmpq %rax, %r14
je 0x140e
movsbq (%rbx,%rdx), %rsi
leaq 0x1(%rdx), %rax
testb $0x8, 0x1(%rcx,%rsi,2)
jne 0x13f6
xorl %eax, %eax
cmpq %r14, %rdx
setae %al
jmp 0x141d
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/phluid61[P]hsf/src/item.c
// Function: SH_Item__init
SH_Item*
SH_Item__init(SH_BareItem* item, SH_dict* params, int* err) {
	SH_Item* obj;

	__cascade(err, (SH_Item*)0);

	obj = (SH_Item*)malloc(sizeof(SH_Item));
	if ((SH_Item*)0 == obj) {
		__raise(err, SH_E_MALLOC_ERROR);
		return (SH_Item*)0;
	}

	if ((SH_dict*)0 == params) {
		params = SH_dict__init(err);
		if (__catch(err)) {
			free(obj);
			return (SH_Item*)0;
		}
	}

	obj->item = item;
	obj->params = params;

	__clear(err);
	return obj;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
testq %rdx, %rdx
je 0x123f
movq %rdx, %r12
cmpl $0x0, (%rdx)
jne 0x1290
movl $0x10, %edi
callq 0x10d0
testq %rax, %rax
je 0x125f
movq %rax, %rbx
testq %r15, %r15
je 0x1279
movq %r14, (%rbx)
movq %r15, 0x8(%rbx)
movl $0x0, (%r12)
jmp 0x1292
movl $0x10, %edi
callq 0x10d0
testq %rax, %rax
je 0x1290
movq %rax, %rbx
testq %r15, %r15
je 0x1269
movq %r14, (%rbx)
movq %r15, 0x8(%rbx)
jmp 0x1292
movl $0x80000001, (%r12)     # imm = 0x80000001
jmp 0x1290
xorl %edi, %edi
callq 0x1050
movq %r14, (%rbx)
movq %rax, 0x8(%rbx)
jmp 0x1292
movq %r12, %rdi
callq 0x1050
cmpl $0x0, (%r12)
je 0x12a1
movq %rbx, %rdi
callq 0x1040
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
jmp 0x122e
// File: /workspace/github_c_makefile_star2_O3/phluid61[P]hsf/src/item.c
// Function: SH_Item__destroy
void
SH_Item__destroy(SH_Item *obj, sh_bool_t recursive, int* err) {
	int local_err1 = SH_E_NO_ERROR;
	int local_err2 = SH_E_NO_ERROR;
	__cascade(err,);
	if (recursive) {
		SH_BareItem__destroy(obj->item, recursive, &local_err1);
		SH_dict__destroy(obj->params, recursive, &local_err2);
		free(obj);
		__raise(err, (SH_E_NO_ERROR == local_err1) ? local_err2 : local_err1);
	} else {
		free(obj);
		__clear(err);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
xorl %eax, %eax
movl %eax, 0xc(%rsp)
movl %eax, 0x8(%rsp)
testq %rdx, %rdx
je 0x12dd
cmpl $0x0, (%rbx)
jne 0x1320
testb %sil, %sil
jne 0x12e2
movq %r14, %rdi
callq 0x1040
movl $0x0, (%rbx)
jmp 0x1320
testb %sil, %sil
je 0x1329
movq (%r14), %rdi
movzbl %sil, %ebp
leaq 0xc(%rsp), %rdx
movl %ebp, %esi
callq 0x1100
movq 0x8(%r14), %rdi
leaq 0x8(%rsp), %rdx
movl %ebp, %esi
callq 0x10e0
movq %r14, %rdi
callq 0x1040
testq %rbx, %rbx
je 0x1320
movl 0xc(%rsp), %eax
testl %eax, %eax
jne 0x131e
movl 0x8(%rsp), %eax
movl %eax, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O3/phluid61[P]hsf/src/item.c
// Function: SH_Item__add_param
void
SH_Item__add_param(SH_Item* obj, SH_Key* key, SH_Item* item, int* err) {
	if (SH_dict__count(obj->params, 0) >= 256) { /* FIXME: magic numer, RFC 8941, 3.1.2 */
		__raise(err, SH_E_PARAMETERS_OVERFLOW);
		return;
	}
	SH_dict__add(obj->params, key, item, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%rdi), %rdi
xorl %esi, %esi
callq 0x1060
cmpq $0x100, %rax            # imm = 0x100
jb 0x139a
testq %rbx, %rbx
je 0x138e
movl $0x100002, (%rbx)       # imm = 0x100002
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8(%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10b0
// File: /workspace/github_c_makefile_star2_O3/phluid61[P]hsf/src/item.c
// Function: _SH_Item__to_s_param
void
__SH_Item__to_s_param(SH_Key* key, SH_Item* obj, void* ptr, int* err) {
	__sh_item__string* str;

	sh_char_t* k; /* key string */
	sh_char_t* o; /* obj string */

	int local_err = SH_E_NO_ERROR;

	__cascade(err,);

	str = (__sh_item__string*)ptr;

	k = SH_Key__to_s(key, &local_err);
	if (local_err) {
		__raise(err, local_err);
		return;
	}

	if (SH_BOOLEAN == SH_BareItem__type(obj->item, &local_err) && SH_Boolean__true(SH_BareItem__get_boolean(obj->item, &local_err), &local_err)) {
		str->a[str->n ++] = k; str->length += strlen((const char*)k);
		str->a[str->n ++] = (sh_char_t*)0;
	} else {
		local_err = SH_E_NO_ERROR; /* ignore any errors above */
		o = SH_Item__to_s(obj, &local_err);
		if (local_err) {
			free(k);
			__raise(err, local_err);
			return;
		}

		str->a[str->n ++] = k; str->length += strlen((const char*)k);
		str->a[str->n ++] = o; str->length += strlen((const char*)o);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movl $0x0, 0xc(%rsp)
testq %rcx, %rcx
je 0x1403
cmpl $0x0, (%r14)
jne 0x14f0
leaq 0xc(%rsp), %r13
movq %r13, %rsi
callq 0x10a0
movq %rax, %r12
movl (%r13), %eax
testl %eax, %eax
jne 0x14ae
jmp 0x141e
leaq 0xc(%rsp), %r13
movq %r13, %rsi
callq 0x10a0
cmpl $0x0, (%r13)
jne 0x14f0
movq %rax, %r12
movq (%r15), %rdi
leaq 0xc(%rsp), %rsi
callq 0x1090
cmpl $0x6, %eax
jne 0x147e
movq (%r15), %rdi
leaq 0xc(%rsp), %r13
movq %r13, %rsi
callq 0x1030
movq %rax, %rdi
movq %r13, %rsi
callq 0x1110
testb %al, %al
je 0x147e
movq 0x8(%rbx), %r14
leaq 0x1(%r14), %rax
movq %rax, 0x8(%rbx)
movq %r12, 0x10(%rbx,%r14,8)
movq %r12, %rdi
callq 0x1070
addq %rax, (%rbx)
leaq 0x2(%r14), %rax
movq %rax, 0x8(%rbx)
movq $0x0, 0x18(%rbx,%r14,8)
jmp 0x14f0
leaq 0xc(%rsp), %r13
movl $0x0, (%r13)
movq %r15, %rdi
movq %r13, %rsi
callq 0x1120
cmpl $0x0, (%r13)
je 0x14b3
movq %r12, %rdi
callq 0x1040
testq %r14, %r14
je 0x14f0
movl 0xc(%rsp), %eax
movl %eax, (%r14)
jmp 0x14f0
movq %rax, %r15
movq 0x8(%rbx), %r13
leaq 0x1(%r13), %rax
movq %rax, 0x8(%rbx)
movq %r12, 0x10(%rbx,%r13,8)
movq %r12, %rdi
callq 0x1070
movq %rax, %r14
addq (%rbx), %r14
leaq 0x2(%r13), %rax
movq %rax, 0x8(%rbx)
movq %r15, 0x18(%rbx,%r13,8)
movq %r15, %rdi
callq 0x1070
addq %r14, %rax
movq %rax, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/additional.c
// Function: Textureflags
static int Textureflags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushtextureflags(L, luaL_checkinteger(L, 1), 0);
    lua_pushinteger(L, checktextureflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x68d0
movq %rbx, %rdi
movl $0x1, %esi
cmpl $0x3, %eax
jne 0x6ad7
callq 0x6440
movq %rbx, %rdi
movl %eax, %esi
xorl %edx, %edx
popq %rbx
jmp 0x6200
callq 0x60f0
movl %eax, %esi
movq %rbx, %rdi
callq 0x6300
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/additional.c
// Function: Primtypes
static int Primtypes(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushprimitivetype(L, luaL_checkinteger(L, 1), 0);
    lua_pushinteger(L, checkprimitivetype(L, 1));
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x68d0
movq %rbx, %rdi
movl $0x1, %esi
cmpl $0x3, %eax
jne 0x6b1a
callq 0x6440
movq %rbx, %rdi
movl %eax, %esi
xorl %edx, %edx
popq %rbx
jmp 0x66a0
callq 0x6410
movl %eax, %esi
movq %rbx, %rdi
callq 0x6300
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/additional.c
// Function: Postprocessflags
static int Postprocessflags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushpostprocessflags(L, luaL_checkinteger(L, 1), 0);
    lua_pushinteger(L, checkpostprocessflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x68d0
movq %rbx, %rdi
movl $0x1, %esi
cmpl $0x3, %eax
jne 0x6b5d
callq 0x6440
movq %rbx, %rdi
movl %eax, %esi
xorl %edx, %edx
popq %rbx
jmp 0x6210
callq 0x6260
movl %eax, %esi
movq %rbx, %rdi
callq 0x6300
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/additional.c
// Function: Sceneflags
static int Sceneflags(lua_State *L)
    {
    if(lua_type(L, 1) == LUA_TNUMBER)
        return pushsceneflags(L, luaL_checkinteger(L, 1), 0);
    lua_pushinteger(L, checksceneflags(L, 1));
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x68d0
movq %rbx, %rdi
movl $0x1, %esi
cmpl $0x3, %eax
jne 0x6ba0
callq 0x6440
movq %rbx, %rdi
movl %eax, %esi
xorl %edx, %edx
popq %rbx
jmp 0x65a0
callq 0x6660
movl %eax, %esi
movq %rbx, %rdi
callq 0x6300
movl $0x1, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/animation.c
// Function: moonassimp_newanimation
int newanimation(lua_State *L, scene_t *scene, animation_t *animation)
    {
    unsigned int i;
    ud_t *ud;
    TRACE_CREATE(animation, "animation");
    if(animation->mChannels != NULL && animation->mNumChannels > 0)
        {
        for(i = 0; i < animation->mNumChannels; i++)
            { newnodeanim(L, scene, animation, animation->mChannels[i]); lua_pop(L, 1); }
        TRACE_CREATE_N(i, "nodeanims");
        }
    if(animation->mMeshChannels != NULL && animation->mNumMeshChannels > 0)
        {
        for(i = 0; i < animation->mNumMeshChannels; i++)
            { newmeshanim(L, scene, animation, animation->mMeshChannels[i]); lua_pop(L, 1); }
        TRACE_CREATE_N(i, "meshanims");
        }
    ud = newuserdata(L, (void*)animation, ANIMATION_MT);
    ud->scene = scene;
    return 1;   
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x9463(%rip), %rdi      # 0x10033
movq %rdx, %rsi
xorl %eax, %eax
callq 0x6710
cmpq $0x0, 0x420(%r14)
je 0x6c37
cmpl $0x0, 0x418(%r14)
je 0x6c37
xorl %r12d, %r12d
movq 0x420(%r14), %rax
movq (%rax,%r12,8), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x6100
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x60c0
incq %r12
movl 0x418(%r14), %eax
cmpq %rax, %r12
jb 0x6bf1
leaq 0x941d(%rip), %rdi      # 0x1004a
movl %r12d, %esi
xorl %eax, %eax
callq 0x6710
cmpq $0x0, 0x430(%r14)
je 0x6c94
cmpl $0x0, 0x428(%r14)
je 0x6c94
xorl %r12d, %r12d
movq 0x430(%r14), %rax
movq (%rax,%r12,8), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x6490
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x60c0
incq %r12
movl 0x428(%r14), %eax
cmpq %rax, %r12
jb 0x6c4e
leaq 0x93d5(%rip), %rdi      # 0x1005f
movl %r12d, %esi
xorl %eax, %eax
callq 0x6710
leaq 0x93d9(%rip), %rdx      # 0x10074
movq %r15, %rdi
movq %r14, %rsi
callq 0x68c0
movq %rbx, 0x10(%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/animation.c
// Function: moonassimp_freeanimation
int freeanimation(lua_State *L, animation_t *animation)
    {
    unsigned int i;
    if(animation->mChannels != NULL && animation->mNumChannels > 0)
        {
        for(i = 0; i < animation->mNumChannels; i++)
            freenodeanim(L, animation->mChannels[i]);
        TRACE_DELETE_N(i, "nodeanims");
        }
    if(animation->mMeshChannels != NULL && animation->mNumMeshChannels > 0)
        {
        for(i = 0; i < animation->mNumMeshChannels; i++)
            freemeshanim(L, animation->mMeshChannels[i]);
        TRACE_DELETE_N(i, "meshanims");
        }
    TRACE_DELETE(animation, "animation");

    freeuserdata(L, animation);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x420(%rsi)
je 0x6d0e
cmpl $0x0, 0x418(%rbx)
je 0x6d0e
xorl %r15d, %r15d
movq 0x420(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x6840
incq %r15
movl 0x418(%rbx), %eax
cmpq %rax, %r15
jb 0x6cdc
leaq 0x9385(%rip), %rdi      # 0x10089
movl %r15d, %esi
xorl %eax, %eax
callq 0x6710
cmpq $0x0, 0x430(%rbx)
je 0x6d56
cmpl $0x0, 0x428(%rbx)
je 0x6d56
xorl %r15d, %r15d
movq 0x430(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x6970
incq %r15
movl 0x428(%rbx), %eax
cmpq %rax, %r15
jb 0x6d24
leaq 0x9352(%rip), %rdi      # 0x1009e
movl %r15d, %esi
xorl %eax, %eax
callq 0x6710
leaq 0x9356(%rip), %rdi      # 0x100b3
movq %rbx, %rsi
xorl %eax, %eax
callq 0x6710
movq %r14, %rdi
movq %rbx, %rsi
callq 0x63f0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/animation.c
// Function: Channel
static int Channel(lua_State *L)
/* nodeanim = animation:node_anim(node_name) */
    {
    unsigned int i;
    animation_t *animation = checkanimation(L, 1);
    const char *name = luaL_checkstring(L, 2);
    if(animation->mChannels == NULL || animation->mNumChannels == 0) return 0;
    for(i = 0; i < animation->mNumChannels; i++)
        {
#define nodename animation->mChannels[i]->mNodeName
        if(strncmp(name, nodename.data, nodename.length) == 0) /* found */
            {
            pushnodeanim(L, animation->mChannels[i]);
            return 1;
            }
#undef nodename
        }
    return 0; /* not found */
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x91f4(%rip), %rdx      # 0x10074
movl $0x1, %esi
callq 0x66f0
movq %rax, %r12
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x6370
movq 0x420(%r12), %r13
testq %r13, %r13
je 0x6ef4
movl 0x418(%r12), %r12d
testq %r12, %r12
je 0x6ef4
movq %rax, %r14
xorl %ebp, %ebp
movq (%r13,%rbp,8), %r15
leaq 0x4(%r15), %rsi
movl (%r15), %edx
movq %r14, %rdi
callq 0x6120
testl %eax, %eax
je 0x6ee3
incq %rbp
cmpq %rbp, %r12
jne 0x6ebe
xorl %r15d, %r15d
jmp 0x6ef4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6380
movl $0x1, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/animation.c
// Function: Channels
static int Channels(lua_State *L)
    {
    unsigned int i;
    animation_t *animation = checkanimation(L, 1);
    lua_newtable(L);
    if(animation->mChannels == NULL || animation->mNumChannels == 0) return 1;
    for(i = 0; i < animation->mNumChannels; i++)
        {
        pushnodeanim(L, animation->mChannels[i]);
        lua_rawseti(L, -2, i+1);
        }
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x915f(%rip), %rdx      # 0x10074
movl $0x1, %esi
callq 0x66f0
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
cmpq $0x0, 0x420(%r14)
je 0x6f77
cmpl $0x0, 0x418(%r14)
je 0x6f77
xorl %r15d, %r15d
movq 0x420(%r14), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x6380
incq %r15
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r15, %rdx
callq 0x6470
movl 0x418(%r14), %eax
cmpq %rax, %r15
jb 0x6f45
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/animation.c
// Function: MeshChannels
static int MeshChannels(lua_State *L)
    {
    unsigned int i;
    animation_t *animation = checkanimation(L, 1);
    const char *name = luaL_optstring(L, 2, NULL);
    lua_newtable(L);
    if(animation->mMeshChannels == NULL || animation->mNumMeshChannels == 0) return 1;
    for(i = 0; i < animation->mNumMeshChannels; i++)
        {
#define maname animation->mMeshChannels[i]->mName
        if(!name || (strncmp(name, maname.data, maname.length) == 0))
            {
            pushmeshanim(L, animation->mMeshChannels[i]);
            lua_rawseti(L, -2, i+1);
            }
#undef maname
        }
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x90b3(%rip), %rdx      # 0x10074
movl $0x1, %esi
callq 0x66f0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x6270
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
cmpq $0x0, 0x430(%r14)
je 0x705b
movl 0x428(%r14), %ebp
testl %ebp, %ebp
je 0x705b
xorl %r12d, %r12d
movq 0x430(%r14), %rax
movq (%rax,%r12,8), %r13
testq %r15, %r15
je 0x702f
leaq 0x4(%r13), %rsi
movl (%r13), %edx
movq %r15, %rdi
callq 0x6120
testl %eax, %eax
je 0x702f
incq %r12
jmp 0x7054
movq %rbx, %rdi
movq %r13, %rsi
callq 0x6380
incq %r12
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r12, %rdx
callq 0x6470
movl 0x428(%r14), %ebp
movl %ebp, %eax
cmpq %rax, %r12
jb 0x7006
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/animmesh.c
// Function: moonassimp_newanimmesh
int newanimmesh(lua_State *L, scene_t *scene, mesh_t *mesh, animmesh_t *animmesh)
    {
    ud_t *ud;
//  TRACE_CREATE(animmesh, "animmesh");
    ud = newuserdata(L, (void*)animmesh, ANIMMESH_MT);
    ud->scene = scene;
    ud->mesh = mesh;
    return 1;   
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x90af(%rip), %rdx      # 0x10130
movq %rcx, %rsi
callq 0x68c0
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/animmesh.c
// Function: Mesh
static int Mesh(lua_State *L)
    {
    animmesh_t *animmesh = checkanimmesh(L, 1);
    ud_t *ud = userdata(animmesh);
    mesh_t *mesh = ud->mesh;
    return pushmesh(L, mesh);
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x904d(%rip), %rdx      # 0x10130
movl $0x1, %esi
callq 0x66f0
movq %rax, %rdi
callq 0x6770
movq 0x18(%rax), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x6380
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/animmesh.c
// Function: HasColors
static int HasColors(lua_State *L)
    {
    animmesh_t *animmesh = checkanimmesh(L, 1);
    unsigned int i = checkindex(L, 2);
    if( i >= AI_MAX_NUMBER_OF_COLOR_SETS )
        lua_pushboolean(L, 0);
    else
        lua_pushboolean(L, animmesh->mColors[i] != NULL);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8f8a(%rip), %rdx      # 0x10130
movl $0x1, %esi
callq 0x66f0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x6310
xorl %esi, %esi
cmpl $0x7, %eax
ja 0x71d8
movl %eax, %eax
xorl %esi, %esi
cmpq $0x0, 0x428(%r14,%rax,8)
setne %sil
movq %rbx, %rdi
callq 0x6540
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/animmesh.c
// Function: HasTextureCoords
static int HasTextureCoords(lua_State *L)
    {
    animmesh_t *animmesh = checkanimmesh(L, 1);
    unsigned int i = checkindex(L, 2);
    if( i >= AI_MAX_NUMBER_OF_TEXTURECOORDS )
        lua_pushboolean(L, 0);
    else
        lua_pushboolean(L, animmesh->mTextureCoords[i] != NULL);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8f35(%rip), %rdx      # 0x10130
movl $0x1, %esi
callq 0x66f0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x6310
xorl %esi, %esi
cmpl $0x7, %eax
ja 0x722d
movl %eax, %eax
xorl %esi, %esi
cmpq $0x0, 0x468(%r14,%rax,8)
setne %sil
movq %rbx, %rdi
callq 0x6540
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/animmesh.c
// Function: Color
static int Color(lua_State *L)
    {
    animmesh_t *animmesh = checkanimmesh(L, 1);
    unsigned int chan = checkindex(L, 2);
    unsigned int i = checkindex(L, 3);
    if( chan >= AI_MAX_NUMBER_OF_COLOR_SETS || animmesh->mColors[chan] == NULL)
        return luaL_argerror(L, 2, "out of range");
    if( i >= animmesh->mNumVertices)
        return luaL_argerror(L, 3, "out of range");
    return pushcolor4(L, &(animmesh->mColors[chan][i]), 0);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8d14(%rip), %rdx      # 0x10130
movl $0x1, %esi
callq 0x66f0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x6310
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x6310
cmpl $0x7, %ebp
ja 0x7479
movl %ebp, %ecx
movq 0x428(%r14,%rcx,8), %rsi
testq %rsi, %rsi
je 0x7479
cmpl 0x4a8(%r14), %eax
jae 0x7491
movl %eax, %eax
shlq $0x4, %rax
addq %rax, %rsi
movq %rbx, %rdi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x62d0
leaq 0x8d29(%rip), %rdx      # 0x101a9
movq %rbx, %rdi
movl $0x2, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x61c0
leaq 0x8d11(%rip), %rdx      # 0x101a9
movq %rbx, %rdi
movl $0x3, %esi
jmp 0x7488
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/animmesh.c
// Function: TextureCoords
static int TextureCoords(lua_State *L)
    {
    vector3_t *coords;
    vector2_t vec2;
    unsigned int ncomp;
    animmesh_t *animmesh = checkanimmesh(L, 1);
    ud_t *ud = userdata(animmesh);
    mesh_t *mesh = ud->mesh;
    unsigned int chan = checkindex(L, 2);
    unsigned int i = checkindex(L, 3);
    if( chan >= AI_MAX_NUMBER_OF_TEXTURECOORDS || animmesh->mTextureCoords[chan] == NULL)
        return luaL_argerror(L, 2, "out of range");
    if( i >= animmesh->mNumVertices)
        return luaL_argerror(L, 3, "out of range");
    ncomp = mesh->mNumUVComponents[chan]; /* no. of components */
    coords =  &(animmesh->mTextureCoords[chan][i]);
    if(ncomp == 3)
        return pushvector3(L, coords, 0);
    if(ncomp == 2)
        {
        vec2.x = coords->x;
        vec2.y = coords->y;
        return pushvector2(L, &vec2, 0);
        }
    if(ncomp == 1)
        {
        lua_pushnumber(L, coords->x);
        return 1;
        }
    return unexpected(L); /* 4 components are currently not supported */
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8c7d(%rip), %rdx      # 0x10130
movl $0x1, %esi
callq 0x66f0
movq %rax, %r14
movq %rax, %rdi
callq 0x6770
movq 0x18(%rax), %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x6310
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
callq 0x6310
cmpl $0x7, %ebp
ja 0x753a
movl %ebp, %edx
movq 0x468(%r14,%rdx,8), %rcx
testq %rcx, %rcx
je 0x753a
cmpl 0x4a8(%r14), %eax
jae 0x7558
movl 0xb0(%r15,%rdx,4), %edx
movl %eax, %eax
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,4), %rsi
cmpl $0x1, %edx
je 0x7580
cmpl $0x2, %edx
je 0x7569
cmpl $0x3, %edx
jne 0x759c
movq %rbx, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6600
leaq 0x8c68(%rip), %rdx      # 0x101a9
movq %rbx, %rdi
movl $0x2, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x61c0
leaq 0x8c4a(%rip), %rdx      # 0x101a9
movq %rbx, %rdi
movl $0x3, %esi
jmp 0x7549
movsd (%rsi), %xmm0
movq %rsp, %rsi
movsd %xmm0, (%rsi)
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6170
jmp 0x7591
cvtss2sd (%rsi), %xmm0
movq %rbx, %rdi
callq 0x6500
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8c13(%rip), %rsi      # 0x101b6
leaq 0x8c26(%rip), %rdx      # 0x101d0
movq %rbx, %rdi
movl $0xa5, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x67a0
nop
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/bitfields.c
// Function: moonassimp_checktextureflags
unsigned int checktextureflags(lua_State *L, int arg)
/* Accepts an integer or a list of strings starting from index=arg */
    {
    unsigned int flags = 0;
    const char *s;
    
    if(lua_type(L, arg) == LUA_TNUMBER)
        return (unsigned int)luaL_checkinteger(L, arg);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x68d0
cmpl $0x3, %eax
jne 0x75f0
movq %r14, %rdi
movl %ebx, %esi
callq 0x6440
movq %rax, %r15
jmp 0x7675
movq %r14, %rdi
movl %ebx, %esi
callq 0x69b0
xorl %r15d, %r15d
testl %eax, %eax
je 0x7675
leaq 0x8bf8(%rip), %r12      # 0x10200
leaq 0x8bf8(%rip), %r13      # 0x10207
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0x61e0
movq %rax, %rbp
movq %rax, %rdi
movq %r12, %rsi
callq 0x6420
testl %eax, %eax
je 0x7656
movq %rbp, %rdi
movq %r13, %rsi
callq 0x6420
testl %eax, %eax
je 0x765d
movq %rbp, %rdi
leaq 0x8bcb(%rip), %rsi      # 0x10211
callq 0x6420
movl $0x4, %ecx
testl %eax, %eax
je 0x7662
jmp 0x7687
movl $0x1, %ecx
jmp 0x7662
movl $0x2, %ecx
orl %ecx, %r15d
incl %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x69b0
testl %eax, %eax
jne 0x760f
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8b90(%rip), %rsi      # 0x1021e
movq %r14, %rdi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x63d0
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x61c0
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/bitfields.c
// Function: moonassimp_pushtextureflags
int pushtextureflags(lua_State *L, unsigned int flags, int pushcode)
/* Pushes an integer followed by a list of strings */
    {
    int n = 0;
    if(pushcode)
        { lua_pushinteger(L, flags); return 1; }

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
testl %edx, %edx
je 0x76d4
movl %ebp, %esi
movq %r14, %rdi
callq 0x6300
movl $0x1, %ebx
jmp 0x772b
xorl %ebx, %ebx
testb $0x1, %bpl
je 0x76f0
leaq 0x8b1d(%rip), %rsi      # 0x10200
movq %r14, %rdi
callq 0x6920
movl $0x1, %ebx
testb $0x2, %bpl
je 0x7707
leaq 0x8b0a(%rip), %rsi      # 0x10207
movq %r14, %rdi
callq 0x6920
incl %ebx
testb $0x4, %bpl
jne 0x771a
testl %ebp, %ebp
jne 0x772b
leaq 0x8b19(%rip), %rsi      # 0x10231
jmp 0x7721
leaq 0x8af0(%rip), %rsi      # 0x10211
movq %r14, %rdi
callq 0x6920
incl %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/bitfields.c
// Function: moonassimp_checkprimitivetype
unsigned int checkprimitivetype(lua_State *L, int arg)
/* Accepts an integer or a list of strings starting from index=arg */
    {
    unsigned int flags = 0;
    const char *s;
    
    if(lua_type(L, arg) == LUA_TNUMBER)
        return (unsigned int)luaL_checkinteger(L, arg);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x68d0
cmpl $0x3, %eax
jne 0x775e
movq %r14, %rdi
movl %ebx, %esi
callq 0x6440
movq %rax, %r15
jmp 0x7801
movq %r14, %rdi
movl %ebx, %esi
callq 0x69b0
xorl %r15d, %r15d
testl %eax, %eax
je 0x7801
leaq 0x8abc(%rip), %r12      # 0x10236
leaq 0x8abb(%rip), %r13      # 0x1023c
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0x61e0
movq %rax, %rbp
movq %rax, %rdi
movq %r12, %rsi
callq 0x6420
testl %eax, %eax
je 0x77db
movq %rbp, %rdi
movq %r13, %rsi
callq 0x6420
testl %eax, %eax
je 0x77e2
movq %rbp, %rdi
leaq 0x8a89(%rip), %rsi      # 0x10241
callq 0x6420
testl %eax, %eax
je 0x77e9
movq %rbp, %rdi
leaq 0x8a7f(%rip), %rsi      # 0x1024a
callq 0x6420
movl $0x8, %ecx
testl %eax, %eax
je 0x77ee
jmp 0x7813
movl $0x1, %ecx
jmp 0x77ee
movl $0x2, %ecx
jmp 0x77ee
movl $0x4, %ecx
orl %ecx, %r15d
incl %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x69b0
testl %eax, %eax
jne 0x7781
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8a04(%rip), %rsi      # 0x1021e
movq %r14, %rdi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x63d0
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x61c0
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/bitfields.c
// Function: moonassimp_pushprimitivetype
int pushprimitivetype(lua_State *L, unsigned int flags, int pushcode)
/* Pushes an integer followed by a list of strings */
    {
    int n = 0;
    if(pushcode)
        { lua_pushinteger(L, flags); return 1; }

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
testl %edx, %edx
je 0x7860
movl %ebp, %esi
movq %r14, %rdi
callq 0x6300
movl $0x1, %ebx
jmp 0x78ce
xorl %ebx, %ebx
testb $0x1, %bpl
je 0x787c
leaq 0x89c7(%rip), %rsi      # 0x10236
movq %r14, %rdi
callq 0x6920
movl $0x1, %ebx
testb $0x2, %bpl
je 0x7893
leaq 0x89b3(%rip), %rsi      # 0x1023c
movq %r14, %rdi
callq 0x6920
incl %ebx
testb $0x4, %bpl
je 0x78aa
leaq 0x89a1(%rip), %rsi      # 0x10241
movq %r14, %rdi
callq 0x6920
incl %ebx
testb $0x8, %bpl
jne 0x78bd
testl %ebp, %ebp
jne 0x78ce
leaq 0x8976(%rip), %rsi      # 0x10231
jmp 0x78c4
leaq 0x8986(%rip), %rsi      # 0x1024a
movq %r14, %rdi
callq 0x6920
incl %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/bitfields.c
// Function: moonassimp_checksceneflags
unsigned int checksceneflags(lua_State *L, int arg)
/* Accepts an integer or a list of strings starting from index=arg */
    {
    unsigned int flags = 0;
    const char *s;
    
    if(lua_type(L, arg) == LUA_TNUMBER)
        return (unsigned int)luaL_checkinteger(L, arg);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x68d0
cmpl $0x3, %eax
jne 0x7901
movq %r14, %rdi
movl %ebx, %esi
callq 0x6440
movq %rax, %r15
jmp 0x79cd
movq %r14, %rdi
movl %ebx, %esi
callq 0x69b0
xorl %r15d, %r15d
testl %eax, %eax
je 0x79cd
leaq 0x8914(%rip), %r12      # 0x10231
leaq 0x892e(%rip), %r13      # 0x10252
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0x61e0
movq %rax, %rbp
movq %rax, %rdi
movq %r12, %rsi
callq 0x6420
testl %eax, %eax
je 0x79b9
movq %rbp, %rdi
movq %r13, %rsi
callq 0x6420
testl %eax, %eax
je 0x79a3
movq %rbp, %rdi
leaq 0x8902(%rip), %rsi      # 0x1025d
callq 0x6420
testl %eax, %eax
je 0x79a9
movq %rbp, %rdi
leaq 0x88f9(%rip), %rsi      # 0x10267
callq 0x6420
testl %eax, %eax
je 0x79af
movq %rbp, %rdi
leaq 0x88f9(%rip), %rsi      # 0x1027a
callq 0x6420
testl %eax, %eax
je 0x79b5
movq %rbp, %rdi
leaq 0x88f9(%rip), %rsi      # 0x1028d
callq 0x6420
testl %eax, %eax
jne 0x79df
orl $0x10, %r15d
jmp 0x79b9
orl $0x1, %r15d
jmp 0x79b9
orl $0x2, %r15d
jmp 0x79b9
orl $0x4, %r15d
jmp 0x79b9
orl $0x8, %r15d
incl %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0x69b0
testl %eax, %eax
jne 0x7924
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8838(%rip), %rsi      # 0x1021e
movq %r14, %rdi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x63d0
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x61c0
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/bitfields.c
// Function: moonassimp_pushsceneflags
int pushsceneflags(lua_State *L, unsigned int flags, int pushcode)
/* Pushes an integer followed by a list of strings */
    {
    int n = 0;
    if(pushcode)
        { lua_pushinteger(L, flags); return 1; }

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
testl %edx, %edx
je 0x7a2f
movl %ebp, %esi
movq %r14, %rdi
callq 0x6300
movl $0x1, %ebx
jmp 0x7ab4
xorl %ebx, %ebx
testb $0x1, %bpl
je 0x7a4b
leaq 0x8814(%rip), %rsi      # 0x10252
movq %r14, %rdi
callq 0x6920
movl $0x1, %ebx
testb $0x2, %bpl
je 0x7a62
leaq 0x8805(%rip), %rsi      # 0x1025d
movq %r14, %rdi
callq 0x6920
incl %ebx
testb $0x4, %bpl
je 0x7a79
leaq 0x87f8(%rip), %rsi      # 0x10267
movq %r14, %rdi
callq 0x6920
incl %ebx
testb $0x8, %bpl
je 0x7a90
leaq 0x87f4(%rip), %rsi      # 0x1027a
movq %r14, %rdi
callq 0x6920
incl %ebx
testb $0x10, %bpl
jne 0x7aa3
testl %ebp, %ebp
jne 0x7ab4
leaq 0x8790(%rip), %rsi      # 0x10231
jmp 0x7aaa
leaq 0x87e3(%rip), %rsi      # 0x1028d
movq %r14, %rdi
callq 0x6920
incl %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/bone.c
// Function: moonassimp_newbone
int newbone(lua_State *L, scene_t *scene, mesh_t *mesh, bone_t *bone)
    {
    ud_t *ud;
    TRACE_CREATE(bone, "bone");
    ud = newuserdata(L, (void*)bone, BONE_MT);
    ud->scene = scene;
    ud->mesh = mesh;
    return 1;   
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x82dd(%rip), %rdi      # 0x10470
movq %rcx, %rsi
xorl %eax, %eax
callq 0x6710
leaq 0x82de(%rip), %rdx      # 0x10482
movq %r12, %rdi
movq %rbx, %rsi
callq 0x68c0
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/bone.c
// Function: Weights
static int Weights(lua_State *L)
/* returns a (possibly sparse) table t 
 * where t[i] is the weight for the vertex i 
 * (i= 1-based index in the mesh's vertices list)
 */
    {
    unsigned int i;
    bone_t *bone = checkbone(L, 1);
    lua_newtable(L);
    if(bone->mWeights == NULL || bone->mNumWeights == 0) return 0;
    for(i = 0; i < bone->mNumWeights; i++)
        {
#define w bone->mWeights[i]
        lua_pushnumber(L, w.mWeight);
        lua_rawseti(L, -2, w.mVertexId+1);
#undef w
        }
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x81de(%rip), %rdx      # 0x10482
movl $0x1, %esi
callq 0x66f0
movq %rax, %r14
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
cmpq $0x0, 0x418(%r14)
je 0x831d
cmpl $0x0, 0x404(%r14)
je 0x831d
xorl %r15d, %r15d
movq 0x418(%r14), %rax
xorps %xmm0, %xmm0
cvtss2sd 0x4(%rax,%r15,8), %xmm0
movq %rbx, %rdi
callq 0x6500
movq 0x418(%r14), %rax
movl (%rax,%r15,8), %edx
incl %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6470
incq %r15
movl 0x404(%r14), %eax
cmpq %rax, %r15
jb 0x82d6
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/bone.c
// Function: OrderedWeights
static int OrderedWeights(lua_State *L)
/* returns a table t of elements { vertex=i, weight=val }
 */
    {
    unsigned int i;
    bone_t *bone = checkbone(L, 1);
    lua_newtable(L);
    if(bone->mWeights == NULL || bone->mNumWeights == 0) return 0;
    for(i = 0; i < bone->mNumWeights; i++)
        {
#define w bone->mWeights[i]
        lua_newtable(L);
        lua_pushinteger(L, w.mVertexId+1);
        lua_setfield(L, -2, "vertex");
        lua_pushnumber(L, w.mWeight);
        lua_setfield(L, -2, "weight");
        lua_rawseti(L, -2, i+1);
#undef w
        }
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8143(%rip), %rdx      # 0x10482
movl $0x1, %esi
callq 0x66f0
movq %rax, %r14
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
cmpq $0x0, 0x418(%r14)
je 0x8405
cmpl $0x0, 0x404(%r14)
je 0x8405
xorl %r15d, %r15d
leaq 0x814e(%rip), %r12      # 0x104ce
leaq 0x814e(%rip), %r13      # 0x104d5
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
movq 0x418(%r14), %rax
movl (%rax,%r15,8), %esi
incl %esi
movq %rbx, %rdi
callq 0x6300
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r12, %rdx
callq 0x62e0
movq 0x418(%r14), %rax
xorps %xmm0, %xmm0
cvtss2sd 0x4(%rax,%r15,8), %xmm0
movq %rbx, %rdi
callq 0x6500
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r13, %rdx
callq 0x62e0
incq %r15
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r15, %rdx
callq 0x6470
movl 0x404(%r14), %eax
cmpq %rax, %r15
jb 0x8387
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/camera.c
// Function: moonassimp_newcamera
int newcamera(lua_State *L, scene_t *scene, camera_t *camera)
    {
    ud_t *ud;
    TRACE_CREATE(camera, "camera");
    ud = newuserdata(L, (void*)camera, CAMERA_MT);
    ud->scene = scene;
    return 1;   
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x80ab(%rip), %rdi      # 0x10500
movq %rdx, %rsi
xorl %eax, %eax
callq 0x6710
leaq 0x80ae(%rip), %rdx      # 0x10514
movq %r15, %rdi
movq %rbx, %rsi
callq 0x68c0
movq %r14, 0x10(%rax)
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/enums.c
// Function: moonassimp_checkanimbehaviour
unsigned int checkanimbehaviour(lua_State *L, int arg)
    {
    const char *s = luaL_checkstring(L, arg);
#define CASE(CODE,str) if((strcmp(s, str)==0)) return CODE
    CASE(aiAnimBehaviour_DEFAULT, "default");
    CASE(aiAnimBehaviour_CONSTANT, "constant");
    CASE(aiAnimBehaviour_LINEAR, "linear");
    CASE(aiAnimBehaviour_REPEAT, "repeat");
#undef CASE
    return (unsigned int)luaL_argerror(L, arg, badvalue(L,s));
    }

// Assembly:
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 0x8023(%rip), %rsi      # 0x10688
movq %rax, %rdi
callq 0x6420
testl %eax, %eax
je 0x86ec
leaq 0x831e(%rip), %rsi      # 0x10996
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x86d6
leaq 0x8320(%rip), %rsi      # 0x109ab
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x86de
leaq 0x7ff2(%rip), %rsi      # 0x10690
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x86e6
leaq 0x7b6d(%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 0x86ec
movl $0x2, %r12d
jmp 0x86ec
movl $0x3, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/enums.c
// Function: moonassimp_pushanimbehaviour
int pushanimbehaviour(lua_State *L, unsigned int value)
    {
    switch(value)
        {
#define CASE(CODE,str) case CODE: lua_pushstring(L, str); break
    CASE(aiAnimBehaviour_DEFAULT, "default");
    CASE(aiAnimBehaviour_CONSTANT, "constant");
    CASE(aiAnimBehaviour_LINEAR, "linear");
    CASE(aiAnimBehaviour_REPEAT, "repeat");
#undef CASE
        default:
            return unexpected(L);
        }
    return 1;
    }

// Assembly:
cmpl $0x3, %esi
ja 0x8741
pushq %rax
movl %esi, %eax
leaq 0x7e96(%rip), %rcx      # 0x105a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x7f6e(%rip), %rsi      # 0x10688
jmp 0x8735
leaq 0x8288(%rip), %rsi      # 0x109ab
jmp 0x8735
leaq 0x7f64(%rip), %rsi      # 0x10690
jmp 0x8735
leaq 0x8261(%rip), %rsi      # 0x10996
callq 0x6920
movl $0x1, %eax
popq %rcx
retq
leaq 0x7a6e(%rip), %rsi      # 0x101b6
leaq 0x7f48(%rip), %rdx      # 0x10697
movl $0x38, %ecx
xorl %eax, %eax
jmp 0x67a0
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/enums.c
// Function: moonassimp_checklogstream
unsigned int checklogstream(lua_State *L, int arg)
    {
    const char *s = luaL_checkstring(L, arg);
#define CASE(CODE,str) if((strcmp(s, str)==0)) return CODE
    CASE(0, "user"); // user Lua callback
    CASE(aiDefaultLogStream_FILE, "file");
    CASE(aiDefaultLogStream_STDOUT, "stdout");
    CASE(aiDefaultLogStream_STDERR, "stderr");
    //CASE(aiDefaultLogStream_DEBUGGER, "debugger");
#undef CASE
    return (unsigned int)luaL_argerror(L, arg, badvalue(L,s));
    }

// Assembly:
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 0x7f23(%rip), %rsi      # 0x1069f
movq %rax, %rdi
callq 0x6420
testl %eax, %eax
je 0x8803
leaq 0x8951(%rip), %rsi      # 0x110e0
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x87ed
leaq 0x7f02(%rip), %rsi      # 0x106a4
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x87f5
leaq 0x7ef6(%rip), %rsi      # 0x106ab
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x87fd
leaq 0x7a56(%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 0x8803
movl $0x2, %r12d
jmp 0x8803
movl $0x4, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/enums.c
// Function: moonassimp_pushlogstream
int pushlogstream(lua_State *L, unsigned int value)
    {
    switch(value)
        {
#define CASE(CODE,str) case CODE: lua_pushstring(L, str); break
    CASE(0, "user"); // user Lua callback
    CASE(aiDefaultLogStream_FILE, "file");
    CASE(aiDefaultLogStream_STDOUT, "stdout");
    CASE(aiDefaultLogStream_STDERR, "stderr");
    //CASE(aiDefaultLogStream_DEBUGGER, "debugger");
#undef CASE
        default:
            return unexpected(L);
        }
    return 1;
    }

// Assembly:
pushq %rax
cmpl $0x4, %esi
ja 0x8858
movl %esi, %eax
leaq 0x7d8f(%rip), %rcx      # 0x105b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x7e6e(%rip), %rsi      # 0x1069f
jmp 0x884c
leaq 0x7e6a(%rip), %rsi      # 0x106a4
jmp 0x884c
leaq 0x889d(%rip), %rsi      # 0x110e0
jmp 0x884c
leaq 0x7e5f(%rip), %rsi      # 0x106ab
callq 0x6920
movl $0x1, %eax
popq %rcx
retq
leaq 0x7957(%rip), %rsi      # 0x101b6
leaq 0x7e31(%rip), %rdx      # 0x10697
movl $0x5b, %ecx
xorl %eax, %eax
popq %r8
jmp 0x67a0
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/enums.c
// Function: moonassimp_checkblendmode
unsigned int checkblendmode(lua_State *L, int arg)
    {
    const char *s = luaL_checkstring(L, arg);
#define CASE(CODE,str) if((strcmp(s, str)==0)) return CODE
    CASE(aiBlendMode_Default, "default");
    CASE(aiBlendMode_Additive, "additive");
#undef CASE
    return (unsigned int)luaL_argerror(L, arg, badvalue(L,s));
    }

// Assembly:
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 0x7df3(%rip), %rsi      # 0x10688
movq %rax, %rdi
callq 0x6420
testl %eax, %eax
je 0x88e6
leaq 0x7e0a(%rip), %rsi      # 0x106b2
movq %r15, %rdi
callq 0x6420
testl %eax, %eax
je 0x88e0
leaq 0x7963(%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
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonassimp/src/enums.c
// Function: moonassimp_pushblendmode
int pushblendmode(lua_State *L, unsigned int value)
    {
    switch(value)
        {
#define CASE(CODE,str) case CODE: lua_pushstring(L, str); break
    CASE(aiBlendMode_Default, "default");
    CASE(aiBlendMode_Additive, "additive");
#undef CASE
        default:
            return unexpected(L);
        }
    return 1;
    }

// Assembly:
pushq %rax
cmpl $0x1, %esi
je 0x8908
testl %esi, %esi
jne 0x891b
leaq 0x7d82(%rip), %rsi      # 0x10688
jmp 0x890f
leaq 0x7da3(%rip), %rsi      # 0x106b2
callq 0x6920
movl $0x1, %eax
popq %rcx
retq
leaq 0x7894(%rip), %rsi      # 0x101b6
leaq 0x7d6e(%rip), %rdx      # 0x10697
movl $0x77, %ecx
xorl %eax, %eax
popq %r8
jmp 0x67a0