LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonassimp/src/texture.c
// Function: moonassimp_newtexture
int newtexture(lua_State *L, scene_t *scene, texture_t *texture)
    {
    ud_t *ud;
    TRACE_CREATE(texture, "texture");
    ud = newuserdata(L, (void*)texture, TEXTURE_MT);
    ud->scene = scene;
    return 1;   
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x36d8(%rip), %rdi      # 0x115c1
movq %rdx, %rsi
xorl %eax, %eax
callq 0x6710
leaq 0x36dc(%rip), %rdx      # 0x115d6
movq %r15, %rdi
movq %rbx, %rsi
callq 0x68c0
movq %r14, 0x10(%rax)
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonassimp/src/texture.c
// Function: Data
static int Data(lua_State *L)
/* returns data as a binary string */
    {
    size_t len;
    texture_t *texture = checktexture(L, 1);
    if(!Compressed(texture)) return 0;
    len = texture->mWidth;
    lua_pushlstring(L, (char*)(texture->pcData), len);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x3565(%rip), %rdx      # 0x115d6
movl $0x1, %esi
callq 0x66f0
xorl %ecx, %ecx
cmpl $0x0, 0x4(%rax)
jne 0xe096
movl (%rax), %edx
movq 0x18(%rax), %rsi
movq %rbx, %rdi
callq 0x6670
movl $0x1, %ecx
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonassimp/src/texture.c
// Function: Texel_
static int Texel_(lua_State *L, int asfloat)
    {
    unsigned int u, v, i;
    texture_t *texture = checktexture(L, 1);
    if(Compressed(texture)) return 0;
    u = checkindex(L, 2);
    v = checkindex(L, 3);
    if(u >= texture->mWidth)
        return luaL_argerror(L, 2, "out of range");
    if(v >= texture->mHeight)
        return luaL_argerror(L, 3, "out of range");
    i =  v * texture->mWidth + u; /* texel index */
    if(asfloat)
        return pushtexelf(L, &(texture->pcData[i]), 0);
    return pushtexel(L, &(texture->pcData[i]), 0);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x34f9(%rip), %rdx      # 0x115d6
movl $0x1, %esi
callq 0x66f0
cmpl $0x0, 0x4(%rax)
je 0xe141
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x6310
movl %eax, %r15d
movq %rbx, %rdi
movl $0x3, %esi
callq 0x6310
movl (%r14), %esi
cmpl %esi, %r15d
jae 0xe14e
cmpl 0x4(%r14), %eax
jae 0xe15f
imull %eax, %esi
addl %r15d, %esi
shlq $0x2, %rsi
addq 0x18(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
addq $0x8, %rsp
testl %ebp, %ebp
je 0xe17d
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x69c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2054(%rip), %rdx      # 0x101a9
movq %rbx, %rdi
movl $0x2, %esi
jmp 0xe16e
leaq 0x2043(%rip), %rdx      # 0x101a9
movq %rbx, %rdi
movl $0x3, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x61c0
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x69c8
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonassimp/src/texture.c
// Function: Texels_
static int Texels_(lua_State *L, int asfloat)
/* returns a W*H matrix (table) of textels (4-value tables) */
    {
#define W texture->mWidth
#define H texture->mHeight
    unsigned int u, v, i;
    int (*push)(lua_State*L, texel_t*, int) = (asfloat==0) ? pushtexel : pushtexelf;
    texture_t *texture = checktexture(L, 1);
    if(Compressed(texture)) return 0;
    lua_newtable(L);
    for(v = 0; v < H; v++)
        {
        lua_newtable(L); /* v-th row */
        for(u = 0; u < W; u++)
            {
            i =  v*W + u; /* texel index */
            push(L, &(texture->pcData[i]), 1); /* u-th texel in the v-th row */
            lua_rawseti(L, -2, u+1);
            }
        lua_rawseti(L, -2, v+1);
        }   
    return 1;
#undef W
#undef H
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jne 0xe1a3
movq 0x9e47(%rip), %r13      # 0x17fe8
jmp 0xe1aa
movq 0x9e26(%rip), %r13      # 0x17fd0
leaq 0x3425(%rip), %rdx      # 0x115d6
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x66f0
cmpl $0x0, 0x4(%rax)
je 0xe254
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
cmpl $0x0, 0x4(%r14)
je 0xe256
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
movl (%r14), %esi
testl %esi, %esi
je 0xe231
xorl %r12d, %r12d
imull %r15d, %esi
addl %r12d, %esi
shlq $0x2, %rsi
addq 0x18(%r14), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq *%r13
incq %r12
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r12, %rdx
callq 0x6460
movl (%r14), %esi
cmpq %rsi, %r12
jb 0xe1fc
incq %r15
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r15, %rdx
callq 0x6460
movl 0x4(%r14), %eax
cmpq %rax, %r15
jb 0xe1e6
movl $0x1, %ebp
jmp 0xe256
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonassimp/src/udata.c
// Function: moonassimp_udata_unref
int udata_unref(lua_State *L, const void *ptr)
/* unreference udata so that it will be garbage collected */
    {
//  printf("unref object %p\n", ptr);
    udata_t *udata = udata_search((uintptr_t)ptr);
    if(!udata) 
        return luaL_error(L, "invalid object pointer %p", ptr);
    if(udata->ref != LUA_NOREF)
        {
        luaL_unref(L, LUA_REGISTRYINDEX, udata->ref);
        udata->ref = LUA_NOREF;
        }
    return 0;
    }

// Assembly:
pushq %rbx
movq %rsi, %rdx
movq 0x9f31(%rip), %rbx      # 0x18510
testq %rbx, %rbx
je 0xe5f5
cmpq %rdx, 0x20(%rbx)
ja 0xe5f0
jae 0xe5f7
addq $0x8, %rbx
movq (%rbx), %rbx
jmp 0xe5df
xorl %ebx, %ebx
testq %rbx, %rbx
je 0xe619
movl 0x28(%rbx), %edx
cmpl $-0x2, %edx
je 0xe615
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x6910
movl $0xfffffffe, 0x28(%rbx) # imm = 0xFFFFFFFE
xorl %eax, %eax
popq %rbx
retq
leaq 0x3082(%rip), %rsi      # 0x116a2
xorl %eax, %eax
popq %rbx
jmp 0x67a0
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonassimp/src/udata.c
// Function: moonassimp_udata_free
int udata_free(lua_State *L, const void *ptr)
/* this should be called in the __gc metamethod
 */
    {
    udata_t *udata = udata_search((uintptr_t)ptr);
//  printf("free object %p\n", ptr);
    if(!udata) 
        return luaL_error(L, "invalid object pointer %p", ptr);
    /* release all references */
    if(udata->ref != LUA_NOREF)
        luaL_unref(L, LUA_REGISTRYINDEX, udata->ref);
    udata_remove(udata);
    free(udata);
    /* mem is released by Lua at garbage collection */
    return 0;
    }

// Assembly:
pushq %rbx
movq %rsi, %rdx
movq 0x9edd(%rip), %rbx      # 0x18510
testq %rbx, %rbx
je 0xe649
cmpq %rdx, 0x20(%rbx)
ja 0xe644
jae 0xe64b
addq $0x8, %rbx
movq (%rbx), %rbx
jmp 0xe633
xorl %ebx, %ebx
testq %rbx, %rbx
je 0xe676
movl 0x28(%rbx), %edx
cmpl $-0x2, %edx
je 0xe662
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x6910
movq %rbx, %rdi
callq 0xe685
movq %rbx, %rdi
callq 0x60a0
xorl %eax, %eax
popq %rbx
retq
leaq 0x3025(%rip), %rsi      # 0x116a2
xorl %eax, %eax
popq %rbx
jmp 0x67a0
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonassimp/src/udata.c
// Function: moonassimp_udata_push
int udata_push(lua_State *L, const void *ptr)
    {
    udata_t *udata = udata_search((uintptr_t)ptr);
//  printf("push object %p\n", ptr);
    if(!udata) 
        return luaL_error(L, "invalid object pointer %p", ptr);
    if(udata->ref == LUA_NOREF)
        return luaL_error(L, "unreferenced object");
    if(lua_rawgeti(L, LUA_REGISTRYINDEX, udata->ref) != LUA_TUSERDATA)
        return luaL_error(L, UNEXPECTED_ERROR);
    return 1; /* one value pushed */
    }

// Assembly:
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x9aa8(%rip), %rax      # 0x18510
testq %rax, %rax
je 0xea7e
cmpq %rdx, 0x20(%rax)
ja 0xea79
jae 0xea80
addq $0x8, %rax
movq (%rax), %rax
jmp 0xea68
xorl %eax, %eax
testq %rax, %rax
je 0xeaa1
movslq 0x28(%rax), %rdx
cmpq $-0x2, %rdx
jne 0xeab3
leaq 0x2c26(%rip), %rsi      # 0x116bc
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x67a0
leaq 0x2bfa(%rip), %rsi      # 0x116a2
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x67a0
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x62b0
cmpl $0x7, %eax
jne 0xeacc
movl $0x1, %eax
popq %rbx
retq
leaq 0x16e3(%rip), %rsi      # 0x101b6
leaq 0x2bf6(%rip), %rdx      # 0x116d0
movq %rbx, %rdi
movl $0xa3, %ecx
xorl %eax, %eax
popq %rbx
jmp 0x67a0
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonassimp/src/udata.c
// Function: moonassimp_udata_free_all
void udata_free_all(void)
/* free all without unreferencing (for atexit()) */
    {
    udata_t *udata;
    while((udata = udata_first(0)))
        {
        udata_remove(udata);
        free(udata);
        }
    }

// Assembly:
pushq %rbx
movq 0x9a1e(%rip), %rax      # 0x18510
testq %rax, %rax
je 0xeb0b
movq %rax, %rbx
cmpq $0x0, 0x20(%rax)
je 0xeb0d
movq (%rbx), %rax
testq %rax, %rax
jne 0xeaf7
jmp 0xeb0d
xorl %ebx, %ebx
testq %rbx, %rbx
je 0xeb24
movq %rbx, %rdi
callq 0xe685
movq %rbx, %rdi
callq 0x60a0
jmp 0xeaeb
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonassimp/src/utils.c
// Function: moonassimp_checkindex
int checkindex(lua_State *L, int arg)
    {
    int val = luaL_checkinteger(L, arg);
    if(val < 1)
        return luaL_argerror(L, arg, "positive integer expected");
    return val - 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x6430
testl %eax, %eax
jle 0xf0aa
decl %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x26d4(%rip), %rdx      # 0x11785
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x61c0
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonassimp/src/utils.c
// Function: moonassimp_optindex
int optindex(lua_State *L, int arg, int optval /* 0-based */)
    {
    int val = luaL_optinteger(L, arg, optval + 1);
    if(val < 1)
        return luaL_argerror(L, arg, "positive integer expected");
    return val - 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
incl %edx
movslq %edx, %rdx
callq 0x6540
testl %eax, %eax
jle 0xf0e3
decl %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x269b(%rip), %rdx      # 0x11785
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x61c0
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonassimp/src/utils.c
// Function: moonassimp_pushvector2
int pushvector2(lua_State *L, vector2_t *vec, int astable)
    {
    if(astable)
        {
        lua_newtable(L);
        lua_pushnumber(L, vec->x); lua_seti(L, -2, 1);
        lua_pushnumber(L, vec->y); lua_seti(L, -2, 2);
        return 1;
        }
    lua_pushnumber(L, vec->x);  
    lua_pushnumber(L, vec->y);  
    return 2;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0xf168
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
cvtss2sd (%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
movl $0x1, %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x63e0
xorps %xmm0, %xmm0
cvtss2sd 0x4(%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
movl $0x2, %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x63e0
movl $0x1, %eax
jmp 0xf18b
cvtss2sd (%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
xorps %xmm0, %xmm0
cvtss2sd 0x4(%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonassimp/src/utils.c
// Function: moonassimp_pushvector3
int pushvector3(lua_State *L, vector3_t *vec, int astable)
    {
    if(astable)
        {
        lua_newtable(L);
        lua_pushnumber(L, vec->x); lua_seti(L, -2, 1);
        lua_pushnumber(L, vec->y); lua_seti(L, -2, 2);
        lua_pushnumber(L, vec->z); lua_seti(L, -2, 3);
        return 1;
        }
    lua_pushnumber(L, vec->x);  
    lua_pushnumber(L, vec->y);  
    lua_pushnumber(L, vec->z);  
    return 3;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0xf219
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
cvtss2sd (%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
movl $0x1, %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x63e0
xorps %xmm0, %xmm0
cvtss2sd 0x4(%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
movl $0x2, %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x63e0
xorps %xmm0, %xmm0
cvtss2sd 0x8(%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
movl $0x3, %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x63e0
movl $0x1, %eax
jmp 0xf24d
cvtss2sd (%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
xorps %xmm0, %xmm0
cvtss2sd 0x4(%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
xorps %xmm0, %xmm0
cvtss2sd 0x8(%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
movl $0x3, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonassimp/src/utils.c
// Function: moonassimp_pushcolor3
int pushcolor3(lua_State *L, color3_t *col, int astable)
    {
    if(astable)
        {
        lua_newtable(L);
        lua_pushnumber(L, col->r); lua_seti(L, -2, 1);
        lua_pushnumber(L, col->g); lua_seti(L, -2, 2);
        lua_pushnumber(L, col->b); lua_seti(L, -2, 3);
        return 1;
        }
    lua_pushnumber(L, col->r);  
    lua_pushnumber(L, col->g);  
    lua_pushnumber(L, col->b);  
    return 3;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0xf2db
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
cvtss2sd (%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
movl $0x1, %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x63e0
xorps %xmm0, %xmm0
cvtss2sd 0x4(%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
movl $0x2, %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x63e0
xorps %xmm0, %xmm0
cvtss2sd 0x8(%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
movl $0x3, %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x63e0
movl $0x1, %eax
jmp 0xf30f
cvtss2sd (%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
xorps %xmm0, %xmm0
cvtss2sd 0x4(%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
xorps %xmm0, %xmm0
cvtss2sd 0x8(%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
movl $0x3, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonassimp/src/utils.c
// Function: moonassimp_pushcolor4
int pushcolor4(lua_State *L, color4_t *col, int astable)
    {
    if(astable)
        {
        lua_newtable(L);
        lua_pushnumber(L, col->r); lua_seti(L, -2, 1);
        lua_pushnumber(L, col->g); lua_seti(L, -2, 2);
        lua_pushnumber(L, col->b); lua_seti(L, -2, 3);
        lua_pushnumber(L, col->a); lua_seti(L, -2, 4);
        return 1;
        }
    lua_pushnumber(L, col->r);  
    lua_pushnumber(L, col->g);  
    lua_pushnumber(L, col->b);  
    lua_pushnumber(L, col->a);  
    return 4;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0xf3c4
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
cvtss2sd (%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
movl $0x1, %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x63e0
xorps %xmm0, %xmm0
cvtss2sd 0x4(%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
movl $0x2, %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x63e0
xorps %xmm0, %xmm0
cvtss2sd 0x8(%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
movl $0x3, %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x63e0
xorps %xmm0, %xmm0
cvtss2sd 0xc(%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
movl $0x4, %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x63e0
movl $0x1, %eax
jmp 0xf409
cvtss2sd (%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
xorps %xmm0, %xmm0
cvtss2sd 0x4(%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
xorps %xmm0, %xmm0
cvtss2sd 0x8(%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
xorps %xmm0, %xmm0
cvtss2sd 0xc(%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
movl $0x4, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonassimp/src/utils.c
// Function: moonassimp_pushquaternion
int pushquaternion(lua_State *L, quaternion_t *quat, int astable)
    {
    if(astable)
        {
        lua_newtable(L);
        lua_pushnumber(L, quat->w); lua_seti(L, -2, 1);
        lua_pushnumber(L, quat->x); lua_seti(L, -2, 2);
        lua_pushnumber(L, quat->y); lua_seti(L, -2, 3);
        lua_pushnumber(L, quat->z); lua_seti(L, -2, 4);
        return 1;
        }
    lua_pushnumber(L, quat->w); 
    lua_pushnumber(L, quat->x); 
    lua_pushnumber(L, quat->y); 
    lua_pushnumber(L, quat->z); 
    return 4;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0xf4be
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
cvtss2sd (%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
movl $0x1, %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x63e0
xorps %xmm0, %xmm0
cvtss2sd 0x4(%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
movl $0x2, %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x63e0
xorps %xmm0, %xmm0
cvtss2sd 0x8(%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
movl $0x3, %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x63e0
xorps %xmm0, %xmm0
cvtss2sd 0xc(%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
movl $0x4, %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x63e0
movl $0x1, %eax
jmp 0xf503
cvtss2sd (%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
xorps %xmm0, %xmm0
cvtss2sd 0x4(%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
xorps %xmm0, %xmm0
cvtss2sd 0x8(%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
xorps %xmm0, %xmm0
cvtss2sd 0xc(%r14), %xmm0
movq %rbx, %rdi
callq 0x64f0
movl $0x4, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonassimp/src/utils.c
// Function: moonassimp_pushtexel
int pushtexel(lua_State *L, texel_t *vec, int astable)
    {
    if(astable)
        {
        lua_newtable(L);
        lua_pushinteger(L, vec->r); lua_seti(L, -2, 1);
        lua_pushinteger(L, vec->g); lua_seti(L, -2, 2);
        lua_pushinteger(L, vec->b); lua_seti(L, -2, 3);
        lua_pushinteger(L, vec->a); lua_seti(L, -2, 4);
        return 1;
        }
    lua_pushinteger(L, vec->r); 
    lua_pushinteger(L, vec->g); 
    lua_pushinteger(L, vec->b); 
    lua_pushinteger(L, vec->a); 
    return 4;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0xf5ab
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
movzbl 0x2(%r14), %esi
movq %rbx, %rdi
callq 0x6300
movl $0x1, %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x63e0
movzbl 0x1(%r14), %esi
movq %rbx, %rdi
callq 0x6300
movl $0x2, %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x63e0
movzbl (%r14), %esi
movq %rbx, %rdi
callq 0x6300
movl $0x3, %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x63e0
movzbl 0x3(%r14), %esi
movq %rbx, %rdi
callq 0x6300
movl $0x4, %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x63e0
movl $0x1, %eax
jmp 0xf5e3
movzbl 0x2(%r14), %esi
movq %rbx, %rdi
callq 0x6300
movzbl 0x1(%r14), %esi
movq %rbx, %rdi
callq 0x6300
movzbl (%r14), %esi
movq %rbx, %rdi
callq 0x6300
movzbl 0x3(%r14), %esi
movq %rbx, %rdi
callq 0x6300
movl $0x4, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonassimp/src/utils.c
// Function: moonassimp_pushtexelf
int pushtexelf(lua_State *L, texel_t *vec, int astable)
    {
    if(astable)
        {
        lua_newtable(L);
        lua_pushnumber(L, vec->r/255.f); lua_seti(L, -2, 1);
        lua_pushnumber(L, vec->g/255.f); lua_seti(L, -2, 2);
        lua_pushnumber(L, vec->b/255.f); lua_seti(L, -2, 3);
        lua_pushnumber(L, vec->a/255.f); lua_seti(L, -2, 4);
        return 1;
        }
    lua_pushnumber(L, vec->r/255.f);    
    lua_pushnumber(L, vec->g/255.f);    
    lua_pushnumber(L, vec->b/255.f);    
    lua_pushnumber(L, vec->a/255.f);    
    return 4;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0xf6d7
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
movzbl 0x2(%r14), %eax
cvtsi2ss %eax, %xmm0
divss 0x20fe(%rip), %xmm0     # 0x11718
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x64f0
movl $0x1, %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x63e0
movzbl 0x1(%r14), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss 0x20cc(%rip), %xmm0     # 0x11718
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x64f0
movl $0x2, %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x63e0
movzbl (%r14), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss 0x209b(%rip), %xmm0     # 0x11718
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x64f0
movl $0x3, %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x63e0
movzbl 0x3(%r14), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss 0x2069(%rip), %xmm0     # 0x11718
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x64f0
movl $0x4, %edx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x63e0
movl $0x1, %eax
jmp 0xf758
movzbl 0x2(%r14), %eax
cvtsi2ss %eax, %xmm0
divss 0x2030(%rip), %xmm0     # 0x11718
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x64f0
movzbl 0x1(%r14), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss 0x2010(%rip), %xmm0     # 0x11718
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x64f0
movzbl (%r14), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss 0x1ff1(%rip), %xmm0     # 0x11718
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x64f0
movzbl 0x3(%r14), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss 0x1fd1(%rip), %xmm0     # 0x11718
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x64f0
movl $0x4, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonassimp/src/utils.c
// Function: moonassimp_newuserdata
ud_t *newuserdata(lua_State *L, void *ptr, const char *mt)
    {
    ud_t *ud;
    ud = (ud_t*)udata_new(L, sizeof(ud_t), ptr, mt);
    memset(ud, 0, sizeof(ud_t));
    ud->obj = ptr ? ptr : (void*)ud;
    MarkValid(ud);
    return ud;
    }

// Assembly:
pushq %rbx
movq %rdx, %rcx
movq %rsi, %rbx
movl $0x30, %esi
movq %rbx, %rdx
callq 0x6280
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
testq %rbx, %rbx
cmoveq %rax, %rbx
movq %rbx, (%rax)
orb $0x1, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonassimp/src/utils.c
// Function: moonassimp_freeuserdata
int freeuserdata(lua_State *L, void *ptr)
    {
    ud_t *ud = userdata(ptr);
    if(!ud || !IsValid(ud))
        return 0; /* already deleted */
    CancelValid(ud);
    udata_free(L, ptr);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x6770
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0xfe85
movl 0x8(%rcx), %edx
testb $0x1, %dl
je 0xfe85
andl $-0x2, %edx
movl %edx, 0x8(%rcx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x62c0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonassimp/src/utils.c
// Function: moonassimp_testxxx
void* testxxx(lua_State *L, int arg, const char *mt)
    {
    ud_t *ud = (ud_t*)udata_test(L, arg, mt);
    if(ud && IsValid(ud))
        return ud->obj;
    return NULL;
    }

// Assembly:
pushq %rax
callq 0x6730
testq %rax, %rax
je 0xfe9e
testb $0x1, 0x8(%rax)
jne 0xfea2
xorl %eax, %eax
jmp 0xfea5
movq (%rax), %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonassimp/src/utils.c
// Function: moonassimp_checkxxx
void* checkxxx(lua_State *L, int arg, const char *mt)
    {
    void *p = testxxx(L, arg, mt);
    if(p) return p;
    lua_pushfstring(L, "not a %s", mt);
    luaL_argerror(L, arg, lua_tostring(L, -1));
    return NULL;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
callq 0x6730
testq %rax, %rax
je 0xfec7
testb $0x1, 0x8(%rax)
jne 0xfecc
xorl %r12d, %r12d
jmp 0xfecf
movq (%rax), %r12
testq %r12, %r12
jne 0xff07
leaq 0x18c4(%rip), %rsi      # 0x1179f
xorl %r12d, %r12d
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x63d0
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x61e0
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
callq 0x61c0
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/videolan[P]bitstream/examples/rtp_check_seqnum.c
// Function: main
int main(int i_argc, char **ppsz_argv)
{
    int i_packet_size = DEFAULT_PACKET_SIZE;

    if (ppsz_argv[1] != NULL &&
        (!strcmp(ppsz_argv[1], "-h") || !strcmp(ppsz_argv[1], "--help")))
        usage(ppsz_argv[0]);

    if (ppsz_argv[1] != NULL)
        i_packet_size = atoi(ppsz_argv[1]);
    if (i_packet_size > 65535 || i_packet_size < RTP_HEADER_SIZE)
        usage(ppsz_argv[0]);

    uint8_t p_buffer[i_packet_size];
    uint16_t i_seqnum = 0;

    for ( ; ; ) {
        ssize_t toto;
        if ((toto=read(STDIN_FILENO, p_buffer, i_packet_size)) != i_packet_size) {
            fprintf(stderr, "couldn't read %zd\n", toto);
            exit(EXIT_FAILURE);
        }

        if (!rtp_check_hdr(p_buffer)) {
            fprintf(stderr, "invalid RTP header\n");
            continue;
        }

        uint16_t i_new_seqnum = rtp_get_seqnum(p_buffer);
        if (i_new_seqnum != i_seqnum)
            fprintf(stderr, "received packet %hu while expecting %hu\n",
                    i_new_seqnum, i_seqnum);
        i_seqnum = (i_new_seqnum + 1) % 65536;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rsi), %r15
movl $0x530, %r14d           # imm = 0x530
testq %r15, %r15
jne 0x1261
leal -0x10000(%r14), %eax
cmpl $0xffff000b, %eax       # imm = 0xFFFF000B
jbe 0x1287
movl %r14d, %ebx
movq %rsp, %r14
leaq 0xf(%rbx), %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
xorl %edi, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1030
cmpq %rbx, %rax
jne 0x129d
movq 0x2e05(%rip), %r13      # 0x3ff8
xorl %r12d, %r12d
movb (%r14), %al
andb $-0x40, %al
negb %al
jno 0x1229
movzwl 0x2(%r14), %r15d
rolw $0x8, %r15w
cmpw %r12w, %r15w
jne 0x1245
incl %r15d
movl %r15d, %r12d
xorl %edi, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1030
cmpq %rbx, %rax
je 0x11f6
jmp 0x129d
movq (%r13), %rcx
movl $0x13, %esi
movl $0x1, %edx
leaq 0xde3(%rip), %rdi       # 0x2021
callq 0x1080
jmp 0x1215
movzwl %r15w, %edx
movzwl %r12w, %ecx
movq (%r13), %rdi
leaq 0xddd(%rip), %rsi       # 0x2035
xorl %eax, %eax
callq 0x1050
jmp 0x120f
leaq 0xd9c(%rip), %rsi       # 0x2004
movq %r15, %rdi
callq 0x1040
testl %eax, %eax
je 0x1287
leaq 0xd8c(%rip), %rsi       # 0x2007
movq %r15, %rdi
callq 0x1040
testl %eax, %eax
jne 0x12c2
movq (%rbx), %rdx
movq 0x2d67(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xdc3(%rip), %rsi       # 0x205e
jmp 0x12b1
movq 0x2d54(%rip), %rcx      # 0x3ff8
movq (%rcx), %rdi
leaq 0xd60(%rip), %rsi       # 0x200e
movq %rax, %rdx
xorl %eax, %eax
callq 0x1050
movl $0x1, %edi
callq 0x1070
testq %r15, %r15
je 0x11b0
movq %r15, %rdi
callq 0x1060
movl %eax, %r14d
jmp 0x11b0
// File: /workspace/github_c_makefile_star2_O1/evilwombat[P]gopro-fw-tools/h3-wifi-address.c
// Function: patch_buffer
static int patch_buffer(unsigned char *buf, int *offsets, unsigned char val, unsigned char old_val)
{
	int i;

	for (i = 0; offsets[i] != -1; i++) {
		if (buf[offsets[i]] != old_val) {
			printf("Patching mismatch at offset %08x, expected %02x, got %02x\n",
			       offsets[i], old_val, buf[offsets[i]]);
			return -1;
		}

		buf[offsets[i]] = val;
	}

	return 0;
}

// Assembly:
movq %rsi, %r8
movl (%rsi), %esi
xorl %eax, %eax
cmpl $-0x1, %esi
je 0x15ca
pushq %rax
addq $0x4, %r8
movslq %esi, %r10
movzbl (%rdi,%r10), %r9d
cmpb %cl, %r9b
jne 0x15ad
movb %dl, (%rdi,%r10)
movl (%r8), %esi
addq $0x4, %r8
cmpl $-0x1, %esi
jne 0x158e
jmp 0x15c6
movzbl %cl, %edx
leaq 0xcdf(%rip), %rdi       # 0x2296
movl %r9d, %ecx
xorl %eax, %eax
callq 0x1080
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_14/sort.c
// Function: main
int main(int argc, char *argv[])
{
  if (!parse_arg_list(argc, argv))
  {
    puts("Error: invalid arguments.");
    return EXIT_FAILURE;
  }

  size_t nr_of_lines;
  char *line_ptr[MAX_NR_OF_LINES];

  if ((nr_of_lines = read_lines(line_ptr, MAX_NR_OF_LINES)) != -1)
  {
    quick_sort((void **)line_ptr, 0, nr_of_lines - 1, (int (*)(void *, void *))comp);
    write_lines(line_ptr, nr_of_lines);
  }
  else
  {
    puts("Error: input too large.");
    return EXIT_FAILURE;
  }

  return EXIT_SUCCESS;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x9c40, %rsp           # imm = 0x9C40
callq 0x121a
testl %eax, %eax
je 0x11f1
movq %rsp, %rdi
movl $0x1388, %esi           # imm = 0x1388
callq 0x12b2
cmpq $-0x1, %rax
je 0x11fa
movq %rax, %r14
movq %rax, %rdx
decq %rdx
movq 0x2e8b(%rip), %rcx      # 0x4060
xorl %ebx, %ebx
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x13a6
movq %r15, %rdi
movq %r14, %rsi
callq 0x1448
jmp 0x120b
leaq 0xe0c(%rip), %rdi       # 0x2004
jmp 0x1201
leaq 0xe1d(%rip), %rdi       # 0x201e
callq 0x1040
movl $0x1, %ebx
movl %ebx, %eax
addq $0x9c40, %rsp           # imm = 0x9C40
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_14/sort.c
// Function: parse_arg_list
int parse_arg_list(int argc, char *argv[])
{
  for (int i = 1; i < argc; ++i)
  {
    size_t arg_len = strlen(argv[i]);
    if (arg_len > 1 && argv[i][0] == '-')
    {
      for (size_t j = 1; j < arg_len; ++j)
      {
        switch (argv[i][j])
        {
        case 'n':
          comp = numcmp;
          break;

        case 'r':
          order = -1;
          break;

        default:
          return 0;
          break;
        }
      }
    }
    else
    {
      return 0;
    }
  }

  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x2, %edi
setl %bpl
jge 0x1244
movzbl %bpl, %eax
andl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %rbx
movl %edi, %r15d
movl $0x1, %r12d
leaq 0x250(%rip), %r13       # 0x14a7
movq (%rbx,%r12,8), %r14
movq %r14, %rdi
callq 0x1060
cmpq $0x2, %rax
jb 0x122e
cmpb $0x2d, (%r14)
jne 0x122e
movl $0x1, %ecx
movq (%rbx,%r12,8), %rdx
movzbl (%rdx,%rcx), %edx
cmpl $0x72, %edx
je 0x128f
cmpl $0x6e, %edx
jne 0x122e
movq %r13, 0x2dd3(%rip)      # 0x4060
jmp 0x1299
movl $0xffffffff, 0x2dbf(%rip) # imm = 0xFFFFFFFF
incq %rcx
cmpq %rcx, %rax
jne 0x1274
incq %r12
cmpq %r15, %r12
setae %bpl
jne 0x1257
jmp 0x122e
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_14/sort.c
// Function: read_lines
size_t read_lines(char *line_ptr[], const size_t max_nr_of_lines)
{
  size_t line_length;
  size_t nr_of_lines = 0;

  char *current_line = alloc(MAX_LINE_LEN);
  char *current_line_copy = NULL;

  while ((line_length = get_line(current_line, MAX_LINE_LEN)))
  {
    if (nr_of_lines >= max_nr_of_lines || (current_line_copy = alloc(line_length)) == NULL)
    {
      return -1;
    }
    else
    {
      current_line[line_length - 1] = '\0';
      strcpy(current_line_copy, current_line);
      line_ptr[nr_of_lines++] = current_line_copy;
    }
  }

  afree(current_line);

  return nr_of_lines;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq 0x2d9e(%rip), %rbx      # 0x4068
leaq 0x2daf(%rip), %r13      # 0x4080
movq %r13, %rax
subq %rbx, %rax
addq $0x2710, %rax           # imm = 0x2710
cmpq $0x3e8, %rax            # imm = 0x3E8
jae 0x12e9
xorl %ebx, %ebx
jmp 0x12f7
leaq 0x3e8(%rbx), %rax
movq %rax, 0x2d71(%rip)      # 0x4068
movl $0x3e8, %esi            # imm = 0x3E8
movq %rbx, %rdi
callq 0x14ea
xorl %ebp, %ebp
testq %rax, %rax
je 0x136b
movq $-0x1, %rcx
cmpq %rbp, %r14
je 0x1394
movq 0x2d4a(%rip), %r12      # 0x4068
movq %r13, %rdx
subq %r12, %rdx
addq $0x2710, %rdx           # imm = 0x2710
cmpq %rax, %rdx
jae 0x1335
xorl %r12d, %r12d
jmp 0x1340
leaq (%r12,%rax), %rdx
movq %rdx, 0x2d28(%rip)      # 0x4068
testq %r12, %r12
je 0x1394
movb $0x0, -0x1(%rbx,%rax)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1030
movq %r12, (%r15,%rbp,8)
incq %rbp
movl $0x3e8, %esi            # imm = 0x3E8
movq %rbx, %rdi
callq 0x14ea
jmp 0x1306
leaq 0x2d0e(%rip), %rax      # 0x4080
cmpq %rax, %rbx
setae %cl
addq $0x2710, %rax           # imm = 0x2710
cmpq %rax, %rbx
setb %al
andb %cl, %al
cmpb $0x1, %al
jne 0x1391
movq %rbx, 0x2cd7(%rip)      # 0x4068
movq %rbp, %rcx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_14/sort.c
// Function: quick_sort
void quick_sort(void *v[], size_t start, size_t end, int (*comp)(void *, void *))
{
  if ((long)start >= (long)end)
  {
    return;
  }

  swap(v, start, (start + end) / 2);

  size_t last = start;
  for (size_t i = start + 1; i <= end; ++i)
  {
    if ((*comp)(v[i], v[start]) < 0)
    {
      swap(v, ++last, i);
    }
  }

  swap(v, start, last);
  quick_sort(v, start, last - 1, comp);
  quick_sort(v, last + 1, end, comp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
cmpq %r14, %r12
jge 0x1439
leaq (%r14,%r12), %rax
movq (%r15,%r12,8), %rcx
andq $-0x2, %rax
movq (%r15,%rax,4), %rdx
movq %rdx, (%r15,%r12,8)
movq %rcx, (%r15,%rax,4)
leaq 0x1(%r12), %rbp
movq %r12, %r13
cmpq %r14, %rbp
ja 0x140f
movq (%r15,%rbp,8), %rdi
movq (%r15,%r12,8), %rsi
callq *%rbx
testl %eax, %eax
jns 0x140a
movq 0x8(%r15,%r13,8), %rax
movq (%r15,%rbp,8), %rcx
movq %rcx, 0x8(%r15,%r13,8)
incq %r13
movq %rax, (%r15,%rbp,8)
incq %rbp
jmp 0x13e2
movq (%r15,%r12,8), %rax
movq (%r15,%r13,8), %rcx
movq %rcx, (%r15,%r12,8)
movq %rax, (%r15,%r13,8)
leaq -0x1(%r13), %rdx
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rcx
callq 0x13a6
incq %r13
movq %r13, %r12
jmp 0x13bd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_14/sort.c
// Function: numcmp
int numcmp(const char *s1, const char *s2)
{
  double nr1 = atof(s1);
  double nr2 = atof(s2);

  if (nr1 < nr2)
  {
    return order * -1;
  }
  else if (nr1 > nr2)
  {
    return order * 1;
  }

  return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
callq 0x1050
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x1050
movsd 0x8(%rsp), %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
jbe 0x14d8
subl 0x2b82(%rip), %eax      # 0x4058
jmp 0x14e4
ucomisd %xmm0, %xmm1
jbe 0x14e4
movl 0x2b74(%rip), %eax      # 0x4058
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ryuichiueda[P]glueutils/src/ign12.c
// Function: usage
void usage(void){
	fputs("ign2: erase stderr\n", stderr);
	fputs("usage: ign2 <command> [args]\n", stderr);
	fputs("\nCopyright (C) 2021 Ryuichi Ueda\n", stderr);
	fputs("Released under the MIT License.\n", stderr);
	fputs("https://github.com/ryuichiueda/glueutils\n", stderr);
}

// Assembly:
pushq %rbx
movq 0x2f20(%rip), %rbx      # 0x3ff8
movq (%rbx), %rsi
leaq 0xf22(%rip), %rdi       # 0x2004
callq 0x1060
movq (%rbx), %rsi
leaq 0xf27(%rip), %rdi       # 0x2018
callq 0x1060
movq (%rbx), %rsi
leaq 0xf36(%rip), %rdi       # 0x2036
callq 0x1060
movq (%rbx), %rsi
leaq 0xf49(%rip), %rdi       # 0x2058
callq 0x1060
movq (%rbx), %rsi
leaq 0xf5b(%rip), %rdi       # 0x2079
popq %rbx
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O1/ryuichiueda[P]glueutils/src/ign12.c
// Function: tryopen
int tryopen(char *filename){
	int fd = open(filename, O_WRONLY);
	if(fd < 0){
		printf("Error: %s: %s\n", filename, strerror(errno));
		exit(1);
	}

	return fd;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
xorl %eax, %eax
callq 0x1080
testl %eax, %eax
js 0x1284
popq %rbx
retq
callq 0x1030
movl (%rax), %edi
callq 0x10b0
leaq 0xe17(%rip), %rdi       # 0x20ae
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1050
movl $0x1, %edi
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O1/ryuichiueda[P]glueutils/src/ign12.c
// Function: main
int main(int argc, char * argv[])
{
	if(argc < 2){
		usage();
		exit(1);
	}

	int fd = tryopen("/dev/null");
	trydup2(1, fd);
	trydup2(2, fd);

	return - execvp(argv[1], &argv[1]);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpl $0x1, %edi
jle 0x12f8
movq %rsi, %rbx
leaq 0xdfd(%rip), %rdi       # 0x20bd
callq 0x126e
movl %eax, %ebp
movl $0x1, %edi
movl %eax, %esi
callq 0x122c
movl $0x2, %edi
movl %ebp, %esi
callq 0x122c
movq 0x8(%rbx), %rdi
addq $0x8, %rbx
movq %rbx, %rsi
callq 0x1090
negl %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1124
// File: /workspace/github_c_makefile_star2_O1/xiongxu[P]bam2bedGraph2/samtools-0.1.19/misc/maq2sam.c
// Function: maq_delete_maqmap
void maq_delete_maqmap(maqmap_t *mm)
{
	int i;
	if (mm == 0) return;
	for (i = 0; i < mm->n_ref; ++i)
		free(mm->ref_name[i]);
	free(mm->ref_name);
	free(mm->mapped_reads);
	free(mm);
}

// Assembly:
testq %rdi, %rdi
je 0x1313
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x4(%rdi)
jle 0x12f2
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x1040
incq %r14
movslq 0x4(%rbx), %rax
cmpq %rax, %r14
jl 0x12d9
movq 0x8(%rbx), %rdi
callq 0x1040
movq 0x18(%rbx), %rdi
callq 0x1040
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O1/xiongxu[P]bam2bedGraph2/samtools-0.1.19/misc/maq2sam.c
// Function: maqmap_read_header
maqmap_t *maqmap_read_header(gzFile fp)
{
	maqmap_t *mm;
	int k, len;
	mm = maq_new_maqmap();
	gzread(fp, &mm->format, sizeof(int));
	if (mm->format != MAQMAP_FORMAT_NEW) {
		if (mm->format > 0) {
			fprintf(stderr, "** Obsolete map format is detected. Please use 'mapass2maq' command to convert the format.\n");
			exit(3);
		}
		assert(mm->format == MAQMAP_FORMAT_NEW);
	}
	gzread(fp, &mm->n_ref, sizeof(int));
	mm->ref_name = (char**)calloc(mm->n_ref, sizeof(char*));
	for (k = 0; k != mm->n_ref; ++k) {
		gzread(fp, &len, sizeof(int));
		mm->ref_name[k] = (char*)malloc(len * sizeof(char));
		gzread(fp, mm->ref_name[k], len);
	}
	/* read number of mapped reads */
	gzread(fp, &mm->n_mapped_reads, sizeof(uint64_t));
	return mm;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x1, %edi
movl $0x20, %esi
callq 0x10a0
movq %rax, %r14
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq %rbx, %rdi
movq %rax, %rsi
movl $0x4, %edx
callq 0x10c0
movl (%r14), %eax
cmpl $-0x1, %eax
jne 0x13f6
leaq 0x4(%r14), %rsi
movq %rbx, %rdi
movl $0x4, %edx
callq 0x10c0
movslq 0x4(%r14), %r15
movl $0x8, %esi
movq %r15, %rdi
callq 0x10a0
movq %rax, 0x8(%r14)
testq %r15, %r15
je 0x13d1
xorl %r13d, %r13d
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
movl $0x4, %edx
callq 0x10c0
movl 0xc(%rsp), %eax
movslq %eax, %r12
movq %r12, %rdi
callq 0x10f0
movq 0x8(%r14), %rcx
movq %rax, (%rcx,%r13,8)
movq 0x8(%r14), %rax
movq (%rax,%r13,8), %rsi
movq %rbx, %rdi
movl %r12d, %edx
callq 0x10c0
incq %r13
movl 0x4(%r14), %eax
cmpq %rax, %r13
jne 0x138b
movq %r14, %rsi
addq $0x10, %rsi
movq %rbx, %rdi
movl $0x8, %edx
callq 0x10c0
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
testl %eax, %eax
jle 0x13ff
callq 0x1140
leaq 0xc5a(%rip), %rdi       # 0x2060
leaq 0xc73(%rip), %rsi       # 0x2080
leaq 0xc76(%rip), %rcx       # 0x208a
movl $0x4b, %edx
callq 0x1090
// File: /workspace/github_c_makefile_star2_O1/xiongxu[P]bam2bedGraph2/samtools-0.1.19/misc/maq2sam.c
// Function: main
int main(int argc, char *argv[])
{
	gzFile fp;
	if (argc == 1) {
		fprintf(stderr, "Version: %s\n", PACKAGE_VERSION);
		fprintf(stderr, "Usage: maq2sam <in.map> [<readGroup>]\n");
		return 1;
	}
	fp = strcmp(argv[1], "-")? gzopen(argv[1], "r") : gzdopen(fileno(stdin), "r");
	maq2tam_core(fp, argc > 2? argv[2] : 0);
	gzclose(fp);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, %edi
je 0x1850
movq %rsi, %rbx
movl %edi, %ebp
movq 0x8(%rsi), %r14
leaq 0x9a4(%rip), %rsi       # 0x2189
movq %r14, %rdi
callq 0x10b0
testl %eax, %eax
je 0x1802
leaq 0x993(%rip), %rsi       # 0x218b
movq %r14, %rdi
callq 0x1100
jmp 0x181f
movq 0x27cf(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
callq 0x10e0
leaq 0x973(%rip), %rsi       # 0x218b
movl %eax, %edi
callq 0x1060
movq %rax, %r15
xorl %r14d, %r14d
cmpl $0x3, %ebp
jl 0x1830
movq 0x10(%rbx), %rsi
jmp 0x1832
xorl %esi, %esi
movq %r15, %rdi
callq 0x141e
movq %r15, %rdi
callq 0x1030
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1187
movl $0x1, %r14d
jmp 0x1842
// File: /workspace/github_c_makefile_star2_O1/timocramer[P]thinklight-fun/tl_deinit.c
// Function: tl_deinit
void tl_deinit(void) {
	if(light_fd < 0)
		return;
	
	close(light_fd);
	light_fd = -1;
}

// Assembly:
pushq %rbx
leaq 0x2cfc(%rip), %rbx      # 0x4090
movl (%rbx), %edi
testl %edi, %edi
js 0x13a5
callq 0x1090
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/timocramer[P]thinklight-fun/tl_on.c
// Function: tl_on
void tl_on(void) {
	if(light_fd < 0)
		return;
	
	lseek(light_fd, 0, SEEK_SET);
	write(light_fd, ON_MESSAGE, sizeof(ON_MESSAGE) - 1);
}

// Assembly:
pushq %rbx
leaq 0x2ce0(%rip), %rbx      # 0x4090
movl (%rbx), %edi
testl %edi, %edi
js 0x13d3
xorl %esi, %esi
xorl %edx, %edx
callq 0x1070
movl (%rbx), %edi
leaq 0xd26(%rip), %rsi       # 0x20ee
movl $0x3, %edx
popq %rbx
jmp 0x1060
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/timocramer[P]thinklight-fun/tl_off.c
// Function: tl_off
void tl_off(void) {
	if(light_fd < 0)
		return;
	
	lseek(light_fd, 0, SEEK_SET);
	write(light_fd, OFF_MESSAGE, sizeof(OFF_MESSAGE) - 1);
}

// Assembly:
pushq %rbx
leaq 0x2cb0(%rip), %rbx      # 0x4090
movl (%rbx), %edi
testl %edi, %edi
js 0x1403
xorl %esi, %esi
xorl %edx, %edx
callq 0x1070
movl (%rbx), %edi
leaq 0xcfa(%rip), %rsi       # 0x20f2
movl $0x1, %edx
popq %rbx
jmp 0x1060
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/timocramer[P]thinklight-fun/tl_toggle.c
// Function: tl_toggle
void tl_toggle(void) {
	int status = tl_status();
	
	if(status == TL_OFF)
		tl_on();
	else if(status == TL_ON)
		tl_off();
}

// Assembly:
pushq %rax
callq 0x1408
cmpl $0x1, %eax
je 0x1469
testl %eax, %eax
jne 0x146f
popq %rax
jmp 0x13a8
popq %rax
jmp 0x13d8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/vanhauser-thc[P]vulntest/hardcoded_password.c
// Function: my_memset_s
char *my_memset_s(void *s, int c, size_t n) {
  volatile uint8_t *p = (uint8_t *)s;

  while (n--)
    *p++ = c;

  return s;
}

// Assembly:
movq %rdi, %rax
testq %rdx, %rdx
je 0x11f2
xorl %ecx, %ecx
movb %sil, (%rax,%rcx)
incq %rcx
cmpq %rcx, %rdx
jne 0x11e6
retq
// File: /workspace/github_c_makefile_star2_O1/vanhauser-thc[P]vulntest/hardcoded_password.c
// Function: getpass_r
char *getpass_r(const char *prompt) {
  struct termios oflags, nflags;
  char password[64] = {'\0'};
  char *ret = NULL;

  /* Disabling echo */
  if (tcgetattr(fileno(stdin), &oflags))
    return NULL;

  nflags = oflags;
  nflags.c_lflag &= ~ECHO;
  nflags.c_lflag |= ECHONL;

  if (tcsetattr(fileno(stdin), TCSAFLUSH, &nflags))
    return NULL;

  /* Read the password */
  fprintf(stderr, "%s", prompt);
  ret = fgets(password, sizeof(password), stdin);

  /* Restore echo */
  if (tcsetattr(fileno(stdin), TCSAFLUSH, &oflags)) {
    my_memset_s(password, 0, sizeof(password));
    return NULL;
  }

  if (ret) {
    strtok(password, "\n");
    ret = strdup(password);
    my_memset_s(password, 0, sizeof(password));
  }

  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq 0x2db9(%rip), %r15      # 0x3fd8
movq (%r15), %rdi
callq 0x1090
leaq 0x44(%rsp), %rsi
movl %eax, %edi
callq 0x10a0
testl %eax, %eax
jne 0x128f
movups 0x44(%rsp), %xmm0
movups 0x54(%rsp), %xmm1
movups 0x64(%rsp), %xmm2
movups 0x70(%rsp), %xmm3
leaq 0x80(%rsp), %r14
movaps %xmm0, (%r14)
movups %xmm3, 0x2c(%r14)
movaps %xmm2, 0x20(%r14)
movaps %xmm1, 0x10(%r14)
movl 0xc(%r14), %eax
andl $-0x49, %eax
orl $0x40, %eax
movl %eax, 0xc(%r14)
movq (%r15), %rdi
callq 0x1090
movl %eax, %edi
movl $0x2, %esi
movq %r14, %rdx
callq 0x10b0
testl %eax, %eax
je 0x129e
xorl %eax, %eax
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x2d53(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x1060
movq (%r15), %rdx
movq %rsp, %rdi
movl $0x40, %esi
callq 0x1070
movq %rax, %rbx
movq (%r15), %rdi
callq 0x1090
leaq 0x44(%rsp), %rdx
movl %eax, %edi
movl $0x2, %esi
callq 0x10b0
testl %eax, %eax
je 0x12f3
xorl %eax, %eax
xorl %ecx, %ecx
movb $0x0, (%rsp,%rcx)
incq %rcx
cmpq $0x40, %rcx
jne 0x12e4
jmp 0x1291
testq %rbx, %rbx
je 0x128f
leaq 0xd05(%rip), %rsi       # 0x2004
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x10c0
movq %rbx, %rdi
callq 0x10d0
xorl %ecx, %ecx
movb $0x0, (%rsp,%rcx)
incq %rcx
cmpq $0x40, %rcx
jne 0x1314
jmp 0x1291
// File: /workspace/github_c_makefile_star2_O1/vanhauser-thc[P]vulntest/hardcoded_password.c
// Function: main
int main(int argc, char *argv[]) {
  int attempts = 0;
  char *password;

  while (attempts++ < 3 && !loggedin) {
    password = getpass_r("Password: ");

    if (password != NULL) {
      if (strcmp(password, "0xDEADBEEF") == 0) {
        loggedin = true;
        printf("Logged in\n");
      } else
        printf("Wrong password\n");

      my_memset_s(password, 0, strlen(password));
      free(password);
    }
  }

  return 0;
}

// Assembly:
cmpb $0x0, 0x2d54(%rip)      # 0x4081
jne 0x13d2
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x1, %ebp
leaq 0xcbc(%rip), %rbx       # 0x2006
leaq 0xcc0(%rip), %r14       # 0x2011
leaq 0xcc4(%rip), %r12       # 0x201c
leaq 0xccc(%rip), %r13       # 0x202b
movq %rbx, %rdi
callq 0x11f3
testq %rax, %rax
je 0x13b4
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x1080
movq %r12, %rdi
testl %eax, %eax
jne 0x138b
movb $0x1, 0x2cf9(%rip)      # 0x4081
movq %r13, %rdi
callq 0x1040
movq %r15, %rdi
callq 0x1050
testq %rax, %rax
je 0x13ac
xorl %ecx, %ecx
movb $0x0, (%r15,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x139f
movq %r15, %rdi
callq 0x1030
cmpl $0x2, %ebp
ja 0x13c4
incl %ebp
testb $0x1, 0x2cbf(%rip)      # 0x4081
je 0x135f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/samtools[P]htslib/test/test-vcf-api.c
// Function: error
void HTS_FORMAT(HTS_PRINTF_FMT, 1, 2) error(const char *format, ...)
{
    va_list ap;
    va_start(ap, format);
    vfprintf(stderr, format, ap);
    va_end(ap);
    if (strrchr(format, '\n') == NULL) fputc('\n', stderr);
    exit(-1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x606d
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq 0xcdf4c(%rip), %r14     # 0xd3fe0
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x46b0
movq %rbx, %rdi
movl $0xa, %esi
callq 0x4530
testq %rax, %rax
jne 0x60be
movq (%r14), %rsi
movl $0xa, %edi
callq 0x4650
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x45f0