LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/space222[P]silo/silo.cpp
// Function: silo_get_text_width(nk_handle, float, char const*, int)
float silo_get_text_width(nk_handle handle, float height, const char *text, int len)
{
	int w, h;
	pango_layout_set_attributes(layout, nullptr);
	pango_layout_set_text(layout, text, len);
	pango_layout_get_pixel_size(layout, &w, &h);
	return w;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq 0x2bc42(%rip), %rdi     # 0x2f1d0
xorl %esi, %esi
callq 0x2100
movq 0x2bc34(%rip), %rdi     # 0x2f1d0
movq %r14, %rsi
movl %ebx, %edx
callq 0x2030
movq 0x2bc23(%rip), %rdi     # 0x2f1d0
leaq 0x4(%rsp), %rbx
movq %rsp, %rdx
movq %rbx, %rsi
callq 0x2180
cvtsi2ssl (%rbx), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/space222[P]silo/silo.cpp
// Function: silo_set_font(char const*)
void silo_set_font(const char* fdsc)
{
	PangoFontDescription* font_desc = pango_font_description_from_string(fdsc);
	pango_layout_set_font_description(layout, nullptr);   // pango will silently not make a copy if 
							      // the new fontdesc matches the old one
							      // whether by pointer or deep compare.
							      // this makes sure the old one is deleted
							      // in favor of a new copy
	pango_layout_set_font_description(layout, font_desc);
	pango_font_map_load_font(font_map, context, font_desc);  // most examples do this, but does not appear
							      // to actually be necessary? There's not much
							      // info out there getting detailed on Pango.

	pango_font_description_free(font_desc); 	      // no longer needed, pango makes a copy
	return;
}

// Assembly:
pushq %rbx
callq 0x2070
movq %rax, %rbx
movq 0x2bbf7(%rip), %rdi     # 0x2f1d0
xorl %esi, %esi
callq 0x20f0
movq 0x2bbe9(%rip), %rdi     # 0x2f1d0
movq %rbx, %rsi
callq 0x20f0
movq 0x2bbe2(%rip), %rdi     # 0x2f1d8
movq 0x2bbe3(%rip), %rsi     # 0x2f1e0
movq %rbx, %rdx
callq 0x21d0
movq %rbx, %rdi
popq %rbx
jmp 0x22f0
// File: /workspace/github_c_makefile_star2_O2/space222[P]silo/silo.cpp
// Function: silo_get_font_height()
int silo_get_font_height()
{
	int w, h;
	pango_layout_set_attributes(layout, nullptr);
	pango_layout_set_text(layout, "Hello", 5);
	pango_layout_get_pixel_size(layout, &w, &h);
	return h;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq 0x2bbb6(%rip), %rdi     # 0x2f1d0
xorl %esi, %esi
callq 0x2100
movq 0x2bba8(%rip), %rdi     # 0x2f1d0
leaq 0x1caca(%rip), %rsi     # 0x200f9
pushq $0x5
popq %rdx
callq 0x2030
movq 0x2bb92(%rip), %rdi     # 0x2f1d0
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdx
callq 0x2180
movl (%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/space222[P]silo/silo.cpp
// Function: silo_init()
void silo_init()
{
	font_map = pango_cairo_font_map_get_default(); // pango-owned, don't delete
	context = pango_font_map_create_context(font_map);
	layout = pango_layout_new(context);

	silo_set_font("sans 15");
	return;
}

// Assembly:
pushq %rax
callq 0x2200
movq %rax, 0x2bb73(%rip)     # 0x2f1d8
movq %rax, %rdi
callq 0x2290
movq %rax, 0x2bb6c(%rip)     # 0x2f1e0
movq %rax, %rdi
callq 0x21a0
movq %rax, 0x2bb4d(%rip)     # 0x2f1d0
leaq 0x1ca75(%rip), %rdi     # 0x200ff
popq %rax
jmp 0x35c9
// File: /workspace/github_c_makefile_star2_O2/space222[P]silo/./nuklear.h
// Function: nk_strlen
NK_API int
nk_strlen(const char *str)
{
    int siz = 0;
    NK_ASSERT(str);
    while (str && *str++ != '\0') siz++;
    return siz;
}

// Assembly:
testq %rdi, %rdi
je 0x3806
xorl %eax, %eax
cmpb $0x0, (%rdi,%rax)
je 0x3805
incq %rax
jmp 0x37fa
retq
pushq %rax
leaq 0x1d494(%rip), %rdi     # 0x20ca2
leaq 0x1ce8e(%rip), %rsi     # 0x206a3
leaq 0x1cef4(%rip), %rcx     # 0x20710
movl $0x1932, %edx           # imm = 0x1932
callq 0x20a0
// File: /workspace/github_c_makefile_star2_O2/space222[P]silo/./nuklear.h
// Function: nk_str_append_str_utf8
NK_API int
nk_str_append_str_utf8(struct nk_str *str, const char *text)
{
    int runes = 0;
    int byte_len = 0;
    int num_runes = 0;
    int glyph_len = 0;
    nk_rune unicode;
    if (!str || !text) return 0;

    glyph_len = byte_len = nk_utf_decode(text+byte_len, &unicode, 4);
    while (unicode != '\0' && glyph_len) {
        glyph_len = nk_utf_decode(text+byte_len, &unicode, 4);
        byte_len += glyph_len;
        num_runes++;
    }
    nk_str_append_text_char(str, text, byte_len);
    return runes;
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x57a8
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %r15
pushq $0x4
popq %rbp
movq %rsi, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x49bd
movl %eax, %r12d
cmpl $0x0, 0xc(%rsp)
je 0x578e
testl %eax, %eax
je 0x578e
movslq %r12d, %rdi
addq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x49bd
addl %eax, %r12d
jmp 0x576e
movq %r14, %rdi
movq %rbx, %rsi
movl %r12d, %edx
callq 0x55e6
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/space222[P]silo/./nuklear.h
// Function: nk_str_insert_str_utf8
NK_API int
nk_str_insert_str_utf8(struct nk_str *str, int pos, const char *text)
{
    int runes = 0;
    int byte_len = 0;
    int num_runes = 0;
    int glyph_len = 0;
    nk_rune unicode;
    if (!str || !text) return 0;

    glyph_len = byte_len = nk_utf_decode(text+byte_len, &unicode, 4);
    while (unicode != '\0' && glyph_len) {
        glyph_len = nk_utf_decode(text+byte_len, &unicode, 4);
        byte_len += glyph_len;
        num_runes++;
    }
    nk_str_insert_at_rune(str, pos, text, byte_len);
    return runes;
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x5dfb
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x4(%rsp), %r15
pushq $0x4
popq %r12
movq %rdx, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x49bd
movl %eax, %r13d
cmpl $0x0, 0x4(%rsp)
je 0x5ddd
testl %eax, %eax
je 0x5ddd
movslq %r13d, %rdi
addq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x49bd
addl %eax, %r13d
jmp 0x5dbc
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
movl %r13d, %ecx
callq 0x5a82
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/space222[P]silo/./nuklear.h
// Function: nk_input_button
NK_API void
nk_input_button(struct nk_context *ctx, enum nk_buttons id, int x, int y, int down)
{
    struct nk_mouse_button *btn;
    struct nk_input *in;
    NK_ASSERT(ctx);
    if (!ctx) return;
    in = &ctx->input;
    if (in->mouse.buttons[id].down == down) return;

    btn = &in->mouse.buttons[id];
    btn->clicked_pos.x = (float)x;
    btn->clicked_pos.y = (float)y;
    btn->down = down;
    btn->clicked++;
}

// Assembly:
testq %rdi, %rdi
je 0x7a05
movl %esi, %eax
shlq $0x4, %rax
cmpl %r8d, 0x104(%rdi,%rax)
je 0x7a04
addq %rdi, %rax
addq $0x104, %rax            # imm = 0x104
movd %ecx, %xmm0
movd %edx, %xmm1
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
cvtdq2ps %xmm1, %xmm0
movlps %xmm0, 0x8(%rax)
movl %r8d, (%rax)
incl 0x4(%rax)
retq
pushq %rax
leaq 0x1bcd6(%rip), %rdi     # 0x236e3
leaq 0x18c8f(%rip), %rsi     # 0x206a3
leaq 0x19d59(%rip), %rcx     # 0x21774
movl $0x36b5, %edx           # imm = 0x36B5
callq 0x20a0
// File: /workspace/github_c_makefile_star2_O2/space222[P]silo/./nuklear.h
// Function: nk_input_has_mouse_click_down_in_rect
NK_API int
nk_input_has_mouse_click_down_in_rect(const struct nk_input *i, enum nk_buttons id,
    struct nk_rect b, int down)
{
    const struct nk_mouse_button *btn;
    if (!i) return nk_false;
    btn = &i->mouse.buttons[id];
    return nk_input_has_mouse_click_in_rect(i, id, b) && (btn->down == down);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x7c13
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r14
callq 0x7b8b
testl %eax, %eax
je 0x7c13
movl %r15d, %eax
shlq $0x4, %rax
xorl %ebp, %ebp
cmpl %ebx, 0x104(%r14,%rax)
sete %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/space222[P]silo/./nuklear.h
// Function: nk_input_is_mouse_click_down_in_rect
NK_API int
nk_input_is_mouse_click_down_in_rect(const struct nk_input *i, enum nk_buttons id,
    struct nk_rect b, int down)
{
    const struct nk_mouse_button *btn;
    if (!i) return nk_false;
    btn = &i->mouse.buttons[id];
    return (nk_input_has_mouse_click_down_in_rect(i, id, b, down) &&
            btn->clicked) ? nk_true : nk_false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x7c89
movl %esi, %ebp
movq %rdi, %r14
callq 0x7bdf
testl %eax, %eax
je 0x7c89
movl %ebp, %eax
shlq $0x4, %rax
xorl %ebx, %ebx
cmpl $0x0, 0x108(%r14,%rax)
setne %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/space222[P]silo/./nuklear.h
// Function: nk_style_set_cursor
NK_API int
nk_style_set_cursor(struct nk_context *ctx, enum nk_style_cursor c)
{
    struct nk_style *style;
    NK_ASSERT(ctx);
    if (!ctx) return 0;
    style = &ctx->style;
    if (style->cursors[c]) {
        style->cursor_active = style->cursors[c];
        return 1;
    }
    return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x9662
movl %esi, %eax
movq 0x170(%rdi,%rax,8), %rax
testq %rax, %rax
je 0x965f
movq %rax, 0x1a8(%rdi)
pushq $0x1
popq %rax
retq
xorl %eax, %eax
retq
pushq %rax
leaq 0x1a079(%rip), %rdi     # 0x236e3
leaq 0x17032(%rip), %rsi     # 0x206a3
leaq 0x18654(%rip), %rcx     # 0x21ccc
movl $0x3a3f, %edx           # imm = 0x3A3F
callq 0x20a0
// File: /workspace/github_c_makefile_star2_O2/space222[P]silo/./nuklear.h
// Function: nk_init_fixed
NK_API int
nk_init_fixed(struct nk_context *ctx, void *memory, nk_size size,
    const struct nk_user_font *font)
{
    NK_ASSERT(memory);
    if (!memory) return 0;
    nk_setup(ctx, font);
    nk_buffer_init_fixed(&ctx->memory, memory, size);
    ctx->use_pool = nk_false;
    return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x97ea
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, %rsi
callq 0x9809
leaq 0x1ee0(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4eb9
andl $0x0, 0x3f84(%rbx)
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x185c5(%rip), %rdi     # 0x21db6
leaq 0x16eab(%rip), %rsi     # 0x206a3
leaq 0x185be(%rip), %rcx     # 0x21dbd
movl $0x3a8e, %edx           # imm = 0x3A8E
callq 0x20a0
// File: /workspace/github_c_makefile_star2_O2/space222[P]silo/./nuklear.h
// Function: nk_pool_init(nk_pool*, nk_allocator*, unsigned int)
NK_LIB void
nk_pool_init(struct nk_pool *pool, struct nk_allocator *alloc,
    unsigned int capacity)
{
    nk_zero(pool, sizeof(*pool));
    pool->alloc = *alloc;
    pool->capacity = capacity;
    pool->type = NK_BUFFER_DYNAMIC;
    pool->pages = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x48
popq %rsi
callq 0x4e90
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r14)
movups (%rbx), %xmm0
movups %xmm0, (%r14)
movl $0x10, 0x30(%r14)
movl $0x1, 0x18(%r14)
andq $0x0, 0x20(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/space222[P]silo/./nuklear.h
// Function: nk_window_has_focus
NK_API int
nk_window_has_focus(const struct nk_context *ctx)
{
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    NK_ASSERT(ctx->current->layout);
    if (!ctx || !ctx->current) return 0;
    return ctx->current == ctx->active;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xc3ca
movq 0x3fe8(%rdi), %rcx
testq %rcx, %rcx
je 0xc3e9
cmpq $0x0, 0xa8(%rcx)
je 0xc408
xorl %eax, %eax
cmpq 0x3fe0(%rdi), %rcx
sete %al
popq %rcx
retq
leaq 0x17312(%rip), %rdi     # 0x236e3
leaq 0x142cb(%rip), %rsi     # 0x206a3
leaq 0x1606b(%rip), %rcx     # 0x2244a
movl $0x40a0, %edx           # imm = 0x40A0
callq 0x20a0
leaq 0x15d7b(%rip), %rdi     # 0x2216b
leaq 0x142ac(%rip), %rsi     # 0x206a3
leaq 0x1604c(%rip), %rcx     # 0x2244a
movl $0x40a1, %edx           # imm = 0x40A1
callq 0x20a0
leaq 0x15ed8(%rip), %rdi     # 0x222e7
leaq 0x1428d(%rip), %rsi     # 0x206a3
leaq 0x1602d(%rip), %rcx     # 0x2244a
movl $0x40a2, %edx           # imm = 0x40A2
callq 0x20a0
// File: /workspace/github_c_makefile_star2_O2/space222[P]silo/./nuklear.h
// Function: nk_window_is_hovered
NK_API int
nk_window_is_hovered(struct nk_context *ctx)
{
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    if (!ctx || !ctx->current) return 0;
    if(ctx->current->flags & NK_WINDOW_HIDDEN)
        return 0;
    return nk_input_is_mouse_hovering_rect(&ctx->input, ctx->current->bounds);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xc453
movq 0x3fe8(%rdi), %rax
testq %rax, %rax
je 0xc472
testb $0x20, 0x49(%rax)
jne 0xc44f
movsd 0x4c(%rax), %xmm0
movsd 0x54(%rax), %xmm1
popq %rax
jmp 0x7cd8
xorl %eax, %eax
popq %rcx
retq
leaq 0x17289(%rip), %rdi     # 0x236e3
leaq 0x14242(%rip), %rsi     # 0x206a3
leaq 0x16015(%rip), %rcx     # 0x2247d
movl $0x40a9, %edx           # imm = 0x40A9
callq 0x20a0
leaq 0x15cf2(%rip), %rdi     # 0x2216b
leaq 0x14223(%rip), %rsi     # 0x206a3
leaq 0x15ff6(%rip), %rcx     # 0x2247d
movl $0x40aa, %edx           # imm = 0x40AA
callq 0x20a0
// File: /workspace/github_c_makefile_star2_O2/space222[P]silo/./nuklear.h
// Function: nk_popup_close
NK_API void
nk_popup_close(struct nk_context *ctx)
{
    struct nk_window *popup;
    NK_ASSERT(ctx);
    if (!ctx || !ctx->current) return;

    popup = ctx->current;
    NK_ASSERT(popup->parent);
    NK_ASSERT(popup->layout->type & NK_PANEL_SET_POPUP);
    popup->flags |= NK_WINDOW_HIDDEN;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xce06
movq 0x3fe8(%rdi), %rax
testq %rax, %rax
je 0xce04
cmpq $0x0, 0x1d0(%rax)
je 0xce25
movq 0xa8(%rax), %rcx
testb $-0xc, (%rcx)
je 0xce44
orb $0x20, 0x49(%rax)
popq %rax
retq
leaq 0x168d6(%rip), %rdi     # 0x236e3
leaq 0x1388f(%rip), %rsi     # 0x206a3
leaq 0x15b44(%rip), %rcx     # 0x2295f
movl $0x4250, %edx           # imm = 0x4250
callq 0x20a0
leaq 0x15b5c(%rip), %rdi     # 0x22988
leaq 0x13870(%rip), %rsi     # 0x206a3
leaq 0x15b25(%rip), %rcx     # 0x2295f
movl $0x4254, %edx           # imm = 0x4254
callq 0x20a0
leaq 0x15b4b(%rip), %rdi     # 0x22996
leaq 0x13851(%rip), %rsi     # 0x206a3
leaq 0x15b06(%rip), %rcx     # 0x2295f
movl $0x4255, %edx           # imm = 0x4255
callq 0x20a0
// File: /workspace/github_c_makefile_star2_O2/space222[P]silo/./nuklear.h
// Function: nk_widget_fitting
NK_API enum nk_widget_layout_states
nk_widget_fitting(struct nk_rect *bounds, struct nk_context *ctx,
    struct nk_vec2 item_padding)
{
    /* update the bounds to stand without padding  */
    struct nk_window *win;
    struct nk_style *style;
    struct nk_panel *layout;
    enum nk_widget_layout_states state;
    struct nk_vec2 panel_padding;

    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    NK_ASSERT(ctx->current->layout);
    if (!ctx || !ctx->current || !ctx->current->layout)
        return NK_WIDGET_INVALID;

    win = ctx->current;
    style = &ctx->style;
    layout = win->layout;
    state = nk_widget(bounds, ctx);

    panel_padding = nk_panel_get_padding(style, layout->type);
    if (layout->row.index == 1) {
        bounds->w += panel_padding.x;
        bounds->x -= panel_padding.x;
    } else bounds->x -= item_padding.x;

    if (layout->row.index == layout->row.columns)
        bounds->w += panel_padding.x;
    else bounds->w += item_padding.x;
    return state;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
je 0xd795
movq 0x3fe8(%rsi), %rax
testq %rax, %rax
je 0xd7b4
movaps %xmm0, (%rsp)
movq 0xa8(%rax), %r15
testq %r15, %r15
je 0xd7d3
movq %rdi, %rbx
leaq 0x168(%rsi), %r14
callq 0xe786
movl %eax, %ebp
movl (%r15), %esi
movq %r14, %rdi
callq 0xe40c
movl 0x74(%r15), %eax
cmpl $0x1, %eax
jne 0xd75f
movss 0x8(%rbx), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x8(%rbx)
movaps %xmm0, %xmm1
movaps (%rsp), %xmm3
jmp 0xd766
movaps (%rsp), %xmm3
movaps %xmm3, %xmm1
movss (%rbx), %xmm2
subss %xmm1, %xmm2
movss %xmm2, (%rbx)
cmpl 0x80(%r15), %eax
je 0xd77e
movaps %xmm3, %xmm0
addss 0x8(%rbx), %xmm0
movss %xmm0, 0x8(%rbx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15f47(%rip), %rdi     # 0x236e3
leaq 0x12f00(%rip), %rsi     # 0x206a3
leaq 0x161cc(%rip), %rcx     # 0x23976
movl $0x4af3, %edx           # imm = 0x4AF3
callq 0x20a0
leaq 0x149b0(%rip), %rdi     # 0x2216b
leaq 0x12ee1(%rip), %rsi     # 0x206a3
leaq 0x161ad(%rip), %rcx     # 0x23976
movl $0x4af4, %edx           # imm = 0x4AF4
callq 0x20a0
leaq 0x14b0d(%rip), %rdi     # 0x222e7
leaq 0x12ec2(%rip), %rsi     # 0x206a3
leaq 0x1618e(%rip), %rcx     # 0x23976
movl $0x4af5, %edx           # imm = 0x4AF5
callq 0x20a0
// File: /workspace/github_c_makefile_star2_O2/space222[P]silo/./nuklear.h
// Function: nk_tree_state_pop
NK_API void
nk_tree_state_pop(struct nk_context *ctx)
{
    struct nk_window *win = 0;
    struct nk_panel *layout = 0;

    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    NK_ASSERT(ctx->current->layout);
    if (!ctx || !ctx->current || !ctx->current->layout)
        return;

    win = ctx->current;
    layout = win->layout;
    layout->at_x -= ctx->style.tab.indent + ctx->style.window.padding.x;
    layout->bounds.w += ctx->style.tab.indent + ctx->style.window.padding.x;
    NK_ASSERT(layout->row.tree_depth);
    layout->row.tree_depth--;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x10a24
movq 0x3fe8(%rdi), %rax
testq %rax, %rax
je 0x10a43
movq 0xa8(%rax), %rax
testq %rax, %rax
je 0x10a62
movss 0x1a98(%rdi), %xmm0
addss 0x1ea4(%rdi), %xmm0
movss 0x28(%rax), %xmm1
subss %xmm0, %xmm1
movss %xmm1, 0x28(%rax)
addss 0x10(%rax), %xmm0
movss %xmm0, 0x10(%rax)
movl 0xb0(%rax), %ecx
testl %ecx, %ecx
je 0x10a81
decl %ecx
movl %ecx, 0xb0(%rax)
popq %rax
retq
leaq 0x12cb8(%rip), %rdi     # 0x236e3
leaq 0xfc71(%rip), %rsi      # 0x206a3
leaq 0x12aa3(%rip), %rcx     # 0x234dc
movl $0x4839, %edx           # imm = 0x4839
callq 0x20a0
leaq 0x11721(%rip), %rdi     # 0x2216b
leaq 0xfc52(%rip), %rsi      # 0x206a3
leaq 0x12a84(%rip), %rcx     # 0x234dc
movl $0x483a, %edx           # imm = 0x483A
callq 0x20a0
leaq 0x1187e(%rip), %rdi     # 0x222e7
leaq 0xfc33(%rip), %rsi      # 0x206a3
leaq 0x12a65(%rip), %rcx     # 0x234dc
movl $0x483b, %edx           # imm = 0x483B
callq 0x20a0
leaq 0x14bc4(%rip), %rdi     # 0x2564c
leaq 0xfc14(%rip), %rsi      # 0x206a3
leaq 0x12a46(%rip), %rcx     # 0x234dc
movl $0x4843, %edx           # imm = 0x4843
callq 0x20a0
// File: /workspace/github_c_makefile_star2_O2/space222[P]silo/./nuklear.h
// Function: nk_draw_button(nk_command_buffer*, nk_rect const*, unsigned int, nk_style_button const*)
NK_LIB const struct nk_style_item*
nk_draw_button(struct nk_command_buffer *out,
    const struct nk_rect *bounds, nk_flags state,
    const struct nk_style_button *style)
{
    const struct nk_style_item *background;
    if (state & NK_WIDGET_STATE_HOVER)
        background = &style->hover;
    else if (state & NK_WIDGET_STATE_ACTIVED)
        background = &style->active;
    else background = &style->normal;

    if (background->type == NK_STYLE_ITEM_IMAGE) {
        nk_draw_image(out, *bounds, &background->data.image, nk_white);
    } else {
        nk_fill_rect(out, *bounds, style->rounding, background->data.color);
        nk_stroke_rect(out, *bounds, style->rounding, style->border, style->border_color);
    }
    return background;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdi, %r14
movl %edx, %eax
addl %edx, %eax
andl $0x40, %eax
testb $0x10, %dl
pushq $0x20
popq %rcx
cmovel %eax, %ecx
leaq (%r15,%rcx), %rbx
cmpl $0x1, (%r15,%rcx)
movsd (%rsi), %xmm0
movsd 0x8(%rsi), %xmm1
jne 0x13524
leaq 0x8(%rbx), %rsi
pushq $-0x1
popq %rdx
movq %r14, %rdi
callq 0x72e2
jmp 0x1355d
movq %rsi, %r12
movss 0x7c(%r15), %xmm2
movl 0x8(%rbx), %esi
movq %r14, %rdi
callq 0x6858
movsd (%r12), %xmm0
movsd 0x8(%r12), %xmm1
movss 0x7c(%r15), %xmm2
movss 0x78(%r15), %xmm3
movl 0x60(%r15), %esi
movq %r14, %rdi
callq 0x6711
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/space222[P]silo/./nuklear.h
// Function: nk_check_text
NK_API int
nk_check_text(struct nk_context *ctx, const char *text, int len, int active)
{
    struct nk_window *win;
    struct nk_panel *layout;
    const struct nk_input *in;
    const struct nk_style *style;

    struct nk_rect bounds;
    enum nk_widget_layout_states state;

    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    NK_ASSERT(ctx->current->layout);
    if (!ctx || !ctx->current || !ctx->current->layout)
        return active;

    win = ctx->current;
    style = &ctx->style;
    layout = win->layout;

    state = nk_widget(&bounds, ctx);
    if (!state) return active;
    in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
    nk_do_toggle(&ctx->last_widget_state, &win->buffer, bounds, &active,
        text, len, NK_TOGGLE_CHECK, &style->checkbox, in, style->font);
    return active;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0x4(%rsp)
testq %rdi, %rdi
je 0x13c21
movq %rdi, %rbx
movq 0x3fe8(%rdi), %r15
testq %r15, %r15
je 0x13c40
movq 0xa8(%r15), %r13
testq %r13, %r13
je 0x13c5f
movl %ecx, %r12d
movl %edx, %ebp
movq %rsi, %r14
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xe786
testl %eax, %eax
je 0x13c0f
cmpl $0x2, %eax
jne 0x13bb9
xorl %eax, %eax
jmp 0x13bc4
xorl %eax, %eax
testb $0x10, 0x5(%r13)
cmoveq %rbx, %rax
leaq 0x1f70(%rbx), %rdi
addq $0x68, %r15
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
subq $0x8, %rsp
leaq 0xc(%rsp), %r12
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
movl %ebp, %r8d
xorl %r9d, %r9d
pushq 0x168(%rbx)
addq $0x4c8, %rbx            # imm = 0x4C8
pushq %rax
pushq %rbx
callq 0x13c7e
addq $0x20, %rsp
movl (%r12), %r12d
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xfabb(%rip), %rdi      # 0x236e3
leaq 0xca74(%rip), %rsi      # 0x206a3
leaq 0x1048f(%rip), %rcx     # 0x240c5
movl $0x5030, %edx           # imm = 0x5030
callq 0x20a0
leaq 0xe524(%rip), %rdi      # 0x2216b
leaq 0xca55(%rip), %rsi      # 0x206a3
leaq 0x10470(%rip), %rcx     # 0x240c5
movl $0x5031, %edx           # imm = 0x5031
callq 0x20a0
leaq 0xe681(%rip), %rdi      # 0x222e7
leaq 0xca36(%rip), %rsi      # 0x206a3
leaq 0x10451(%rip), %rcx     # 0x240c5
movl $0x5032, %edx           # imm = 0x5032
callq 0x20a0
// File: /workspace/github_c_makefile_star2_O2/space222[P]silo/./nuklear.h
// Function: nk_checkbox_text
NK_API int
nk_checkbox_text(struct nk_context *ctx, const char *text, int len, int *active)
{
    int old_val;
    NK_ASSERT(ctx);
    NK_ASSERT(text);
    NK_ASSERT(active);
    if (!ctx || !text || !active) return 0;
    old_val = *active;
    *active = nk_check_text(ctx, text, len, *active);
    return old_val != *active;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x14289
testq %rsi, %rsi
je 0x142a8
movq %rcx, %rbx
testq %rcx, %rcx
je 0x142c7
movl (%rbx), %ebp
movl %ebp, %ecx
callq 0x13b59
movl %eax, (%rbx)
xorl %ecx, %ecx
cmpl %eax, %ebp
setne %cl
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xf453(%rip), %rdi      # 0x236e3
leaq 0xc40c(%rip), %rsi      # 0x206a3
leaq 0xfecb(%rip), %rcx      # 0x24169
movl $0x5053, %edx           # imm = 0x5053
callq 0x20a0
leaq 0xca3c(%rip), %rdi      # 0x20ceb
leaq 0xc3ed(%rip), %rsi      # 0x206a3
leaq 0xfeac(%rip), %rcx      # 0x24169
movl $0x5054, %edx           # imm = 0x5054
callq 0x20a0
leaq 0xfedf(%rip), %rdi      # 0x241ad
leaq 0xc3ce(%rip), %rsi      # 0x206a3
leaq 0xfe8d(%rip), %rcx      # 0x24169
movl $0x5055, %edx           # imm = 0x5055
callq 0x20a0
// File: /workspace/github_c_makefile_star2_O2/space222[P]silo/./nuklear.h
// Function: nk_option_text
NK_API int
nk_option_text(struct nk_context *ctx, const char *text, int len, int is_active)
{
    struct nk_window *win;
    struct nk_panel *layout;
    const struct nk_input *in;
    const struct nk_style *style;

    struct nk_rect bounds;
    enum nk_widget_layout_states state;

    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    NK_ASSERT(ctx->current->layout);
    if (!ctx || !ctx->current || !ctx->current->layout)
        return is_active;

    win = ctx->current;
    style = &ctx->style;
    layout = win->layout;

    state = nk_widget(&bounds, ctx);
    if (!state) return (int)state;
    in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
    nk_do_toggle(&ctx->last_widget_state, &win->buffer, bounds, &is_active,
        text, len, NK_TOGGLE_OPTION, &style->option, in, style->font);
    return is_active;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, 0xc(%rsp)
testq %rdi, %rdi
je 0x14518
movq %rdi, %rbx
movq 0x3fe8(%rdi), %r15
testq %r15, %r15
je 0x14537
movq 0xa8(%r15), %r12
testq %r12, %r12
je 0x14556
movl %edx, %ebp
movq %rsi, %r14
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0xe786
testl %eax, %eax
je 0x1450b
cmpl $0x2, %eax
jne 0x144b2
xorl %eax, %eax
jmp 0x144be
xorl %eax, %eax
testb $0x10, 0x5(%r12)
cmoveq %rbx, %rax
leaq 0x1f70(%rbx), %rdi
addq $0x68, %r15
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
leaq 0x3d8(%rbx), %r10
subq $0x8, %rsp
leaq 0x14(%rsp), %r12
pushq $0x1
popq %r9
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
movl %ebp, %r8d
pushq 0x168(%rbx)
pushq %rax
pushq %r10
callq 0x13c7e
addq $0x20, %rsp
movl (%r12), %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf1c4(%rip), %rdi      # 0x236e3
leaq 0xc17d(%rip), %rsi      # 0x206a3
leaq 0xfcee(%rip), %rcx      # 0x2421b
movl $0x508f, %edx           # imm = 0x508F
callq 0x20a0
leaq 0xdc2d(%rip), %rdi      # 0x2216b
leaq 0xc15e(%rip), %rsi      # 0x206a3
leaq 0xfccf(%rip), %rcx      # 0x2421b
movl $0x5090, %edx           # imm = 0x5090
callq 0x20a0
leaq 0xdd8a(%rip), %rdi      # 0x222e7
leaq 0xc13f(%rip), %rsi      # 0x206a3
leaq 0xfcb0(%rip), %rcx      # 0x2421b
movl $0x5091, %edx           # imm = 0x5091
callq 0x20a0
// File: /workspace/github_c_makefile_star2_O2/space222[P]silo/./nuklear.h
// Function: nk_selectable_text
NK_API int
nk_selectable_text(struct nk_context *ctx, const char *str, int len,
    nk_flags align, int *value)
{
    struct nk_window *win;
    struct nk_panel *layout;
    const struct nk_input *in;
    const struct nk_style *style;

    enum nk_widget_layout_states state;
    struct nk_rect bounds;

    NK_ASSERT(ctx);
    NK_ASSERT(value);
    NK_ASSERT(ctx->current);
    NK_ASSERT(ctx->current->layout);
    if (!ctx || !ctx->current || !ctx->current->layout || !value)
        return 0;

    win = ctx->current;
    layout = win->layout;
    style = &ctx->style;

    state = nk_widget(&bounds, ctx);
    if (!state) return 0;
    in = (state == NK_WIDGET_ROM || layout->flags & NK_WINDOW_ROM) ? 0 : &ctx->input;
    return nk_do_selectable(&ctx->last_widget_state, &win->buffer, bounds,
                str, len, align, value, &style->selectable, in, style->font);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x1471c
testq %r8, %r8
je 0x1473b
movq %rdi, %rbx
movq 0x3fe8(%rdi), %r13
testq %r13, %r13
je 0x1475a
movq %r8, (%rsp)
movq 0xa8(%r13), %rbp
testq %rbp, %rbp
je 0x14779
movq %rsi, %r14
movl %edx, %r12d
movl %ecx, %r15d
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xe786
testl %eax, %eax
je 0x1470d
cmpl $0x2, %eax
jne 0x146c0
xorl %eax, %eax
jmp 0x146ca
xorl %eax, %eax
testb $0x10, 0x5(%rbp)
cmoveq %rbx, %rax
movl %r15d, %r8d
movl %r12d, %ecx
movq %r14, %rdx
movq (%rsp), %r9
leaq 0x1f70(%rbx), %rdi
addq $0x68, %r13
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
subq $0x8, %rsp
movq %r13, %rsi
pushq 0x168(%rbx)
addq $0x5b8, %rbx            # imm = 0x5B8
pushq %rax
pushq %rbx
callq 0x14798
addq $0x20, %rsp
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xefc0(%rip), %rdi      # 0x236e3
leaq 0xbf79(%rip), %rsi      # 0x206a3
leaq 0xfb6b(%rip), %rcx      # 0x2429c
movl $0x5180, %edx           # imm = 0x5180
callq 0x20a0
leaq 0xfbaa(%rip), %rdi      # 0x242ec
leaq 0xbf5a(%rip), %rsi      # 0x206a3
leaq 0xfb4c(%rip), %rcx      # 0x2429c
movl $0x5181, %edx           # imm = 0x5181
callq 0x20a0
leaq 0xda0a(%rip), %rdi      # 0x2216b
leaq 0xbf3b(%rip), %rsi      # 0x206a3
leaq 0xfb2d(%rip), %rcx      # 0x2429c
movl $0x5182, %edx           # imm = 0x5182
callq 0x20a0
leaq 0xdb67(%rip), %rdi      # 0x222e7
leaq 0xbf1c(%rip), %rsi      # 0x206a3
leaq 0xfb0e(%rip), %rcx      # 0x2429c
movl $0x5183, %edx           # imm = 0x5183
callq 0x20a0
// File: /workspace/github_c_makefile_star2_O2/space222[P]silo/./nuklear.h
// Function: nk_chart_add_slot_colored
NK_API void
nk_chart_add_slot_colored(struct nk_context *ctx, const enum nk_chart_type type,
    struct nk_color color, struct nk_color highlight,
    int count, float min_value, float max_value)
{
    NK_ASSERT(ctx);
    NK_ASSERT(ctx->current);
    NK_ASSERT(ctx->current->layout);
    NK_ASSERT(ctx->current->layout->chart.slot < NK_CHART_MAX_SLOT);
    if (!ctx || !ctx->current || !ctx->current->layout) return;
    if (ctx->current->layout->chart.slot >= NK_CHART_MAX_SLOT) return;

    /* add another slot into the graph */
    {struct nk_chart *chart = &ctx->current->layout->chart;
    struct nk_chart_slot *slot = &chart->slots[chart->slot++];
    slot->type = type;
    slot->count = count;
    slot->color = color;
    slot->highlight = highlight;
    slot->min = NK_MIN(min_value, max_value);
    slot->max = NK_MAX(min_value, max_value);
    slot->range = slot->max - slot->min;}
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x19ae6
movq 0x3fe8(%rdi), %rax
testq %rax, %rax
je 0x19b05
movq 0xa8(%rax), %rax
testq %rax, %rax
je 0x19b24
movslq 0xf8(%rax), %rdi
cmpq $0x4, %rdi
jge 0x19b43
leal 0x1(%rdi), %r9d
movl %r9d, 0xf8(%rax)
imulq $0x28, %rdi, %rdi
movl %esi, 0x10c(%rax,%rdi)
movl %r8d, 0x124(%rax,%rdi)
movl %edx, 0x110(%rax,%rdi)
movl %ecx, 0x114(%rax,%rdi)
movaps %xmm0, %xmm2
minss %xmm1, %xmm2
movss %xmm2, 0x118(%rax,%rdi)
maxss %xmm0, %xmm1
movss %xmm1, 0x11c(%rax,%rdi)
subss %xmm2, %xmm1
movss %xmm1, 0x120(%rax,%rdi)
popq %rax
retq
leaq 0x9bf6(%rip), %rdi      # 0x236e3
leaq 0x6baf(%rip), %rsi      # 0x206a3
leaq 0xae78(%rip), %rcx      # 0x24973
movl $0x5e1e, %edx           # imm = 0x5E1E
callq 0x20a0
leaq 0x865f(%rip), %rdi      # 0x2216b
leaq 0x6b90(%rip), %rsi      # 0x206a3
leaq 0xae59(%rip), %rcx      # 0x24973
movl $0x5e1f, %edx           # imm = 0x5E1F
callq 0x20a0
leaq 0x87bc(%rip), %rdi      # 0x222e7
leaq 0x6b71(%rip), %rsi      # 0x206a3
leaq 0xae3a(%rip), %rcx      # 0x24973
movl $0x5e20, %edx           # imm = 0x5E20
callq 0x20a0
leaq 0xaeac(%rip), %rdi      # 0x249f6
leaq 0x6b52(%rip), %rsi      # 0x206a3
leaq 0xae1b(%rip), %rcx      # 0x24973
movl $0x5e21, %edx           # imm = 0x5E21
callq 0x20a0
// File: /workspace/github_c_makefile_star2_O2/space222[P]silo/./nuklear.h
// Function: nk_button_behavior(unsigned int*, nk_rect, nk_input const*, nk_button_behavior)
NK_LIB int
nk_button_behavior(nk_flags *state, struct nk_rect r,
    const struct nk_input *i, enum nk_button_behavior behavior)
{
    int ret = 0;
    nk_widget_state_reset(state);
    if (!i) return 0;
    if (nk_input_is_mouse_hovering_rect(i, r)) {
        *state = NK_WIDGET_STATE_HOVERED;
        if (nk_input_is_mouse_down(i, NK_BUTTON_LEFT))
            *state = NK_WIDGET_STATE_ACTIVE;
        if (nk_input_has_mouse_click_in_rect(i, NK_BUTTON_LEFT, r)) {
            ret = (behavior != NK_BUTTON_DEFAULT) ?
                nk_input_is_mouse_down(i, NK_BUTTON_LEFT):
#ifdef NK_BUTTON_TRIGGER_ON_RELEASE
                nk_input_is_mouse_released(i, NK_BUTTON_LEFT);
#else
                nk_input_is_mouse_pressed(i, NK_BUTTON_LEFT);
#endif
        }
    }
    if (*state & NK_WIDGET_STATE_HOVER && !nk_input_is_mouse_prev_hovering_rect(i, r))
        *state |= NK_WIDGET_STATE_ENTERED;
    else if (nk_input_is_mouse_prev_hovering_rect(i, r))
        *state |= NK_WIDGET_STATE_LEFT;
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl (%rdi), %r12d
andl $0x2, %r12d
orl $0x4, %r12d
movl %r12d, (%rdi)
testq %rsi, %rsi
je 0x1aede
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movaps %xmm0, (%rsp)
movaps %xmm1, 0x10(%rsp)
callq 0x7cd8
testl %eax, %eax
je 0x1aee2
movl $0x12, (%rbx)
xorl %r12d, %r12d
cmpl $0x0, 0x104(%r14)
setne %r12b
shll $0x4, %r12d
addl $0x12, %r12d
movl %r12d, (%rbx)
xorl %ebp, %ebp
movq %r14, %rdi
xorl %esi, %esi
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
callq 0x7b8b
testl %eax, %eax
je 0x1aee4
movl 0x104(%r14), %eax
testl %r15d, %r15d
je 0x1af39
movl %eax, %ebp
jmp 0x1aee4
xorl %ebp, %ebp
jmp 0x1af2a
xorl %ebp, %ebp
movaps 0x10(%rsp), %xmm1
movaps (%rsp), %xmm0
testb $0x10, %r12b
je 0x1af11
movq %r14, %rdi
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
callq 0x7d1c
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
testl %eax, %eax
je 0x1af21
movq %r14, %rdi
callq 0x7d1c
testl %eax, %eax
je 0x1af2a
pushq $0x40
jmp 0x1af23
pushq $0x8
popq %rax
orl %eax, %r12d
movl %r12d, (%rbx)
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
testl %eax, %eax
movaps 0x10(%rsp), %xmm1
movaps (%rsp), %xmm0
jne 0x1aeed
xorl %ebp, %ebp
cmpl $0x0, 0x108(%r14)
setne %bpl
jmp 0x1aeed
// File: /workspace/github_c_makefile_star2_O2/space222[P]silo/./nuklear.h
// Function: nk_draw_scrollbar(nk_command_buffer*, unsigned int, nk_style_scrollbar const*, nk_rect const*, nk_rect const*)
NK_LIB void
nk_draw_scrollbar(struct nk_command_buffer *out, nk_flags state,
    const struct nk_style_scrollbar *style, const struct nk_rect *bounds,
    const struct nk_rect *scroll)
{
    const struct nk_style_item *background;
    const struct nk_style_item *cursor;

    /* select correct colors/images to draw */
    if (state & NK_WIDGET_STATE_ACTIVED) {
        background = &style->active;
        cursor = &style->cursor_active;
    } else if (state & NK_WIDGET_STATE_HOVER) {
        background = &style->hover;
        cursor = &style->cursor_hover;
    } else {
        background = &style->normal;
        cursor = &style->cursor_normal;
    }

    /* draw background */
    if (background->type == NK_STYLE_ITEM_COLOR) {
        nk_fill_rect(out, *bounds, style->rounding, background->data.color);
        nk_stroke_rect(out, *bounds, style->rounding, style->border, style->border_color);
    } else {
        nk_draw_image(out, *bounds, &background->data.image, nk_white);
    }

    /* draw cursor */
    if (cursor->type == NK_STYLE_ITEM_COLOR) {
        nk_fill_rect(out, *scroll, style->rounding_cursor, cursor->data.color);
        nk_stroke_rect(out, *scroll, style->rounding_cursor, style->border_cursor, style->cursor_border_color);
    } else nk_draw_image(out, *scroll, &cursor->data.image, nk_white);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %r14
movq %rdi, %rbx
movl %esi, %eax
addl %eax, %eax
andl $0x20, %eax
leaq 0x68(%rax), %rcx
testb $0x20, %sil
movl $0xa8, %r12d
cmoveq %rcx, %r12
pushq $0x40
popq %rcx
cmovel %eax, %ecx
leaq (%rdx,%rcx), %rsi
addq %rdx, %r12
cmpl $0x0, (%rdx,%rcx)
movsd (%r13), %xmm0
movsd 0x8(%r13), %xmm1
je 0x1d616
addq $0x8, %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x72e2
jmp 0x1d654
movss 0xd0(%r14), %xmm2
movl 0x8(%rsi), %esi
movq %rbx, %rdi
callq 0x6858
movsd (%r13), %xmm0
movsd 0x8(%r13), %xmm1
movss 0xd0(%r14), %xmm2
movss 0xcc(%r14), %xmm3
movl 0x60(%r14), %esi
movq %rbx, %rdi
callq 0x6711
cmpl $0x0, (%r12)
movsd (%r15), %xmm0
movsd 0x8(%r15), %xmm1
je 0x1d681
addq $0x8, %r12
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %r12, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x72e2
movss 0xd8(%r14), %xmm2
movl 0x8(%r12), %esi
movq %rbx, %rdi
callq 0x6858
movsd (%r15), %xmm0
movsd 0x8(%r15), %xmm1
movss 0xd8(%r14), %xmm2
movss 0xd4(%r14), %xmm3
movl 0xc8(%r14), %esi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x6711
// File: /workspace/github_c_makefile_star2_O2/chatziko-k08[P]lecture-code/programs/cat/cat.c
// Function: process_file
void process_file(char* filename) {
	// Διαβάζουμε το αρχείο ή την είσοδο. Το io.h module κάνει όλη τη δουλειά.
	Vector vec = strcmp(filename, "-") == 0
		? io_read_stream_as_vector(stdin)
		: io_read_file_as_vector(filename);

	if (vec == NULL) {
		fprintf(stderr, "cat: %s: cannot read file\n", filename);
		return;
	}

	io_write_vector_to_stream(stdout, vec);
	vector_destroy(vec);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x2d, (%rdi)
jne 0x11de
cmpb $0x0, 0x1(%rbx)
je 0x120f
movq %rbx, %rdi
callq 0x12fc
movq %rax, %r14
testq %rax, %rax
je 0x1220
movq 0x2ddb(%rip), %rax      # 0x3fd0
movq (%rax), %rdi
movq %r14, %rsi
callq 0x1336
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x15b6
movq 0x2dc2(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
callq 0x1288
jmp 0x11e6
movq 0x2dd1(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xdd5(%rip), %rsi       # 0x2006
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1080
// File: /workspace/github_c_makefile_star2_O2/chatziko-k08[P]lecture-code/programs/cat/cat.c
// Function: main
int main(int argc, char* argv[]) {
	for (int i = 1; i < argc; i++)
		process_file(argv[i]);

	// χωρίς κανένα αρχείο διαβάζουμε από την είσοδο
	if (argc == 1)
		process_file("-");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %ebx
movslq %edi, %r15
pushq $0x1
popq %r12
cmpq %r15, %r12
jge 0x1269
movq (%r14,%r12,8), %rdi
callq 0x11cc
incq %r12
jmp 0x1256
cmpl $0x1, %ebx
jne 0x127a
leaq 0xd8f(%rip), %rdi       # 0x2004
callq 0x11cc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/chatziko-k08[P]lecture-code/programs/cat/io.c
// Function: io_read_stream_as_vector
Vector io_read_stream_as_vector(FILE* stream) {
	// TODO: θεωρούμε ότι κάθε γραμμή έχει max 500 χαρακτήρες. Πώς μπορούμε να αφαιρέσουμε αυτόν τον περιορισμό;
	int max_len = 500;
	char line[max_len];

	Vector vec = vector_create(0, free);		// αυτόματο free για κάθε στοιχείο που αφαιρείται

	while (fgets(line, max_len, stream)) {
		// αφαίρεση του newline, αν υπάρχει
		char* newline = strchr(line, '\n');
		if (newline != NULL)
			*newline = '\0';

		// προσθήκη στο vector
		vector_insert_last(vec, strdup(line));
	}

	return vec;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdi, %rbx
movq 0x2d19(%rip), %rsi      # 0x3fb8
xorl %edi, %edi
callq 0x13e0
movq %rax, %r14
movq %rsp, %r15
pushq $0xa
popq %rbp
movq %r15, %rdi
movl $0x1f4, %esi            # imm = 0x1F4
movq %rbx, %rdx
callq 0x1060
testq %rax, %rax
je 0x12eb
movq %r15, %rdi
movl %ebp, %esi
callq 0x1040
testq %rax, %rax
je 0x12d6
movb $0x0, (%rax)
movq %r15, %rdi
callq 0x10c0
movq %r14, %rdi
movq %rax, %rsi
callq 0x14a7
jmp 0x12af
movq %r14, %rax
addq $0x1f8, %rsp            # imm = 0x1F8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/chatziko-k08[P]lecture-code/programs/cat/io.c
// Function: io_read_file_as_vector
Vector io_read_file_as_vector(char* filename) {
	// απλά ανοίγουμε το αρχείο και καλούμε την io_read_stream_as_vector
	FILE* file = fopen(filename, "r");
	if (file == NULL)
		return NULL;

	Vector vec = io_read_stream_as_vector(file);
	fclose(file);

	return vec;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xd1a(%rip), %rsi       # 0x2021
callq 0x10b0
testq %rax, %rax
je 0x132c
movq %rax, %rbx
movq %rax, %rdi
callq 0x1288
movq %rax, %r14
movq %rbx, %rdi
callq 0x1030
movq %r14, %rax
jmp 0x132e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/chatziko-k08[P]lecture-code/programs/cat/io.c
// Function: io_write_vector_to_stream
int io_write_vector_to_stream(FILE* stream, Vector vec) {
	int written = 0;
	int size = vector_size(vec);

	// διασχίζουμε το vector και τυπώνουμε κάθε γραμμή
	for (int i = 0; i < size; i++) {
		char* line = vector_get_at(vec, i);
		written += fprintf(stream, "%s\n", line);
	}

	return written;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x141a
movl %eax, %ebp
xorl %eax, %eax
testl %ebp, %ebp
cmovlel %eax, %ebp
leaq 0xcc4(%rip), %r15       # 0x2023
xorl %r13d, %r13d
xorl %r12d, %r12d
cmpl %r13d, %ebp
je 0x138d
movq %rbx, %rdi
movl %r13d, %esi
callq 0x141e
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1080
addl %eax, %r12d
incl %r13d
jmp 0x1365
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/chatziko-k08[P]lecture-code/programs/cat/io.c
// Function: io_write_vector_to_file
int io_write_vector_to_file(char* filename, Vector vec) {
	// απλά ανοίγουμε το αρχείο και καλούμε την io_write_vector_to_stream
	FILE* file = fopen(filename, "w");
	if (file == NULL)
		return 0;

	int written = io_write_vector_to_stream(file, vec);
	fclose(file);

	return written;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0xc7a(%rip), %rsi       # 0x2027
callq 0x10b0
testq %rax, %rax
je 0x13d3
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1336
movl %eax, %ebx
movq %r14, %rdi
callq 0x1030
movl %ebx, %eax
jmp 0x13d5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/mikeakohn[P]print_pe/build/../src/cil.c
// Function: read_clr_header
int read_clr_header(FILE *in, struct _clr_header *clr_header, int address, int size, struct section_header_t *section_header)
{
  long marker;
  uint32_t virtual_address, raw_ptr;

  virtual_address = section_header->VirtualAddress;
  raw_ptr = section_header->PointerToRawData;

  address = (address - virtual_address) + raw_ptr;

  marker = ftell(in);
  fseek(in, address, SEEK_SET);

  clr_header->header_size = read_uint32(in);
  clr_header->major_runtime_version = read_uint16(in);
  clr_header->minor_runtime_version = read_uint16(in);
  clr_header->meta_data_directory_address = read_uint32(in);
  clr_header->meta_data_directory_size = read_uint32(in);
  clr_header->flags = read_uint32(in);
  clr_header->entry_point_token = read_uint32(in);
  clr_header->resources_directory_address = read_uint32(in);
  clr_header->resources_directory_size = read_uint32(in);
  clr_header->strong_name_signature_address = read_uint32(in);
  clr_header->strong_name_signature_size = read_uint32(in);
  clr_header->v_table_fixups_address = read_uint32(in);
  clr_header->v_table_fixups_size = read_uint32(in);
  clr_header->export_address_table_jump_address = read_uint32(in);
  clr_header->export_address_table_jump_size = read_uint32(in);
  clr_header->managed_native_header_address = read_uint32(in);
  clr_header->managed_native_header_size = read_uint32(in);

  fseek(in, marker, SEEK_SET);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
subl 0x10(%r8), %ebp
addl 0x18(%r8), %ebp
callq 0x30f0
movq %rax, %r15
movslq %ebp, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3110
movq %rbx, %rdi
callq 0x5126
movl %eax, (%r14)
movq %rbx, %rdi
callq 0x5168
movw %ax, 0x4(%r14)
movq %rbx, %rdi
callq 0x5168
movw %ax, 0x6(%r14)
movq %rbx, %rdi
callq 0x5126
movl %eax, 0x8(%r14)
movq %rbx, %rdi
callq 0x5126
movl %eax, 0xc(%r14)
movq %rbx, %rdi
callq 0x5126
movl %eax, 0x10(%r14)
movq %rbx, %rdi
callq 0x5126
movl %eax, 0x14(%r14)
movq %rbx, %rdi
callq 0x5126
movl %eax, 0x18(%r14)
movq %rbx, %rdi
callq 0x5126
movl %eax, 0x1c(%r14)
movq %rbx, %rdi
callq 0x5126
movl %eax, 0x20(%r14)
movq %rbx, %rdi
callq 0x5126
movl %eax, 0x24(%r14)
movq %rbx, %rdi
callq 0x5126
movl %eax, 0x28(%r14)
movq %rbx, %rdi
callq 0x5126
movl %eax, 0x2c(%r14)
movq %rbx, %rdi
callq 0x5126
movl %eax, 0x30(%r14)
movq %rbx, %rdi
callq 0x5126
movl %eax, 0x34(%r14)
movq %rbx, %rdi
callq 0x5126
movl %eax, 0x38(%r14)
movq %rbx, %rdi
callq 0x5126
movl %eax, 0x3c(%r14)
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3110
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mikeakohn[P]print_pe/build/../src/cil.c
// Function: print_clr_header
void print_clr_header(struct _clr_header *clr_header)
{
  printf("                Header Size: %d\n", clr_header->header_size);
  printf("      Major Runtime Version: %d\n", clr_header->major_runtime_version);
  printf("      Minor Runtime Version: %d\n", clr_header->minor_runtime_version);
  printf("          MetaData Dir Addr: %d\n", clr_header->meta_data_directory_address);
  printf("          MetaData Dir Size: %d\n", clr_header->meta_data_directory_size);
  printf("                      Flags: %d\n", clr_header->flags);
  printf("          Entry Point Token: %d\n", clr_header->entry_point_token);
  printf("         Resources Dir Addr: %d\n", clr_header->resources_directory_address);
  printf("         Resources Dir Size: %d\n", clr_header->resources_directory_size);
  printf("       Strong Name Sig Addr: %d\n", clr_header->strong_name_signature_address);
  printf("       Strong Name Sig Size: %d\n", clr_header->strong_name_signature_size);
  printf("         VTable Fixups Addr: %d\n", clr_header->v_table_fixups_address);
  printf("         VTable Fixups Size: %d\n", clr_header->v_table_fixups_size);
  printf("Export Addr Table Jump Addr: %d\n", clr_header->export_address_table_jump_address);
  printf("Export Addr Table Jump Size: %d\n", clr_header->export_address_table_jump_size);
  printf("    Mngd Native Header Addr: %d\n", clr_header->managed_native_header_address);
  printf("    Mngd Native Header Size: %d\n", clr_header->managed_native_header_size);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %esi
leaq 0x4d82(%rip), %rdi      # 0x8795
xorl %eax, %eax
callq 0x3090
movzwl 0x4(%rbx), %esi
leaq 0x4d91(%rip), %rdi      # 0x87b6
xorl %eax, %eax
callq 0x3090
movzwl 0x6(%rbx), %esi
leaq 0x4da0(%rip), %rdi      # 0x87d7
xorl %eax, %eax
callq 0x3090
movl 0x8(%rbx), %esi
leaq 0x4db0(%rip), %rdi      # 0x87f8
xorl %eax, %eax
callq 0x3090
movl 0xc(%rbx), %esi
leaq 0x4dc0(%rip), %rdi      # 0x8819
xorl %eax, %eax
callq 0x3090
movl 0x10(%rbx), %esi
leaq 0x4dd0(%rip), %rdi      # 0x883a
xorl %eax, %eax
callq 0x3090
movl 0x14(%rbx), %esi
leaq 0x4de0(%rip), %rdi      # 0x885b
xorl %eax, %eax
callq 0x3090
movl 0x18(%rbx), %esi
leaq 0x4df0(%rip), %rdi      # 0x887c
xorl %eax, %eax
callq 0x3090
movl 0x1c(%rbx), %esi
leaq 0x4e00(%rip), %rdi      # 0x889d
xorl %eax, %eax
callq 0x3090
movl 0x20(%rbx), %esi
leaq 0x4e10(%rip), %rdi      # 0x88be
xorl %eax, %eax
callq 0x3090
movl 0x24(%rbx), %esi
leaq 0x4e20(%rip), %rdi      # 0x88df
xorl %eax, %eax
callq 0x3090
movl 0x28(%rbx), %esi
leaq 0x4e30(%rip), %rdi      # 0x8900
xorl %eax, %eax
callq 0x3090
movl 0x2c(%rbx), %esi
leaq 0x4e40(%rip), %rdi      # 0x8921
xorl %eax, %eax
callq 0x3090
movl 0x30(%rbx), %esi
leaq 0x4e50(%rip), %rdi      # 0x8942
xorl %eax, %eax
callq 0x3090
movl 0x34(%rbx), %esi
leaq 0x4e60(%rip), %rdi      # 0x8963
xorl %eax, %eax
callq 0x3090
movl 0x38(%rbx), %esi
leaq 0x4e70(%rip), %rdi      # 0x8984
xorl %eax, %eax
callq 0x3090
movl 0x3c(%rbx), %esi
leaq 0x4e80(%rip), %rdi      # 0x89a5
xorl %eax, %eax
popq %rbx
jmp 0x3090
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/mikeakohn[P]print_pe/build/../src/clsid.c
// Function: clsid_read
int clsid_read(char *clsid, FILE *in)
{
  int8_t transpose[16] =
  {
     3,  2,  1,  0,
     5,  4,  7,  6,
     8,  9, 10, 11,
    12, 13, 14, 15
  };

  int t;

  for (t = 0; t < 16; t++)
  {
    clsid[(int)transpose[t]] = getc(in);
  }

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
leaq 0x4e88(%rip), %r12      # 0x89d0
cmpq $0x10, %r15
je 0x3b64
movq %rbx, %rdi
callq 0x3160
movsbq (%r15,%r12), %rcx
movb %al, (%r14,%rcx)
incq %r15
jmp 0x3b48
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq