LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x12ae7
jmp 0x12b06
leaq 0x35a31(%rip), %rdi     # 0x4851f
leaq 0x328be(%rip), %rsi     # 0x453b3
movl $0x3a3f, %edx           # imm = 0x3A3F
leaq 0x33ed4(%rip), %rcx     # 0x469d5
callq 0x20a0
cmpq $0x0, 0x18(%rsp)
jne 0x12b18
movl $0x0, 0x24(%rsp)
jmp 0x12b62
movq 0x18(%rsp), %rax
addq $0x168, %rax            # imm = 0x168
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
cmpq $0x0, 0x8(%rax,%rcx,8)
je 0x12b5a
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
movq 0x8(%rax,%rcx,8), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x40(%rax)
movl $0x1, 0x24(%rsp)
jmp 0x12b62
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x12e01
jmp 0x12e20
leaq 0x33cb7(%rip), %rdi     # 0x46abf
leaq 0x325a4(%rip), %rsi     # 0x453b3
movl $0x3a8e, %edx           # imm = 0x3A8E
leaq 0x33cab(%rip), %rcx     # 0x46ac6
callq 0x20a0
cmpq $0x0, 0x10(%rsp)
jne 0x12e32
movl $0x0, 0x24(%rsp)
jmp 0x12e72
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
callq 0x12e80
movq 0x18(%rsp), %rdi
addq $0x1ee0, %rdi           # imm = 0x1EE0
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x81a0
movq 0x18(%rsp), %rax
movl $0x0, 0x3f84(%rax)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/space222[P]silo/./nuklear.h
// Function: nk_pool_init_fixed(nk_pool*, void*, unsigned long)
NK_LIB void
nk_pool_init_fixed(struct nk_pool *pool, void *memory, nk_size size)
{
    nk_zero(pool, sizeof(*pool));
    NK_ASSERT(size >= sizeof(struct nk_page));
    if (size < sizeof(struct nk_page)) return;
    pool->capacity = (unsigned)(size - sizeof(struct nk_page)) / sizeof(struct nk_page_element);
    pool->pages = (struct nk_page*)memory;
    pool->type = NK_BUFFER_FIXED;
    pool->size = size;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rdi
movl $0x48, %esi
callq 0x8150
cmpq $0x210, (%rsp)          # imm = 0x210
jb 0x1306d
jmp 0x1308c
leaq 0x3725a(%rip), %rdi     # 0x4a2ce
leaq 0x32338(%rip), %rsi     # 0x453b3
movl $0x3be5, %edx           # imm = 0x3BE5
leaq 0x37266(%rip), %rcx     # 0x4a2ed
callq 0x20a0
cmpq $0x210, (%rsp)          # imm = 0x210
jae 0x13098
jmp 0x130d9
movq (%rsp), %rax
subq $0x210, %rax            # imm = 0x210
movl %eax, %eax
shrq $0x9, %rax
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x30(%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x18(%rax)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x38(%rax)
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movl $0x48, %esi
callq 0x8150
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movl 0x4(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x30(%rax)
movq 0x10(%rsp), %rax
movl $0x1, 0x18(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x20(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x18bb3
jmp 0x18bd2
leaq 0x2f965(%rip), %rdi     # 0x4851f
leaq 0x2c7f2(%rip), %rsi     # 0x453b3
movl $0x40a0, %edx           # imm = 0x40A0
leaq 0x2e60b(%rip), %rcx     # 0x471d8
callq 0x20a0
movq 0x8(%rsp), %rax
cmpq $0x0, 0x3fe8(%rax)
je 0x18be3
jmp 0x18c02
leaq 0x2e30f(%rip), %rdi     # 0x46ef9
leaq 0x2c7c2(%rip), %rsi     # 0x453b3
movl $0x40a1, %edx           # imm = 0x40A1
leaq 0x2e5db(%rip), %rcx     # 0x471d8
callq 0x20a0
movq 0x8(%rsp), %rax
movq 0x3fe8(%rax), %rax
cmpq $0x0, 0xa8(%rax)
je 0x18c1a
jmp 0x18c39
leaq 0x2e454(%rip), %rdi     # 0x47075
leaq 0x2c78b(%rip), %rsi     # 0x453b3
movl $0x40a2, %edx           # imm = 0x40A2
leaq 0x2e5a4(%rip), %rcx     # 0x471d8
callq 0x20a0
cmpq $0x0, 0x8(%rsp)
je 0x18c50
movq 0x8(%rsp), %rax
cmpq $0x0, 0x3fe8(%rax)
jne 0x18c5a
movl $0x0, 0x14(%rsp)
jmp 0x18c7e
movq 0x8(%rsp), %rax
movq 0x3fe8(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x3fe0(%rcx), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x18ca3
jmp 0x18cc2
leaq 0x2f875(%rip), %rdi     # 0x4851f
leaq 0x2c702(%rip), %rsi     # 0x453b3
movl $0x40a9, %edx           # imm = 0x40A9
leaq 0x2e54e(%rip), %rcx     # 0x4720b
callq 0x20a0
movq 0x18(%rsp), %rax
cmpq $0x0, 0x3fe8(%rax)
je 0x18cd3
jmp 0x18cf2
leaq 0x2e21f(%rip), %rdi     # 0x46ef9
leaq 0x2c6d2(%rip), %rsi     # 0x453b3
movl $0x40aa, %edx           # imm = 0x40AA
leaq 0x2e51e(%rip), %rcx     # 0x4720b
callq 0x20a0
cmpq $0x0, 0x18(%rsp)
je 0x18d09
movq 0x18(%rsp), %rax
cmpq $0x0, 0x3fe8(%rax)
jne 0x18d13
movl $0x0, 0x24(%rsp)
jmp 0x18d5e
movq 0x18(%rsp), %rax
movq 0x3fe8(%rax), %rax
movl 0x48(%rax), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x18d36
movl $0x0, 0x24(%rsp)
jmp 0x18d5e
movq 0x18(%rsp), %rdi
movq 0x3fe8(%rdi), %rax
movups 0x4c(%rax), %xmm0
movaps %xmm0, (%rsp)
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0xd770
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x19f93
jmp 0x19fb2
leaq 0x2e585(%rip), %rdi     # 0x4851f
leaq 0x2b412(%rip), %rsi     # 0x453b3
movl $0x4250, %edx           # imm = 0x4250
leaq 0x2d7c2(%rip), %rcx     # 0x4776f
callq 0x20a0
cmpq $0x0, 0x10(%rsp)
je 0x19fc9
movq 0x10(%rsp), %rax
cmpq $0x0, 0x3fe8(%rax)
jne 0x19fce
jmp 0x1a059
movq 0x10(%rsp), %rax
movq 0x3fe8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x1d0(%rax)
je 0x19ff0
jmp 0x1a00f
leaq 0x2d7a1(%rip), %rdi     # 0x47798
leaq 0x2b3b5(%rip), %rsi     # 0x453b3
movl $0x4254, %edx           # imm = 0x4254
leaq 0x2d765(%rip), %rcx     # 0x4776f
callq 0x20a0
movq 0x8(%rsp), %rax
movq 0xa8(%rax), %rax
movl (%rax), %eax
andl $0xf4, %eax
cmpl $0x0, %eax
je 0x1a029
jmp 0x1a048
leaq 0x2d776(%rip), %rdi     # 0x477a6
leaq 0x2b37c(%rip), %rsi     # 0x453b3
movl $0x4255, %edx           # imm = 0x4255
leaq 0x2d72c(%rip), %rcx     # 0x4776f
callq 0x20a0
movq 0x8(%rsp), %rax
movl 0x48(%rax), %ecx
orl $0x2000, %ecx           # imm = 0x2000
movl %ecx, 0x48(%rax)
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/space222[P]silo/./nuklear.h
// Function: nk_layout_row_calculate_usable_space(nk_style const*, nk_panel_type, float, int)
NK_LIB float
nk_layout_row_calculate_usable_space(const struct nk_style *style, enum nk_panel_type type,
    float total_space, int columns)
{
    float panel_padding;
    float panel_spacing;
    float panel_space;

    struct nk_vec2 spacing;
    struct nk_vec2 padding;

    spacing = style->window.spacing;
    padding = nk_panel_get_padding(style, type);

    /* calculate the usable panel space */
    panel_padding = 2 * padding.x;
    panel_spacing = (float)NK_MAX(columns - 1, 0) * spacing.x;
    panel_space  = total_space - panel_padding - panel_spacing;
    return panel_space;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movss %xmm0, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x40(%rsp), %rax
movq 0x1d24(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0x1c630
movlpd %xmm0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movss 0x24f3a(%rip), %xmm0    # 0x45108
mulss 0x18(%rsp), %xmm0
movss %xmm0, 0x30(%rsp)
movl 0x34(%rsp), %eax
subl $0x1, %eax
cmpl $0x0, %eax
jge 0x201ee
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0x201f9
movl 0x34(%rsp), %eax
subl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cvtsi2ss %eax, %xmm0
mulss 0x20(%rsp), %xmm0
movss %xmm0, 0x2c(%rsp)
movss 0x38(%rsp), %xmm0
subss 0x30(%rsp), %xmm0
subss 0x2c(%rsp), %xmm0
movss %xmm0, 0x28(%rsp)
movss 0x28(%rsp), %xmm0
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x217b4
jmp 0x217d3
leaq 0x26d64(%rip), %rdi     # 0x4851f
leaq 0x23bf1(%rip), %rsi     # 0x453b3
movl $0x4839, %edx           # imm = 0x4839
leaq 0x26b1e(%rip), %rcx     # 0x482ec
callq 0x20a0
movq 0x10(%rsp), %rax
cmpq $0x0, 0x3fe8(%rax)
je 0x217e4
jmp 0x21803
leaq 0x2570e(%rip), %rdi     # 0x46ef9
leaq 0x23bc1(%rip), %rsi     # 0x453b3
movl $0x483a, %edx           # imm = 0x483A
leaq 0x26aee(%rip), %rcx     # 0x482ec
callq 0x20a0
movq 0x10(%rsp), %rax
movq 0x3fe8(%rax), %rax
cmpq $0x0, 0xa8(%rax)
je 0x2181b
jmp 0x2183a
leaq 0x25853(%rip), %rdi     # 0x47075
leaq 0x23b8a(%rip), %rsi     # 0x453b3
movl $0x483b, %edx           # imm = 0x483B
leaq 0x26ab7(%rip), %rcx     # 0x482ec
callq 0x20a0
cmpq $0x0, 0x10(%rsp)
je 0x21867
movq 0x10(%rsp), %rax
cmpq $0x0, 0x3fe8(%rax)
je 0x21867
movq 0x10(%rsp), %rax
movq 0x3fe8(%rax), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x2186c
jmp 0x21922
movq 0x10(%rsp), %rax
movq 0x3fe8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0xa8(%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movss 0x1a98(%rax), %xmm1
movq 0x10(%rsp), %rax
addss 0x1ea4(%rax), %xmm1
movq (%rsp), %rax
movss 0x28(%rax), %xmm0
subss %xmm1, %xmm0
movss %xmm0, 0x28(%rax)
movq 0x10(%rsp), %rax
movss 0x1a98(%rax), %xmm0
movq 0x10(%rsp), %rax
addss 0x1ea4(%rax), %xmm0
movq (%rsp), %rax
addss 0x10(%rax), %xmm0
movss %xmm0, 0x10(%rax)
movq (%rsp), %rax
cmpl $0x0, 0xb0(%rax)
je 0x218f0
jmp 0x2190f
leaq 0x28cbe(%rip), %rdi     # 0x4a5b5
leaq 0x23ab5(%rip), %rsi     # 0x453b3
movl $0x4843, %edx           # imm = 0x4843
leaq 0x269e2(%rip), %rcx     # 0x482ec
callq 0x20a0
movq (%rsp), %rax
movl 0xb0(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xb0(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movl %edx, 0x74(%rsp)
movq %rcx, 0x68(%rsp)
movl 0x74(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x267a9
movq 0x68(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x60(%rsp)
jmp 0x267d1
movl 0x74(%rsp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x267c5
movq 0x68(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x60(%rsp)
jmp 0x267cf
movq 0x68(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x267d1
movq 0x60(%rsp), %rax
cmpl $0x1, (%rax)
jne 0x2681b
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rax
movups (%rax), %xmm0
movaps %xmm0, 0x50(%rsp)
movq 0x60(%rsp), %rsi
addq $0x8, %rsi
movl $0xffffffff, 0x4c(%rsp) # imm = 0xFFFFFFFF
movsd 0x50(%rsp), %xmm0
movsd 0x58(%rsp), %xmm1
movl 0x4c(%rsp), %edx
callq 0xc3c0
jmp 0x2689b
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rax
movups (%rax), %xmm0
movaps %xmm0, 0x30(%rsp)
movq 0x68(%rsp), %rax
movss 0x7c(%rax), %xmm2
movq 0x60(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x2c(%rsp)
movsd 0x30(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
movl 0x2c(%rsp), %esi
callq 0xb130
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rax
movups (%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x68(%rsp), %rax
movss 0x78(%rax), %xmm3
movss 0x7c(%rax), %xmm2
movl 0x60(%rax), %eax
movl %eax, 0xc(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movl 0xc(%rsp), %esi
callq 0xaf00
movq 0x60(%rsp), %rax
addq $0x88, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq %rcx, 0x10(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x27f41
jmp 0x27f60
leaq 0x205d7(%rip), %rdi     # 0x4851f
leaq 0x1d464(%rip), %rsi     # 0x453b3
movl $0x5053, %edx           # imm = 0x5053
leaq 0x2104a(%rip), %rcx     # 0x48fa5
callq 0x20a0
cmpq $0x0, 0x20(%rsp)
je 0x27f6a
jmp 0x27f89
leaq 0x1da88(%rip), %rdi     # 0x459f9
leaq 0x1d43b(%rip), %rsi     # 0x453b3
movl $0x5054, %edx           # imm = 0x5054
leaq 0x21021(%rip), %rcx     # 0x48fa5
callq 0x20a0
cmpq $0x0, 0x10(%rsp)
je 0x27f93
jmp 0x27fb2
leaq 0x2104f(%rip), %rdi     # 0x48fe9
leaq 0x1d412(%rip), %rsi     # 0x453b3
movl $0x5055, %edx           # imm = 0x5055
leaq 0x20ff8(%rip), %rcx     # 0x48fa5
callq 0x20a0
cmpq $0x0, 0x28(%rsp)
je 0x27fca
cmpq $0x0, 0x20(%rsp)
je 0x27fca
cmpq $0x0, 0x10(%rsp)
jne 0x27fd4
movl $0x0, 0x34(%rsp)
jmp 0x28019
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
movq 0x10(%rsp), %rax
movl (%rax), %ecx
callq 0x275b0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x88, %rsp
movlpd %xmm0, 0x74(%rsp)
movlpd %xmm1, 0x7c(%rsp)
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movl %edx, 0x5c(%rsp)
movl $0x0, 0x58(%rsp)
movq 0x68(%rsp), %rax
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x33905
movq 0x68(%rsp), %rax
movl $0x6, (%rax)
jmp 0x33910
movq 0x68(%rsp), %rax
movl $0x4, (%rax)
cmpq $0x0, 0x60(%rsp)
jne 0x33928
movl $0x0, 0x84(%rsp)
jmp 0x33a54
movq 0x60(%rsp), %rdi
movups 0x74(%rsp), %xmm0
movaps %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
callq 0xd770
cmpl $0x0, %eax
je 0x339d4
movq 0x68(%rsp), %rax
movl $0x12, (%rax)
movq 0x60(%rsp), %rdi
xorl %esi, %esi
callq 0xd9a0
cmpl $0x0, %eax
je 0x33978
movq 0x68(%rsp), %rax
movl $0x22, (%rax)
movq 0x60(%rsp), %rdi
movups 0x74(%rsp), %xmm0
movaps %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
xorl %eax, %eax
xorl %esi, %esi
callq 0xd410
cmpl $0x0, %eax
je 0x339d2
cmpl $0x0, 0x5c(%rsp)
je 0x339ba
movq 0x60(%rsp), %rdi
xorl %esi, %esi
callq 0xd9a0
movl %eax, 0xc(%rsp)
jmp 0x339ca
movq 0x60(%rsp), %rdi
xorl %esi, %esi
callq 0xda50
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x58(%rsp)
jmp 0x339d4
movq 0x68(%rsp), %rax
movl (%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x33a16
movq 0x60(%rsp), %rdi
movups 0x74(%rsp), %xmm0
movaps %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
callq 0xd840
cmpl $0x0, %eax
jne 0x33a16
movq 0x68(%rsp), %rax
movl (%rax), %ecx
orl $0x8, %ecx
movl %ecx, (%rax)
jmp 0x33a49
movq 0x60(%rsp), %rdi
movups 0x74(%rsp), %xmm0
movaps %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0xd840
cmpl $0x0, %eax
je 0x33a47
movq 0x68(%rsp), %rax
movl (%rax), %ecx
orl $0x40, %ecx
movl %ecx, (%rax)
jmp 0x33a49
movl 0x58(%rsp), %eax
movl %eax, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/space222[P]silo/./nuklear.h
// Function: nk_panel_has_header(unsigned int, char const*)
NK_LIB int
nk_panel_has_header(nk_flags flags, const char *title)
{
    int active = 0;
    active = (flags & (NK_WINDOW_CLOSABLE|NK_WINDOW_MINIMIZABLE));
    active = active || (flags & NK_WINDOW_TITLE);
    active = active && !(flags & NK_WINDOW_HIDDEN) && title;
    return active;
}

// Assembly:
movl %edi, -0x4(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movl -0x4(%rsp), %eax
andl $0x18, %eax
movl %eax, -0x14(%rsp)
movb $0x1, %al
cmpl $0x0, -0x14(%rsp)
movb %al, -0x15(%rsp)
jne 0x3837a
movl -0x4(%rsp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rsp)
movb -0x15(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rsp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rsp)
movb %al, -0x16(%rsp)
je 0x383b6
movl -0x4(%rsp), %ecx
andl $0x2000, %ecx           # imm = 0x2000
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x16(%rsp)
jne 0x383b6
cmpq $0x0, -0x10(%rsp)
setne %al
movb %al, -0x16(%rsp)
movb -0x16(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/space222[P]silo/./nuklear.h
// Function: nk_draw_button_text_image(nk_command_buffer*, nk_rect const*, nk_rect const*, nk_rect const*, unsigned int, nk_style_button const*, char const*, int, nk_user_font const*, nk_image const*)
NK_LIB void
nk_draw_button_text_image(struct nk_command_buffer *out,
    const struct nk_rect *bounds, const struct nk_rect *label,
    const struct nk_rect *image, nk_flags state, const struct nk_style_button *style,
    const char *str, int len, const struct nk_user_font *font,
    const struct nk_image *img)
{
    struct nk_text text;
    const struct nk_style_item *background;
    background = nk_draw_button(out, bounds, state, style);

    /* select correct colors */
    if (background->type == NK_STYLE_ITEM_COLOR)
        text.background = background->data.color;
    else text.background = style->text_background;
    if (state & NK_WIDGET_STATE_HOVER)
        text.text = style->text_hover;
    else if (state & NK_WIDGET_STATE_ACTIVED)
        text.text = style->text_active;
    else text.text = style->text_normal;

    text.padding = nk_vec2(0,0);
    nk_widget_text(out, *label, str, len, &text, NK_TEXT_CENTERED, font);
    nk_draw_image(out, *image, img, nk_white);
}

// Assembly:
subq $0x88, %rsp
movq 0xa8(%rsp), %rax
movq 0xa0(%rsp), %rax
movl 0x98(%rsp), %eax
movq 0x90(%rsp), %rax
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movl %r8d, 0x64(%rsp)
movq %r9, 0x58(%rsp)
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rsi
movl 0x64(%rsp), %edx
movq 0x58(%rsp), %rcx
callq 0x26770
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x3c11f
movq 0x40(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x50(%rsp)
jmp 0x3c12b
movq 0x58(%rsp), %rax
movl 0x64(%rax), %eax
movl %eax, 0x50(%rsp)
movl 0x64(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x3c145
movq 0x58(%rsp), %rax
movl 0x6c(%rax), %eax
movl %eax, 0x54(%rsp)
jmp 0x3c16d
movl 0x64(%rsp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x3c15f
movq 0x58(%rsp), %rax
movl 0x70(%rax), %eax
movl %eax, 0x54(%rsp)
jmp 0x3c16b
movq 0x58(%rsp), %rax
movl 0x68(%rax), %eax
movl %eax, 0x54(%rsp)
jmp 0x3c16d
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x41b0
movlpd %xmm0, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x80(%rsp), %rdi
movq 0x70(%rsp), %rax
movups (%rax), %xmm0
movaps %xmm0, 0x20(%rsp)
movq 0x90(%rsp), %rsi
movl 0x98(%rsp), %edx
movq 0xa0(%rsp), %r9
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
leaq 0x48(%rsp), %rcx
movl $0x12, %r8d
callq 0x24820
movq 0x80(%rsp), %rdi
movq 0x68(%rsp), %rax
movups (%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0xa8(%rsp), %rsi
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movl 0xc(%rsp), %edx
callq 0xc3c0
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/space222[P]silo/./nuklear.h
// Function: nk_toggle_behavior(nk_input const*, nk_rect, unsigned int*, int)
NK_LIB int
nk_toggle_behavior(const struct nk_input *in, struct nk_rect select,
    nk_flags *state, int active)
{
    nk_widget_state_reset(state);
    if (nk_button_behavior(state, select, in, NK_BUTTON_DEFAULT)) {
        *state = NK_WIDGET_STATE_ACTIVE;
        active = !active;
    }
    if (*state & NK_WIDGET_STATE_HOVER && !nk_input_is_mouse_prev_hovering_rect(in, select))
        *state |= NK_WIDGET_STATE_ENTERED;
    else if (nk_input_is_mouse_prev_hovering_rect(in, select))
        *state |= NK_WIDGET_STATE_LEFT;
    return active;
}

// Assembly:
subq $0x58, %rsp
movlpd %xmm0, 0x48(%rsp)
movlpd %xmm1, 0x50(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x38(%rsp), %rax
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x3c25a
movq 0x38(%rsp), %rax
movl $0x6, (%rax)
jmp 0x3c265
movq 0x38(%rsp), %rax
movl $0x4, (%rax)
movq 0x38(%rsp), %rdi
movups 0x48(%rsp), %xmm0
movaps %xmm0, 0x20(%rsp)
movq 0x40(%rsp), %rsi
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
xorl %edx, %edx
callq 0x338c0
cmpl $0x0, %eax
je 0x3c2af
movq 0x38(%rsp), %rax
movl $0x22, (%rax)
cmpl $0x0, 0x34(%rsp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x34(%rsp)
movq 0x38(%rsp), %rax
movl (%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x3c2f1
movq 0x40(%rsp), %rdi
movups 0x48(%rsp), %xmm0
movaps %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0xd840
cmpl $0x0, %eax
jne 0x3c2f1
movq 0x38(%rsp), %rax
movl (%rax), %ecx
orl $0x8, %ecx
movl %ecx, (%rax)
jmp 0x3c322
movq 0x40(%rsp), %rdi
movups 0x48(%rsp), %xmm0
movaps %xmm0, (%rsp)
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0xd840
cmpl $0x0, %eax
je 0x3c320
movq 0x38(%rsp), %rax
movl (%rax), %ecx
orl $0x40, %ecx
movl %ecx, (%rax)
jmp 0x3c322
movl 0x34(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xe0d(%rip), %rsi       # 0x2004
callq 0x1080
cmpl $0x0, %eax
jne 0x1216
movq 0x2dd0(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
callq 0x12e0
movq %rax, -0x18(%rbp)
jmp 0x1223
movq -0x8(%rbp), %rdi
callq 0x1390
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1250
movq 0x2dbf(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0xdbf(%rip), %rsi       # 0x2006
movb $0x0, %al
callq 0x1090
jmp 0x126c
movq 0x2d79(%rip), %rax      # 0x3fd0
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x13f0
movq -0x10(%rbp), %rdi
callq 0x1880
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x12c1
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x11e0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x129d
cmpl $0x1, -0x8(%rbp)
jne 0x12d3
leaq 0xd36(%rip), %rdi       # 0x2004
callq 0x11e0
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1f4, -0xc(%rbp)      # imm = 0x1F4
movl -0xc(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x18(%rbp)
movq %rax, %rdx
addq $0xf, %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x38(%rbp)
movq %rcx, %rsp
movq %rax, -0x20(%rbp)
xorl %edi, %edi
movq 0x2c96(%rip), %rsi      # 0x3fb8
callq 0x14d0
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rdx
callq 0x1060
cmpq $0x0, %rax
je 0x1380
movq -0x38(%rbp), %rdi
movl $0xa, %esi
callq 0x1040
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x1361
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x10d0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x1670
jmp 0x132b
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rsp
movq %rbp, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xc7a(%rip), %rsi       # 0x2021
callq 0x10c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x13c1
movq $0x0, -0x8(%rbp)
jmp 0x13df
movq -0x18(%rbp), %rdi
callq 0x12e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1550
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x1459
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x1570
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0xbe2(%rip), %rsi       # 0x2023
movb $0x0, %al
callq 0x1090
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x141a
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xb9c(%rip), %rsi       # 0x2027
callq 0x10c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x14a4
movl $0x0, -0x4(%rbp)
jmp 0x14c3
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13f0
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1030
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x6ab9(%rip), %rax      # 0xa9d0
movq %rax, -0x20(%rbp)
movq 0x6ab6(%rip), %rax      # 0xa9d8
movq %rax, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x10, -0x24(%rbp)
jge 0x3f5c
movq -0x10(%rbp), %rdi
callq 0x3150
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl -0x20(%rbp,%rcx), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3f2d
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/clsid.c
// Function: clsid_print
int clsid_print(const uint8_t *clsid)
{
  int t;

  for (t = 0; t < 16; t++)
  {
    printf("%02X", clsid[t]);

    if (t == 3 || t == 5 || t == 7 || t == 9) { printf("-"); }
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x10, -0xc(%rbp)
jge 0x3fd6
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0x6a44(%rip), %rdi      # 0xa9e0
movb $0x0, %al
callq 0x3080
cmpl $0x3, -0xc(%rbp)
je 0x3fbb
cmpl $0x5, -0xc(%rbp)
je 0x3fbb
cmpl $0x7, -0xc(%rbp)
je 0x3fbb
cmpl $0x9, -0xc(%rbp)
jne 0x3fc9
leaq 0x6a23(%rip), %rdi      # 0xa9e5
movb $0x0, %al
callq 0x3080
jmp 0x3fcb
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3f83
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/com.c
// Function: reg_info_read
int reg_info_read(struct reg_info_t *reg_info, FILE *in, int offset)
{
  int marker;

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

  reg_info->bNextObject = read_uint32(in);
  reg_info->bObjectName = read_uint32(in);
  reg_info->bObjectDescription = read_uint32(in);
  reg_info->dwInstancing = read_uint32(in);
  reg_info->dwObjectId = read_uint32(in);
  clsid_read((char *)reg_info->uuidObject, in);
  reg_info->fIsInterface = read_uint32(in);
  reg_info->bUidObjectIFace = read_uint32(in);
  reg_info->bUidEventsIFace = read_uint32(in);
  reg_info->fHasEvents = read_uint32(in);
  reg_info->dwMiscStatus = read_uint32(in);
  reg_info->fClassType = read_uint32(in);
  reg_info->fObjectType = read_uint16(in);
  reg_info->wToolboxBitmap32 = read_uint16(in);
  reg_info->wDefaultIcon = read_uint16(in);
  reg_info->fIsDesigner = read_uint16(in);
  reg_info->bDesignerData = read_uint32(in);

  fseek(in, marker, SEEK_SET);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30e0
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
xorl %edx, %edx
callq 0x3100
movq -0x10(%rbp), %rdi
callq 0x6010
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x6010
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rdi
callq 0x6010
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x6010
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rdi
callq 0x6010
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rdi
addq $0x14, %rdi
movq -0x10(%rbp), %rsi
callq 0x3f00
movq -0x10(%rbp), %rdi
callq 0x6010
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x10(%rbp), %rdi
callq 0x6010
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rdi
callq 0x6010
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x10(%rbp), %rdi
callq 0x6010
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rdi
callq 0x6010
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x10(%rbp), %rdi
callq 0x6010
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x10(%rbp), %rdi
callq 0x6070
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x3c(%rax)
movq -0x10(%rbp), %rdi
callq 0x6070
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x3e(%rax)
movq -0x10(%rbp), %rdi
callq 0x6070
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x40(%rax)
movq -0x10(%rbp), %rdi
callq 0x6070
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x42(%rax)
movq -0x10(%rbp), %rdi
callq 0x6010
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x44(%rax)
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x3100
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/com.c
// Function: com_reg_data_read
int com_reg_data_read(struct com_reg_data_t *com_reg_data, FILE *in, int offset)
{
  int marker;

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

  com_reg_data->bRegInfo = read_uint32(in);
  com_reg_data->bSZProjectName = read_uint32(in);
  com_reg_data->bSZHelpDirectory = read_uint32(in);
  com_reg_data->bSZProjectDescription = read_uint32(in);
  clsid_read((char *)com_reg_data->uuidProjectClsId, in);
  com_reg_data->dwTlbLcid = read_uint32(in);
  com_reg_data->wUnknown = read_uint16(in);
  com_reg_data->wTlbVerMajor = read_uint16(in);
  com_reg_data->wTlbVerMinor = read_uint16(in);

  fseek(in, marker, SEEK_SET);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30e0
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
xorl %edx, %edx
callq 0x3100
movq -0x10(%rbp), %rdi
callq 0x6010
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x6010
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rdi
callq 0x6010
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x6010
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x3f00
movq -0x10(%rbp), %rdi
callq 0x6010
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rdi
callq 0x6070
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x24(%rax)
movq -0x10(%rbp), %rdi
callq 0x6070
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x26(%rax)
movq -0x10(%rbp), %rdi
callq 0x6070
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x28(%rax)
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x3100
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/com.c
// Function: com_reg_data_print
int com_reg_data_print(struct com_reg_data_t *com_reg_data)
{
  printf("  -- COM Reg Data --\n");
  printf("          bRegInfo: %d\n", com_reg_data->bRegInfo);
  printf("    bSZProjectName: %d\n", com_reg_data->bSZProjectName);
  printf("  bSZHelpDirectory: %d\n", com_reg_data->bSZHelpDirectory);
  printf("bSZProjectDescrptn: %d\n", com_reg_data->bSZProjectDescription);
  printf("  uuidProjectClsId: ");
  clsid_print(com_reg_data->uuidProjectClsId);
  printf("\n");
  printf("         dwTlbLcid: %d\n", com_reg_data->dwTlbLcid);
  printf("          wUnknown: %d\n", com_reg_data->wUnknown);
  printf("      wTlbVerMajor: %d\n", com_reg_data->wTlbVerMajor);
  printf("      wTlbVerMinor: %d\n", com_reg_data->wTlbVerMinor);
  printf("\n");

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x6774(%rip), %rdi      # 0xab97
movb $0x0, %al
callq 0x3080
movq -0x8(%rbp), %rax
movl (%rax), %esi
leaq 0x6776(%rip), %rdi      # 0xabad
movb $0x0, %al
callq 0x3080
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
leaq 0x6779(%rip), %rdi      # 0xabc5
movb $0x0, %al
callq 0x3080
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
leaq 0x677c(%rip), %rdi      # 0xabdd
movb $0x0, %al
callq 0x3080
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
leaq 0x677f(%rip), %rdi      # 0xabf5
movb $0x0, %al
callq 0x3080
leaq 0x6789(%rip), %rdi      # 0xac0d
movb $0x0, %al
callq 0x3080
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x3f70
leaq 0x5c8d(%rip), %rdi      # 0xa12c
movb $0x0, %al
callq 0x3080
movq -0x8(%rbp), %rax
movl 0x20(%rax), %esi
leaq 0x676e(%rip), %rdi      # 0xac22
movb $0x0, %al
callq 0x3080
movq -0x8(%rbp), %rax
movzwl 0x24(%rax), %esi
leaq 0x6770(%rip), %rdi      # 0xac3a
movb $0x0, %al
callq 0x3080
movq -0x8(%rbp), %rax
movzwl 0x26(%rax), %esi
leaq 0x6772(%rip), %rdi      # 0xac52
movb $0x0, %al
callq 0x3080
movq -0x8(%rbp), %rax
movzwl 0x28(%rax), %esi
leaq 0x6774(%rip), %rdi      # 0xac6a
movb $0x0, %al
callq 0x3080
leaq 0x5c28(%rip), %rdi      # 0xa12c
movb $0x0, %al
callq 0x3080
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/debug_directory.c
// Function: debug_directory_print
int debug_directory_print(
  FILE *in,
  int addr,
  int size,
  struct section_header_t *section_header)
{
  struct debug_directory_t debug_directory;
  int n;

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

  addr = (addr - virtual_address) + raw_ptr;
  long marker = ftell(in);
  fseek(in, addr, SEEK_SET);

  printf("  -- Debug Directory --\n\n");

  for (n = 0; n < size; n += 28)
  {
    printf("  -- Debug Directory Entry %d --\n", n / 28);

    debug_directory_entry_read(&debug_directory, in);
    debug_directory_entry_print(&debug_directory);

    if (debug_directory.type == 2)
    {
      debug_directory_print_codeview(&debug_directory, in);
    }
  }

  fseek(in, marker, SEEK_SET);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x40(%rbp)
movl -0xc(%rbp), %eax
subl -0x3c(%rbp), %eax
addl -0x40(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30e0
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
xorl %edx, %edx
callq 0x3100
leaq 0x6709(%rip), %rdi      # 0xac82
movb $0x0, %al
callq 0x3080
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x45e0
movl -0x38(%rbp), %eax
movl $0x1c, %ecx
cltd
idivl %ecx
movl %eax, %esi
leaq 0x66f9(%rip), %rdi      # 0xac9c
movb $0x0, %al
callq 0x3080
movq -0x8(%rbp), %rsi
leaq -0x34(%rbp), %rdi
callq 0x4600
leaq -0x34(%rbp), %rdi
callq 0x46b0
cmpl $0x2, -0x28(%rbp)
jne 0x45d3
movq -0x8(%rbp), %rsi
leaq -0x34(%rbp), %rdi
callq 0x47f0
jmp 0x45d5
movl -0x38(%rbp), %eax
addl $0x1c, %eax
movl %eax, -0x38(%rbp)
jmp 0x4587
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
xorl %edx, %edx
callq 0x3100
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/debug_directory.c
// Function: debug_directory_entry_read
static int debug_directory_entry_read(
  struct debug_directory_t *debug_directory,
  FILE *in)
{
  debug_directory->characteristics = read_uint32(in);
  debug_directory->time_date_stamp = read_uint32(in);
  debug_directory->major_version = read_uint16(in);
  debug_directory->minor_version = read_uint16(in);
  debug_directory->type = read_uint32(in);
  debug_directory->size_of_data = read_uint32(in);
  debug_directory->address_of_raw_data = read_uint32(in);
  debug_directory->pointer_to_raw_data = read_uint32(in);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6010
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x6010
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rdi
callq 0x6070
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x6070
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0xa(%rax)
movq -0x10(%rbp), %rdi
callq 0x6010
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rdi
callq 0x6010
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x6010
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rdi
callq 0x6010
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/debug_directory.c
// Function: debug_directory_entry_print
static int debug_directory_entry_print(
  struct debug_directory_t *debug_directory)
{
  char *debug_types[] =
  {
    "Unknown",
    "COFF",
    "CODEVIEW",
    "FPO",
    "MISC",
    "EXCEPTION",
    "FIXUP",
    "OMAP_TO_SRC",
    "OMAP_FROM_SRC",
    "BORLAND",
    "RESERVED10",
    "CLSID",
    "VC_FEATURE",
    "POGO",
    "ILTCG",
    "MPX",
    "REPRO",
  };

  printf("   Characteristics: %d\n", debug_directory->characteristics);
  printf("     TimeDateStamp: %s", ctime((time_t *)&debug_directory->time_date_stamp));
  printf("      MajorVersion: %d\n", debug_directory->major_version);
  printf("      MinorVersion: %d\n", debug_directory->minor_version);
  printf("              Type: %d (", debug_directory->type);

  if (debug_directory->type < sizeof(debug_types) / sizeof(char *))
  {
    printf("%s", debug_types[debug_directory->type]);
  }
    else
  {
    printf("???");
  }

  printf(")\n");
  printf("        SizeOfData: %d\n", debug_directory->size_of_data);
  printf("  AddressOfRawData: 0x%04x\n", debug_directory->address_of_raw_data);
  printf("  PointerToRawData: 0x%04x\n", debug_directory->pointer_to_raw_data);
  printf("\n");

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x90(%rbp), %rdi
leaq 0xa5d3(%rip), %rsi      # 0xeca0
movl $0x88, %edx
callq 0x30f0
movq -0x8(%rbp), %rax
movl (%rax), %esi
leaq 0x665c(%rip), %rdi      # 0xad40
movb $0x0, %al
callq 0x3080
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
callq 0x3070
movq %rax, %rsi
leaq 0x6656(%rip), %rdi      # 0xad58
movb $0x0, %al
callq 0x3080
movq -0x8(%rbp), %rax
movzwl 0x8(%rax), %esi
leaq 0x6657(%rip), %rdi      # 0xad6f
movb $0x0, %al
callq 0x3080
movq -0x8(%rbp), %rax
movzwl 0xa(%rax), %esi
leaq 0x6659(%rip), %rdi      # 0xad87
movb $0x0, %al
callq 0x3080
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
leaq 0x665c(%rip), %rdi      # 0xad9f
movb $0x0, %al
callq 0x3080
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
cmpq $0x11, %rax
jae 0x4776
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x90(%rbp,%rax,8), %rsi
leaq 0x65ff(%rip), %rdi      # 0xad6c
movb $0x0, %al
callq 0x3080
jmp 0x4784
leaq 0x663b(%rip), %rdi      # 0xadb8
movb $0x0, %al
callq 0x3080
leaq 0x850a(%rip), %rdi      # 0xcc95
movb $0x0, %al
callq 0x3080
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
leaq 0x661c(%rip), %rdi      # 0xadbc
movb $0x0, %al
callq 0x3080
movq -0x8(%rbp), %rax
movl 0x14(%rax), %esi
leaq 0x661f(%rip), %rdi      # 0xadd4
movb $0x0, %al
callq 0x3080
movq -0x8(%rbp), %rax
movl 0x18(%rax), %esi
leaq 0x6626(%rip), %rdi      # 0xadf0
movb $0x0, %al
callq 0x3080
leaq 0x5954(%rip), %rdi      # 0xa12c
movb $0x0, %al
callq 0x3080
xorl %eax, %eax
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)