LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_draw_list_init
NK_API void
nk_draw_list_init(struct nk_draw_list *list)
{
    nk_size i = 0;
    NK_ASSERT(list);
    if (!list) return;
    nk_zero(list, sizeof(*list));
    for (i = 0; i < NK_LEN(list->circle_vtx); ++i) {
        const float a = ((float)i / (float)NK_LEN(list->circle_vtx)) * 2 * NK_PI;
        list->circle_vtx[i].x = (float)NK_COS(a);
        list->circle_vtx[i].y = (float)NK_SIN(a);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x34ced
movq 0x9032f(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x7c6d5(%rip), %rsi     # 0xb13a0
leaq 0x7c6ec(%rip), %rdx     # 0xb13be
movl $0x2524, %ecx           # imm = 0x2524
movb $0x0, %al
callq 0x13ec0
movq 0x9030b(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x34cef
cmpq $0x0, 0x20(%rsp)
jne 0x34cfc
jmp 0x34dd7
movq 0x20(%rsp), %rdi
movl $0xf0, %esi
callq 0x2f0e0
movq $0x0, 0x18(%rsp)
cmpq $0xc, 0x18(%rsp)
jae 0x34dd7
movq 0x18(%rsp), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, 0xc(%rsp)
testq %rax, %rax
movss %xmm0, 0x10(%rsp)
js 0x34d5e
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x10(%rsp)
movss 0x10(%rsp), %xmm0
movss 0x787a4(%rip), %xmm1    # 0xad510
divss %xmm1, %xmm0
movss 0x7876c(%rip), %xmm1    # 0xad4e4
mulss %xmm1, %xmm0
movss 0x78788(%rip), %xmm1    # 0xad50c
mulss %xmm1, %xmm0
movss %xmm0, 0x14(%rsp)
movss 0x14(%rsp), %xmm0
callq 0x13820
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movss %xmm0, 0x10(%rax,%rcx,8)
movss 0x14(%rsp), %xmm0
callq 0x132f0
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movss %xmm0, 0x14(%rax,%rcx,8)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x34d14
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk__draw_list_begin
NK_API const struct nk_draw_command*
nk__draw_list_begin(const struct nk_draw_list *canvas, const struct nk_buffer *buffer)
{
    nk_byte *memory;
    nk_size offset;
    const struct nk_draw_command *cmd;

    NK_ASSERT(buffer);
    if (!buffer || !buffer->size || !canvas->cmd_count)
        return 0;

    memory = (nk_byte*)buffer->memory.ptr;
    offset = buffer->memory.size - canvas->cmd_offset;
    cmd = nk_ptr_add(const struct nk_draw_command, memory, offset);
    return cmd;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x35099
movq 0x8ff83(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x7c329(%rip), %rsi     # 0xb13a0
leaq 0x7c340(%rip), %rdx     # 0xb13be
movl $0x2550, %ecx           # imm = 0x2550
movb $0x0, %al
callq 0x13ec0
movq 0x8ff5f(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x3509b
cmpq $0x0, 0x20(%rsp)
je 0x350bd
movq 0x20(%rsp), %rax
cmpq $0x0, 0x70(%rax)
je 0x350bd
movq 0x28(%rsp), %rax
cmpl $0x0, 0xd0(%rax)
jne 0x350c8
movq $0x0, 0x30(%rsp)
jmp 0x35109
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x28(%rsp), %rcx
subq 0xd8(%rcx), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
addq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk__draw_list_end
NK_API const struct nk_draw_command*
nk__draw_list_end(const struct nk_draw_list *canvas, const struct nk_buffer *buffer)
{
    nk_size size;
    nk_size offset;
    nk_byte *memory;
    const struct nk_draw_command *end;

    NK_ASSERT(buffer);
    NK_ASSERT(canvas);
    if (!buffer || !canvas)
        return 0;

    memory = (nk_byte*)buffer->memory.ptr;
    size = buffer->memory.size;
    offset = size - canvas->cmd_offset;
    end = nk_ptr_add(const struct nk_draw_command, memory, offset);
    end -= (canvas->cmd_count-1);
    return end;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x35169
movq 0x8feb3(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x7c259(%rip), %rsi     # 0xb13a0
leaq 0x7c270(%rip), %rdx     # 0xb13be
movl $0x2561, %ecx           # imm = 0x2561
movb $0x0, %al
callq 0x13ec0
movq 0x8fe8f(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x3516b
jmp 0x3516d
cmpq $0x0, 0x28(%rsp)
jne 0x351a8
movq 0x8fe74(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x7c21a(%rip), %rsi     # 0xb13a0
leaq 0x7c231(%rip), %rdx     # 0xb13be
movl $0x2562, %ecx           # imm = 0x2562
movb $0x0, %al
callq 0x13ec0
movq 0x8fe50(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x351aa
cmpq $0x0, 0x20(%rsp)
je 0x351ba
cmpq $0x0, 0x28(%rsp)
jne 0x351c5
movq $0x0, 0x30(%rsp)
jmp 0x35234
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
subq 0xd8(%rcx), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rax
movl 0xd0(%rax), %ecx
subl $0x1, %ecx
movq (%rsp), %rax
movl %ecx, %ecx
movl %ecx, %edx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk__draw_list_next
NK_API const struct nk_draw_command*
nk__draw_list_next(const struct nk_draw_command *cmd,
    const struct nk_buffer *buffer, const struct nk_draw_list *canvas)
{
    const struct nk_draw_command *end;
    NK_ASSERT(buffer);
    NK_ASSERT(canvas);
    if (!cmd || !buffer || !canvas)
        return 0;

    end = nk__draw_list_end(canvas, buffer);
    if (cmd <= end) return 0;
    return (cmd-1);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x3528e
movq 0x8fd8e(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x7c134(%rip), %rsi     # 0xb13a0
leaq 0x7c14b(%rip), %rdx     # 0xb13be
movl $0x2572, %ecx           # imm = 0x2572
movb $0x0, %al
callq 0x13ec0
movq 0x8fd6a(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x35290
jmp 0x35292
cmpq $0x0, 0x8(%rsp)
jne 0x352cd
movq 0x8fd4f(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x7c0f5(%rip), %rsi     # 0xb13a0
leaq 0x7c10c(%rip), %rdx     # 0xb13be
movl $0x2573, %ecx           # imm = 0x2573
movb $0x0, %al
callq 0x13ec0
movq 0x8fd2b(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x352cf
cmpq $0x0, 0x18(%rsp)
je 0x352e7
cmpq $0x0, 0x10(%rsp)
je 0x352e7
cmpq $0x0, 0x8(%rsp)
jne 0x352f2
movq $0x0, 0x20(%rsp)
jmp 0x35329
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x14ce0
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
cmpq (%rsp), %rax
ja 0x3531b
movq $0x0, 0x20(%rsp)
jmp 0x35329
movq 0x18(%rsp), %rax
addq $-0x20, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_draw_list_alloc_vertices
NK_INTERN void*
nk_draw_list_alloc_vertices(struct nk_draw_list *list, nk_size count)
{
    void *vtx;
    NK_ASSERT(list);
    if (!list) return 0;
    vtx = nk_buffer_alloc(list->vertices, NK_BUFFER_FRONT,
        list->config.vertex_size*count, list->config.vertex_alignment);
    if (!vtx) return 0;
    list->vertex_count += (unsigned int)count;

    /* This assert triggers because your are drawing a lot of stuff and nuklear
     * defined `nk_draw_index` as `nk_ushort` to safe space be default.
     *
     * So you reached the maximum number of indices or rather vertexes.
     * To solve this issue please change typedef `nk_draw_index` to `nk_uint`
     * and don't forget to specify the new element size in your drawing
     * backend (OpenGL, DirectX, ...). For example in OpenGL for `glDrawElements`
     * instead of specifying `GL_UNSIGNED_SHORT` you have to define `GL_UNSIGNED_INT`.
     * Sorry for the inconvenience. */
    if(sizeof(nk_draw_index)==2) NK_ASSERT((list->vertex_count < NK_USHORT_MAX &&
        "To many vertices for 16-bit vertex indices. Please read comment above on how to solve this problem"));
    return vtx;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x37649
movq 0x8d9d3(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x79d79(%rip), %rsi     # 0xb13a0
leaq 0x79d90(%rip), %rdx     # 0xb13be
movl $0x25f2, %ecx           # imm = 0x25F2
movb $0x0, %al
callq 0x13ec0
movq 0x8d9af(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x3764b
cmpq $0x0, 0x18(%rsp)
jne 0x37661
movq $0x0, 0x20(%rsp)
jmp 0x3771a
movq 0x18(%rsp), %rax
movq 0xb8(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0xa0(%rax), %rdx
imulq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0xa8(%rax), %rcx
xorl %esi, %esi
callq 0x2f2e0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x376aa
movq $0x0, 0x20(%rsp)
jmp 0x3771a
movq 0x10(%rsp), %rax
movl %eax, %ecx
movq 0x18(%rsp), %rax
addl 0xcc(%rax), %ecx
movl %ecx, 0xcc(%rax)
movq 0x18(%rsp), %rax
cmpl $0xffff, 0xcc(%rax)     # imm = 0xFFFF
jae 0x376db
movb $0x1, %al
testb $0x1, %al
jne 0x3770e
jmp 0x376db
movq 0x8d90e(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x79cb4(%rip), %rsi     # 0xb13a0
leaq 0x79ccb(%rip), %rdx     # 0xb13be
movl $0x2603, %ecx           # imm = 0x2603
movb $0x0, %al
callq 0x13ec0
movq 0x8d8ea(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x37710
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_draw_list_alloc_elements
NK_INTERN nk_draw_index*
nk_draw_list_alloc_elements(struct nk_draw_list *list, nk_size count)
{
    nk_draw_index *ids;
    struct nk_draw_command *cmd;
    NK_STORAGE const nk_size elem_align = NK_ALIGNOF(nk_draw_index);
    NK_STORAGE const nk_size elem_size = sizeof(nk_draw_index);
    NK_ASSERT(list);
    if (!list) return 0;

    ids = (nk_draw_index*)
        nk_buffer_alloc(list->elements, NK_BUFFER_FRONT, elem_size*count, elem_align);
    if (!ids) return 0;
    cmd = nk_draw_list_command_last(list);
    list->element_count += (unsigned int)count;
    cmd->elem_count += (unsigned int)count;
    return ids;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x37779
movq 0x8d8a3(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x79c49(%rip), %rsi     # 0xb13a0
leaq 0x79c60(%rip), %rdx     # 0xb13be
movl $0x260d, %ecx           # imm = 0x260D
movb $0x0, %al
callq 0x13ec0
movq 0x8d87f(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x3777b
cmpq $0x0, 0x18(%rsp)
jne 0x3778e
movq $0x0, 0x20(%rsp)
jmp 0x37805
movq 0x18(%rsp), %rax
movq 0xc0(%rax), %rdi
movq 0x10(%rsp), %rdx
shlq %rdx
xorl %esi, %esi
movl $0x2, %ecx
callq 0x2f2e0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x377c6
movq $0x0, 0x20(%rsp)
jmp 0x37805
movq 0x18(%rsp), %rdi
callq 0x38800
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movl %eax, %ecx
movq 0x18(%rsp), %rax
addl 0xc8(%rax), %ecx
movl %ecx, 0xc8(%rax)
movq 0x10(%rsp), %rax
movl %eax, %ecx
movq (%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_inv_sqrt
NK_LIB float
nk_inv_sqrt(float n)
{
    float x2;
    const float threehalfs = 1.5f;
    union {nk_uint i; float f;} conv = {0};
    conv.f = n;
    x2 = n * 0.5f;
    conv.i = 0x5f375A84 - (conv.i >> 1);
    conv.f = conv.f * (threehalfs - (x2 * conv.f * conv.f));
    return conv.f;
}

// Assembly:
subq $0x18, %rsp
movss %xmm0, 0x14(%rsp)
movss 0x75cfe(%rip), %xmm0    # 0xad520
movss %xmm0, 0xc(%rsp)
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x13c40
movss 0x14(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
movss 0x75cc7(%rip), %xmm0    # 0xad514
mulss 0x14(%rsp), %xmm0
movss %xmm0, 0x10(%rsp)
movl 0x8(%rsp), %ecx
shrl %ecx
movl $0x5f375a84, %eax       # imm = 0x5F375A84
subl %ecx, %eax
movl %eax, 0x8(%rsp)
movss 0x8(%rsp), %xmm0
movss 0x10(%rsp), %xmm1
mulss 0x8(%rsp), %xmm1
movss 0x8(%rsp), %xmm2
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm1
movss 0x75c85(%rip), %xmm2    # 0xad520
addss %xmm2, %xmm1
mulss %xmm1, %xmm0
movss %xmm0, 0x8(%rsp)
movss 0x8(%rsp), %xmm0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_draw_vertex
NK_INTERN void*
nk_draw_vertex(void *dst, const struct nk_convert_config *config,
    struct nk_vec2 pos, struct nk_vec2 uv, struct nk_colorf color)
{
    void *result = (void*)((char*)dst + config->vertex_size);
    const struct nk_draw_vertex_layout_element *elem_iter = config->vertex_layout;
    while (!nk_draw_vertex_layout_element_is_end_of_layout(elem_iter)) {
        void *address = (void*)((char*)dst + elem_iter->offset);
        switch (elem_iter->attribute) {
        case NK_VERTEX_ATTRIBUTE_COUNT:
        default: NK_ASSERT(0 && "wrong element attribute"); break;
        case NK_VERTEX_POSITION: nk_draw_vertex_element(address, &pos.x, 2, elem_iter->format); break;
        case NK_VERTEX_TEXCOORD: nk_draw_vertex_element(address, &uv.x, 2, elem_iter->format); break;
        case NK_VERTEX_COLOR: nk_draw_vertex_color(address, &color.r, elem_iter->format); break;
        }
        elem_iter++;
    }
    return result;
}

// Assembly:
subq $0x58, %rsp
movlpd %xmm0, 0x50(%rsp)
movlpd %xmm1, 0x48(%rsp)
movlpd %xmm2, 0x38(%rsp)
movlpd %xmm3, 0x40(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
addq 0x30(%rcx), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x7ce90
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x37922
jmp 0x379fe
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %eax
movq %rax, 0x8(%rsp)
subq $0x3, %rax
ja 0x37961
movq 0x8(%rsp), %rax
leaq 0x75cd2(%rip), %rcx     # 0xad628
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x37961
jmp 0x37963
movq 0x8d686(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x79a2c(%rip), %rsi     # 0xb13a0
leaq 0x79a43(%rip), %rdx     # 0xb13be
movl $0x26aa, %ecx           # imm = 0x26AA
movb $0x0, %al
callq 0x13ec0
movq 0x8d662(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x379eb
movq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movq 0x18(%rsp), %rax
movl 0x4(%rax), %ecx
movl $0x2, %edx
callq 0x7cec0
jmp 0x379eb
movq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rsi
movq 0x18(%rsp), %rax
movl 0x4(%rax), %ecx
movl $0x2, %edx
callq 0x7cec0
jmp 0x379eb
movq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
movq 0x18(%rsp), %rax
movl 0x4(%rax), %edx
callq 0x7d5d0
movq 0x18(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x18(%rsp)
jmp 0x37907
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_draw_list_path_clear
NK_API void
nk_draw_list_path_clear(struct nk_draw_list *list)
{
    NK_ASSERT(list);
    if (!list) return;
    nk_buffer_reset(list->buffer, NK_BUFFER_FRONT);
    list->path_count = 0;
    list->path_offset = 0;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x385cf
movq 0x8ca4d(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x78df3(%rip), %rsi     # 0xb13a0
leaq 0x78e0a(%rip), %rdx     # 0xb13be
movl $0x2822, %ecx           # imm = 0x2822
movb $0x0, %al
callq 0x13ec0
movq 0x8ca29(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x385d1
cmpq $0x0, (%rsp)
jne 0x385da
jmp 0x38608
movq (%rsp), %rax
movq 0xb0(%rax), %rdi
xorl %esi, %esi
callq 0x13890
movq (%rsp), %rax
movl $0x0, 0xe0(%rax)
movq (%rsp), %rax
movl $0x0, 0xe4(%rax)
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_draw_list_path_line_to
NK_API void
nk_draw_list_path_line_to(struct nk_draw_list *list, struct nk_vec2 pos)
{
    struct nk_vec2 *points = 0;
    struct nk_draw_command *cmd = 0;
    NK_ASSERT(list);
    if (!list) return;
    if (!list->cmd_count)
        nk_draw_list_add_clip(list, nk_null_rect);

    cmd = nk_draw_list_command_last(list);
    if (cmd && cmd->texture.ptr != list->config.tex_null.texture.ptr)
        nk_draw_list_push_image(list, list->config.tex_null.texture);

    points = nk_draw_list_alloc_path(list, 1);
    if (!points) return;
    points[0] = pos;
}

// Assembly:
subq $0x28, %rsp
movlpd %xmm0, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x3866c
movq 0x8c9b0(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x78d56(%rip), %rsi     # 0xb13a0
leaq 0x78d6d(%rip), %rdx     # 0xb13be
movl $0x282d, %ecx           # imm = 0x282D
movb $0x0, %al
callq 0x13ec0
movq 0x8c98c(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x3866e
cmpq $0x0, 0x18(%rsp)
jne 0x3867b
jmp 0x38712
movq 0x18(%rsp), %rax
cmpl $0x0, 0xd0(%rax)
jne 0x386a3
movq 0x18(%rsp), %rdi
movsd 0x751ce(%rip), %xmm0    # 0xad864
movsd 0x751ce(%rip), %xmm1    # 0xad86c
callq 0x38720
movq 0x18(%rsp), %rdi
callq 0x38800
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x386e7
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x88(%rcx), %rax
je 0x386e7
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x88(%rax), %rsi
callq 0x388c0
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x389a0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x38705
jmp 0x38712
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_draw_list_add_clip
NK_INTERN void
nk_draw_list_add_clip(struct nk_draw_list *list, struct nk_rect rect)
{
    NK_ASSERT(list);
    if (!list) return;
    if (!list->cmd_count) {
        nk_draw_list_push_command(list, rect, list->config.tex_null.texture);
    } else {
        struct nk_draw_command *prev = nk_draw_list_command_last(list);
        if (prev->elem_count == 0)
            prev->clip_rect = rect;
        nk_draw_list_push_command(list, rect, prev->texture);
    }
}

// Assembly:
subq $0x28, %rsp
movlpd %xmm0, 0x18(%rsp)
movlpd %xmm1, 0x20(%rsp)
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x38770
movq 0x8c8ac(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x78c52(%rip), %rsi     # 0xb13a0
leaq 0x78c69(%rip), %rdx     # 0xb13be
movl $0x25c7, %ecx           # imm = 0x25C7
movb $0x0, %al
callq 0x13ec0
movq 0x8c888(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x38772
cmpq $0x0, 0x10(%rsp)
jne 0x3877c
jmp 0x387fb
movq 0x10(%rsp), %rax
cmpl $0x0, 0xd0(%rax)
jne 0x387ac
movq 0x10(%rsp), %rax
movq %rax, %rdi
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movq 0x88(%rax), %rsi
callq 0x7dce0
jmp 0x387fb
movq 0x10(%rsp), %rdi
callq 0x38800
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x387dc
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x4(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0xc(%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movq 0x18(%rax), %rsi
callq 0x7dce0
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_draw_list_command_last
NK_INTERN struct nk_draw_command*
nk_draw_list_command_last(struct nk_draw_list *list)
{
    void *memory;
    nk_size size;
    struct nk_draw_command *cmd;
    NK_ASSERT(list->cmd_count);

    memory = nk_buffer_memory(list->buffer);
    size = nk_buffer_total(list->buffer);
    cmd = nk_ptr_add(struct nk_draw_command, memory, size - list->cmd_offset);
    return (cmd - (list->cmd_count-1));
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpl $0x0, 0xd0(%rax)
jne 0x3884a
movq 0x8c7d2(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x78b78(%rip), %rsi     # 0xb13a0
leaq 0x78b8f(%rip), %rdx     # 0xb13be
movl $0x25bd, %ecx           # imm = 0x25BD
movb $0x0, %al
callq 0x13ec0
movq 0x8c7ae(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x3884c
movq 0x20(%rsp), %rax
movq 0xb0(%rax), %rdi
callq 0x141e0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0xb0(%rax), %rdi
callq 0x152e0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rdx
subq 0xd8(%rdx), %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
movl 0xd0(%rcx), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movl %ecx, %edx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_draw_list_push_image
NK_INTERN void
nk_draw_list_push_image(struct nk_draw_list *list, nk_handle texture)
{
    NK_ASSERT(list);
    if (!list) return;
    if (!list->cmd_count) {
        nk_draw_list_push_command(list, nk_null_rect, texture);
    } else {
        struct nk_draw_command *prev = nk_draw_list_command_last(list);
        if (prev->elem_count == 0) {
            prev->texture = texture;
        #ifdef NK_INCLUDE_COMMAND_USERDATA
            prev->userdata = list->userdata;
        #endif
    } else if (prev->texture.id != texture.id
        #ifdef NK_INCLUDE_COMMAND_USERDATA
            || prev->userdata.id != list->userdata.id
        #endif
        ) nk_draw_list_push_command(list, prev->clip_rect, texture);
    }
}

// Assembly:
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x38909
movq 0x8c713(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x78ab9(%rip), %rsi     # 0xb13a0
leaq 0x78ad0(%rip), %rdx     # 0xb13be
movl $0x25d5, %ecx           # imm = 0x25D5
movb $0x0, %al
callq 0x13ec0
movq 0x8c6ef(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x3890b
cmpq $0x0, 0x8(%rsp)
jne 0x38918
jmp 0x3899b
movq 0x8(%rsp), %rax
cmpl $0x0, 0xd0(%rax)
jne 0x38947
movq 0x8(%rsp), %rdi
movsd 0x74f31(%rip), %xmm0    # 0xad864
movsd 0x74f31(%rip), %xmm1    # 0xad86c
movq 0x10(%rsp), %rsi
callq 0x7dce0
jmp 0x3899b
movq 0x8(%rsp), %rdi
callq 0x38800
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x0, (%rax)
jne 0x3896d
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x38999
movq (%rsp), %rax
movl 0x18(%rax), %eax
cmpl 0x10(%rsp), %eax
je 0x38997
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movsd 0x4(%rax), %xmm0
movsd 0xc(%rax), %xmm1
movq 0x10(%rsp), %rsi
callq 0x7dce0
jmp 0x38999
jmp 0x3899b
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_draw_list_alloc_path
NK_INTERN struct nk_vec2*
nk_draw_list_alloc_path(struct nk_draw_list *list, int count)
{
    struct nk_vec2 *points;
    NK_STORAGE const nk_size point_align = NK_ALIGNOF(struct nk_vec2);
    NK_STORAGE const nk_size point_size = sizeof(struct nk_vec2);
    points = (struct nk_vec2*)
        nk_buffer_alloc(list->buffer, NK_BUFFER_FRONT,
                        point_size * (nk_size)count, point_align);

    if (!points) return 0;
    if (!list->path_offset) {
        void *memory = nk_buffer_memory(list->buffer);
        list->path_offset = (unsigned int)((nk_byte*)points - (nk_byte*)memory);
    }
    list->path_count += (unsigned int)count;
    return points;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq 0xb0(%rax), %rdi
movslq 0x14(%rsp), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
movl $0x4, %ecx
callq 0x2f2e0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x389e6
movq $0x0, 0x20(%rsp)
jmp 0x38a41
movq 0x18(%rsp), %rax
cmpl $0x0, 0xe4(%rax)
jne 0x38a22
movq 0x18(%rsp), %rax
movq 0xb0(%rax), %rdi
callq 0x141e0
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0xe4(%rax)
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %rax
addl 0xe0(%rax), %ecx
movl %ecx, 0xe0(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_draw_list_path_arc_to_fast
NK_API void
nk_draw_list_path_arc_to_fast(struct nk_draw_list *list, struct nk_vec2 center,
    float radius, int a_min, int a_max)
{
    int a = 0;
    NK_ASSERT(list);
    if (!list) return;
    if (a_min <= a_max) {
        for (a = a_min; a <= a_max; a++) {
            const struct nk_vec2 c = list->circle_vtx[(nk_size)a % NK_LEN(list->circle_vtx)];
            const float x = center.x + c.x * radius;
            const float y = center.y + c.y * radius;
            nk_draw_list_path_line_to(list, nk_vec2(x, y));
        }
    }
}

// Assembly:
subq $0x48, %rsp
movlpd %xmm0, 0x40(%rsp)
movq %rdi, 0x38(%rsp)
movss %xmm1, 0x34(%rsp)
movl %esi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x38ab0
movq 0x8c56c(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x78912(%rip), %rsi     # 0xb13a0
leaq 0x78929(%rip), %rdx     # 0xb13be
movl $0x283f, %ecx           # imm = 0x283F
movb $0x0, %al
callq 0x13ec0
movq 0x8c548(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x38ab2
cmpq $0x0, 0x38(%rsp)
jne 0x38abf
jmp 0x38ba2
movl 0x30(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jg 0x38ba2
movl 0x30(%rsp), %eax
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jg 0x38ba0
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movslq 0x28(%rsp), %rax
movl %eax, %ecx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rdx
movq (%rsp), %rax
movl %edx, %esi
shrl %esi
andl $-0x4, %esi
movl %esi, %edx
leal (%rdx,%rdx,2), %edx
subl %edx, %ecx
shll $0x3, %ecx
movq 0x10(%rax,%rcx), %rax
movq %rax, 0x20(%rsp)
movss 0x40(%rsp), %xmm1
movss 0x20(%rsp), %xmm0
movss 0x34(%rsp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x1c(%rsp)
movss 0x44(%rsp), %xmm1
movss 0x24(%rsp), %xmm0
movss 0x34(%rsp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movss 0x1c(%rsp), %xmm0
movss 0x18(%rsp), %xmm1
callq 0x13460
movq 0x8(%rsp), %rdi
movlpd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x13a50
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x38ad5
jmp 0x38ba2
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_draw_list_path_last
NK_INTERN struct nk_vec2
nk_draw_list_path_last(struct nk_draw_list *list)
{
    void *memory;
    struct nk_vec2 *point;
    NK_ASSERT(list->path_count);
    memory = nk_buffer_memory(list->buffer);
    point = nk_ptr_add(struct nk_vec2, memory, list->path_offset);
    point += (list->path_count-1);
    return *point;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x0, 0xe0(%rax)
jne 0x3958a
movq 0x8ba92(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x77e38(%rip), %rsi     # 0xb13a0
leaq 0x77e4f(%rip), %rdx     # 0xb13be
movl $0x2592, %ecx           # imm = 0x2592
movb $0x0, %al
callq 0x13ec0
movq 0x8ba6e(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x3958c
movq 0x18(%rsp), %rax
movq 0xb0(%rax), %rdi
callq 0x141e0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movl 0xe4(%rcx), %ecx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movl 0xe0(%rax), %ecx
decl %ecx
movq 0x8(%rsp), %rax
leaq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_draw_list_path_fill
NK_API void
nk_draw_list_path_fill(struct nk_draw_list *list, struct nk_color color)
{
    struct nk_vec2 *points;
    NK_ASSERT(list);
    if (!list) return;
    points = (struct nk_vec2*)nk_buffer_memory(list->buffer);
    nk_draw_list_fill_poly_convex(list, points, list->path_count, color, list->config.shape_AA);
    nk_draw_list_path_clear(list);
}

// Assembly:
subq $0x18, %rsp
movl %esi, 0x14(%rsp)
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x39638
movq 0x8b9e4(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x77d8a(%rip), %rsi     # 0xb13a0
leaq 0x77da1(%rip), %rdx     # 0xb13be
movl $0x28ad, %ecx           # imm = 0x28AD
movb $0x0, %al
callq 0x13ec0
movq 0x8b9c0(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x3963a
cmpq $0x0, 0x8(%rsp)
jne 0x39644
jmp 0x39689
movq 0x8(%rsp), %rax
movq 0xb0(%rax), %rdi
callq 0x141e0
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rax
movl 0xe0(%rax), %edx
movq 0x8(%rsp), %rax
movl 0x78(%rax), %r8d
movl 0x14(%rsp), %ecx
callq 0x133e0
movq 0x8(%rsp), %rdi
callq 0x13040
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_draw_list_path_stroke
NK_API void
nk_draw_list_path_stroke(struct nk_draw_list *list, struct nk_color color,
    enum nk_draw_list_stroke closed, float thickness)
{
    struct nk_vec2 *points;
    NK_ASSERT(list);
    if (!list) return;
    points = (struct nk_vec2*)nk_buffer_memory(list->buffer);
    nk_draw_list_stroke_poly_line(list, points, list->path_count, color,
        closed, thickness, list->config.line_AA);
    nk_draw_list_path_clear(list);
}

// Assembly:
subq $0x28, %rsp
movl %esi, 0x24(%rsp)
movq %rdi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movss %xmm0, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x396e2
movq 0x8b93a(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x77ce0(%rip), %rsi     # 0xb13a0
leaq 0x77cf7(%rip), %rdx     # 0xb13be
movl $0x28b8, %ecx           # imm = 0x28B8
movb $0x0, %al
callq 0x13ec0
movq 0x8b916(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x396e4
cmpq $0x0, 0x18(%rsp)
jne 0x396ee
jmp 0x39740
movq 0x18(%rsp), %rax
movq 0xb0(%rax), %rdi
callq 0x141e0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movl 0xe0(%rax), %edx
movl 0x14(%rsp), %r8d
movss 0x10(%rsp), %xmm0
movq 0x18(%rsp), %rax
movl 0x74(%rax), %r9d
movl 0x24(%rsp), %ecx
callq 0x14b40
movq 0x18(%rsp), %rdi
callq 0x13040
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_draw_list_stroke_line
NK_API void
nk_draw_list_stroke_line(struct nk_draw_list *list, struct nk_vec2 a,
    struct nk_vec2 b, struct nk_color col, float thickness)
{
    NK_ASSERT(list);
    if (!list || !col.a) return;
    if (list->line_AA == NK_ANTI_ALIASING_ON) {
        nk_draw_list_path_line_to(list, a);
        nk_draw_list_path_line_to(list, b);
    } else {
        nk_draw_list_path_line_to(list, nk_vec2_sub(a,nk_vec2(0.5f,0.5f)));
        nk_draw_list_path_line_to(list, nk_vec2_sub(b,nk_vec2(0.5f,0.5f)));
    }
    nk_draw_list_path_stroke(list,  col, NK_STROKE_OPEN, thickness);
}

// Assembly:
subq $0x88, %rsp
movlpd %xmm0, 0x80(%rsp)
movlpd %xmm1, 0x78(%rsp)
movl %esi, 0x74(%rsp)
movq %rdi, 0x68(%rsp)
movss %xmm2, 0x64(%rsp)
cmpq $0x0, 0x68(%rsp)
jne 0x397b0
movq 0x8b86c(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x77c12(%rip), %rsi     # 0xb13a0
leaq 0x77c29(%rip), %rdx     # 0xb13be
movl $0x28c3, %ecx           # imm = 0x28C3
movb $0x0, %al
callq 0x13ec0
movq 0x8b848(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x397b2
cmpq $0x0, 0x68(%rsp)
je 0x397c1
cmpb $0x0, 0x77(%rsp)
jne 0x397c6
jmp 0x3994e
movq 0x68(%rsp), %rax
cmpl $0x1, 0xe8(%rax)
jne 0x397fc
movq 0x68(%rsp), %rdi
movsd 0x80(%rsp), %xmm0
callq 0x13a50
movq 0x68(%rsp), %rdi
movsd 0x78(%rsp), %xmm0
callq 0x13a50
jmp 0x39938
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movss 0x80(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
movss 0x73cf7(%rip), %xmm1    # 0xad514
movss %xmm1, 0x18(%rsp)
movaps %xmm1, %xmm0
callq 0x13460
movss 0x18(%rsp), %xmm1
movaps %xmm0, %xmm2
movss 0x4(%rsp), %xmm0
movlpd %xmm2, 0x54(%rsp)
movss 0x54(%rsp), %xmm2
subss %xmm2, %xmm0
movss %xmm0, 0xc(%rsp)
movss 0x84(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
movaps %xmm1, %xmm0
callq 0x13460
movss 0x8(%rsp), %xmm1
movaps %xmm0, %xmm2
movss 0xc(%rsp), %xmm0
movlpd %xmm2, 0x4c(%rsp)
movss 0x50(%rsp), %xmm2
subss %xmm2, %xmm1
callq 0x13460
movq 0x10(%rsp), %rdi
movlpd %xmm0, 0x5c(%rsp)
movsd 0x5c(%rsp), %xmm0
callq 0x13a50
movss 0x18(%rsp), %xmm1
movq 0x68(%rsp), %rax
movq %rax, 0x28(%rsp)
movss 0x78(%rsp), %xmm0
movss %xmm0, 0x1c(%rsp)
movaps %xmm1, %xmm0
callq 0x13460
movss 0x18(%rsp), %xmm1
movaps %xmm0, %xmm2
movss 0x1c(%rsp), %xmm0
movlpd %xmm2, 0x3c(%rsp)
movss 0x3c(%rsp), %xmm2
subss %xmm2, %xmm0
movss %xmm0, 0x24(%rsp)
movss 0x7c(%rsp), %xmm0
movss %xmm0, 0x20(%rsp)
movaps %xmm1, %xmm0
callq 0x13460
movss 0x20(%rsp), %xmm1
movaps %xmm0, %xmm2
movss 0x24(%rsp), %xmm0
movlpd %xmm2, 0x34(%rsp)
movss 0x38(%rsp), %xmm2
subss %xmm2, %xmm1
callq 0x13460
movq 0x28(%rsp), %rdi
movlpd %xmm0, 0x44(%rsp)
movsd 0x44(%rsp), %xmm0
callq 0x13a50
movq 0x68(%rsp), %rdi
movss 0x64(%rsp), %xmm0
movl 0x74(%rsp), %esi
xorl %edx, %edx
callq 0x14dd0
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_draw_list_fill_rect
NK_API void
nk_draw_list_fill_rect(struct nk_draw_list *list, struct nk_rect rect,
    struct nk_color col, float rounding)
{
    NK_ASSERT(list);
    if (!list || !col.a) return;

    if (list->line_AA == NK_ANTI_ALIASING_ON) {
        nk_draw_list_path_rect_to(list, nk_vec2(rect.x, rect.y),
            nk_vec2(rect.x + rect.w, rect.y + rect.h), rounding);
    } else {
        nk_draw_list_path_rect_to(list, nk_vec2(rect.x-0.5f, rect.y-0.5f),
            nk_vec2(rect.x + rect.w, rect.y + rect.h), rounding);
    } nk_draw_list_path_fill(list,  col);
}

// Assembly:
subq $0x58, %rsp
movlpd %xmm0, 0x48(%rsp)
movlpd %xmm1, 0x50(%rsp)
movl %esi, 0x44(%rsp)
movq %rdi, 0x38(%rsp)
movss %xmm2, 0x34(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x399ba
movq 0x8b662(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x77a08(%rip), %rsi     # 0xb13a0
leaq 0x77a1f(%rip), %rdx     # 0xb13be
movl $0x28d2, %ecx           # imm = 0x28D2
movb $0x0, %al
callq 0x13ec0
movq 0x8b63e(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x399bc
cmpq $0x0, 0x38(%rsp)
je 0x399cb
cmpb $0x0, 0x47(%rsp)
jne 0x399d0
jmp 0x39acc
movq 0x38(%rsp), %rax
cmpl $0x1, 0xe8(%rax)
jne 0x39a48
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movss 0x48(%rsp), %xmm0
movss 0x4c(%rsp), %xmm1
callq 0x13460
movlpd %xmm0, 0x2c(%rsp)
movss 0x50(%rsp), %xmm2
movss 0x48(%rsp), %xmm0
movss 0x4c(%rsp), %xmm1
addss %xmm2, %xmm0
movss 0x54(%rsp), %xmm2
addss %xmm2, %xmm1
callq 0x13460
movq 0x8(%rsp), %rdi
movlpd %xmm0, 0x24(%rsp)
movss 0x34(%rsp), %xmm2
movsd 0x2c(%rsp), %xmm0
movsd 0x24(%rsp), %xmm1
callq 0x141c0
jmp 0x39abe
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movss 0x48(%rsp), %xmm0
movss 0x4c(%rsp), %xmm1
movss 0x73aaf(%rip), %xmm2    # 0xad514
subss %xmm2, %xmm0
subss %xmm2, %xmm1
callq 0x13460
movlpd %xmm0, 0x1c(%rsp)
movss 0x50(%rsp), %xmm2
movss 0x48(%rsp), %xmm0
movss 0x4c(%rsp), %xmm1
addss %xmm2, %xmm0
movss 0x54(%rsp), %xmm2
addss %xmm2, %xmm1
callq 0x13460
movq (%rsp), %rdi
movlpd %xmm0, 0x14(%rsp)
movss 0x34(%rsp), %xmm2
movsd 0x1c(%rsp), %xmm0
movsd 0x14(%rsp), %xmm1
callq 0x141c0
movq 0x38(%rsp), %rdi
movl 0x44(%rsp), %esi
callq 0x138e0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_draw_list_stroke_rect
NK_API void
nk_draw_list_stroke_rect(struct nk_draw_list *list, struct nk_rect rect,
    struct nk_color col, float rounding, float thickness)
{
    NK_ASSERT(list);
    if (!list || !col.a) return;
    if (list->line_AA == NK_ANTI_ALIASING_ON) {
        nk_draw_list_path_rect_to(list, nk_vec2(rect.x, rect.y),
            nk_vec2(rect.x + rect.w, rect.y + rect.h), rounding);
    } else {
        nk_draw_list_path_rect_to(list, nk_vec2(rect.x-0.5f, rect.y-0.5f),
            nk_vec2(rect.x + rect.w, rect.y + rect.h), rounding);
    } nk_draw_list_path_stroke(list,  col, NK_STROKE_CLOSED, thickness);
}

// Assembly:
subq $0x58, %rsp
movlpd %xmm0, 0x48(%rsp)
movlpd %xmm1, 0x50(%rsp)
movl %esi, 0x44(%rsp)
movq %rdi, 0x38(%rsp)
movss %xmm2, 0x34(%rsp)
movss %xmm3, 0x30(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x39b40
movq 0x8b4dc(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x77882(%rip), %rsi     # 0xb13a0
leaq 0x77899(%rip), %rdx     # 0xb13be
movl $0x28e1, %ecx           # imm = 0x28E1
movb $0x0, %al
callq 0x13ec0
movq 0x8b4b8(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x39b42
cmpq $0x0, 0x38(%rsp)
je 0x39b51
cmpb $0x0, 0x47(%rsp)
jne 0x39b56
jmp 0x39c5d
movq 0x38(%rsp), %rax
cmpl $0x1, 0xe8(%rax)
jne 0x39bce
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movss 0x48(%rsp), %xmm0
movss 0x4c(%rsp), %xmm1
callq 0x13460
movlpd %xmm0, 0x28(%rsp)
movss 0x50(%rsp), %xmm2
movss 0x48(%rsp), %xmm0
movss 0x4c(%rsp), %xmm1
addss %xmm2, %xmm0
movss 0x54(%rsp), %xmm2
addss %xmm2, %xmm1
callq 0x13460
movq 0x8(%rsp), %rdi
movlpd %xmm0, 0x20(%rsp)
movss 0x34(%rsp), %xmm2
movsd 0x28(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
callq 0x141c0
jmp 0x39c44
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movss 0x48(%rsp), %xmm0
movss 0x4c(%rsp), %xmm1
movss 0x73929(%rip), %xmm2    # 0xad514
subss %xmm2, %xmm0
subss %xmm2, %xmm1
callq 0x13460
movlpd %xmm0, 0x18(%rsp)
movss 0x50(%rsp), %xmm2
movss 0x48(%rsp), %xmm0
movss 0x4c(%rsp), %xmm1
addss %xmm2, %xmm0
movss 0x54(%rsp), %xmm2
addss %xmm2, %xmm1
callq 0x13460
movq (%rsp), %rdi
movlpd %xmm0, 0x10(%rsp)
movss 0x34(%rsp), %xmm2
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x141c0
movq 0x38(%rsp), %rdi
movss 0x30(%rsp), %xmm0
movl 0x44(%rsp), %esi
movl $0x1, %edx
callq 0x14dd0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_draw_list_fill_triangle
NK_API void
nk_draw_list_fill_triangle(struct nk_draw_list *list, struct nk_vec2 a,
    struct nk_vec2 b, struct nk_vec2 c, struct nk_color col)
{
    NK_ASSERT(list);
    if (!list || !col.a) return;
    nk_draw_list_path_line_to(list, a);
    nk_draw_list_path_line_to(list, b);
    nk_draw_list_path_line_to(list, c);
    nk_draw_list_path_fill(list, col);
}

// Assembly:
subq $0x28, %rsp
movlpd %xmm0, 0x20(%rsp)
movlpd %xmm1, 0x18(%rsp)
movlpd %xmm2, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x3a0a8
movq 0x8af74(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x7731a(%rip), %rsi     # 0xb13a0
leaq 0x77331(%rip), %rdx     # 0xb13be
movl $0x2911, %ecx           # imm = 0x2911
movb $0x0, %al
callq 0x13ec0
movq 0x8af50(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x3a0aa
cmpq $0x0, (%rsp)
je 0x3a0b8
cmpb $0x0, 0xf(%rsp)
jne 0x3a0ba
jmp 0x3a0f4
movq (%rsp), %rdi
movsd 0x20(%rsp), %xmm0
callq 0x13a50
movq (%rsp), %rdi
movsd 0x18(%rsp), %xmm0
callq 0x13a50
movq (%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0x13a50
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x138e0
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_draw_list_stroke_triangle
NK_API void
nk_draw_list_stroke_triangle(struct nk_draw_list *list, struct nk_vec2 a,
    struct nk_vec2 b, struct nk_vec2 c, struct nk_color col, float thickness)
{
    NK_ASSERT(list);
    if (!list || !col.a) return;
    nk_draw_list_path_line_to(list, a);
    nk_draw_list_path_line_to(list, b);
    nk_draw_list_path_line_to(list, c);
    nk_draw_list_path_stroke(list, col, NK_STROKE_CLOSED, thickness);
}

// Assembly:
subq $0x38, %rsp
movlpd %xmm0, 0x30(%rsp)
movlpd %xmm1, 0x28(%rsp)
movlpd %xmm2, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdi, 0x10(%rsp)
movss %xmm3, 0xc(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x3a160
movq 0x8aebc(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x77262(%rip), %rsi     # 0xb13a0
leaq 0x77279(%rip), %rdx     # 0xb13be
movl $0x291c, %ecx           # imm = 0x291C
movb $0x0, %al
callq 0x13ec0
movq 0x8ae98(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x3a162
cmpq $0x0, 0x10(%rsp)
je 0x3a171
cmpb $0x0, 0x1f(%rsp)
jne 0x3a173
jmp 0x3a1bc
movq 0x10(%rsp), %rdi
movsd 0x30(%rsp), %xmm0
callq 0x13a50
movq 0x10(%rsp), %rdi
movsd 0x28(%rsp), %xmm0
callq 0x13a50
movq 0x10(%rsp), %rdi
movsd 0x20(%rsp), %xmm0
callq 0x13a50
movq 0x10(%rsp), %rdi
movss 0xc(%rsp), %xmm0
movl 0x1c(%rsp), %esi
movl $0x1, %edx
callq 0x14dd0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_draw_list_fill_circle
NK_API void
nk_draw_list_fill_circle(struct nk_draw_list *list, struct nk_vec2 center,
    float radius, struct nk_color col, unsigned int segs)
{
    float a_max;
    NK_ASSERT(list);
    if (!list || !col.a) return;
    a_max = NK_PI * 2.0f * ((float)segs - 1.0f) / (float)segs;
    nk_draw_list_path_arc_to(list, center, radius, 0.0f, a_max, segs);
    nk_draw_list_path_fill(list, col);
}

// Assembly:
subq $0x28, %rsp
movlpd %xmm0, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdi, 0x10(%rsp)
movss %xmm1, 0xc(%rsp)
movl %edx, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x3a228
movq 0x8adf4(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x7719a(%rip), %rsi     # 0xb13a0
leaq 0x771b1(%rip), %rdx     # 0xb13be
movl $0x2928, %ecx           # imm = 0x2928
movb $0x0, %al
callq 0x13ec0
movq 0x8add0(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x3a22a
cmpq $0x0, 0x10(%rsp)
je 0x3a239
cmpb $0x0, 0x1f(%rsp)
jne 0x3a23b
jmp 0x3a29a
movl 0x8(%rsp), %eax
cvtsi2ss %rax, %xmm1
movss 0x732ac(%rip), %xmm2    # 0xad4f8
movaps %xmm1, %xmm0
addss %xmm2, %xmm0
movss 0x732cd(%rip), %xmm2    # 0xad528
mulss %xmm2, %xmm0
divss %xmm1, %xmm0
movss %xmm0, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movss 0xc(%rsp), %xmm1
movss 0x4(%rsp), %xmm3
movl 0x8(%rsp), %esi
movsd 0x20(%rsp), %xmm0
xorps %xmm2, %xmm2
callq 0x14630
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x138e0
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_draw_list_stroke_circle
NK_API void
nk_draw_list_stroke_circle(struct nk_draw_list *list, struct nk_vec2 center,
    float radius, struct nk_color col, unsigned int segs, float thickness)
{
    float a_max;
    NK_ASSERT(list);
    if (!list || !col.a) return;
    a_max = NK_PI * 2.0f * ((float)segs - 1.0f) / (float)segs;
    nk_draw_list_path_arc_to(list, center, radius, 0.0f, a_max, segs);
    nk_draw_list_path_stroke(list, col, NK_STROKE_CLOSED, thickness);
}

// Assembly:
subq $0x28, %rsp
movlpd %xmm0, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdi, 0x10(%rsp)
movss %xmm1, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movss %xmm2, 0x4(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x3a2fe
movq 0x8ad1e(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x770c4(%rip), %rsi     # 0xb13a0
leaq 0x770db(%rip), %rdx     # 0xb13be
movl $0x2933, %ecx           # imm = 0x2933
movb $0x0, %al
callq 0x13ec0
movq 0x8acfa(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x3a300
cmpq $0x0, 0x10(%rsp)
je 0x3a30f
cmpb $0x0, 0x1f(%rsp)
jne 0x3a311
jmp 0x3a379
movl 0x8(%rsp), %eax
cvtsi2ss %rax, %xmm1
movss 0x731d6(%rip), %xmm2    # 0xad4f8
movaps %xmm1, %xmm0
addss %xmm2, %xmm0
movss 0x731f7(%rip), %xmm2    # 0xad528
mulss %xmm2, %xmm0
divss %xmm1, %xmm0
movss %xmm0, (%rsp)
movq 0x10(%rsp), %rdi
movss 0xc(%rsp), %xmm1
movss (%rsp), %xmm3
movl 0x8(%rsp), %esi
movsd 0x20(%rsp), %xmm0
xorps %xmm2, %xmm2
callq 0x14630
movq 0x10(%rsp), %rdi
movss 0x4(%rsp), %xmm0
movl 0x1c(%rsp), %esi
movl $0x1, %edx
callq 0x14dd0
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk_draw_list_stroke_curve
NK_API void
nk_draw_list_stroke_curve(struct nk_draw_list *list, struct nk_vec2 p0,
    struct nk_vec2 cp0, struct nk_vec2 cp1, struct nk_vec2 p1,
    struct nk_color col, unsigned int segments, float thickness)
{
    NK_ASSERT(list);
    if (!list || !col.a) return;
    nk_draw_list_path_line_to(list, p0);
    nk_draw_list_path_curve_to(list, cp0, cp1, p1, segments);
    nk_draw_list_path_stroke(list, col, NK_STROKE_OPEN, thickness);
}

// Assembly:
subq $0x38, %rsp
movlpd %xmm0, 0x30(%rsp)
movlpd %xmm1, 0x28(%rsp)
movlpd %xmm2, 0x20(%rsp)
movlpd %xmm3, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movss %xmm4, (%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x3a3e9
movq 0x8ac33(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x76fd9(%rip), %rsi     # 0xb13a0
leaq 0x76ff0(%rip), %rdx     # 0xb13be
movl $0x293e, %ecx           # imm = 0x293E
movb $0x0, %al
callq 0x13ec0
movq 0x8ac0f(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x3a3eb
cmpq $0x0, 0x8(%rsp)
je 0x3a3fa
cmpb $0x0, 0x17(%rsp)
jne 0x3a3fc
jmp 0x3a441
movq 0x8(%rsp), %rdi
movsd 0x30(%rsp), %xmm0
callq 0x13a50
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
movsd 0x28(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
callq 0x15020
movq 0x8(%rsp), %rdi
movss (%rsp), %xmm0
movl 0x14(%rsp), %esi
xorl %edx, %edx
callq 0x14dd0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/./nuklear/nuklear.h
// Function: nk__begin
NK_API const struct nk_command*
nk__begin(struct nk_context *ctx)
{
    struct nk_window *iter;
    nk_byte *buffer;
    NK_ASSERT(ctx);
    if (!ctx) return 0;
    if (!ctx->count) return 0;

    buffer = (nk_byte*)ctx->memory.memory.ptr;
    if (!ctx->build) {
        nk_build(ctx);
        ctx->build = nk_true;
    }
    iter = ctx->begin;
    while (iter && ((iter->buffer.begin == iter->buffer.end) ||
        (iter->flags & NK_WINDOW_HIDDEN) || iter->seq != ctx->seq))
        iter = iter->next;
    if (!iter) return 0;
    return nk_ptr_add_const(struct nk_command, buffer, iter->buffer.begin);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x3bf74
movq 0x890a8(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
leaq 0x7544e(%rip), %rsi     # 0xb13a0
leaq 0x75465(%rip), %rdx     # 0xb13be
movl $0x4b8e, %ecx           # imm = 0x4B8E
movb $0x0, %al
callq 0x13ec0
movq 0x89084(%rip), %rax     # 0xc4ff0
movq (%rax), %rdi
callq 0x149a0
jmp 0x3bf76
cmpq $0x0, 0x18(%rsp)
jne 0x3bf8c
movq $0x0, 0x20(%rsp)
jmp 0x3c0a2
movq 0x18(%rsp), %rax
cmpl $0x0, 0x4790(%rax)
jne 0x3bfa8
movq $0x0, 0x20(%rsp)
jmp 0x3c0a2
movq 0x18(%rsp), %rax
movq 0x2548(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x0, 0x4718(%rax)
jne 0x3bfe0
movq 0x18(%rsp), %rdi
callq 0x54620
movq 0x18(%rsp), %rax
movl $0x1, 0x4718(%rax)
movq 0x18(%rsp), %rax
movq 0x4768(%rax), %rax
movq %rax, 0x10(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x10(%rsp)
movb %al, 0x7(%rsp)
je 0x3c059
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rcx
movq 0x10(%rsp), %rdx
movb $0x1, %al
cmpq 0x98(%rdx), %rcx
movb %al, 0x6(%rsp)
je 0x3c051
movq 0x10(%rsp), %rax
movl 0x48(%rax), %ecx
andl $0x2000, %ecx           # imm = 0x2000
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, 0x6(%rsp)
jne 0x3c051
movq 0x10(%rsp), %rax
movl (%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0x4794(%rcx), %eax
setne %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x3c063
jmp 0x3c079
movq 0x10(%rsp), %rax
movq 0x1c8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x3bff1
cmpq $0x0, 0x10(%rsp)
jne 0x3c08c
movq $0x0, 0x20(%rsp)
jmp 0x3c0a2
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
addq 0x90(%rcx), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)