LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xe58(%rip), %rcx       # 0x60280
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12dd0
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x13bf0
testl %eax, %eax
je 0x5f478
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
movl %eax, %ebp
jmp 0x5f4e3
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r12
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x14030
testl %eax, %eax
jle 0x5f4c0
pushq $0x5
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12dd0
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
movl %r12d, %ecx
callq 0x12410
jmp 0x5f4d9
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x12710
movq %rbx, %rdi
movl %eax, %esi
callq 0x133d0
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xcbd(%rip), %rcx       # 0x60280
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x120e0
movq %rax, %rdi
callq 0x133b0
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x132d0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xc87(%rip), %rcx       # 0x60280
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x120e0
movq %rax, %rdi
callq 0x12b30
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x132d0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb76(%rip), %rcx       # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %rdi
callq 0x138f0
testq %rax, %rax
je 0x5f72d
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x121d0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb3c(%rip), %rcx       # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
leaq 0xc(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x13630
movl (%r14), %esi
movq %rbx, %rdi
callq 0x12c20
movl (%r15), %esi
movq %rbx, %rdi
callq 0x12c20
pushq $0x2
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8fa(%rip), %rcx       # 0x60280
xorl %ebx, %ebx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r15
pushq $0x2
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x12dd0
movq %rax, %r12
pushq $0x3
popq %rsi
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x13bf0
testl %eax, %eax
je 0x5f9d8
pushq $-0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x3
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x124a0
movl %eax, %ebx
jmp 0x5f9ef
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %r15, %rdi
movq %r12, %rsi
callq 0x138a0
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x871(%rip), %rcx       # 0x60280
xorl %ebx, %ebx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r15
pushq $0x2
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x12dd0
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rsp, %rdx
movq %r14, %rdi
callq 0x143f0
testl %eax, %eax
je 0x5fa5f
pushq $-0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x3
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x124a0
movl %eax, %ebx
jmp 0x5fa6f
movsd (%rsp), %xmm0
movq %r15, %rdi
movq %r12, %rsi
callq 0x13740
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7f1(%rip), %rcx       # 0x60280
xorl %ebx, %ebx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r15
pushq $0x2
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x12dd0
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rsp, %rdx
movq %r14, %rdi
callq 0x143f0
testl %eax, %eax
je 0x5fadf
pushq $-0x1
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x3
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x124a0
movl %eax, %ebx
jmp 0x5faef
movsd (%rsp), %xmm0
movq %r15, %rdi
movq %r12, %rsi
callq 0x120f0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x775(%rip), %rcx       # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12dd0
movq %r14, %rdi
movq %rax, %rsi
callq 0x13240
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x737(%rip), %rcx       # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %r14, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x13e80
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6ee(%rip), %rcx       # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12dd0
movq %r14, %rdi
movq %rax, %rsi
callq 0x13a30
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6b0(%rip), %rcx       # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12dd0
movq %rax, %r15
pushq $0x4
popq %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x13450
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x13fb0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x65e(%rip), %rcx       # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12dd0
movq %rax, %r15
pushq $0x4
popq %rbp
pushq $0x3
popq %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x13450
movl %eax, %r12d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x13950
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %edx
movl %eax, %ecx
callq 0x14430
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5fa(%rip), %rcx       # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12dd0
movq %rax, %r15
pushq $0x5
popq %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x13450
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x13ae0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5a9(%rip), %rcx       # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12dd0
movq %rax, %r15
pushq $0x5
popq %rsi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x13450
movl %eax, %ebp
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x13950
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
movl %eax, %ecx
callq 0x13d50
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x543(%rip), %rcx       # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12dd0
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r12
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x14030
testl %eax, %eax
jle 0x5fd97
pushq $0x4
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12dd0
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
movl %r12d, %ecx
callq 0x143c0
jmp 0x5fda5
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x142e0
movq %rbx, %rdi
movl %eax, %esi
callq 0x133d0
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x48e(%rip), %rcx       # 0x60280
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12dd0
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r12
pushq $0x4
popq %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x126b0
testl %eax, %eax
je 0x5fe52
pushq $-0x1
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12690
pushq $0x4
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x124a0
movl %eax, %ebp
jmp 0x5fe77
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %r15, %rdx
movl %r12d, %ecx
callq 0x13490
movq %rbx, %rdi
testl %eax, %eax
je 0x5fe70
movl %ebp, %esi
jmp 0x5fe72
xorl %esi, %esi
callq 0x133d0
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x3c6(%rip), %rcx       # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x12dd0
leaq 0xc(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x122e0
movl (%r15), %esi
movq %rbx, %rdi
callq 0x12c20
movl (%r12), %esi
movq %rbx, %rdi
callq 0x12c20
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x357(%rip), %rcx       # 0x60280
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x120e0
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x12dd0
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %rax, %r12
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x13060
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %edx
movl %eax, %ecx
callq 0x142d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x2796
movsd 0x10(%r15), %xmm0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x722a
movq (%rbx), %rdi
leaq 0x8d7d(%rip), %rsi      # 0xb4d8
callq 0x616a
movq %rax, (%rbx)
callq 0x5c78
movq %rsp, %r14
movq %rax, (%r14)
movsd 0x18(%r15), %xmm0
movq %r14, %rdi
movl %ebp, %esi
callq 0x722a
movq (%rbx), %rdi
movq (%r14), %rsi
callq 0x6191
movq %rax, (%rbx)
movq (%r14), %rdi
callq 0x5cf4
jmp 0x27d5
movsd (%r15), %xmm0
cmpb $0x1, 0x8(%r15)
jne 0x27ae
movq %rbx, %rdi
movl %ebp, %esi
callq 0x722a
jmp 0x27d5
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x8cde(%rip), %xmm0     # 0xb4a0
cvttsd2si %xmm0, %rsi
andq %rcx, %rsi
orq %rax, %rsi
movq %rbx, %rdi
callq 0x7164
movl 0x2c(%r15), %eax
leaq 0xe8d0(%rip), %rcx      # 0x110b0
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_O2/JesseBuesking[P]omnomnum/scan.c
// Function: scanstate_init
void scanstate_init(scanstate *ss, const char *bufptr, size_t bufsiz)
{
    ss->cursor = bufptr;
    ss->marker = NULL;
    ss->token = bufptr;
    ss->limit = bufptr + bufsiz;
}

// Assembly:
movq %rsi, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
addq %rsi, %rdx
movq %rdx, 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/JesseBuesking[P]omnomnum/sds.c
// Function: sdsReqType
static inline char sdsReqType(size_t string_size) {
    if (string_size < 1<<5)
        return SDS_TYPE_5;
    if (string_size < 1<<8)
        return SDS_TYPE_8;
    if (string_size < 1<<16)
        return SDS_TYPE_16;
#if (LONG_MAX == LLONG_MAX)
    if (string_size < 1ll<<32)
        return SDS_TYPE_32;
#endif
    return SDS_TYPE_64;
}

// Assembly:
cmpq $0x20, %rdi
jae 0x5c3a
xorl %eax, %eax
retq
movb $0x1, %al
cmpq $0x100, %rdi            # imm = 0x100
jb 0x5c39
movb $0x2, %al
cmpq $0x10000, %rdi          # imm = 0x10000
jb 0x5c39
shrq $0x20, %rdi
cmpq $0x1, %rdi
movb $0x4, %al
sbbb $0x0, %al
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x2e
popq %rsi
movq %rbx, %rdi
callq 0x1080
testq %rax, %rax
je 0x71d7
subl %ebx, %eax
addl %ebp, %eax
movzbl -0x1(%rbx), %ecx
movl %ecx, %edx
andl $0x7, %edx
cmpl $0x4, %edx
ja 0x71f5
leaq 0x4c33(%rip), %rsi      # 0xbdfc
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
shrl $0x3, %ecx
jmp 0x71f7
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq -0x11(%rbx), %rcx
jmp 0x71f7
movzwl -0x5(%rbx), %ecx
jmp 0x71f7
movl -0x9(%rbx), %ecx
jmp 0x71f7
movzbl -0x3(%rbx), %ecx
jmp 0x71f7
xorl %ecx, %ecx
cltq
decl %ecx
movslq %ecx, %rdx
cmpq %rdx, %rax
cmovlq %rax, %rdx
movzbl (%rbx,%rdx), %eax
cmpl $0x30, %eax
jne 0x7213
decq %rdx
jmp 0x7205
cmpl $0x2e, %eax
jne 0x721a
decl %edx
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6841
// File: /workspace/github_c_makefile_star2_O2/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 0x9fdb(%rip), %r15      # 0x11220
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
xorl %esi, %esi
callq 0x10a0
movsd 0x8(%rsp), %xmm0
movq %r15, %rdi
callq 0x7458
movq (%r14), %rdi
movq %r15, %rsi
callq 0x616a
movq %rax, (%r14)
movq %r14, %rdi
movl %ebx, %esi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x7198
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x72e9
leaq (%rcx,%rcx), %rdx
testq %rcx, %rcx
pushq $0x1
popq %rcx
cmovneq %rdx, %rcx
movq %rcx, 0x10(%rbx)
imulq $0x30, %rcx, %rsi
movq %rax, %rdi
callq 0x10f0
movq %rax, (%rbx)
movq 0x8(%rbx), %rcx
imulq $0x30, %rcx, %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_O2/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 0x9dd0(%rip), %rax      # 0x110f8
cmpq %rax, 0x10(%rdi)
jbe 0x7341
movq %rax, 0x10(%rbx)
movq (%rbx), %rdi
imulq $0x30, %rax, %rsi
callq 0x10f0
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5cf4
andl $0x0, 0x10(%rbx)
leaq 0x18(%rbx), %rdi
callq 0x731d
movb $0x0, 0x30(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
cmpq %rax, %rsi
je 0x73fd
movsbl (%rdi,%rax), %r8d
cmpl %edx, %r8d
jne 0x73f8
movb %cl, (%rdi,%rax)
incq %rax
jmp 0x73e6
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
decq %rsi
xorl %r8d, %r8d
movabsq $0x2, %r9
movabsq $0x1, %r10
xorl %eax, %eax
cmpq %rsi, %r8
jae 0x744d
movb (%rdi,%r8), %r11b
cmpb (%rdx), %r11b
jne 0x743c
movb 0x1(%rdi,%r8), %bpl
movl %ecx, %ebx
movq %r9, %r14
cmpb 0x1(%rdx), %bpl
je 0x7442
movl %r11d, %ebx
movq %r10, %r14
movb %bl, (%rdi,%rax)
addq %r14, %r8
incq %rax
jmp 0x741e
movb $0x0, (%rdi,%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x7479
jp 0x7479
movl $0x302e30, (%rbx)       # imm = 0x302E30
jmp 0x7506
ucomisd %xmm0, %xmm1
jbe 0x748d
movb $0x2d, (%rbx)
incq %rbx
xorpd 0x1bd3(%rip), %xmm0     # 0x9060
leaq 0x4(%rsp), %r14
movq %rsp, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x7597
movslq (%r14), %r14
movslq (%r15), %rcx
leaq (%rcx,%r14), %rax
movb $0x0, (%rbx,%r14)
testq %rcx, %rcx
js 0x74cb
cmpl $0x15, %eax
jg 0x74cb
cmpq %rax, %r14
jge 0x74fb
movb $0x30, (%rbx,%r14)
incq %r14
jmp 0x74bc
leaq (%rbx,%r14), %r15
leal -0x1(%rax), %ebp
cmpl $0x14, %ebp
ja 0x7513
movl %eax, %eax
leaq (%rbx,%rax), %rsi
addq %rax, %rbx
incq %rbx
negl %ecx
movslq %ecx, %rdx
movq %rbx, %rdi
callq 0x1100
movb $0x2e, -0x1(%rbx)
movb $0x0, 0x1(%r15)
jmp 0x7506
movw $0x302e, (%rbx,%rax)    # imm = 0x302E
movb $0x0, 0x2(%rbx,%rax)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leal 0x5(%rax), %ecx
cmpl $0x5, %ecx
ja 0x7553
pushq $0x2
popq %r15
subl %eax, %r15d
leaq (%rbx,%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1100
movw $0x2e30, (%rbx)         # imm = 0x2E30
pushq $0x2
popq %rax
cmpq %r15, %rax
jae 0x7547
movb $0x30, (%rbx,%rax)
incq %rax
jmp 0x7539
leal (%r14,%r15), %eax
cltq
movb $0x0, (%rbx,%rax)
jmp 0x7506
cmpl $0x1, %r14d
jne 0x7568
movb $0x65, 0x1(%rbx)
addq $0x2, %rbx
movl %ebp, %edi
movq %rbx, %rsi
jmp 0x758d
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 0x78e2
jmp 0x7506
// File: /workspace/github_c_makefile_star2_O2/JesseBuesking[P]omnomnum/grisu2/grisu2.c
// Function: grisu2
void grisu2(double v, char* buffer, int* length, int* K) {
  diy_fp_t w_m, w_p;
  int q = 64, alpha = -59, gamma = -56; int pos;
  normalized_boundaries(v, &w_m, &w_p);
  diy_fp_t w = normalize_diy_fp(double2diy_fp(v));
  int mk = k_comp(w_p.e + q, alpha, gamma);
  diy_fp_t c_mk = cached_power(mk);
  diy_fp_t W  = multiply(w,   c_mk);
  diy_fp_t Wp = multiply(w_p, c_mk);
  diy_fp_t Wm = multiply(w_m, c_mk);
  Wm.f++; Wp.f--;
  diy_fp_t delta = minus(Wp, Wm);
  *K = -mk;
  digit_gen(W, Wp, delta, buffer, length, K);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
callq 0x7859
movq %rax, %rdi
leaq (%rax,%rax), %r9
leaq 0x1(,%rax,2), %r12
leal -0x1(%rdx), %ecx
pushq $0xb
popq %r8
subl %edx, %r8d
btq $0x35, %r12
jb 0x75e1
addq %r12, %r12
incl %r8d
jmp 0x75d2
movabsq $0x10000000000000, %r10 # imm = 0x10000000000000
leal -0xb(%rdx), %esi
testq %r10, %rdi
jne 0x75fa
addq %rdi, %rdi
decl %esi
jmp 0x75ee
decq %r9
addl $-0x2, %edx
cmpq %r10, %rax
movabsq $0x3fffffffffffff, %r13 # imm = 0x3FFFFFFFFFFFFF
cmovneq %r9, %r13
cmovel %edx, %ecx
movl %r8d, %ebp
addl %r8d, %ecx
shlq %cl, %r13
negl %ebp
shlq $0xa, %r12
shlq $0xb, %rdi
addl $-0x3c, %r8d
cvtsi2sd %r8d, %xmm0
mulsd 0x47d8(%rip), %xmm0     # 0xbe10
roundsd $0xa, %xmm0, %xmm0
cvttsd2si %xmm0, %eax
movslq %eax, %r15
leaq 0x47d4(%rip), %rax      # 0xbe20
movq 0xab8(%rax,%r15,8), %rbx
leaq 0x5d45(%rip), %rax      # 0xd3a0
movl 0x55c(%rax,%r15,4), %r14d
movq %rbx, %rdx
movl %r14d, %ecx
callq 0x7891
movq %rax, 0x8(%rsp)
movq %r12, %rdi
movl %ebp, %esi
movq %rbx, %rdx
movl %r14d, %ecx
callq 0x7891
movq %rax, %r12
movl %edx, 0x4(%rsp)
movq %r13, %rdi
movl %ebp, %esi
movq %rbx, %rdx
movl %r14d, %ecx
callq 0x7891
notq %rax
leaq (%r12,%rax), %r8
decq %r8
decq %r12
negl %r15d
movq 0x10(%rsp), %rax
movl %r15d, (%rax)
subq $0x8, %rsp
movq 0x10(%rsp), %rdi
movq %r12, %rdx
movl 0xc(%rsp), %ecx
pushq %rax
pushq 0x28(%rsp)
pushq 0x38(%rsp)
callq 0x7719
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movslq %esi, %rax
subq %rcx, %rdx
movq %r8, %rsi
subq %r9, %rsi
movq %r9, %r10
subq %rcx, %r10
cmpq %r9, %rcx
jae 0x7718
subq %r8, %rdx
jb 0x7718
leaq (%rcx,%r8), %r11
cmpq %r9, %r11
jb 0x770c
addq %rsi, %rcx
cmpq %rcx, %r10
jbe 0x7718
decb -0x1(%rdi,%rax)
subq %r8, %r10
movq %r11, %rcx
jmp 0x76f1
retq
// File: /workspace/github_c_makefile_star2_O2/JesseBuesking[P]omnomnum/grisu2/grisu2.c
// Function: digit_gen
void digit_gen(diy_fp_t W, diy_fp_t Mp, diy_fp_t delta,
	       char* buffer, int* len, int* K) {
  uint32_t div; int d,kappa; diy_fp_t one, wp_w;
  wp_w = minus(Mp, W);
  one.f = ((uint64_t) 1) << -Mp.e; one.e = Mp.e;
  uint32_t p1 = Mp.f >> -one.e; /// Mp_cut
  uint64_t p2 = Mp.f & (one.f - 1);
  *len = 0; kappa = 10; div = TEN9;
  while (kappa > 0) {
    d = p1 / div;
    if (d || *len) buffer[(*len)++] = '0' + d; /// Mp_inv1
    p1 %= div; kappa--;
    uint64_t tmp = (((uint64_t)p1)<<-one.e)+p2;
    if (tmp <= delta.f) { /// Mp_delta
      *K += kappa;
      grisu_round(buffer, *len, delta.f, tmp, ((uint64_t)div) << -one.e, wp_w.f);
      return;
    }
    div /= 10;
  }
  uint64_t unit = 1;
  while (1) {
    p2 *= 10; delta.f *= 10; unit *= 10;
    d = p2 >> -one.e;
    if (d || *len) buffer[(*len)++] = '0' + d;
    p2 &= one.f - 1; kappa--;
    if (p2 < delta.f) {
      *K += kappa;
      grisu_round(buffer, *len, delta.f, p2, one.f, wp_w.f*unit);
      return;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r11
movq %rdx, %rsi
movq %rdi, %rax
movq 0x48(%rsp), %rdx
movq %rdx, -0x18(%rsp)
movq 0x40(%rsp), %r14
negl %ecx
movabsq $0x1, %r10
movq %r10, %rdi
shlq %cl, %rdi
movq %rsi, %rdx
movq %rdi, -0x8(%rsp)
leaq -0x1(%rdi), %r12
movq %r12, %rbx
andq %rsi, %rbx
shrq %cl, %rsi
movq 0x38(%rsp), %rdi
andl $0x0, (%r14)
subq %rax, %rdx
movq %rdx, -0x10(%rsp)
movl $0x3b9aca00, %ebp       # imm = 0x3B9ACA00
movl $0x9, %r13d
movl $0xa, %r8d
cmpl $-0x1, %r13d
je 0x77d6
cmpl %esi, %ebp
seta %al
movl (%r14), %r15d
testl %r15d, %r15d
sete %dl
testb %dl, %al
jne 0x77b2
movslq %r15d, %r9
movl %esi, %eax
xorl %edx, %edx
divl %ebp
addb $0x30, %al
leal 0x1(%r15), %edx
movl %edx, (%r14)
movb %al, (%rdi,%r9)
movl %esi, %eax
xorl %edx, %edx
divl %ebp
movl %edx, %esi
movq %rsi, %rax
shlq %cl, %rax
addq %rbx, %rax
cmpq %r11, %rax
jbe 0x782e
movl %ebp, %eax
xorl %edx, %edx
divl %r8d
decl %r13d
movl %eax, %ebp
jmp 0x7784
xorl %eax, %eax
imulq $0xa, %rbx, %rbx
movq %rbx, %rdx
shrq %cl, %rdx
movl (%r14), %esi
movl %edx, %r8d
orl %esi, %r8d
je 0x77fc
movslq %esi, %r8
addb $0x30, %dl
incl %esi
movl %esi, (%r14)
movb %dl, (%rdi,%r8)
imulq $0xa, %r11, %r11
imulq $0xa, %r10, %r10
andq %r12, %rbx
decl %eax
cmpq %r11, %rbx
jae 0x77d8
movq -0x18(%rsp), %rcx
addl %eax, (%rcx)
movl (%r14), %esi
imulq -0x10(%rsp), %r10
movq %r11, %rdx
movq %rbx, %rcx
movq -0x8(%rsp), %r8
movq %r10, %r9
jmp 0x784a
movq -0x18(%rsp), %rdx
addl %r13d, (%rdx)
movl %ebp, %r8d
shlq %cl, %r8
movl (%r14), %esi
movq %r11, %rdx
movq %rax, %rcx
movq -0x10(%rsp), %r9
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x76df
// File: /workspace/github_c_makefile_star2_O2/JesseBuesking[P]omnomnum/grisu2/diy_fp.h
// Function: multiply
static diy_fp_t multiply(diy_fp_t x, diy_fp_t y) {
    uint64_t a,b,c,d,ac,bc,ad,bd,tmp,h;
  diy_fp_t r; uint64_t M32 = 0xFFFFFFFF;
  a = x.f >> 32; b = x.f & M32;
  c = y.f >> 32; d = y.f & M32;
  ac = a*c; bc = b*c; ad = a*d; bd = b*d;
  tmp = (bd>>32) + (ad&M32) + (bc&M32);
  tmp += 1U << 31; /// mult_round
  r.f = ac+(ad>>32)+(bc>>32)+(tmp >>32);
  r.e = x.e + y.e + 64;
  return r;
}

// Assembly:
movl %edi, %eax
shrq $0x20, %rdi
movl %edx, %r8d
shrq $0x20, %rdx
movq %rdx, %r9
imulq %rdi, %r9
imulq %rax, %rdx
imulq %r8, %rdi
imulq %rax, %r8
shrq $0x20, %r8
movl %edi, %r10d
addq %r8, %r10
movl %edx, %eax
addq %r10, %rax
subq $-0x80000000, %rax      # imm = 0x80000000
shrq $0x20, %rdi
addq %r9, %rdi
shrq $0x20, %rdx
addq %rdi, %rdx
shrq $0x20, %rax
addq %rdx, %rax
leal (%rsi,%rcx), %edx
addl $0x40, %edx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %ecx, %ecx
testl %edi, %edi
jns 0x78f0
movb $0x2d, (%rsi)
negl %edi
pushq $0x1
popq %rcx
cmpl $0x64, %edi
jb 0x7923
pushq $0x64
popq %r8
movl %edi, %eax
xorl %edx, %edx
divl %r8d
addb $0x30, %al
movl %ecx, %edi
movb %al, (%rsi,%rdi)
movzbl %dl, %eax
movb $0xa, %dl
divb %dl
movzbl %ah, %edx
orb $0x30, %al
movb %al, 0x1(%rsi,%rdi)
orb $0x30, %dl
addl $0x3, %ecx
movb %dl, 0x2(%rsi,%rdi)
jmp 0x7954
movl %ecx, %edx
cmpl $0xa, %edi
jb 0x794a
movzbl %dil, %eax
movb $0xa, %dil
divb %dil
movzbl %ah, %edi
orb $0x30, %al
movb %al, (%rsi,%rdx)
orb $0x30, %dil
orl $0x2, %ecx
movb %dil, 0x1(%rsi,%rdx)
jmp 0x7954
orb $0x30, %dil
incl %ecx
movb %dil, (%rsi,%rdx)
movl %ecx, %eax
movb $0x0, (%rsi,%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x7bd0
pushq %rax
movb $0x2d, (%rsi)
incq %rsi
negq %rdi
callq 0x7bd0
incl %eax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x737b
movb %r14b, 0x30(%r12)
movl %ebp, (%r12)
testl %r15d, %r15d
je 0x8226
leaq 0x5d3b(%rip), %rdi      # 0xdf28
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 0x297d
movq 0x8(%r14), %rsi
leaq 0x5d19(%rip), %rdi      # 0xdf36
xorl %eax, %eax
callq 0x1090
jmp 0x823e
movq %rbx, %rdi
callq 0x1070
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x297d
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x738f
movq %rbx, %rdi
callq 0x73b5
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x737b
movl $0x3e8, %ebp            # imm = 0x3E8
subl $0x1, %ebp
jb 0x82a2
movq %rbx, %rdi
callq 0x1070
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x297d
movq %r14, %rdi
callq 0x738f
jmp 0x827d
leaq 0x8(%rsp), %rdi
callq 0x73b5
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4d16(%rip), %xmm0     # 0x60d0
movups %xmm0, (%rdi)
movaps 0x4d1c(%rip), %xmm0     # 0x60e0
movups %xmm0, 0x10(%rdi)
movabsq $0x3fb999999999999a, %rax # imm = 0x3FB999999999999A
movq %rax, 0x20(%rdi)
andl $0x0, 0x28(%rdi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x30(%rdi)
andq $0x0, 0x38(%rdi)
movb $0x1, 0x40(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cvtsi2sd %esi, %xmm1
addsd 0x4b6c(%rip), %xmm1     # 0x6110
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
imulq $0x18, %rsi, %rcx
pushq $0x1
popq %rdx
movsd 0x4b5e(%rip), %xmm2     # 0x6118
cmpq %rax, %rcx
je 0x15de
movsd %xmm0, (%rdi,%rax)
cvtsi2sd %edx, %xmm3
divsd %xmm1, %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, 0x8(%rdi,%rax)
addq $0x18, %rax
incl %edx
jmp 0x15ba
retq
// File: /workspace/github_c_makefile_star2_O2/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), %r15d
movl 0x8(%rdi), %edi
imull %r15d, %edi
xorl %ecx, %ecx
testl %edi, %edi
cmovlel %ecx, %edi
xorl %r12d, %r12d
xorl %eax, %eax
cmpq %rcx, %rdi
je 0x1621
movl (%rbx,%rcx,4), %esi
cmpl %esi, %r12d
cmovlel %esi, %r12d
cmpl $0x1, %esi
sbbl $-0x1, %eax
incq %rcx
jmp 0x1607
testl %edx, %edx
je 0x16aa
movl %eax, 0x4(%rsp)
xorl %r13d, %r13d
pushq $0x30
popq %rbp
pushq $0xa
popq %rdi
callq 0x1040
cmpl %r15d, %r13d
jge 0x1697
xorl %r15d, %r15d
movl 0x8(%r14), %eax
cmpl %eax, %r15d
jge 0x168e
imull %r13d, %eax
addl %r15d, %eax
cltq
movl (%rbx,%rax,4), %ecx
testl %ecx, %ecx
je 0x166f
imull $0x22, %ecx, %eax
cltd
idivl %r12d
movl %eax, %edi
cmpl $0x8, %eax
jg 0x1681
addl $0x31, %edi
jmp 0x1684
movq 0x10(%r14), %rcx
cmpb $0x0, (%rcx,%rax)
movl %ebp, %edi
pushq $0x23
popq %rax
cmovel %eax, %edi
jmp 0x1684
addl $0x38, %edi
callq 0x1040
incl %r15d
jmp 0x1643
incl %r13d
movl 0xc(%r14), %r15d
jmp 0x1633
movq 0x7942(%rip), %rax      # 0x8fe0
movq (%rax), %rdi
callq 0x10f0
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kernfel[P]fNEAT/cppn.c
// Function: create_CPPN
int create_CPPN( CPPN *net, struct NEAT_Params *params )
{
	int i, j, err=0;
	
	// Determine number of nodes and links
	net->num_outputs = N_OUTPUTS;
	net->num_inputs = 2*DIMENSIONS + ((params->flags & CFL_USE_DIST)? 1:0) + ((params->flags & CFL_USE_BIAS)? 1:0);
	net->num_hidden = 0;
	if ( params->flags & CFL_MASK_INIT_UNLINKED ) {
		net->num_links = net->num_inputs * net->num_outputs;
	} else {
		net->num_links = 0;
		for ( i=0; i<net->num_outputs; i++ )
			if ( params->initially_linked_outputs[i] )
				net->num_links += net->num_inputs;
	}
	
	// Allocate the storage necessary
	if (( err = allocate_CPPN( net ) ))
		return err;

	// Create input and output nodes
	for ( i=0; i<net->num_inputs; i++ )
		net->nodes[i].func = CF_LINEAR;
	for ( i=0; i<net->num_outputs; i++ )
		net->nodes[i+net->num_inputs].func = params->output_funcs[i];

	// Create links from input to output nodes, where applicable
	for ( i=0; i<net->num_outputs; i++ ) {
		if ( ! (params->flags & CFL_MASK_INIT_UNLINKED) && ! params->initially_linked_outputs[i] )
			continue;
		for ( j=0; j<net->num_inputs; j++ ) {
			net->links[j].innov_id = ++params->innov_counter;
			net->links[j].from = j;
			net->links[j].to = i+net->num_inputs;
			net->links[j].weight = 0;
			net->links[j].is_disabled = ! params->initially_linked_outputs[i];
		}
	}

	return err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, 0xc(%rdi)
movl (%rsi), %ecx
movl %ecx, %eax
andl $0x1, %eax
btl $0x2, %ecx
adcl $0x0, %eax
orl $0x4, %eax
movl %eax, 0x8(%rdi)
andl $0x0, 0x10(%rdi)
testb %cl, %cl
js 0x1b8b
andl $0x0, 0x20(%r14)
movl 0x3c(%rbx), %ecx
testl %ecx, %ecx
cmovel %ecx, %eax
movl %eax, 0x20(%r14)
movq %r14, %rdi
callq 0x1c6c
testl %eax, %eax
je 0x1ba1
popq %rbx
popq %r14
popq %r15
retq
movslq 0x8(%r14), %rcx
xorl %esi, %esi
testl %ecx, %ecx
movl $0x0, %edx
cmovgl %ecx, %edx
movq %rdx, %rdi
shlq $0x4, %rdi
cmpq %rsi, %rdi
je 0x1bce
movq (%r14), %r8
movl $0x3, (%r8,%rsi)
addq $0x10, %rsi
jmp 0x1bb8
movl 0xc(%r14), %esi
xorl %edi, %edi
testl %esi, %esi
cmovlel %edi, %esi
movq %rcx, %r8
shlq $0x4, %r8
leaq (,%rsi,4), %r9
cmpq %rdi, %r9
je 0x1c02
movl 0x38(%rbx,%rdi), %r10d
movq (%r14), %r11
addq %r8, %r11
movl %r10d, (%r11,%rdi,4)
addq $0x4, %rdi
jmp 0x1be8
xorl %edi, %edi
cmpq %rsi, %rdi
je 0x1b9b
testb $-0x80, (%rbx)
jne 0x1c15
cmpl $0x0, 0x3c(%rbx,%rdi,4)
je 0x1c67
leal (%rdi,%rcx), %r8d
xorl %r9d, %r9d
xorl %r10d, %r10d
cmpq %r10, %rdx
je 0x1c67
movl 0x108(%rbx), %r11d
incl %r11d
movl %r11d, 0x108(%rbx)
movq 0x18(%r14), %r15
movl %r11d, (%r15,%r9)
movl %r10d, 0x4(%r15,%r9)
movl %r8d, 0x8(%r15,%r9)
andq $0x0, 0x10(%r15,%r9)
xorl %r11d, %r11d
cmpl $0x0, 0x3c(%rbx,%rdi,4)
sete %r11b
movl %r11d, 0x18(%r15,%r9)
incq %r10
addq $0x20, %r9
jmp 0x1c1f
incq %rdi
jmp 0x1c04
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, (%rdi)
andq $0x0, 0x18(%rdi)
addq $0x18, %rdi
movslq 0x20(%rbx), %rsi
shlq $0x5, %rsi
callq 0x4208
testl %eax, %eax
jne 0x1cb2
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 0x4208
testl %eax, %eax
je 0x1cc5
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1d31
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %ebp, %ebp
jmp 0x1cbc
// File: /workspace/github_c_makefile_star2_O2/kernfel[P]fNEAT/cppn.c
// Function: delete_CPPN
void delete_CPPN( CPPN *net ) {
	free( net->nodes );
	free( net->links );
	net->links = 0;
	net->nodes = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1030
movq 0x18(%rbx), %rdi
callq 0x1030
andq $0x0, 0x18(%rbx)
andq $0x0, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/kernfel[P]fNEAT/cppn.c
// Function: randomise_CPPN_weights
void randomise_CPPN_weights( CPPN *net, struct NEAT_Params *params ) {
	int i;
	double k=params->random_weights_range*2/RAND_MAX;
	for ( i=0; i<net->num_links; i++ ) {
		net->links[i].weight = k * rand() - params->random_weights_range;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movsd 0x100(%rsi), %xmm0
addsd %xmm0, %xmm0
divsd 0x44ad(%rip), %xmm0     # 0x6220
movsd %xmm0, (%rsp)
pushq $0x10
popq %r15
xorl %r12d, %r12d
movslq 0x20(%r14), %rax
cmpq %rax, %r12
jge 0x1db1
callq 0x11a0
cvtsi2sd %eax, %xmm0
mulsd (%rsp), %xmm0
subsd 0x100(%rbx), %xmm0
movq 0x18(%r14), %rax
movsd %xmm0, (%rax,%r15)
incq %r12
addq $0x20, %r15
jmp 0x1d7f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq