LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/widgets.c
// Function: Tree_state_image_push
static int Tree_state_image_push(lua_State *L)
    {
    int rc;
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_tree_type tree_type = checktreetype(L, 2);
    nk_image_t *image = checkimage(L, 3, NULL);
    const char *title = luaL_checkstring(L, 4);
    enum nk_collapse_states state = checkcollapsestates(L, 5);
    rc = nk_tree_state_image_push(context, tree_type, *image, title, &state);
    lua_pushboolean(L, rc);
    pushcollapsestates(L, state);
    return 2;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x1b19(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0xd, %esi
movl $0x2, %edx
callq 0x132f0
movl %eax, %ebp
leaq 0x1ab3(%rip), %rcx      # 0x67244
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0x12cd0
movq %rax, %r12
movq %rbx, %rdi
movl $0x4, %esi
movl $0x5, %edx
callq 0x132f0
leaq 0x24(%rsp), %r13
movl %eax, (%r13)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
movq %r13, %rcx
callq 0x140f0
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
movl (%r13), %edx
movq %rbx, %rdi
movl $0x4, %esi
callq 0x125e0
movl $0x2, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/widgets.c
// Function: Rgba_to_hsva
static int Rgba_to_hsva(lua_State *L)
    {
    float h, s, v, a;
    nk_colorf_t color;
    if(echeckcolorf(L, 1, &color)) return argerror(L, 1);
    nk_colorf_hsva_f(&h, &s, &v, &a, color);
    color.r = h;
    color.g = s;
    color.b = v;
    color.a = a;
    return pushcolorf(L, &color);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rdx
movl $0x1, %esi
callq 0x13210
testl %eax, %eax
je 0x6599a
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x1, %esi
movq %rax, %rdx
callq 0x12460
jmp 0x65a07
leaq 0x18(%rsp), %r14
movsd (%r14), %xmm0
movsd 0x8(%r14), %xmm1
leaq 0x14(%rsp), %r15
leaq 0x10(%rsp), %r12
leaq 0xc(%rsp), %r13
leaq 0x8(%rsp), %rbp
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x13b30
movss (%r15), %xmm0
movss %xmm0, (%r14)
movss (%r12), %xmm0
movss %xmm0, 0x4(%r14)
movss (%r13), %xmm0
movss %xmm0, 0x8(%r14)
movss (%rbp), %xmm0
movss %xmm0, 0xc(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13db0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/widgets.c
// Function: ValueGetter
static float ValueGetter(void* info_, int index)
    {
#define info ((cbinfo_t*)(info_))
#define L moonnuklear_L
    float val;
    lua_rawgeti(L, LUA_REGISTRYINDEX, info->ref);
    pushindex(L, index);
    if(lua_pcall(L, 1, 1, 0) != LUA_OK)
        { lua_error(L); return 0; }
    val = luaL_checknumber(L, -1);
    lua_pop(L, 1);
    return val;
#undef L
#undef info
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0x21554(%rip), %r14     # 0x86ff0
movq (%r14), %rax
movslq (%rdi), %rdx
movq %rax, %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x12950
movq (%r14), %rdi
movl %ebx, %esi
callq 0x14060
movq (%r14), %rdi
movl $0x1, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x140b0
movq (%r14), %rdi
testl %eax, %eax
je 0x65ae4
callq 0x13780
xorps %xmm0, %xmm0
jmp 0x65b0b
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x12870
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movq (%r14), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movss 0x4(%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/widgets.c
// Function: ItemGetter
static void ItemGetter(void* info_, int selected, const char** item)
    {
#define info ((cbinfo_t*)(info_))
#define L moonnuklear_L
    const char *s;
    lua_rawgeti(L, LUA_REGISTRYINDEX, info->ref);
    lua_pushinteger(L, selected+1);
    if(lua_pcall(L, 1, 1, 0) != LUA_OK)
        { lua_error(L); return; }
    if(info->item) Free(L, info->item);
    s = luaL_checkstring(L, -1);
    info->item = Strdup(L, s);
    *item = info->item;
    lua_pop(L, 1);
    return;
#undef L
#undef info
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq 0x214c7(%rip), %r15     # 0x86ff0
movq (%r15), %rdi
movslq (%r14), %rdx
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x12950
movq (%r15), %rdi
incl %ebp
movslq %ebp, %rsi
callq 0x12b60
movq (%r15), %rdi
movl $0x1, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x140b0
testl %eax, %eax
je 0x65b76
movq (%r15), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x13780
movq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0x65b87
movq (%r15), %rdi
callq 0x130d0
movq (%r15), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12cd0
movq (%r15), %rdi
movq %rax, %rsi
callq 0x136d0
movq %rax, 0x8(%r14)
movq %rax, (%rbx)
movq (%r15), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x12180
nop
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/window.c
// Function: Window_begin
static int Window_begin(lua_State *L)
    {
    int rc = 0;
    const char *name;
    nk_rect_t bounds;
    nk_flags flags;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char *title = luaL_checkstring(L, 2);
    if(echeckrect(L, 3, &bounds)) return argerror(L, 3);
    flags = checkflags(L, 4); /* nk_panel_flags */
    if(lua_isnoneornil(L, 5))
        rc = nk_begin(context, title, bounds, flags);
    else
        {
        name = luaL_checkstring(L, 5);
        rc = nk_begin_titled(context, name, title, bounds, flags);
        }
    lua_pushboolean(L, rc);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x169d(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x12cd0
movq %rax, %r15
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x139f0
movq %rbx, %rdi
testl %eax, %eax
je 0x65c3b
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x12460
jmp 0x65cb0
movl $0x4, %esi
callq 0x12f30
movq %rax, %r12
movq %rbx, %rdi
movl $0x5, %esi
callq 0x13df0
testl %eax, %eax
jle 0x65c87
movq %rbx, %rdi
movl $0x5, %esi
xorl %edx, %edx
callq 0x12cd0
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
movl %r12d, %ecx
callq 0x123d0
jmp 0x65ca1
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x126a0
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/window.c
// Function: Window_get_width
static int Window_get_width(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    float w = nk_window_get_width(context);
    lua_pushnumber(L, w);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x14ed(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %rdi
callq 0x13260
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x13180
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/window.c
// Function: Window_get_height
static int Window_get_height(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    float h = nk_window_get_height(context);
    lua_pushnumber(L, h);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x14bb(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %rdi
callq 0x12a70
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x13180
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/window.c
// Function: Window_get_canvas
static int Window_get_canvas(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    nk_canvas_t* canvas = nk_window_get_canvas(context);
    if(!canvas) return 0;
    return newcanvas(L, canvas);
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x13a4(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %rdi
callq 0x13710
testq %rax, %rax
je 0x65f01
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x121b0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/window.c
// Function: Window_get_scroll
static int Window_get_scroll(lua_State *L)
    {
    nk_uint offset_x, offset_y;
    nk_context_t *context = checkcontext(L, 1, NULL);
    nk_window_get_scroll(context, &offset_x, &offset_y);
    lua_pushinteger(L, offset_x);
    lua_pushinteger(L, offset_y);
    return 2;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x1368(%rip), %rcx      # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
leaq 0xc(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x134a0
movl (%r14), %esi
movq %rbx, %rdi
callq 0x12b60
movl (%r15), %esi
movq %rbx, %rdi
callq 0x12b60
movl $0x2, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/window.c
// Function: Window_set_bounds
static int Window_set_bounds(lua_State *L)
    {
    nk_rect_t bounds;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char *name = luaL_checkstring(L, 2);
    if(echeckrect(L, 3, &bounds)) return argerror(L, 3);
    nk_window_set_bounds(context, name, bounds);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x1112(%rip), %rcx      # 0x67280
xorl %ebx, %ebx
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r15
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x12cd0
movq %rax, %r12
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movl $0x3, %esi
callq 0x139f0
testl %eax, %eax
je 0x661ca
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %r14, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %ebx
jmp 0x661e1
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %r15, %rdi
movq %r12, %rsi
callq 0x136c0
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/window.c
// Function: Window_set_position
static int Window_set_position(lua_State *L)
    {
    nk_vec2_t pos;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char *name = luaL_checkstring(L, 2);
    if(echeckvec2(L, 3, &pos)) return argerror(L, 3);
    nk_window_set_position(context, name, pos);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x107f(%rip), %rcx      # 0x67280
xorl %ebx, %ebx
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r15
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x12cd0
movq %rax, %r12
movq %rsp, %rdx
movq %r14, %rdi
movl $0x3, %esi
callq 0x14160
testl %eax, %eax
je 0x6625b
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %r14, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %ebx
jmp 0x6626b
movsd (%rsp), %xmm0
movq %r15, %rdi
movq %r12, %rsi
callq 0x13580
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/window.c
// Function: Window_set_size
static int Window_set_size(lua_State *L)
    {
    nk_vec2_t size;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char *name = luaL_checkstring(L, 2);
    if(echeckvec2(L, 3, &size)) return argerror(L, 3);
    nk_window_set_size(context, name, size);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0xff5(%rip), %rcx       # 0x67280
xorl %ebx, %ebx
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r15
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x12cd0
movq %rax, %r12
movq %rsp, %rdx
movq %r14, %rdi
movl $0x3, %esi
callq 0x14160
testl %eax, %eax
je 0x662e5
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %r14, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %ebx
jmp 0x662f5
movsd (%rsp), %xmm0
movq %r15, %rdi
movq %r12, %rsi
callq 0x120e0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/window.c
// Function: Window_set_focus
static int Window_set_focus(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char *name = luaL_checkstring(L, 2);
    nk_window_set_focus(context, name);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xf6f(%rip), %rcx       # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x12cd0
movq %r14, %rdi
movq %rax, %rsi
callq 0x130f0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/window.c
// Function: Window_set_scroll
static int Window_set_scroll(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    nk_uint offset_x = luaL_checkinteger(L, 2);
    nk_uint offset_y = luaL_checkinteger(L, 3);
    nk_window_set_scroll(context, offset_x, offset_y);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xf2d(%rip), %rcx       # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12f30
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
movq %r14, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x13c80
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/window.c
// Function: Window_close
static int Window_close(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char *name = luaL_checkstring(L, 2);
    nk_window_close(context, name);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xede(%rip), %rcx       # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x12cd0
movq %r14, %rdi
movq %rax, %rsi
callq 0x13840
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/window.c
// Function: Window_collapse
static int Window_collapse(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char *name = luaL_checkstring(L, 2);
    enum nk_collapse_states state = checkcollapsestates(L, 3);
    nk_window_collapse(context, name, state);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xe9c(%rip), %rcx       # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x12cd0
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
movl $0x3, %edx
callq 0x132f0
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x13d90
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/window.c
// Function: Window_collapse_if
static int Window_collapse_if(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char *name = luaL_checkstring(L, 2);
    enum nk_collapse_states state = checkcollapsestates(L, 3);
    int cond = checkboolean(L, 4);
    nk_window_collapse_if(context, name, state, cond);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xe43(%rip), %rcx       # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x12cd0
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
movl $0x3, %edx
callq 0x132f0
movl %eax, %ebp
movq %rbx, %rdi
movl $0x4, %esi
callq 0x13770
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
movl %eax, %ecx
callq 0x141a0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/window.c
// Function: Window_show
static int Window_show(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char *name = luaL_checkstring(L, 2);
    enum nk_show_states state = checkshowstates(L, 3);
    nk_window_show(context, name, state);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xdd6(%rip), %rcx       # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x12cd0
movq %rax, %r15
movq %rbx, %rdi
movl $0x5, %esi
movl $0x3, %edx
callq 0x132f0
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x138f0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/window.c
// Function: Window_show_if
static int Window_show_if(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char *name = luaL_checkstring(L, 2);
    enum nk_show_states state = checkshowstates(L, 3);
    int cond = checkboolean(L, 4);
    nk_window_show_if(context, name, state, cond);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xd7d(%rip), %rcx       # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x12cd0
movq %rax, %r15
movq %rbx, %rdi
movl $0x5, %esi
movl $0x3, %edx
callq 0x132f0
movl %eax, %ebp
movq %rbx, %rdi
movl $0x4, %esi
callq 0x13770
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
movl %eax, %ecx
callq 0x13b50
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/window.c
// Function: Group_begin
static int Group_begin(lua_State *L)
    {
    int rc = 0;
    const char *name;
    nk_flags flags;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char *title = luaL_checkstring(L, 2);
    flags = checkflags(L, 3); /* nk_panel_flags */
    if(lua_isnoneornil(L, 4))
        rc = nk_group_begin(context, title, flags);
    else
        {
        name = luaL_checkstring(L, 4);
        rc = nk_group_begin_titled(context, name, title, flags);
        }
    lua_pushboolean(L, rc);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xd0d(%rip), %rcx       # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x12cd0
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
movq %rax, %r12
movq %rbx, %rdi
movl $0x4, %esi
callq 0x13df0
testl %eax, %eax
jle 0x665d7
movq %rbx, %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0x12cd0
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
movl %r12d, %ecx
callq 0x14130
jmp 0x665e5
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x14080
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/window.c
// Function: Group_scrolled_begin
static int Group_scrolled_begin(lua_State *L)
    {
    nk_scroll_t offset;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char *title = luaL_checkstring(L, 2);
    nk_flags flags = checkflags(L, 3); /* nk_panel_flags */
    if(echeckscroll(L, 4, &offset)) return argerror(L, 4);
    if(!nk_group_scrolled_begin(context, &offset, title, flags))
        {
        lua_pushboolean(L, 0);
        return 1;
        }
    lua_pushboolean(L, 1);
    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc4a(%rip), %rcx       # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x12cd0
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
movq %rax, %r12
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12650
testl %eax, %eax
je 0x666a0
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x4, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %ebp
jmp 0x666da
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %r15, %rdx
movl %r12d, %ecx
callq 0x13330
testl %eax, %eax
je 0x666cb
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x13270
jmp 0x666da
movq %rbx, %rdi
xorl %esi, %esi
callq 0x13270
movl $0x1, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/window.c
// Function: Group_get_scroll
static int Group_get_scroll(lua_State *L)
    {
    nk_uint offset_x, offset_y;
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char *title = luaL_checkstring(L, 2);
    nk_group_get_scroll(context, title, &offset_x, &offset_y);
    lua_pushinteger(L, offset_x);
    lua_pushinteger(L, offset_y);
    return 2;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb65(%rip), %rcx       # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x12cd0
leaq 0x4(%rsp), %r15
movq %rsp, %r12
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x122a0
movl (%r15), %esi
movq %rbx, %rdi
callq 0x12b60
movl (%r12), %esi
movq %rbx, %rdi
callq 0x12b60
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/window.c
// Function: Group_set_scroll
static int Group_set_scroll(lua_State *L)
    {
    nk_context_t *context = checkcontext(L, 1, NULL);
    const char *title = luaL_checkstring(L, 2);
    nk_uint offset_x = luaL_checkinteger(L, 3);
    nk_uint offset_y = luaL_checkinteger(L, 4);
    nk_group_set_scroll(context, title, offset_x, offset_y);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xaf4(%rip), %rcx       # 0x67280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x12cd0
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
movq %rax, %r12
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12f30
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %edx
movl %eax, %ecx
callq 0x14070
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O3/JesseBuesking[P]omnomnum/omnomnum.c
// Function: yystypeToString
void yystypeToString(sds *s, YYSTYPE A, int precision) {
    if (A.is_frac) {
        dtoa(s, A.frac_num, precision);
        *s = sdscat(*s, "/");
        sds tmp = sdsempty();
        dtoa(&tmp, A.frac_denom, precision);
        *s = sdscatsds(*s, tmp);
        sdsfree(tmp);
    } else if (A.is_dbl) {
        dtoa(s, A.dbl, precision);
    } else {
        itoa(s, (uint64_t)A.dbl);
    }

    jump_table[A.suffix](s);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
cmpb $0x1, 0x20(%r15)
jne 0x2856
movsd 0x10(%r15), %xmm0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x81ec
movq (%rbx), %rdi
leaq 0x9cbd(%rip), %rsi      # 0xc4d8
callq 0x69f7
movq %rax, (%rbx)
callq 0x6261
movq %rsp, %r14
movq %rax, (%r14)
movsd 0x18(%r15), %xmm0
movq %r14, %rdi
movl %ebp, %esi
callq 0x81ec
movq (%rbx), %rdi
movq (%r14), %rsi
callq 0x6a1e
movq %rax, (%rbx)
movq (%r14), %rdi
callq 0x6304
jmp 0x2895
movsd (%r15), %xmm0
cmpb $0x1, 0x8(%r15)
jne 0x286e
movq %rbx, %rdi
movl %ebp, %esi
callq 0x81ec
jmp 0x2895
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x9c1e(%rip), %xmm0     # 0xc4a0
cvttsd2si %xmm0, %rsi
andq %rcx, %rsi
orq %rax, %rsi
movq %rbx, %rdi
callq 0x8124
movl 0x2c(%r15), %eax
leaq 0xf810(%rip), %rcx      # 0x120b0
movq %rbx, %rdi
callq *(%rcx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JesseBuesking[P]omnomnum/dtoa.c
// Function: morphNumericString
void morphNumericString(sds *s, int n) {
    char *p = strchr(*s, '.');                    // Find decimal point, if any.
    if (p != NULL) {
        int dotPosition = (p - *s);
        int endRange = dotPosition + n;
        int lastPosition = (int) sdslen(*s) - 1;

        endRange = endRange < lastPosition ? endRange : lastPosition;

        while ((*s)[endRange] == '0') {     // Remove trailing zeros.
            endRange -= 1;
        }

        if ((*s)[endRange] == '.') {        // If all decimals were zeros, remove "."
            endRange -= 1;
        }

        sdsrange(*s, 0, endRange);          // Trim the string to the range.
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq (%rdi), %rbx
movq %rbx, %rdi
movl $0x2e, %esi
callq 0x1080
testq %rax, %rax
je 0x8199
subl %ebx, %eax
addl %ebp, %eax
movzbl -0x1(%rbx), %ecx
movl %ecx, %edx
andl $0x7, %edx
cmpl $0x4, %edx
ja 0x81b7
leaq 0x4c75(%rip), %rsi      # 0xce00
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
shrl $0x3, %ecx
jmp 0x81b9
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq -0x11(%rbx), %rcx
jmp 0x81b9
movzwl -0x5(%rbx), %ecx
jmp 0x81b9
movl -0x9(%rbx), %ecx
jmp 0x81b9
movzbl -0x3(%rbx), %ecx
jmp 0x81b9
xorl %ecx, %ecx
cltq
decl %ecx
movslq %ecx, %rdx
cmpq %rdx, %rax
cmovlq %rax, %rdx
movzbl (%rbx,%rdx), %eax
cmpl $0x30, %eax
jne 0x81d5
decq %rdx
jmp 0x81c7
cmpl $0x2e, %eax
jne 0x81dc
decl %edx
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x760d
// File: /workspace/github_c_makefile_star2_O3/JesseBuesking[P]omnomnum/dtoa.c
// Function: dtoa
void dtoa(sds *s, double d, int precision) {
    memset(DTOA_BUFFER, 0, 256);
    fill_double(d, DTOA_BUFFER);
    *s = sdscat(*s, DTOA_BUFFER);
    morphNumericString(s, precision);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movsd %xmm0, 0x8(%rsp)
movq %rdi, %r14
leaq 0xa019(%rip), %r15      # 0x12220
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
xorl %esi, %esi
callq 0x10a0
movsd 0x8(%rsp), %xmm0
movq %r15, %rdi
callq 0x8458
movq (%r14), %rdi
movq %r15, %rsi
callq 0x69f7
movq %rax, (%r14)
movq %r14, %rdi
movl %ebx, %esi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x8158
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/JesseBuesking[P]omnomnum/scanner.def.c
// Function: insertYYSTYPE
void insertYYSTYPE(YYSTYPEList *l, YYSTYPE element) {
    if (l->used == l->size) {
        if (l->size == 0) {
            l->size = 1;
        } else {
            l->size *= 2;
        }
        l->values = (YYSTYPE *)realloc(l->values, l->size * sizeof(YYSTYPE));
    }
    l->values[l->used] = element;
    l->used += 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
cmpq 0x10(%rdi), %rcx
jne 0x82bd
leaq (%rcx,%rcx), %rdx
testq %rcx, %rcx
movl $0x1, %ecx
cmovneq %rdx, %rcx
movq %rcx, 0x10(%rbx)
shlq $0x4, %rcx
leaq (%rcx,%rcx,2), %rsi
movq %rax, %rdi
callq 0x10f0
movq %rax, (%rbx)
movq 0x8(%rbx), %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rax,%rcx)
movups %xmm1, 0x10(%rax,%rcx)
movups %xmm0, (%rax,%rcx)
incq 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/JesseBuesking[P]omnomnum/scanner.def.c
// Function: resetYYSTYPElist
void resetYYSTYPElist(YYSTYPEList *l) {
    if (l->size > RESET_LIST_SIZE) {
        l->size = RESET_LIST_SIZE;
        l->values = (YYSTYPE *)realloc(l->values, l->size * sizeof(YYSTYPE));
    }
    l->used = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x9df8(%rip), %rax      # 0x120f8
cmpq %rax, 0x10(%rdi)
jbe 0x831d
movq %rax, 0x10(%rbx)
movq (%rbx), %rdi
shlq $0x4, %rax
leaq (%rax,%rax,2), %rsi
callq 0x10f0
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/JesseBuesking[P]omnomnum/scanner.def.c
// Function: resetParserState
void resetParserState(ParserState *state) {
    state->precision = 6;
    sdsfree(state->result);
    state->error = NO_ERROR;
    resetYYSTYPElist(&(state->yystypeList));
    state->parse_second = false;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x6, (%rdi)
movq 0x8(%rdi), %rdi
callq 0x6304
movl $0x0, 0x10(%rbx)
leaq 0x18(%rbx), %rdi
callq 0x82f5
movb $0x0, 0x30(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/JesseBuesking[P]omnomnum/util.c
// Function: remove_char_inplace
size_t remove_char_inplace(char *str, size_t str_len, const unsigned char remove) {
    size_t orig_index = 0, new_index = 0;
    for(;orig_index < str_len;) {
        if (str[orig_index] == remove) {
            orig_index += 1;
        } else {
            str[new_index] = str[orig_index];
            orig_index += 1;
            new_index += 1;
        }
    }

    str[new_index] = '\0';
    return new_index;
}

// Assembly:
testq %rsi, %rsi
je 0x83e7
movzbl %dl, %ecx
xorl %eax, %eax
xorl %edx, %edx
movsbl (%rdi,%rdx), %r8d
cmpl %ecx, %r8d
je 0x83dd
movb %r8b, (%rdi,%rax)
incq %rax
incq %rdx
cmpq %rdx, %rsi
jne 0x83cc
jmp 0x83e9
xorl %eax, %eax
movb $0x0, (%rdi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/JesseBuesking[P]omnomnum/util.c
// Function: replace_char_inplace
void replace_char_inplace(char *str, size_t str_len, const unsigned char remove, const unsigned char replacement) {
    size_t index = 0;
    for(;index < str_len; index++) {
        if (str[index] == remove) {
            str[index] = replacement;
        }
    }
}

// Assembly:
testq %rsi, %rsi
je 0x840d
movzbl %dl, %eax
xorl %edx, %edx
movsbl (%rdi,%rdx), %r8d
cmpl %eax, %r8d
jne 0x8405
movb %cl, (%rdi,%rdx)
incq %rdx
cmpq %rdx, %rsi
jne 0x83f8
retq
// File: /workspace/github_c_makefile_star2_O3/JesseBuesking[P]omnomnum/util.c
// Function: replace_two_byte_char_inplace
size_t replace_two_byte_char_inplace(unsigned char *str, size_t str_len, const unsigned char* remove, const unsigned char replacement) {
    size_t orig_index = 0, new_index = 0;
    for(;orig_index < str_len - 1;) {
        if (str[orig_index] == remove[0] && str[orig_index + 1] == remove[1]) {
            str[new_index] = replacement;
            orig_index += 2;
            new_index += 1;
        } else {
            str[new_index] = str[orig_index];
            orig_index += 1;
            new_index += 1;
        }
    }

    str[new_index] = '\0';
    return new_index;
}

// Assembly:
decq %rsi
je 0x8450
pushq %rbx
xorl %eax, %eax
xorl %r8d, %r8d
movb (%rdi,%r8), %r9b
cmpb (%rdx), %r9b
jne 0x8435
movb 0x1(%rdi,%r8), %bl
movl $0x2, %r10d
movl %ecx, %r11d
cmpb 0x1(%rdx), %bl
je 0x843e
movl $0x1, %r10d
movl %r9d, %r11d
movb %r11b, (%rdi,%rax)
addq %r10, %r8
incq %rax
cmpq %rsi, %r8
jb 0x8419
popq %rbx
jmp 0x8452
xorl %eax, %eax
movb $0x0, (%rdi,%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O3/JesseBuesking[P]omnomnum/grisu2/grisu2.c
// Function: fill_double
bool fill_double(double v, char* buffer) {
    if (v == 0) {
        strcpy(buffer, "0.0");
        return 1;
    } else {
        if (v < 0) {
            *buffer++ = '-';
            v = -v;
        }

        int length, K;
        grisu2(v, buffer, &length, &K);
#ifndef HUMAN_READABLE
        buffer[length] = 'e';
        fill_exponent(K, &buffer[length+1]);
#else
        prettify_string(buffer, 0, length, K);
#endif
        return 1;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x847e
jp 0x847e
movl $0x302e30, (%rbx)       # imm = 0x302E30
jmp 0x85d0
ucomisd %xmm0, %xmm1
jbe 0x8492
movb $0x2d, (%rbx)
incq %rbx
xorpd 0x1bce(%rip), %xmm0     # 0xa060
leaq 0xc(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x85df
movslq (%r14), %r14
movl (%r15), %eax
leal (%rax,%r14), %r12d
leaq (%rbx,%r14), %r15
movb $0x0, (%rbx,%r14)
testl %eax, %eax
sets %cl
cmpl $0x16, %r12d
setge %dl
orb %cl, %dl
jne 0x8509
testl %eax, %eax
je 0x84f6
movl %r14d, %eax
incl %eax
cmpl %eax, %r12d
cmovgl %r12d, %eax
notl %r14d
addl %eax, %r14d
incq %r14
movq %r15, %rdi
movl $0x30, %esi
movq %r14, %rdx
callq 0x10a0
movslq %r12d, %rax
movw $0x302e, (%rbx,%rax)    # imm = 0x302E
movb $0x0, 0x2(%rbx,%rax)
jmp 0x85d0
leal -0x1(%r12), %ebp
cmpl $0x14, %ebp
ja 0x853b
movl %r12d, %ecx
leaq (%rbx,%rcx), %rsi
addq %rcx, %rbx
incq %rbx
negl %eax
movslq %eax, %rdx
movq %rbx, %rdi
callq 0x1100
movb $0x2e, -0x1(%rbx)
movb $0x0, 0x1(%r15)
jmp 0x85d0
leal 0x5(%r12), %eax
cmpl $0x5, %eax
ja 0x8591
movl $0x2, %r15d
subl %r12d, %r15d
leaq (%rbx,%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1100
movw $0x2e30, (%rbx)         # imm = 0x2E30
testl %r12d, %r12d
jns 0x8585
leaq 0x2(%rbx), %rdi
cmpl $0x4, %r15d
movl $0x3, %edx
cmovael %r15d, %edx
addl $-0x2, %edx
movl $0x30, %esi
callq 0x10a0
addl %r14d, %r15d
movslq %r15d, %rax
movb $0x0, (%rbx,%rax)
jmp 0x85d0
cmpl $0x1, %r14d
jne 0x85a6
movb $0x65, 0x1(%rbx)
addq $0x2, %rbx
movl %ebp, %edi
movq %rbx, %rsi
jmp 0x85cb
leaq 0x2(%rbx), %rdi
leaq 0x1(%rbx), %rsi
decq %r14
movq %r14, %rdx
callq 0x1100
movb $0x2e, 0x1(%rbx)
movb $0x65, 0x1(%r15)
addq $0x2, %r15
movl %ebp, %edi
movq %r15, %rsi
callq 0x8a6f
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JesseBuesking[P]omnomnum/grisu2/grisu2.c
// Function: grisu_round
void grisu_round(char* buffer, int len,
		 uint64_t delta, uint64_t rest,
		 uint64_t ten_kappa, uint64_t wp_w) {
  while (rest < wp_w &&
	 delta - rest >= ten_kappa &&
	 (rest + ten_kappa < wp_w || /// closer
	 wp_w - rest > rest+ten_kappa - wp_w))
  {
    buffer[len-1]--; rest += ten_kappa;
  }
}

// Assembly:
movq %r9, %rax
subq %rcx, %rax
setbe %r10b
movq %rdx, %r11
subq %rcx, %r11
cmpq %r8, %r11
setb %r11b
orb %r10b, %r11b
jne 0x8863
movslq %esi, %rsi
addq %r8, %rcx
subq %rcx, %rdx
movq %r9, %r10
negq %r10
cmpq %r9, %rcx
jb 0x8848
leaq (%r10,%rcx), %r11
cmpq %r11, %rax
jbe 0x8863
decb -0x1(%rdi,%rsi)
subq %r8, %rdx
setb %r11b
cmpq %r9, %rcx
jae 0x8863
subq %r8, %rax
addq %r8, %rcx
testb %r11b, %r11b
je 0x883a
retq
// File: /workspace/github_c_makefile_star2_O3/JesseBuesking[P]omnomnum/grisu2/fast_exponent.h
// Function: fill_exponent
static void fill_exponent(int K, char* buffer) {
    int i = 0;
    if (K < 0) {
	buffer[i++] = '-';
	K = -K;
    }
    if (K >= 100) {
	buffer[i++] = '0' + K / 100; K %= 100;
	buffer[i++] = '0' + K / 10; K %= 10;
	buffer[i++] = '0' + K;
    } else if (K >= 10) {
	buffer[i++] = '0' + K / 10; K %= 10;
	buffer[i++] = '0' + K;
    } else {
	buffer[i++] = '0' + K;
    }
    buffer[i] = '\0';
}

// Assembly:
xorl %eax, %eax
testl %edi, %edi
jns 0x8a7f
movb $0x2d, (%rsi)
negl %edi
movl $0x1, %eax
cmpl $0x64, %edi
jb 0x8ac9
movl %edi, %ecx
imulq $0x51eb851f, %rcx, %rcx # imm = 0x51EB851F
shrq $0x25, %rcx
leal 0x30(%rcx), %edx
movl %eax, %r8d
movb %dl, (%rsi,%r8)
imull $0x64, %ecx, %ecx
subl %ecx, %edi
imull $0x67, %edi, %ecx
movzwl %cx, %ecx
shrl $0xa, %ecx
movl %ecx, %edx
orb $0x30, %dl
movb %dl, 0x1(%rsi,%r8)
addl %ecx, %ecx
leal (%rcx,%rcx,4), %ecx
subb %cl, %dil
orb $0x30, %dil
addl $0x3, %eax
movb %dil, 0x2(%rsi,%r8)
jmp 0x8b08
movl %eax, %ecx
cmpl $0xa, %edi
jb 0x8afe
movzbl %dil, %edx
imull $0xcd, %edx, %edx
shrl $0xb, %edx
movl %edx, %r8d
orb $0x30, %r8b
movb %r8b, (%rsi,%rcx)
addl %edx, %edx
leal (%rdx,%rdx,4), %edx
subb %dl, %dil
orb $0x30, %dil
orl $0x2, %eax
movb %dil, 0x1(%rsi,%rcx)
jmp 0x8b08
orb $0x30, %dil
incl %eax
movb %dil, (%rsi,%rcx)
movl %eax, %eax
movb $0x0, (%rsi,%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O3/JesseBuesking[P]omnomnum/branchlut/branchlut.c
// Function: i64toa_branchlut
int i64toa_branchlut(int64_t value, char* buffer) {
    uint64_t u = (uint64_t) (value);
    if (value < 0) {
        *buffer++ = '-';
        u = ~u + 1;

        // Adding 1 to account for the negative sign.
        return u64toa_branchlut(u, buffer) + 1;
    }

    return u64toa_branchlut(u, buffer);
}

// Assembly:
testq %rdi, %rdi
jns 0x8dc4
pushq %rax
movb $0x2d, (%rsi)
incq %rsi
negq %rdi
callq 0x8dc4
incl %eax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/JesseBuesking[P]omnomnum/main.c
// Function: test_single
void test_single(const char *data, bool verbose, bool parse_second, int precision) {
    ParserState state;
    initParserState(&state);
    state.parse_second = parse_second;
    state.precision = precision;

    if (verbose) printf("Input:  '%s'\n", data);
    normalize(data, strlen(data), &state);
    if (verbose) printf("Output: '%s'\n", state.result);
    resetParserState(&state);

    freeParserState(&state);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x835c
movb %r14b, 0x30(%r12)
movl %ebp, (%r12)
testl %r15d, %r15d
je 0x94a2
leaq 0x5abf(%rip), %rdi      # 0xef28
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1090
movq %rbx, %rdi
callq 0x1070
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x2a88
movq 0x8(%r14), %rsi
leaq 0x5a9d(%rip), %rdi      # 0xef36
xorl %eax, %eax
callq 0x1090
jmp 0x94ba
movq %rbx, %rdi
callq 0x1070
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2a88
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x838b
movq %rbx, %rdi
callq 0x83b4
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JesseBuesking[P]omnomnum/main.c
// Function: test_loop
void test_loop(const char *data) {
    ParserState state;
    initParserState(&state);

    int i;
    for (i = 0; i < 1000; i++) {
        normalize(data, strlen(data), &state);
        resetParserState(&state);
    }

    freeParserState(&state);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x835c
movl $0x3e8, %ebp            # imm = 0x3E8
movq %rbx, %rdi
callq 0x1070
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x2a88
movq %r14, %rdi
callq 0x838b
decl %ebp
jne 0x94f9
leaq 0x8(%rsp), %rdi
callq 0x83b4
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/main.c
// Function: get_robot_params
void get_robot_params( struct Robot_Params *params ) {
	params->radius = 1;
	
	params->motor_sensitivity = 0.01;
	params->motor_threshold = 0.1;
	params->turn_sensitivity = 0.01;
	params->turn_threshold = 0.1;
	
	params->num_dist_sensors = 0;
	params->dist_sensor_length = 1;
	params->dist_sensor_pos = NULL;
	params->invert_dist_sensors = 1;
}

// Assembly:
movaps 0x5d13(%rip), %xmm0     # 0x70d0
movups %xmm0, (%rdi)
movaps 0x5d19(%rip), %xmm0     # 0x70e0
movups %xmm0, 0x10(%rdi)
movabsq $0x3fb999999999999a, %rax # imm = 0x3FB999999999999A
movq %rax, 0x20(%rdi)
movl $0x0, 0x28(%rdi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x30(%rdi)
movq $0x0, 0x38(%rdi)
movb $0x1, 0x40(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/main.c
// Function: run_trial
int run_trial( pNetwork *controller_structure, struct NEAT_Params *n_params, struct Robot_Params *r_params, TileMaze *maze, int *behaviour ) {
	int err=0;

	struct Implementation_Params i_params = {3};

	eNetwork controller;
	if (( err = create_eNetwork( &controller ) ))
		return err;
	if (( err = build_eNetwork( &controller, controller_structure, n_params, &i_params ) )) {
		delete_eNetwork( &controller );
		return err;
	}

	Robot bot = { 1, 1, 0 };
/*	double sensors[NUM_SENSORS+1], motors[NUM_MOTORS];*/
/*	sensors[NUM_SENSORS] = 1;*/
	double sensors[NUM_SENSORS], motors[NUM_MOTORS];
	int i, tile_counter=0, tile=0, prev_tile;
	for ( i=0; i<20000 && tile_counter < 400; i++ ) {
		get_sensor_readings_in_tilemaze( &bot, maze, r_params, sensors );
		activate( &controller, sensors, motors );
		move_robot_in_tilemaze( &bot, maze, r_params, motors );
		
		prev_tile = tile;
		tile = (int)(bot.x / maze->tile_width) + maze->x*(int)(bot.y / maze->tile_width);
		tile_counter++;
		if ( tile != prev_tile )
			tile_counter = 0;

		++behaviour[tile];
	}
	
	if ( i==tile_counter && bot.x == 1 && bot.y == 1 )
		behaviour[tile] = 0;

	delete_eNetwork( &controller );

	return err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movabsq $0x4008000000000000, %rax # imm = 0x4008000000000000
movq %rax, 0x18(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x6200
movl %eax, %ebp
testl %eax, %eax
jne 0x1574
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rcx
movq %r13, %rsi
movq %r12, %rdx
callq 0x6261
testl %eax, %eax
je 0x1468
movl %eax, %ebp
leaq 0x38(%rsp), %rdi
callq 0x621d
jmp 0x1574
movq %rbx, 0x10(%rsp)
movupd 0x5cdb(%rip), %xmm0     # 0x7150
leaq 0x20(%rsp), %rax
movapd %xmm0, (%rax)
movq $0x0, 0x10(%rax)
xorl %eax, %eax
xorl %ebx, %ebx
xorl %edx, %edx
movl %edx, %r12d
movl %eax, 0xc(%rsp)
leaq 0x20(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r15, %r13
leaq 0x90(%rsp), %r15
movq %r15, %rcx
callq 0x5f5a
leaq 0x38(%rsp), %rdi
movq %r15, %rsi
movq %r13, %r15
leaq 0x70(%rsp), %r13
movq %r13, %rdx
callq 0x6679
movq %rbp, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0x5925
movsd 0x20(%rsp), %xmm1
movsd 0x28(%rsp), %xmm0
movsd (%r14), %xmm2
movapd %xmm1, %xmm3
divsd %xmm2, %xmm3
cvttsd2si %xmm3, %ecx
movapd %xmm0, %xmm3
divsd %xmm2, %xmm3
cvttsd2si %xmm3, %eax
imull 0x8(%r14), %eax
addl %ecx, %eax
incl %ebx
cmpl 0xc(%rsp), %eax
movl $0x0, %ecx
cmovnel %ecx, %ebx
movslq %eax, %rcx
movq 0x10(%rsp), %rdx
incl (%rdx,%rcx,4)
leal 0x1(%r12), %edx
cmpl $0x4e1e, %r12d          # imm = 0x4E1E
ja 0x1540
cmpl $0x190, %ebx            # imm = 0x190
jl 0x148c
cmpl %ebx, %edx
jne 0x1568
ucomisd 0x5be4(%rip), %xmm1     # 0x7130
jne 0x1568
jp 0x1568
ucomisd 0x5bd8(%rip), %xmm0     # 0x7130
jne 0x1568
jp 0x1568
movq 0x10(%rsp), %rax
movl $0x0, (%rax,%rcx,4)
leaq 0x38(%rsp), %rdi
callq 0x621d
xorl %ebp, %ebp
movl %ebp, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/main.c
// Function: m_get_spread
void m_get_spread( pNode *in, int n, double x ) {
	int i;
	for ( i=1; i<=n; i++ ) {
		in[i-1].x[0] = x;
		in[i-1].x[1] = (-0.5) + i/(1.0+n);
	}
}

// Assembly:
testl %esi, %esi
jle 0x15c8
incl %esi
cvtsi2sd %rsi, %xmm1
addq $0x8, %rdi
movl $0x1, %eax
movsd 0x5b94(%rip), %xmm2     # 0x7138
movsd %xmm0, -0x8(%rdi)
xorps %xmm3, %xmm3
cvtsi2sd %eax, %xmm3
divsd %xmm1, %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, (%rdi)
incq %rax
addq $0x18, %rdi
cmpq %rax, %rsi
jne 0x15a4
retq
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/main.c
// Function: analyse_maze
int analyse_maze( TileMaze *m, int *behaviour, int print ) {
	int x, y, maxval=0, tiles_visited=0;
	for ( x=0; x<m->x*m->y; x++ ) {
		maxval = max(maxval, behaviour[x]);
		if ( behaviour[x] )
			tiles_visited++;
	}
	if ( print ) {
		for ( y=0; y<m->y; y++ ) {
			putchar('\n');
			for ( x=0; x<m->x; x++ ) {
				if ( behaviour[x + m->x*y] ) {
					int track = (int)(34 * behaviour[x + m->x*y] / maxval);
					if ( track < 9 )
						putchar( '1'+track );
					else
						putchar( 'A'+(track-9) );
				} else if ( m->tiles[x + m->x*y] )
					putchar('0');
				else
					putchar('#');
			}
		}
		putchar('\n');
		fflush(stdout);
	}
	return tiles_visited;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0xc(%rdi), %eax
movl 0x8(%rdi), %ecx
imull %eax, %ecx
testl %ecx, %ecx
jle 0x160a
movl %ecx, %ecx
xorl %esi, %esi
xorl %ebp, %ebp
xorl %r15d, %r15d
movl (%rbx,%rsi,4), %edi
cmpl %edi, %r15d
cmovlel %edi, %r15d
cmpl $0x1, %edi
sbbl $-0x1, %ebp
incq %rsi
cmpq %rsi, %rcx
jne 0x15f0
jmp 0x160f
xorl %r15d, %r15d
xorl %ebp, %ebp
testl %edx, %edx
je 0x16ac
testl %eax, %eax
jle 0x1693
xorl %r12d, %r12d
movl $0xa, %edi
callq 0x1040
movl 0x8(%r14), %eax
testl %eax, %eax
jle 0x168a
xorl %r13d, %r13d
imull %r12d, %eax
movslq %eax, %rcx
leaq (%rcx,%r13), %rax
movl (%rbx,%rax,4), %eax
testl %eax, %eax
je 0x165d
movl %eax, %ecx
shll $0x5, %ecx
leal (%rcx,%rax,2), %eax
cltd
idivl %r15d
movl %eax, %edi
cmpl $0x8, %eax
jg 0x1676
addl $0x31, %edi
jmp 0x1679
addq 0x10(%r14), %rcx
cmpb $0x0, (%r13,%rcx)
movl $0x30, %edi
movl $0x23, %eax
cmovel %eax, %edi
jmp 0x1679
addl $0x38, %edi
callq 0x1040
movl 0x8(%r14), %eax
incq %r13
cmpl %eax, %r13d
jl 0x1633
incl %r12d
cmpl 0xc(%r14), %r12d
jl 0x161e
movl $0xa, %edi
callq 0x1040
movq 0x893c(%rip), %rax      # 0x9fe0
movq (%rax), %rdi
callq 0x10f0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/cppn.c
// Function: allocate_CPPN
int allocate_CPPN( CPPN *net ) {
	int err=0;

	net->nodes = 0;
	net->links = 0;

	if (( err = Malloc( net->links, net->num_links*sizeof *net->links ) ) \
	 || ( err = Malloc( net->nodes, (net->num_inputs+net->num_outputs+net->num_hidden)*sizeof *net->nodes ) )) {
		delete_CPPN( net );
	}

	return err;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq %r14, (%rdi)
addq $0x18, %rdi
movq %r14, 0x18(%rbx)
movslq 0x20(%rbx), %rsi
shlq $0x5, %rsi
callq 0x47e4
testl %eax, %eax
jne 0x1e47
movslq 0x8(%rbx), %rax
movslq 0xc(%rbx), %rcx
addq %rax, %rcx
movslq 0x10(%rbx), %rsi
addq %rcx, %rsi
shlq $0x4, %rsi
movq %rbx, %rdi
callq 0x47e4
testl %eax, %eax
je 0x1e64
movl %eax, %r14d
movq (%rbx), %rdi
callq 0x1030
movq 0x18(%rbx), %rdi
callq 0x1030
xorl %eax, %eax
movq %rax, 0x18(%rbx)
movq %rax, (%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/kernfel[P]fNEAT/cppn.c
// Function: clone_CPPN
int clone_CPPN( CPPN *net, const CPPN *original ) {
	int err=0;
	
	// Copy values over
	memcpy( net, original, sizeof *original );

	// Reassign pointers
	if (( err = allocate_CPPN( net ) ))
		return err;
	
	// Copy nodes and links
	memcpy( net->nodes, original->nodes, (net->num_inputs+net->num_outputs+net->num_hidden)*sizeof *net->nodes );
	memcpy( net->links, original->links, net->num_links*sizeof *net->links );

	return err;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %rax
movq %rax, 0x20(%rdi)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
callq 0x1dff
movl %eax, %ebp
testl %eax, %eax
jne 0x1ed0
movq (%rbx), %rdi
movq (%r14), %rsi
movslq 0x8(%rbx), %rax
movslq 0xc(%rbx), %rcx
addq %rax, %rcx
movslq 0x10(%rbx), %rdx
addq %rcx, %rdx
shlq $0x4, %rdx
callq 0x10c0
movq 0x18(%rbx), %rdi
movq 0x18(%r14), %rsi
movslq 0x20(%rbx), %rdx
shlq $0x5, %rdx
callq 0x10c0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq