LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Tree_element_push
static int Tree_element_push(lua_State *L)
/* tree_element_push(context, type, title, state, selected, hash, [image] */
    {
    int rc;
    size_t len;
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_tree_type tree_type = checktreetype(L, 2);
    const char *title = luaL_checkstring(L, 3);
    enum nk_collapse_states init_state = checkcollapsestates(L, 4);
    int selected = checkboolean(L, 5);
    const char *hash = luaL_checklstring(L, 6, &len);
    int seed = __LINE__; //* always the same... is it important? @@
    nk_image_t *image = testimage(L, 7, NULL);
    if(image)
        rc = nk_tree_element_image_push_hashed(context, tree_type, *image, title, init_state, &selected, hash, (int)len, seed);
    else
        rc = nk_tree_element_push_hashed(context, tree_type, title, init_state, &selected, hash, (int)len, seed);
    lua_pushboolean(L, rc);
    lua_pushboolean(L, selected);
    return 2;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x2097(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, 0x38(%rsp)
movq %rbx, %rdi
movl $0xd, %esi
movl $0x2, %edx
callq 0x132f0
movl %eax, %ebp
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x12cd0
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
movl $0x4, %edx
callq 0x132f0
movl %eax, %r12d
movq %rbx, %rdi
movl $0x5, %esi
callq 0x13770
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %r14
movq %rbx, %rdi
movl $0x6, %esi
movq %r14, %rdx
callq 0x12cd0
movq %rax, %r13
leaq 0x1fdf(%rip), %rcx      # 0x68244
movq %rbx, %rdi
movl $0x7, %esi
xorl %edx, %edx
callq 0x14150
movl (%r14), %ecx
testq %rax, %rax
je 0x662b4
movq 0x10(%rax), %rdx
movq %rdx, 0x10(%rsp)
movups (%rax), %xmm0
movups %xmm0, (%rsp)
movl %ecx, 0x18(%rsp)
movl $0x3af, 0x20(%rsp)      # imm = 0x3AF
leaq 0x34(%rsp), %r8
movq 0x38(%rsp), %rdi
movl %ebp, %esi
movq %r15, %rdx
movl %r12d, %ecx
movq %r13, %r9
callq 0x13850
jmp 0x662d9
movl %ecx, (%rsp)
movl $0x3af, 0x8(%rsp)       # imm = 0x3AF
leaq 0x34(%rsp), %r8
movq 0x38(%rsp), %rdi
movl %ebp, %esi
movq %r15, %rdx
movl %r12d, %ecx
movq %r13, %r9
callq 0x13a80
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
movl 0x34(%rsp), %esi
movq %rbx, %rdi
callq 0x13270
movl $0x2, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Tree_state_push
static int Tree_state_push(lua_State *L)
    {
    int rc;
    nk_context_t *context = checkcontext(L, 1, NULL);
    enum nk_tree_type tree_type = checktreetype(L, 2);
    const char *title = luaL_checkstring(L, 3);
    enum nk_collapse_states state = checkcollapsestates(L, 4);
    rc = nk_tree_state_push(context, tree_type, title, &state);
    lua_pushboolean(L, rc);
    pushcollapsestates(L, state);
    return 2;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x1f47(%rip), %rcx      # 0x68280
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
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x12cd0
movq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
movl $0x4, %edx
callq 0x132f0
leaq 0xc(%rsp), %r12
movl %eax, (%r12)
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %r12, %rcx
callq 0x13300
movq %rbx, %rdi
movl %eax, %esi
callq 0x13270
movl (%r12), %edx
movq %rbx, %rdi
movl $0x4, %esi
callq 0x125e0
movl $0x2, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1ea2(%rip), %rcx      # 0x68280
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 0x1e3c(%rip), %rcx      # 0x68244
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_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Color_from_bytes
static int Color_from_bytes(lua_State *L)
/* converts a RGBA-0-255 color to a normalized float color */
    {
    nk_color_t color;
    color.r = luaL_checkinteger(L, 1);
    color.g = luaL_checkinteger(L, 2);
    color.b = luaL_checkinteger(L, 3);
    color.a = luaL_optinteger(L, 4, 255);
    return pushcolor(L, &color);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x12f30
leaq 0x4(%rsp), %r14
movb %al, (%r14)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12f30
movb %al, 0x1(%r14)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
movb %al, 0x2(%r14)
movl $0xff, %edx
movq %rbx, %rdi
movl $0x4, %esi
callq 0x13310
movb %al, 0x3(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13820
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/widgets.c
// Function: Color_bytes
static int Color_bytes(lua_State *L)
    {
    nk_color_t colorb;
    nk_colorf_t color;
    if(echeckcolorf(L, 1, &color)) return argerror(L, 1);
    colorb = nk_rgba_cf(color);
    lua_pushinteger(L, colorb.r);
    lua_pushinteger(L, colorb.g);
    lua_pushinteger(L, colorb.b);
    lua_pushinteger(L, colorb.a);
    return 4;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsp, %rdx
movl $0x1, %esi
callq 0x13210
testl %eax, %eax
je 0x6655c
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 0x665bf
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x137c0
movl %eax, %r14d
shrl $0x8, %r14d
movl %eax, %r15d
shrl $0x10, %r15d
movl %eax, %r12d
shrl $0x18, %r12d
movl $0xff, %ebp
andl %ebp, %eax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x12b60
andl %ebp, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12b60
andl %ebp, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x12b60
movq %rbx, %rdi
movq %r12, %rsi
callq 0x12b60
movl $0x4, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x66611
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 0x6667e
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_O1/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 0x218dd(%rip), %r14     # 0x87ff0
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 0x6675b
callq 0x13780
xorps %xmm0, %xmm0
jmp 0x66782
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_O1/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 0x21850(%rip), %r15     # 0x87ff0
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 0x667ed
movq (%r15), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x13780
movq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0x667fe
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_O1/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 0x1a25(%rip), %rcx      # 0x68280
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 0x668b3
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x12460
jmp 0x66928
movl $0x4, %esi
callq 0x12f30
movq %rax, %r12
movq %rbx, %rdi
movl $0x5, %esi
callq 0x13df0
testl %eax, %eax
jle 0x668ff
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 0x66919
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_O1/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 0x1875(%rip), %rcx      # 0x68280
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_O1/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 0x1843(%rip), %rcx      # 0x68280
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_O1/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 0x172c(%rip), %rcx      # 0x68280
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %rdi
callq 0x13710
testq %rax, %rax
je 0x66b79
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x121b0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x16f0(%rip), %rcx      # 0x68280
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_O1/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 0x149a(%rip), %rcx      # 0x68280
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 0x66e42
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 0x66e59
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_O1/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 0x1407(%rip), %rcx      # 0x68280
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 0x66ed3
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 0x66ee3
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_O1/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 0x137d(%rip), %rcx      # 0x68280
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 0x66f5d
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 0x66f6d
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_O1/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 0x12f7(%rip), %rcx      # 0x68280
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_O1/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 0x12b5(%rip), %rcx      # 0x68280
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_O1/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 0x1266(%rip), %rcx      # 0x68280
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_O1/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 0x1224(%rip), %rcx      # 0x68280
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_O1/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 0x11cb(%rip), %rcx      # 0x68280
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_O1/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 0x115e(%rip), %rcx      # 0x68280
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_O1/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 0x1105(%rip), %rcx      # 0x68280
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_O1/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 0x1095(%rip), %rcx      # 0x68280
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 0x6724f
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 0x6725d
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_O1/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 0xfd2(%rip), %rcx       # 0x68280
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 0x67318
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 0x67352
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %r15, %rdx
movl %r12d, %ecx
callq 0x13330
testl %eax, %eax
je 0x67343
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x13270
jmp 0x67352
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_O1/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 0xeed(%rip), %rcx       # 0x68280
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_O1/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 0xe7c(%rip), %rcx       # 0x68280
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
// File: /workspace/github_c_makefile_star2_O1/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 0x284a
movsd 0x10(%r15), %xmm0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8210
movq (%rbx), %rdi
leaq 0x9cc9(%rip), %rsi      # 0xc4d8
callq 0x69d7
movq %rax, (%rbx)
callq 0x623e
movq %rsp, %r14
movq %rax, (%r14)
movsd 0x18(%r15), %xmm0
movq %r14, %rdi
movl %ebp, %esi
callq 0x8210
movq (%rbx), %rdi
movq (%r14), %rsi
callq 0x69fe
movq %rax, (%rbx)
movq (%r14), %rdi
callq 0x62d2
jmp 0x2889
movsd (%r15), %xmm0
cmpb $0x1, 0x8(%r15)
jne 0x2862
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8210
jmp 0x2889
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x9c2a(%rip), %xmm0     # 0xc4a0
cvttsd2si %xmm0, %rsi
andq %rcx, %rsi
orq %rax, %rsi
movq %rbx, %rdi
callq 0x8148
movl 0x2c(%r15), %eax
leaq 0xf81c(%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_O1/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)
movq $0x0, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
addq %rsi, %rdx
movq %rdx, 0x8(%rdi)
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x81bd
subl %ebx, %eax
addl %ebp, %eax
movzbl -0x1(%rbx), %ecx
movl %ecx, %edx
andl $0x7, %edx
cmpl $0x4, %edx
ja 0x81db
leaq 0x4df1(%rip), %rsi      # 0xcfa0
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
shrl $0x3, %ecx
jmp 0x81dd
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq -0x11(%rbx), %rcx
jmp 0x81dd
movzwl -0x5(%rbx), %ecx
jmp 0x81dd
movl -0x9(%rbx), %ecx
jmp 0x81dd
movzbl -0x3(%rbx), %ecx
jmp 0x81dd
xorl %ecx, %ecx
cltq
decl %ecx
movslq %ecx, %rdx
cmpq %rdx, %rax
cmovlq %rax, %rdx
movzbl (%rbx,%rdx), %eax
cmpl $0x30, %eax
jne 0x81f9
decq %rdx
jmp 0x81eb
cmpl $0x2e, %eax
jne 0x8200
decl %edx
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x75ec
// File: /workspace/github_c_makefile_star2_O1/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 0x9ff5(%rip), %r15      # 0x12220
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
xorl %esi, %esi
callq 0x10a0
movsd 0x8(%rsp), %xmm0
movq %r15, %rdi
callq 0x847c
movq (%r14), %rdi
movq %r15, %rsi
callq 0x69d7
movq %rax, (%r14)
movq %r14, %rdi
movl %ebx, %esi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x817c
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x10(%rdi), %rax
cmpq %rax, 0x8(%rdi)
jne 0x82da
leaq (%rax,%rax), %rcx
testq %rax, %rax
movl $0x1, %eax
cmovneq %rcx, %rax
movq %rax, 0x10(%rbx)
movq (%rbx), %rdi
shlq $0x4, %rax
leaq (%rax,%rax,2), %rsi
callq 0x10f0
movq %rax, (%rbx)
movq (%rbx), %rax
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_O1/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 0x9dd4(%rip), %rax      # 0x120f8
cmpq %rax, 0x10(%rdi)
jbe 0x8341
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_O1/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 0x62d2
movl $0x0, 0x10(%rbx)
leaq 0x18(%rbx), %rdi
callq 0x8319
movb $0x0, 0x30(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x840b
movzbl %dl, %ecx
xorl %eax, %eax
xorl %edx, %edx
movsbl (%rdi,%rdx), %r8d
cmpl %ecx, %r8d
je 0x8401
movb %r8b, (%rdi,%rax)
incq %rax
incq %rdx
cmpq %rdx, %rsi
jne 0x83f0
jmp 0x840d
xorl %eax, %eax
movb $0x0, (%rdi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8431
movzbl %dl, %eax
xorl %edx, %edx
movsbl (%rdi,%rdx), %r8d
cmpl %eax, %r8d
jne 0x8429
movb %cl, (%rdi,%rdx)
incq %rdx
cmpq %rdx, %rsi
jne 0x841c
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8474
pushq %rbx
xorl %eax, %eax
xorl %r8d, %r8d
movb (%rdi,%r8), %r9b
cmpb (%rdx), %r9b
jne 0x8459
movb 0x1(%rdi,%r8), %bl
movl $0x2, %r10d
movl %ecx, %r11d
cmpb 0x1(%rdx), %bl
je 0x8462
movl $0x1, %r10d
movl %r9d, %r11d
movb %r11b, (%rdi,%rax)
addq %r10, %r8
incq %rax
cmpq %rsi, %r8
jb 0x843d
popq %rbx
jmp 0x8476
xorl %eax, %eax
movb $0x0, (%rdi,%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x84a2
jp 0x84a2
movl $0x302e30, (%rbx)       # imm = 0x302E30
jmp 0x85f4
ucomisd %xmm0, %xmm1
jbe 0x84b6
movb $0x2d, (%rbx)
incq %rbx
xorpd 0x1baa(%rip), %xmm0     # 0xa060
leaq 0xc(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x8603
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 0x852d
testl %eax, %eax
jle 0x851a
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 0x85f4
leal -0x1(%r12), %ebp
cmpl $0x14, %ebp
ja 0x855f
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 0x85f4
leal 0x5(%r12), %eax
cmpl $0x5, %eax
ja 0x85b5
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 0x85a9
leaq 0x2(%rbx), %rdi
cmpl $0x4, %r15d
movl $0x3, %edx
cmovgel %r15d, %edx
addl $-0x2, %edx
movl $0x30, %esi
callq 0x10a0
addl %r14d, %r15d
movslq %r15d, %rax
movb $0x0, (%rbx,%rax)
jmp 0x85f4
cmpl $0x1, %r14d
jne 0x85ca
movb $0x65, 0x1(%rbx)
addq $0x2, %rbx
movl %ebp, %edi
movq %rbx, %rsi
jmp 0x85ef
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 0x8a79
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x888c
movslq %esi, %rsi
addq %r8, %rcx
subq %rcx, %rdx
movq %r9, %r10
negq %r10
cmpq %r9, %rcx
jb 0x8871
leaq (%r10,%rcx), %r11
cmpq %r11, %rax
jbe 0x888c
decb -0x1(%rdi,%rsi)
subq %r8, %rdx
setb %r11b
cmpq %r9, %rcx
jae 0x888c
subq %r8, %rax
addq %r8, %rcx
testb %r11b, %r11b
je 0x8863
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8a89
movb $0x2d, (%rsi)
negl %edi
movl $0x1, %eax
cmpl $0x64, %edi
jl 0x8ad4
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
imulq $0x1999999a, %rdi, %rcx # imm = 0x1999999A
shrq $0x20, %rcx
movl %ecx, %edx
orb $0x30, %dl
movb %dl, 0x1(%rsi,%r8)
addl %ecx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %edi
orb $0x30, %dil
addl $0x3, %eax
movb %dil, 0x2(%rsi,%r8)
jmp 0x8b13
movl %eax, %ecx
cmpl $0xa, %edi
jl 0x8b09
movl %edi, %edx
movl $0xcccccccd, %r8d       # imm = 0xCCCCCCCD
imulq %rdx, %r8
shrq $0x23, %r8
leal 0x30(%r8), %edx
movb %dl, (%rsi,%rcx)
addl %r8d, %r8d
leal (%r8,%r8,4), %edx
subl %edx, %edi
orb $0x30, %dil
orl $0x2, %eax
movb %dil, 0x1(%rsi,%rcx)
jmp 0x8b13
addb $0x30, %dil
incl %eax
movb %dil, (%rsi,%rcx)
movl %eax, %eax
movb $0x0, (%rsi,%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x8d5a
pushq %rax
movb $0x2d, (%rsi)
incq %rsi
negq %rdi
callq 0x8d5a
incl %eax
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x8380
movb %r14b, 0x30(%r12)
movl %ebp, (%r12)
testl %r15d, %r15d
je 0x9376
leaq 0x5d8b(%rip), %rdi      # 0xf0c8
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 0x2a7c
movq 0x8(%r14), %rsi
leaq 0x5d69(%rip), %rdi      # 0xf0d6
xorl %eax, %eax
callq 0x1090
jmp 0x938e
movq %rbx, %rdi
callq 0x1070
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2a7c
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x83af
movq %rbx, %rdi
callq 0x83d8
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8380
movl $0x3e8, %ebp            # imm = 0x3E8
movq %rbx, %rdi
callq 0x1070
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x2a7c
movq %r14, %rdi
callq 0x83af
decl %ebp
jne 0x93cd
leaq 0x8(%rsp), %rdi
callq 0x83d8
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, (%rdi)
movabsq $0x3f847ae147ae147b, %rcx # imm = 0x3F847AE147AE147B
movq %rcx, 0x8(%rdi)
movabsq $0x3fb999999999999a, %rdx # imm = 0x3FB999999999999A
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
movl $0x0, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movq $0x0, 0x38(%rdi)
movb $0x1, 0x40(%rdi)
retq