LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x3be4(%rip), %rdi      # 0x115c1
movq %rdx, %rsi
xorl %eax, %eax
callq 0x6710
leaq 0x3be8(%rip), %rdx      # 0x115d6
movq %r15, %rdi
movq %rbx, %rsi
callq 0x68c0
movq %r14, 0x10(%rax)
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stetre[P]moonassimp/src/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x3a71(%rip), %rdx      # 0x115d6
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x66f0
xorl %ecx, %ecx
cmpl $0x0, 0x4(%rax)
jne 0xdb87
movl (%rax), %edx
movq 0x18(%rax), %rsi
movq %r14, %rdi
callq 0x6670
movl %ebx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x39fc(%rip), %rdx      # 0x115d6
pushq $0x1
popq %rsi
callq 0x66f0
cmpl $0x0, 0x4(%rax)
je 0xdc38
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x6310
movl %eax, %r15d
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x6310
movl (%r14), %esi
cmpl %esi, %r15d
jae 0xdc45
cmpl 0x4(%r14), %eax
jae 0xdc50
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 0xdc6c
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 0x255d(%rip), %rdx      # 0x101a9
pushq $0x2
jmp 0xdc59
leaq 0x2552(%rip), %rdx      # 0x101a9
pushq $0x3
popq %rsi
movq %rbx, %rdi
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_O2/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 0xdc92
movq 0xb358(%rip), %r12      # 0x18fe8
jmp 0xdc99
movq 0xb337(%rip), %r12      # 0x18fd0
leaq 0x3936(%rip), %rdx      # 0x115d6
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x66f0
cmpl $0x0, 0x4(%rax)
je 0xdd22
movq %rax, %r14
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
movl 0x4(%r14), %eax
cmpq %rax, %r15
jae 0xdd24
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
xorl %r13d, %r13d
movl (%r14), %esi
cmpq %rsi, %r13
jae 0xdd0f
imull %r15d, %esi
addl %r13d, %esi
shlq $0x2, %rsi
addq 0x18(%r14), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq *%r12
incq %r13
movq %rbx, %rdi
pushq $-0x2
popq %rsi
movq %r13, %rdx
callq 0x6470
jmp 0xdcdd
incq %r15
movq %rbx, %rdi
pushq $-0x2
popq %rsi
movq %r15, %rdx
callq 0x6470
jmp 0xdcc5
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xe045
testq %rax, %rax
je 0xe0b8
movq %rax, %r14
movl 0x28(%rax), %edx
cmpl $-0x2, %edx
je 0xe0b0
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x6910
movl $0xfffffffe, 0x28(%r14) # imm = 0xFFFFFFFE
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x35e3(%rip), %rsi      # 0x116a2
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x67a0
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0xe045
testq %rax, %rax
je 0xe119
movq %rax, %rbx
movl 0x28(%rax), %edx
cmpl $-0x2, %edx
je 0xe101
movq %r14, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x6910
movq %rbx, %rdi
callq 0xe132
movq %rbx, %rdi
callq 0x60a0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3582(%rip), %rsi      # 0x116a2
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x67a0
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xe045
testq %rax, %rax
je 0xe530
movslq 0x28(%rax), %rdx
cmpq $-0x2, %rdx
jne 0xe54b
leaq 0x319d(%rip), %rsi      # 0x116bc
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x67a0
leaq 0x316b(%rip), %rsi      # 0x116a2
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x67a0
movq %rbx, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x62b0
cmpl $0x7, %eax
jne 0xe568
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1c47(%rip), %rsi      # 0x101b6
leaq 0x315a(%rip), %rdx      # 0x116d0
movq %rbx, %rdi
movl $0xa3, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x67a0
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
leaq 0xaf79(%rip), %r14      # 0x19510
xorl %eax, %eax
movq %r14, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xe5b0
cmpq $0x0, 0x20(%rbx)
movq %rbx, %rax
jne 0xe59c
jmp 0xe5b8
movq %rax, %rbx
testq %rax, %rax
je 0xe5cf
movq %rbx, %rdi
callq 0xe132
movq %rbx, %rdi
callq 0x60a0
movq %r14, %rbx
xorl %eax, %eax
jmp 0xe59c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6440
testl %eax, %eax
jle 0xeb0f
decl %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2c6f(%rip), %rdx      # 0x11785
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x61c0
// File: /workspace/github_c_makefile_star2_O2/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 0x6550
testl %eax, %eax
jle 0xeb48
decl %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2c36(%rip), %rdx      # 0x11785
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x61c0
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0xebc0
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
cvtss2sd (%r14), %xmm0
movq %rbx, %rdi
callq 0x6500
pushq $-0x2
popq %rbp
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x63e0
cvtss2sd 0x4(%r14), %xmm0
movq %rbx, %rdi
callq 0x6500
pushq $0x2
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x63e0
pushq $0x1
jmp 0xebdd
cvtss2sd (%r14), %xmm0
movq %rbx, %rdi
callq 0x6500
cvtss2sd 0x4(%r14), %xmm0
movq %rbx, %rdi
callq 0x6500
pushq $0x2
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0xec54
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
cvtss2sd (%r14), %xmm0
movq %rbx, %rdi
callq 0x6500
pushq $-0x2
popq %rbp
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x63e0
cvtss2sd 0x4(%r14), %xmm0
movq %rbx, %rdi
callq 0x6500
pushq $0x2
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x63e0
cvtss2sd 0x8(%r14), %xmm0
movq %rbx, %rdi
callq 0x6500
pushq $0x3
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x63e0
pushq $0x1
jmp 0xec7f
cvtss2sd (%r14), %xmm0
movq %rbx, %rdi
callq 0x6500
cvtss2sd 0x4(%r14), %xmm0
movq %rbx, %rdi
callq 0x6500
cvtss2sd 0x8(%r14), %xmm0
movq %rbx, %rdi
callq 0x6500
pushq $0x3
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0xecf6
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
cvtss2sd (%r14), %xmm0
movq %rbx, %rdi
callq 0x6500
pushq $-0x2
popq %rbp
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x63e0
cvtss2sd 0x4(%r14), %xmm0
movq %rbx, %rdi
callq 0x6500
pushq $0x2
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x63e0
cvtss2sd 0x8(%r14), %xmm0
movq %rbx, %rdi
callq 0x6500
pushq $0x3
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x63e0
pushq $0x1
jmp 0xed21
cvtss2sd (%r14), %xmm0
movq %rbx, %rdi
callq 0x6500
cvtss2sd 0x4(%r14), %xmm0
movq %rbx, %rdi
callq 0x6500
cvtss2sd 0x8(%r14), %xmm0
movq %rbx, %rdi
callq 0x6500
pushq $0x3
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0xedb3
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
cvtss2sd (%r14), %xmm0
movq %rbx, %rdi
callq 0x6500
pushq $-0x2
popq %rbp
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x63e0
cvtss2sd 0x4(%r14), %xmm0
movq %rbx, %rdi
callq 0x6500
pushq $0x2
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x63e0
cvtss2sd 0x8(%r14), %xmm0
movq %rbx, %rdi
callq 0x6500
pushq $0x3
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x63e0
cvtss2sd 0xc(%r14), %xmm0
movq %rbx, %rdi
callq 0x6500
pushq $0x4
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x63e0
pushq $0x1
jmp 0xedec
cvtss2sd (%r14), %xmm0
movq %rbx, %rdi
callq 0x6500
cvtss2sd 0x4(%r14), %xmm0
movq %rbx, %rdi
callq 0x6500
cvtss2sd 0x8(%r14), %xmm0
movq %rbx, %rdi
callq 0x6500
cvtss2sd 0xc(%r14), %xmm0
movq %rbx, %rdi
callq 0x6500
pushq $0x4
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0xef45
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
movzbl 0x2(%r14), %esi
movq %rbx, %rdi
callq 0x6300
pushq $-0x2
popq %rbp
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x63e0
movzbl 0x1(%r14), %esi
movq %rbx, %rdi
callq 0x6300
pushq $0x2
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x63e0
movzbl (%r14), %esi
movq %rbx, %rdi
callq 0x6300
pushq $0x3
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x63e0
movzbl 0x3(%r14), %esi
movq %rbx, %rdi
callq 0x6300
pushq $0x4
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x63e0
pushq $0x1
jmp 0xef7a
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
pushq $0x4
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
je 0xf04c
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6250
movzbl 0x2(%r14), %eax
cvtsi2ss %eax, %xmm0
divss 0x2769(%rip), %xmm0     # 0x11718
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x6500
pushq $-0x2
popq %rbp
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x63e0
movzbl 0x1(%r14), %eax
cvtsi2ss %eax, %xmm0
divss 0x273c(%rip), %xmm0     # 0x11718
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x6500
pushq $0x2
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x63e0
movzbl (%r14), %eax
cvtsi2ss %eax, %xmm0
divss 0x2713(%rip), %xmm0     # 0x11718
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x6500
pushq $0x3
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x63e0
movzbl 0x3(%r14), %eax
cvtsi2ss %eax, %xmm0
divss 0x26e9(%rip), %xmm0     # 0x11718
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x6500
pushq $0x4
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x63e0
pushq $0x1
jmp 0xf0c1
movzbl 0x2(%r14), %eax
cvtsi2ss %eax, %xmm0
divss 0x26bb(%rip), %xmm0     # 0x11718
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x6500
movzbl 0x1(%r14), %eax
cvtsi2ss %eax, %xmm0
divss 0x269e(%rip), %xmm0     # 0x11718
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x6500
movzbl (%r14), %eax
cvtsi2ss %eax, %xmm0
divss 0x2682(%rip), %xmm0     # 0x11718
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x6500
movzbl 0x3(%r14), %eax
cvtsi2ss %eax, %xmm0
divss 0x2665(%rip), %xmm0     # 0x11718
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x6500
pushq $0x4
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x30
popq %rsi
movq %rbx, %rdx
callq 0x6280
xorps %xmm0, %xmm0
andq $0x0, 0x28(%rax)
movups %xmm0, 0x8(%rax)
testq %rbx, %rbx
cmoveq %rax, %rbx
movups %xmm0, 0x18(%rax)
movq %rbx, (%rax)
movl $0x1, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf6e7
movl 0x8(%rcx), %edx
testb $0x1, %dl
je 0xf6e7
andl $-0x2, %edx
movl %edx, 0x8(%rcx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x62c0
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf700
testb $0x1, 0x8(%rax)
jne 0xf704
xorl %eax, %eax
jmp 0xf707
movq (%rax), %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r12
movl %esi, %ebx
movq %rdi, %r14
callq 0x65b0
movq %rax, %r15
testq %rax, %rax
jne 0xf754
leaq 0x2072(%rip), %rsi      # 0x1179f
movq %r14, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x63d0
pushq $-0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x61e0
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
callq 0x61c0
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8(%rsi), %r14
movl $0x530, %eax            # imm = 0x530
testq %r14, %r14
jne 0x125c
movl %eax, %ebx
movq %rsp, %r14
leaq 0xf(%rbx), %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
pushq $0x1
popq %r15
xorl %r13d, %r13d
xorl %edi, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1030
cmpq %rbx, %rax
jne 0x1239
movb (%r14), %al
andb $-0x40, %al
negb %al
jo 0x11ff
movq 0x2e10(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xe2c(%rip), %rdi       # 0x201e
pushq $0x13
popq %rsi
movq %r15, %rdx
callq 0x1080
jmp 0x11c6
movzwl 0x2(%r14), %r12d
rolw $0x8, %r12w
cmpw %r13w, %r12w
jne 0x1217
incl %r12d
movl %r12d, %r13d
jmp 0x11c6
movzwl %r12w, %edx
movzwl %r13w, %ecx
movq 0x2dd2(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xe02(%rip), %rsi       # 0x2032
xorl %eax, %eax
callq 0x1050
jmp 0x120f
movq 0x2db8(%rip), %rcx      # 0x3ff8
movq (%rcx), %rdi
leaq 0xdc1(%rip), %rsi       # 0x200b
movq %rax, %rdx
xorl %eax, %eax
callq 0x1050
pushq $0x1
popq %rdi
callq 0x1070
movq %rsi, %rbx
cmpb $0x2d, (%r14)
jne 0x1273
cmpb $0x68, 0x1(%r14)
jne 0x1273
cmpb $0x0, 0x2(%r14)
je 0x12a2
leaq 0xd8a(%rip), %rsi       # 0x2004
movq %r14, %rdi
callq 0x1040
testl %eax, %eax
je 0x12a2
movq %r14, %rdi
callq 0x1060
movl %eax, %ecx
addl $0xffff0000, %ecx       # imm = 0xFFFF0000
cmpl $0xffff000b, %ecx       # imm = 0xFFFF000B
ja 0x11ac
movq (%rbx), %rdi
callq 0x12aa
// File: /workspace/github_c_makefile_star2_O2/evilwombat[P]gopro-fw-tools/h3-wifi-address.c
// Function: read_word
static uint32_t read_word(unsigned char *buf, int offset)
{
	return (buf[offset] << 24) |
	       (buf[offset+1] << 16) |
	       (buf[offset+2] << 8) |
	       (buf[offset+3]);
}

// Assembly:
movl %esi, %eax
movzbl (%rdi,%rax), %eax
shll $0x18, %eax
movslq %esi, %rcx
movzbl 0x1(%rdi,%rcx), %edx
shll $0x10, %edx
orl %eax, %edx
movzbl 0x2(%rdi,%rcx), %esi
shll $0x8, %esi
orl %edx, %esi
movzbl 0x3(%rdi,%rcx), %eax
orl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1218
testl %eax, %eax
je 0x11f1
movq %rsp, %rdi
movl $0x1388, %esi           # imm = 0x1388
callq 0x12a3
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 0x1382
movq %r15, %rdi
movq %r14, %rsi
callq 0x1422
jmp 0x1209
leaq 0xe0c(%rip), %rdi       # 0x2004
jmp 0x1201
leaq 0xe1d(%rip), %rdi       # 0x201e
callq 0x1040
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x9c40, %rsp           # imm = 0x9C40
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, %rbx
movslq %edi, %r15
pushq $0x1
popq %r13
leaq 0x24a(%rip), %rbp       # 0x147e
movq %r13, %r12
cmpq %r15, %r12
jge 0x128c
movq (%rbx,%r12,8), %r14
movq %r14, %rdi
callq 0x1060
cmpq $0x2, %rax
jb 0x128c
cmpb $0x2d, (%r14)
jne 0x128c
movq %r13, %rcx
cmpq %rcx, %rax
je 0x1283
movq (%rbx,%r12,8), %rdx
movzbl (%rdx,%rcx), %edx
cmpl $0x72, %edx
je 0x1277
cmpl $0x6e, %edx
jne 0x1288
movq %rbp, 0x2deb(%rip)      # 0x4060
jmp 0x127e
orl $-0x1, 0x2dda(%rip)     # 0x4058
incq %rcx
jmp 0x1257
incq %r12
jmp 0x1237
xorl %eax, %eax
jmp 0x1294
xorl %eax, %eax
cmpq %r15, %r12
setge %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movq %rdi, %r12
movq 0x2dad(%rip), %rbx      # 0x4068
leaq 0x2dbe(%rip), %rbp      # 0x4080
movq %rbp, %rax
subq %rbx, %rax
addq $0x2710, %rax           # imm = 0x2710
cmpq $0x3e8, %rax            # imm = 0x3E8
jae 0x12da
xorl %ebx, %ebx
jmp 0x12e8
leaq 0x3e8(%rbx), %rax
movq %rax, 0x2d80(%rip)      # 0x4068
xorl %r14d, %r14d
movl $0x3e8, %esi            # imm = 0x3E8
movq %rbx, %rdi
callq 0x14c1
testq %rax, %rax
je 0x135a
cmpq %r14, %r15
je 0x1344
movq 0x2d5f(%rip), %r13      # 0x4068
movq %rbp, %rcx
subq %r13, %rcx
addq $0x2710, %rcx           # imm = 0x2710
cmpq %rax, %rcx
jb 0x1344
leaq (%rax,%r13), %rcx
movq %rcx, 0x2d42(%rip)      # 0x4068
testq %r13, %r13
je 0x1344
movb $0x0, -0x1(%rbx,%rax)
movq %r13, %rdi
movq %rbx, %rsi
callq 0x1030
movq %r13, (%r12,%r14,8)
incq %r14
jmp 0x12eb
pushq $-0x1
popq %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2d1f(%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 0x1348
movq %rbx, 0x2ce8(%rip)      # 0x4068
jmp 0x1348
// File: /workspace/github_c_makefile_star2_O2/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 0x1413
leaq (%r12,%r14), %rax
movq (%r15,%r12,8), %rcx
andq $-0x2, %rax
movq (%r15,%rax,4), %rdx
movq %rdx, (%r15,%r12,8)
movq %rcx, (%r15,%rax,4)
movq %r12, %r13
movq %r12, %rbp
incq %rbp
cmpq %r14, %rbp
ja 0x13e9
movq (%r15,%rbp,8), %rdi
movq (%r15,%r12,8), %rsi
callq *%rbx
testl %eax, %eax
jns 0x13bc
movq 0x8(%r15,%r13,8), %rax
movq (%r15,%rbp,8), %rcx
movq %rcx, 0x8(%r15,%r13,8)
incq %r13
movq %rax, (%r15,%rbp,8)
jmp 0x13bc
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 0x1382
incq %r13
movq %r13, %r12
jmp 0x1399
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x14af
subl 0x2bab(%rip), %eax      # 0x4058
jmp 0x14bb
ucomisd %xmm0, %xmm1
jbe 0x14bb
movl 0x2b9d(%rip), %eax      # 0x4058
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2e34(%rip), %rbx      # 0x3ff8
movq (%rbx), %rsi
leaq 0xe36(%rip), %rdi       # 0x2004
callq 0x1060
movq (%rbx), %rsi
leaq 0xe3b(%rip), %rdi       # 0x2018
callq 0x1060
movq (%rbx), %rsi
leaq 0xe4a(%rip), %rdi       # 0x2036
callq 0x1060
movq (%rbx), %rsi
leaq 0xe5d(%rip), %rdi       # 0x2058
callq 0x1060
movq (%rbx), %rsi
leaq 0xe6f(%rip), %rdi       # 0x2079
popq %rbx
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
xorl %eax, %eax
callq 0x1080
testl %eax, %eax
js 0x1264
popq %rbx
retq
callq 0x1030
movl (%rax), %edi
callq 0x10b0
leaq 0xe37(%rip), %rdi       # 0x20ae
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1050
pushq $0x1
popq %rdi
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/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 0x12d2
movq %rsi, %rbx
leaq 0xe1f(%rip), %rdi       # 0x20bd
callq 0x1250
movl %eax, %ebp
pushq $0x1
popq %rdi
movl %eax, %esi
callq 0x1210
pushq $0x2
popq %rdi
movl %ebp, %esi
callq 0x1210
movq 0x8(%rbx), %rdi
addq $0x8, %rbx
movq %rbx, %rsi
callq 0x1090
negl %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x11bc
pushq $0x1
popq %rdi
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/timocramer[P]thinklight-fun/tl-morsestrobo.c
// Function: main
int main(int argc, char **argv) {
	if(tl_init()) {
		fputs("Light Interface cannot be opened!\n", stderr);
		return 1;
	}
	if(tl_status() == TL_ON)
		initial_status = TL_ON;
	
	if(lock()) {
		if(errno != EEXIST)
			perror("open " LOCKFILE);
		else
			fputs("Thinklight is in use!\n", stderr);
		return 1;
	}
	
	install_signal_handler();
	
#ifdef MORSE
	if(argc < 2) {
		fputs(argv[0], stderr);
		fputs(": No arguments!\n", stderr);
		goto finish;
	}
	
	/* morse the arguments */
	int i = 1;
	while(1) {
		morse_string(argv[i]);
		
		++i;
		
		if(i >= argc) /* is it the last argument? */
			break;
		morse_char(' ');
	}
	
	/* save the initial status */
	if(initial_status == TL_ON)
		tl_on();
	else
		tl_off();
	
	finish:
	tl_deinit();
	unlock();
#elif defined STROBO
	/* use argc and argv so the compiler doesn't complain */
	(void) argc;
	(void) argv;
	
	while(1) {
		tl_toggle();
		usleep(DELAY);
	}
	/* deinit and unlock happens in the signal handler */
#endif
	
	return 0;
}

// Assembly:
subq $0x98, %rsp
callq 0x1348
testl %eax, %eax
jne 0x12b1
callq 0x13d8
cmpl $0x1, %eax
jne 0x1221
movb $0x1, 0x2e77(%rip)      # 0x4098
leaq 0xe83(%rip), %rdi       # 0x20ab
movl $0xc1, %esi
movl $0x1a4, %edx            # imm = 0x1A4
xorl %eax, %eax
callq 0x10c0
testl %eax, %eax
js 0x12c4
movl %eax, %edi
callq 0x1090
leaq 0xae(%rip), %rax        # 0x12fd
leaq 0x8(%rsp), %rdi
movq %rax, -0x8(%rdi)
andl $0x0, 0x80(%rdi)
callq 0x10b0
pushq $0x2
popq %rdi
movq %rsp, %rsi
xorl %edx, %edx
callq 0x1050
cmpl $-0x1, %eax
je 0x1299
pushq $0xf
popq %rdi
movq %rsp, %rsi
xorl %edx, %edx
callq 0x1050
cmpl $-0x1, %eax
je 0x1299
callq 0x1420
movl $0x9c40, %edi           # imm = 0x9C40
callq 0x10f0
jmp 0x1288
movq 0x2d58(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xdae(%rip), %rdi       # 0x2058
callq 0x1080
jmp 0x1288
movq 0x2d40(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xd42(%rip), %rdi       # 0x2004
jmp 0x12df
callq 0x1030
cmpl $0x11, (%rax)
jne 0x12e6
movq 0x2d23(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xd62(%rip), %rdi       # 0x2041
callq 0x1080
jmp 0x12f2
leaq 0xd3a(%rip), %rdi       # 0x2027
callq 0x10d0
pushq $0x1
popq %rax
addq $0x98, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2d20(%rip), %rbx      # 0x4090
movl (%rbx), %edi
testl %edi, %edi
js 0x137e
callq 0x1090
orl $-0x1, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2d08(%rip), %rbx      # 0x4090
movl (%rbx), %edi
testl %edi, %edi
js 0x13a9
xorl %esi, %esi
xorl %edx, %edx
callq 0x1070
movl (%rbx), %edi
leaq 0xd4e(%rip), %rsi       # 0x20ee
pushq $0x3
popq %rdx
popq %rbx
jmp 0x1060
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x2cdc(%rip), %rbx      # 0x4090
movl (%rbx), %edi
testl %edi, %edi
js 0x13d5
xorl %esi, %esi
xorl %edx, %edx
callq 0x1070
movl (%rbx), %edi
leaq 0xd26(%rip), %rsi       # 0x20f2
pushq $0x1
popq %rdx
popq %rbx
jmp 0x1060
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x13d8
cmpl $0x1, %eax
je 0x1435
testl %eax, %eax
jne 0x143b
popq %rax
jmp 0x1380
popq %rax
jmp 0x13ac
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %ecx, %ecx
cmpq %rcx, %rdx
je 0x11ef
movb %sil, (%rax,%rcx)
incq %rcx
jmp 0x11e1
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2dbc(%rip), %r15      # 0x3fd8
movq (%r15), %rdi
callq 0x1090
leaq 0x44(%rsp), %rsi
movl %eax, %edi
callq 0x10a0
testl %eax, %eax
jne 0x128a
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
pushq $0x2
popq %rsi
movl %eax, %edi
movq %r14, %rdx
callq 0x10b0
testl %eax, %eax
je 0x1299
xorl %eax, %eax
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x2d58(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x1060
movq (%r15), %rdx
movq %rsp, %rdi
pushq $0x40
popq %rsi
callq 0x1070
movq %rax, %rbx
movq (%r15), %rdi
callq 0x1090
pushq $0x2
popq %rsi
leaq 0x44(%rsp), %rdx
movl %eax, %edi
callq 0x10b0
testl %eax, %eax
je 0x12ea
xorl %eax, %eax
xorl %ecx, %ecx
cmpq $0x40, %rcx
je 0x128c
movb $0x0, (%rsp,%rcx)
incq %rcx
jmp 0x12db
testq %rbx, %rbx
je 0x128a
leaq 0xd0e(%rip), %rsi       # 0x2004
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x10c0
movq %rbx, %rdi
callq 0x10d0
xorl %ecx, %ecx
cmpq $0x40, %rcx
je 0x128c
movb $0x0, (%rsp,%rcx)
incq %rcx
jmp 0x130b
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %r12d, %r12d
leaq 0xcd3(%rip), %rbx       # 0x2006
leaq 0xcd7(%rip), %r14       # 0x2011
leaq 0xcdb(%rip), %r13       # 0x201c
leaq 0xce3(%rip), %rbp       # 0x202b
cmpl $0x2, %r12d
ja 0x13ae
testb $0x1, 0x2d2c(%rip)      # 0x4081
jne 0x13ae
incl %r12d
movq %rbx, %rdi
callq 0x11f0
testq %rax, %rax
je 0x1348
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x1080
movq %r13, %rdi
testl %eax, %eax
jne 0x1386
movb $0x1, 0x2cfe(%rip)      # 0x4081
movq %rbp, %rdi
callq 0x1040
movq %r15, %rdi
callq 0x1050
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x13a4
movb $0x0, (%r15,%rcx)
incq %rcx
jmp 0x1395
movq %r15, %rdi
callq 0x1030
jmp 0x1348
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5b1d
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 0xad49c(%rip), %r14     # 0xb2fe0
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x46b0
pushq $0xa
popq %rsi
movq %rbx, %rdi
callq 0x4530
testq %rax, %rax
jne 0x5b6a
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x4650
pushq $-0x1
popq %rdi
callq 0x45f0
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/test/test-vcf-api.c
// Function: check_alleles
static int check_alleles(bcf1_t *rec, const char **alleles, int num) {
    int i;
    if (rec->n_allele !=  num) {
        fprintf(stderr, "Wrong number of alleles - expected %d, got %d\n",
                num, rec->n_allele);
        return -1;
    }
    if (bcf_unpack(rec, BCF_UN_STR) != 0)
        return -1;
    for (i = 0; i < num; i++) {
        if (0 != strcmp(alleles[i], rec->d.allele[i])) {
            fprintf(stderr,
                    "Mismatch for allele %d : expected '%s' got '%s'\n",
                    i, alleles[i], rec->d.allele[i]);
            return -1;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl 0x18(%rdi), %ecx
shrl $0x10, %ecx
cmpl %edx, %ecx
jne 0x6d3d
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rsi
callq 0x2d678
pushq $-0x1
popq %rcx
testl %eax, %eax
jne 0x6d2c
movl %ebp, %ebx
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0x6d2a
movq (%r14,%r12,8), %r13
movq 0x88(%r15), %rax
movq (%rax,%r12,8), %rbp
movq %r13, %rdi
movq %rbp, %rsi
callq 0x46e0
testl %eax, %eax
jne 0x6d59
incq %r12
jmp 0x6d02
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xac29c(%rip), %rax     # 0xb2fe0
movq (%rax), %rdi
leaq 0x7f7ed(%rip), %rsi     # 0x8653b
movl %ebp, %edx
xorl %eax, %eax
callq 0x4720
jmp 0x6d7a
movq 0xac280(%rip), %rax     # 0xb2fe0
movq (%rax), %rdi
leaq 0x7f800(%rip), %rsi     # 0x8656a
movl %r12d, %edx
movq %r13, %rcx
movq %rbp, %r8
xorl %eax, %eax
callq 0x4720
pushq $-0x1
popq %rcx
jmp 0x6d2c
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/test/test-vcf-api.c
// Function: iterator
void iterator(const char *fname)
{
    htsFile *fp = hts_open(fname, "r");
    if (!fp) error("Failed to open \"%s\" : %s", fname, strerror(errno));
    bcf_hdr_t *hdr = bcf_hdr_read(fp);
    if (!hdr) error("bcf_hdr_read : %s", strerror(errno));
    hts_idx_t *idx;
    hts_itr_t *iter;

    bcf_index_build(fname, 0);
    idx = bcf_index_load(fname);

    iter = bcf_itr_queryi(idx, bcf_hdr_name2id(hdr, "20"), 1110600, 1110800);
    bcf_itr_destroy(iter);

    iter = bcf_itr_querys(idx, hdr, "20:1110600-1110800");
    bcf_itr_destroy(iter);

    hts_idx_destroy(idx);
    bcf_hdr_destroy(hdr);
    int ret;
    if ( (ret=hts_close(fp)) )
    {
        fprintf(stderr,"hts_close(%s): non-zero status %d\n",fname,ret);
        exit(ret);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x81fff(%rip), %rsi     # 0x8950f
callq 0xa70f
testq %rax, %rax
je 0x75da
movq %rax, %r14
movq %rax, %rdi
callq 0x27ba6
testq %rax, %rax
je 0x75fa
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2edb6
movq %rbx, %rdi
xorl %esi, %esi
callq 0x108fc
movq %rax, %r12
leaq 0x7dcfa(%rip), %rsi     # 0x8524d
movq %r15, %rdi
callq 0x6cc6
leaq 0x21d03(%rip), %rbp     # 0x29265
movl $0x10f248, %edx         # imm = 0x10F248
movl $0x10f310, %ecx         # imm = 0x10F310
movq %r12, %rdi
movl %eax, %esi
movq %rbp, %r8
callq 0xdb2d
leaq 0x65ad(%rip), %r13      # 0xdb2d
movq %rax, %rdi
callq 0xe2ed
leaq 0x7e509(%rip), %rsi     # 0x85a98
movq %r12, %rdi
leaq -0x8d3(%rip), %rdx      # 0x6cc6
movq %r15, %rcx
movq %r13, %r8
movq %rbp, %r9
callq 0xfacd
movq %rax, %rdi
callq 0xe2ed
movq %r12, %rdi
callq 0xba4a
movq %r15, %rdi
callq 0x27a34
movq %r14, %rdi
callq 0xb8e5
testl %eax, %eax
jne 0x7617
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4050
movl (%rax), %edi
callq 0x4140
leaq 0x7ca62(%rip), %rdi     # 0x8404f
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x5abc
callq 0x4050
movl (%rax), %edi
callq 0x4140
leaq 0x7e0f1(%rip), %rdi     # 0x856fe
movq %rax, %rsi
xorl %eax, %eax
callq 0x5abc
movl %eax, %ebp
movq 0xab9c0(%rip), %rax     # 0xb2fe0
movq (%rax), %rdi
leaq 0x7e0ae(%rip), %rsi     # 0x856d8
movq %rbx, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x4720
movl %ebp, %edi
callq 0x45f0