LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::PrimRect(ImVec2 const&, ImVec2 const&, unsigned int)
void ImDrawList::PrimRect(const ImVec2& a, const ImVec2& c, ImU32 col)
{
    const ImVec2 uv = GImGui->FontTexUvWhitePixel;
    const ImVec2 b(c.x, a.y);
    const ImVec2 d(a.x, c.y);
    _IdxWritePtr[0] = (ImDrawIdx)(_VtxCurrentIdx); _IdxWritePtr[1] = (ImDrawIdx)(_VtxCurrentIdx+1); _IdxWritePtr[2] = (ImDrawIdx)(_VtxCurrentIdx+2);
    _IdxWritePtr[3] = (ImDrawIdx)(_VtxCurrentIdx); _IdxWritePtr[4] = (ImDrawIdx)(_VtxCurrentIdx+2); _IdxWritePtr[5] = (ImDrawIdx)(_VtxCurrentIdx+3);
    _VtxWritePtr[0].pos = a; _VtxWritePtr[0].uv = uv; _VtxWritePtr[0].col = col;
    _VtxWritePtr[1].pos = b; _VtxWritePtr[1].uv = uv; _VtxWritePtr[1].col = col;
    _VtxWritePtr[2].pos = c; _VtxWritePtr[2].uv = uv; _VtxWritePtr[2].col = col;
    _VtxWritePtr[3].pos = d; _VtxWritePtr[3].uv = uv; _VtxWritePtr[3].col = col;
    _VtxWritePtr += 4;
    _VtxCurrentIdx += 4;
    _IdxWritePtr += 6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
leaq 0x2744a(%rip), %rax     # 0x55490
movq (%rax), %rax
movq 0x1720(%rax), %rax
movl (%rsi), %r8d
movl 0x4(%rsi), %r10d
movl (%rdx), %r11d
movl 0x4(%rdx), %r9d
movl 0x38(%rdi), %ebx
movq 0x48(%rdi), %r14
movw %bx, (%r14)
leal 0x1(%rbx), %r15d
movw %r15w, 0x2(%r14)
leal 0x2(%rbx), %r15d
movw %r15w, 0x4(%r14)
movw %bx, 0x6(%r14)
movw %r15w, 0x8(%r14)
addl $0x3, %ebx
movw %bx, 0xa(%r14)
movq 0x40(%rdi), %rbx
movq (%rsi), %rsi
movq %rsi, (%rbx)
movq 0x40(%rdi), %rsi
movq %rax, 0x8(%rsi)
movq 0x40(%rdi), %rsi
movl %ecx, 0x10(%rsi)
movl %r11d, 0x14(%rsi)
movl %r10d, 0x18(%rsi)
movq 0x40(%rdi), %rsi
movq %rax, 0x1c(%rsi)
movq 0x40(%rdi), %rsi
movl %ecx, 0x24(%rsi)
movq (%rdx), %rdx
movq %rdx, 0x28(%rsi)
movq 0x40(%rdi), %rdx
movq %rax, 0x30(%rdx)
movq 0x40(%rdi), %rdx
movl %ecx, 0x38(%rdx)
movl %r8d, 0x3c(%rdx)
movl %r9d, 0x40(%rdx)
movq 0x40(%rdi), %rdx
movq %rax, 0x44(%rdx)
movq 0x40(%rdi), %rax
movl %ecx, 0x4c(%rax)
addq $0x50, %rax
movq %rax, 0x40(%rdi)
addl $0x4, 0x38(%rdi)
addq $0xc, 0x48(%rdi)
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::PrimRectUV(ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int)
void ImDrawList::PrimRectUV(const ImVec2& a, const ImVec2& c, const ImVec2& uv_a, const ImVec2& uv_c, ImU32 col)
{
    const ImVec2 b(c.x, a.y);
    const ImVec2 d(a.x, c.y);
    const ImVec2 uv_b(uv_c.x, uv_a.y);
    const ImVec2 uv_d(uv_a.x, uv_c.y);
    _IdxWritePtr[0] = (ImDrawIdx)(_VtxCurrentIdx); _IdxWritePtr[1] = (ImDrawIdx)(_VtxCurrentIdx+1); _IdxWritePtr[2] = (ImDrawIdx)(_VtxCurrentIdx+2);
    _IdxWritePtr[3] = (ImDrawIdx)(_VtxCurrentIdx); _IdxWritePtr[4] = (ImDrawIdx)(_VtxCurrentIdx+2); _IdxWritePtr[5] = (ImDrawIdx)(_VtxCurrentIdx+3);
    _VtxWritePtr[0].pos = a; _VtxWritePtr[0].uv = uv_a; _VtxWritePtr[0].col = col;
    _VtxWritePtr[1].pos = b; _VtxWritePtr[1].uv = uv_b; _VtxWritePtr[1].col = col;
    _VtxWritePtr[2].pos = c; _VtxWritePtr[2].uv = uv_c; _VtxWritePtr[2].col = col;
    _VtxWritePtr[3].pos = d; _VtxWritePtr[3].uv = uv_d; _VtxWritePtr[3].col = col;
    _VtxWritePtr += 4;
    _VtxCurrentIdx += 4;
    _IdxWritePtr += 6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r10
movq %rcx, %r8
movl (%rsi), %eax
movl %eax, -0x34(%rbp)
movl 0x4(%rsi), %r14d
movl (%rdx), %r12d
movl 0x4(%rdx), %eax
movl %eax, -0x2c(%rbp)
movl (%rcx), %eax
movl %eax, -0x30(%rbp)
movl 0x4(%rcx), %r15d
movl (%r10), %r13d
movl 0x4(%r10), %ebx
movl 0x38(%rdi), %eax
movq 0x48(%rdi), %rcx
movw %ax, (%rcx)
leal 0x1(%rax), %r11d
movw %r11w, 0x2(%rcx)
leal 0x2(%rax), %r11d
movw %r11w, 0x4(%rcx)
movw %ax, 0x6(%rcx)
movw %r11w, 0x8(%rcx)
addl $0x3, %eax
movw %ax, 0xa(%rcx)
movq (%rsi), %rax
movq 0x40(%rdi), %rcx
movq %rax, (%rcx)
movq (%r8), %rax
movq 0x40(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x40(%rdi), %rax
movl %r9d, 0x10(%rax)
movl %r12d, 0x14(%rax)
movl %r14d, 0x18(%rax)
movq 0x40(%rdi), %rax
movl %r13d, 0x1c(%rax)
movl %r15d, 0x20(%rax)
movq 0x40(%rdi), %rax
movl %r9d, 0x24(%rax)
movq (%rdx), %rcx
movq %rcx, 0x28(%rax)
movq 0x40(%rdi), %rax
movq (%r10), %rcx
movq %rcx, 0x30(%rax)
movq 0x40(%rdi), %rax
movl %r9d, 0x38(%rax)
movl -0x34(%rbp), %ecx
movl %ecx, 0x3c(%rax)
movl -0x2c(%rbp), %ecx
movl %ecx, 0x40(%rax)
movq 0x40(%rdi), %rax
movl -0x30(%rbp), %ecx
movl %ecx, 0x44(%rax)
movl %ebx, 0x48(%rax)
movq 0x40(%rdi), %rax
movl %r9d, 0x4c(%rax)
addq $0x50, %rax
movq %rax, 0x40(%rdi)
addl $0x4, 0x38(%rdi)
addq $0xc, 0x48(%rdi)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddLine(ImVec2 const&, ImVec2 const&, unsigned int, float)
void ImDrawList::AddLine(const ImVec2& a, const ImVec2& b, ImU32 col, float thickness)
{
    if ((col >> 24) == 0)
        return;
    PathLineTo(a + ImVec2(0.5f,0.5f));
    PathLineTo(b + ImVec2(0.5f,0.5f));
    PathStroke(col, false, thickness);
}

// Assembly:
cmpl $0x1000000, %ecx        # imm = 0x1000000
jb 0x2ffdc
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r14d
movq %rdx, %r15
movq %rdi, %rbx
movss 0xd5a0(%rip), %xmm2     # 0x3d3bc
movss (%rsi), %xmm3
addss %xmm2, %xmm3
movss 0x4(%rsi), %xmm1
addss %xmm2, %xmm1
unpcklps %xmm1, %xmm3            # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
movl 0x70(%rdi), %r13d
movl 0x74(%rdi), %eax
cmpl %eax, %r13d
jne 0x2feaf
incl %r13d
testl %eax, %eax
je 0x2fe50
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x2fe55
movl $0x8, %ecx
cmpl %r13d, %ecx
cmovgl %ecx, %r13d
cmpl %r13d, %eax
jge 0x2feaf
movslq %r13d, %rdi
shlq $0x3, %rdi
movss %xmm0, -0x2c(%rbp)
movaps %xmm3, -0x40(%rbp)
callq 0x85d9
movq %rax, %r12
movq 0x78(%rbx), %rsi
movslq 0x70(%rbx), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x78(%rbx), %rdi
callq 0x9065
movaps -0x40(%rbp), %xmm3
movss 0xd51a(%rip), %xmm2     # 0x3d3bc
movss -0x2c(%rbp), %xmm0
movq %r12, 0x78(%rbx)
movl %r13d, 0x74(%rbx)
movq 0x78(%rbx), %rax
movslq 0x70(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x70(%rbx)
movlps %xmm3, (%rax,%rcx,8)
movss (%r15), %xmm1
addss %xmm2, %xmm1
addss 0x4(%r15), %xmm2
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movl 0x70(%rbx), %r12d
movl 0x74(%rbx), %eax
cmpl %eax, %r12d
jne 0x2ff4a
incl %r12d
testl %eax, %eax
je 0x2fef3
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x2fef8
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
cmpl %r12d, %eax
jge 0x2ff4a
movslq %r12d, %rdi
shlq $0x3, %rdi
movss %xmm0, -0x2c(%rbp)
movaps %xmm1, -0x40(%rbp)
callq 0x85d9
movq %rax, %r15
movq 0x78(%rbx), %rsi
movslq 0x70(%rbx), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x78(%rbx), %rdi
callq 0x9065
movaps -0x40(%rbp), %xmm1
movss -0x2c(%rbp), %xmm0
movq %r15, 0x78(%rbx)
movl %r12d, 0x74(%rbx)
movq 0x78(%rbx), %rax
movslq 0x70(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x70(%rbx)
movlps %xmm1, (%rax,%rcx,8)
movq 0x78(%rbx), %rsi
movl 0x70(%rbx), %edx
xorl %r15d, %r15d
movq %rbx, %rdi
movl %r14d, %ecx
xorl %r8d, %r8d
movl $0x1, %r9d
callq 0x2e1f4
movl 0x74(%rbx), %eax
testl %eax, %eax
jns 0x2ffc7
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
testl %ecx, %ecx
cmovgl %ecx, %r15d
leaq (,%r15,8), %rdi
callq 0x85d9
movq %rax, %r14
movq 0x78(%rbx), %rsi
movslq 0x70(%rbx), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x78(%rbx), %rdi
callq 0x9065
movq %r14, 0x78(%rbx)
movl %r15d, 0x74(%rbx)
movl $0x0, 0x70(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddRect(ImVec2 const&, ImVec2 const&, unsigned int, float, int)
void ImDrawList::AddRect(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding, int rounding_corners)
{
    if ((col >> 24) == 0)
        return;
    PathRect(a + ImVec2(0.5f,0.5f), b + ImVec2(0.5f,0.5f), rounding, rounding_corners);
    PathStroke(col, true);
}

// Assembly:
cmpl $0x1000000, %ecx        # imm = 0x1000000
jb 0x300c6
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r14d
movq %rdi, %rbx
movss 0xd3b7(%rip), %xmm1     # 0x3d3bc
movss (%rsi), %xmm2
addss %xmm1, %xmm2
movss 0x4(%rsi), %xmm3
addss %xmm1, %xmm3
unpcklps %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
leaq -0x28(%rbp), %rsi
movlps %xmm2, (%rsi)
movss (%rdx), %xmm2
addss %xmm1, %xmm2
addss 0x4(%rdx), %xmm1
unpcklps %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
leaq -0x20(%rbp), %rdx
movlps %xmm2, (%rdx)
movl %r8d, %ecx
callq 0x2fa0c
movq 0x78(%rbx), %rsi
movl 0x70(%rbx), %edx
movss 0xd332(%rip), %xmm0     # 0x3d380
movq %rbx, %rdi
movl %r14d, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x2e1f4
movl 0x74(%rbx), %eax
testl %eax, %eax
jns 0x300b5
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
xorl %r15d, %r15d
testl %ecx, %ecx
cmovgl %ecx, %r15d
leaq (,%r15,8), %rdi
callq 0x85d9
movq %rax, %r14
movq 0x78(%rbx), %rsi
movslq 0x70(%rbx), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x78(%rbx), %rdi
callq 0x9065
movq %r14, 0x78(%rbx)
movl %r15d, 0x74(%rbx)
movl $0x0, 0x70(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddRectFilled(ImVec2 const&, ImVec2 const&, unsigned int, float, int)
void ImDrawList::AddRectFilled(const ImVec2& a, const ImVec2& b, ImU32 col, float rounding, int rounding_corners)
{
    if ((col >> 24) == 0)
        return;
    if (rounding > 0.0f)
    {
        PathRect(a, b, rounding, rounding_corners);
        PathFill(col);
    }
    else
    {
        PrimReserve(6, 4);
        PrimRect(a, b, col);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x1000000, %ecx        # imm = 0x1000000
jb 0x30174
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x3017d
movq %r12, %rsi
movq %r15, %rdx
movl %r8d, %ecx
callq 0x2fa0c
movq 0x78(%rbx), %rsi
movl 0x70(%rbx), %edx
movq %rbx, %rdi
movl %r14d, %ecx
movl $0x1, %r8d
callq 0x2ec54
movl 0x74(%rbx), %eax
testl %eax, %eax
jns 0x3016d
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
xorl %r15d, %r15d
testl %ecx, %ecx
cmovgl %ecx, %r15d
leaq (,%r15,8), %rdi
callq 0x85d9
movq %rax, %r14
movq 0x78(%rbx), %rsi
movslq 0x70(%rbx), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x78(%rbx), %rdi
callq 0x9065
movq %r14, 0x78(%rbx)
movl %r15d, 0x74(%rbx)
movl $0x0, 0x70(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x6, %esi
movl $0x4, %edx
callq 0x2def2
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %r14d, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2e036
nop
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddRectFilledMultiColor(ImVec2 const&, ImVec2 const&, unsigned int, unsigned int, unsigned int, unsigned int)
void ImDrawList::AddRectFilledMultiColor(const ImVec2& a, const ImVec2& c, ImU32 col_upr_left, ImU32 col_upr_right, ImU32 col_bot_right, ImU32 col_bot_left)
{
    if (((col_upr_left | col_upr_right | col_bot_right | col_bot_left) >> 24) == 0)
        return;

    const ImVec2 uv = GImGui->FontTexUvWhitePixel;
    PrimReserve(6, 4);
    PrimWriteIdx((ImDrawIdx)(_VtxCurrentIdx)); PrimWriteIdx((ImDrawIdx)(_VtxCurrentIdx+1)); PrimWriteIdx((ImDrawIdx)(_VtxCurrentIdx+2));
    PrimWriteIdx((ImDrawIdx)(_VtxCurrentIdx)); PrimWriteIdx((ImDrawIdx)(_VtxCurrentIdx+2)); PrimWriteIdx((ImDrawIdx)(_VtxCurrentIdx+3));
    PrimWriteVtx(a, uv, col_upr_left);
    PrimWriteVtx(ImVec2(c.x, a.y), uv, col_upr_right);
    PrimWriteVtx(c, uv, col_bot_right);
    PrimWriteVtx(ImVec2(a.x, c.y), uv, col_bot_left);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %eax
orl %ecx, %eax
orl %r9d, %eax
orl 0x10(%rbp), %eax
cmpl $0x1000000, %eax        # imm = 0x1000000
jb 0x302f5
movl %r9d, %r12d
movl %r8d, %r13d
movl %ecx, %r14d
movq %rdi, %rbx
leaq 0x252b0(%rip), %rax     # 0x55490
movq (%rax), %rax
movq 0x1720(%rax), %r15
movq %rsi, -0x30(%rbp)
movl $0x6, %esi
movq %rdx, -0x38(%rbp)
movl $0x4, %edx
callq 0x2def2
movl 0x38(%rbx), %eax
movq 0x48(%rbx), %rcx
movw %ax, (%rcx)
leaq 0x2(%rcx), %rdx
movq %rdx, 0x48(%rbx)
leal 0x1(%rax), %edx
movw %dx, 0x2(%rcx)
leaq 0x4(%rcx), %rdx
movq %rdx, 0x48(%rbx)
leal 0x2(%rax), %edx
movw %dx, 0x4(%rcx)
leaq 0x6(%rcx), %rsi
movq %rsi, 0x48(%rbx)
movw %ax, 0x6(%rcx)
leaq 0x8(%rcx), %rsi
movq %rsi, 0x48(%rbx)
movw %dx, 0x8(%rcx)
leaq 0xa(%rcx), %rdx
movq %rdx, 0x48(%rbx)
addl $0x3, %eax
movw %ax, 0xa(%rcx)
addq $0xc, %rcx
movq %rcx, 0x48(%rbx)
movq 0x40(%rbx), %rax
movq -0x30(%rbp), %rdi
movq (%rdi), %rcx
movq %rcx, (%rax)
movq 0x40(%rbx), %rax
movq %r15, 0x8(%rax)
movq 0x40(%rbx), %rax
movl %r14d, 0x10(%rax)
leaq 0x14(%rax), %rcx
movq %rcx, 0x40(%rbx)
incl 0x38(%rbx)
movq -0x38(%rbp), %rsi
movl (%rsi), %ecx
movl 0x4(%rdi), %edx
movl %ecx, 0x14(%rax)
movl %edx, 0x18(%rax)
movq 0x40(%rbx), %rax
movq %r15, 0x8(%rax)
movq 0x40(%rbx), %rax
movl %r13d, 0x10(%rax)
leaq 0x14(%rax), %rcx
movq %rcx, 0x40(%rbx)
incl 0x38(%rbx)
movq (%rsi), %rcx
movq %rcx, 0x14(%rax)
movq 0x40(%rbx), %rax
movq %r15, 0x8(%rax)
movq 0x40(%rbx), %rax
movl %r12d, 0x10(%rax)
leaq 0x14(%rax), %rcx
movq %rcx, 0x40(%rbx)
incl 0x38(%rbx)
movl (%rdi), %ecx
movl 0x4(%rsi), %edx
movl %ecx, 0x14(%rax)
movl %edx, 0x18(%rax)
movq 0x40(%rbx), %rax
movq %r15, 0x8(%rax)
movq 0x40(%rbx), %rax
movl 0x10(%rbp), %ecx
movl %ecx, 0x10(%rax)
addq $0x14, %rax
movq %rax, 0x40(%rbx)
incl 0x38(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddCircle(ImVec2 const&, float, unsigned int, int)
void ImDrawList::AddCircle(const ImVec2& centre, float radius, ImU32 col, int num_segments)
{
    if ((col >> 24) == 0)
        return;

    const float a_max = IM_PI*2.0f * ((float)num_segments - 1.0f) / (float)num_segments;
    PathArcTo(centre, radius, 0.0f, a_max, num_segments);
    PathStroke(col, true);
}

// Assembly:
cmpl $0x1000000, %edx        # imm = 0x1000000
jb 0x30601
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rdi, %rbx
cvtsi2ss %ecx, %xmm1
movss 0xce2c(%rip), %xmm2     # 0x3d38c
addss %xmm1, %xmm2
mulss 0xcedc(%rip), %xmm2     # 0x3d448
divss %xmm1, %xmm2
xorps %xmm1, %xmm1
movl %ecx, %edx
callq 0x2f290
movq 0x78(%rbx), %rsi
movl 0x70(%rbx), %edx
movss 0xcdf7(%rip), %xmm0     # 0x3d380
movq %rbx, %rdi
movl %r14d, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x2e1f4
movl 0x74(%rbx), %eax
testl %eax, %eax
jns 0x305f0
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
xorl %r15d, %r15d
testl %ecx, %ecx
cmovgl %ecx, %r15d
leaq (,%r15,8), %rdi
callq 0x85d9
movq %rax, %r14
movq 0x78(%rbx), %rsi
movslq 0x70(%rbx), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x78(%rbx), %rdi
callq 0x9065
movq %r14, 0x78(%rbx)
movl %r15d, 0x74(%rbx)
movl $0x0, 0x70(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddCircleFilled(ImVec2 const&, float, unsigned int, int)
void ImDrawList::AddCircleFilled(const ImVec2& centre, float radius, ImU32 col, int num_segments)
{
    if ((col >> 24) == 0)
        return;

    const float a_max = IM_PI*2.0f * ((float)num_segments - 1.0f) / (float)num_segments;
    PathArcTo(centre, radius, 0.0f, a_max, num_segments);
    PathFill(col);
}

// Assembly:
cmpl $0x1000000, %edx        # imm = 0x1000000
jb 0x306bd
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rdi, %rbx
cvtsi2ss %ecx, %xmm1
movss 0xcd62(%rip), %xmm2     # 0x3d38c
addss %xmm1, %xmm2
mulss 0xce12(%rip), %xmm2     # 0x3d448
divss %xmm1, %xmm2
xorps %xmm1, %xmm1
movl %ecx, %edx
callq 0x2f290
movq 0x78(%rbx), %rsi
movl 0x70(%rbx), %edx
movq %rbx, %rdi
movl %r14d, %ecx
movl $0x1, %r8d
callq 0x2ec54
movl 0x74(%rbx), %eax
testl %eax, %eax
jns 0x306ac
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
xorl %r15d, %r15d
testl %ecx, %ecx
cmovgl %ecx, %r15d
leaq (,%r15,8), %rdi
callq 0x85d9
movq %rax, %r14
movq 0x78(%rbx), %rsi
movslq 0x70(%rbx), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x78(%rbx), %rdi
callq 0x9065
movq %r14, 0x78(%rbx)
movl %r15d, 0x74(%rbx)
movl $0x0, 0x70(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddBezierCurve(ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int, float, int)
void ImDrawList::AddBezierCurve(const ImVec2& pos0, const ImVec2& cp0, const ImVec2& cp1, const ImVec2& pos1, ImU32 col, float thickness, int num_segments) 
{ 
    if ((col >> 24) == 0)
        return;

    PathLineTo(pos0); 
    PathBezierCurveTo(cp0, cp1, pos1, num_segments); 
    PathStroke(col, false, thickness); 
}

// Assembly:
cmpl $0x1000000, %r9d        # imm = 0x1000000
jb 0x3081d
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %r14d
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
movss %xmm0, -0x2c(%rbp)
movl 0x10(%rbp), %r9d
movl 0x70(%rdi), %r12d
movl 0x74(%rdi), %eax
cmpl %eax, %r12d
jne 0x3076f
incl %r12d
testl %eax, %eax
je 0x30711
movl %eax, %edx
shrl $0x1f, %edx
addl %eax, %edx
sarl %edx
addl %eax, %edx
jmp 0x30716
movl $0x8, %edx
cmpl %r12d, %edx
cmovgl %edx, %r12d
cmpl %r12d, %eax
jge 0x3076f
movslq %r12d, %rdi
shlq $0x3, %rdi
movq %r8, -0x48(%rbp)
movq %rcx, -0x40(%rbp)
callq 0x85d9
movq %rax, -0x38(%rbp)
movq 0x78(%rbx), %rsi
movslq 0x70(%rbx), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x78(%rbx), %rdi
callq 0x9065
movl 0x10(%rbp), %r9d
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %r8
movq -0x38(%rbp), %rax
movq %rax, 0x78(%rbx)
movl %r12d, 0x74(%rbx)
movq 0x78(%rbx), %rax
movslq 0x70(%rbx), %rsi
leal 0x1(%rsi), %edx
movl %edx, 0x70(%rbx)
movq (%r15), %rdx
movq %rdx, (%rax,%rsi,8)
movq %rbx, %rdi
movq %r13, %rsi
movq %rcx, %rdx
movq %r8, %rcx
movl %r9d, %r8d
callq 0x2f4d8
movq 0x78(%rbx), %rsi
movl 0x70(%rbx), %edx
xorl %r15d, %r15d
movq %rbx, %rdi
movl %r14d, %ecx
xorl %r8d, %r8d
movss -0x2c(%rbp), %xmm0
movl $0x1, %r9d
callq 0x2e1f4
movl 0x74(%rbx), %eax
testl %eax, %eax
jns 0x30808
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
testl %ecx, %ecx
cmovgl %ecx, %r15d
leaq (,%r15,8), %rdi
callq 0x85d9
movq %rax, %r14
movq 0x78(%rbx), %rsi
movslq 0x70(%rbx), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x78(%rbx), %rdi
callq 0x9065
movq %r14, 0x78(%rbx)
movl %r15d, 0x74(%rbx)
movl $0x0, 0x70(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawList::AddImage(void*, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int)
void ImDrawList::AddImage(ImTextureID user_texture_id, const ImVec2& a, const ImVec2& b, const ImVec2& uv0, const ImVec2& uv1, ImU32 col)
{
    if ((col >> 24) == 0)
        return;

    // FIXME-OPT: This is wasting draw calls.
    const bool push_texture_id = _TextureIdStack.empty() || user_texture_id != _TextureIdStack.back();
    if (push_texture_id)
        PushTextureID(user_texture_id);

    PrimReserve(6, 4);
    PrimRectUV(a, b, uv0, uv1, col);

    if (push_texture_id)
        PopTextureID();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0x10(%rbp), %r15d
movq %rsi, -0x38(%rbp)
cmpl $0x1000000, %r15d       # imm = 0x1000000
jae 0x311e3
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %rbx
movq %rdi, %r12
movq %r9, -0x30(%rbp)
movl 0x60(%rdi), %eax
testq %rax, %rax
je 0x3120f
testl %eax, %eax
jle 0x31293
movq 0x68(%r12), %rcx
cmpq %rsi, -0x8(%rcx,%rax,8)
je 0x3125b
leaq -0x38(%rbp), %rsi
movq %r12, %rdi
callq 0x2d60a
movq %r12, %rdi
movl $0x6, %esi
movl $0x4, %edx
callq 0x2def2
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r14, %rcx
movq -0x30(%rbp), %r8
movl %r15d, %r9d
callq 0x2e102
movq %r12, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2d6a6
movq %r12, %rdi
movl $0x6, %esi
movl $0x4, %edx
callq 0x2def2
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r14, %rcx
movq -0x30(%rbp), %r8
movl %r15d, %r9d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2e102
leaq 0x1591b(%rip), %rdi     # 0x46bb5
leaq 0xd7f2(%rip), %rsi      # 0x3ea93
leaq 0x160cf(%rip), %rcx     # 0x47377
movl $0x326, %edx            # imm = 0x326
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImDrawData::ScaleClipRects(ImVec2 const&)
void ImDrawData::ScaleClipRects(const ImVec2& scale)
{
    for (int i = 0; i < CmdListsCount; i++)
    {
        ImDrawList* cmd_list = CmdLists[i];
        for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++)
        {
            ImDrawCmd* cmd = &cmd_list->CmdBuffer[cmd_i];
            cmd->ClipRect = ImVec4(cmd->ClipRect.x * scale.x, cmd->ClipRect.y * scale.y, cmd->ClipRect.z * scale.x, cmd->ClipRect.w * scale.y);
        }
    }
}

// Assembly:
movslq 0x10(%rdi), %rax
testq %rax, %rax
jle 0x31531
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rdi
movslq (%rdi), %r8
testq %r8, %r8
jle 0x31528
movq 0x8(%rdi), %rdi
shlq $0x4, %r8
leaq (%r8,%r8,2), %r8
xorl %r9d, %r9d
movss (%rsi), %xmm0
movss 0x4(%rsi), %xmm1
movss 0x4(%rdi,%r9), %xmm2
mulss %xmm0, %xmm2
movss 0x8(%rdi,%r9), %xmm3
mulss %xmm1, %xmm3
mulss 0xc(%rdi,%r9), %xmm0
mulss 0x10(%rdi,%r9), %xmm1
movss %xmm2, 0x4(%rdi,%r9)
movss %xmm3, 0x8(%rdi,%r9)
movss %xmm0, 0xc(%rdi,%r9)
movss %xmm1, 0x10(%rdi,%r9)
addq $0x30, %r9
cmpq %r9, %r8
jne 0x314d6
incq %rdx
cmpq %rax, %rdx
jne 0x314bb
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImFontConfig::ImFontConfig()
ImFontConfig::ImFontConfig()
{
    FontData = NULL;
    FontDataSize = 0;
    FontDataOwnedByAtlas = true;
    FontNo = 0;
    SizePixels = 0.0f;
    OversampleH = 3;
    OversampleV = 1;
    PixelSnapH = false;
    GlyphExtraSpacing = ImVec2(0.0f, 0.0f);
    GlyphRanges = NULL;
    MergeMode = false;
    MergeGlyphCenterV = false;
    DstFont = NULL;
    memset(Name, 0, sizeof(Name));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movq %rax, 0x24(%rdi)
movq %rax, (%rdi)
movl %eax, 0x8(%rdi)
movb $0x1, 0xc(%rdi)
movaps 0x11313(%rip), %xmm0    # 0x42860
movups %xmm0, 0x10(%rdi)
movb $0x0, 0x20(%rdi)
movl %eax, 0x24(%rdi)
movq %rax, 0x60(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x4a(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImFontAtlas::ClearInputData()
void    ImFontAtlas::ClearInputData()
{
    for (int i = 0; i < ConfigData.Size; i++)
        if (ConfigData[i].FontData && ConfigData[i].FontDataOwnedByAtlas)
        {
            ImGui::MemFree(ConfigData[i].FontData);
            ConfigData[i].FontData = NULL;
        }

    // When clearing this we lose access to the font name and other information used to build the font.
    for (int i = 0; i < Fonts.Size; i++)
        if (Fonts[i]->ConfigData >= ConfigData.Data && Fonts[i]->ConfigData < ConfigData.Data + ConfigData.Size)
        {
            Fonts[i]->ConfigData = NULL;
            Fonts[i]->ConfigDataCount = 0;
        }
    ConfigData.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x40(%rdi), %esi
testl %esi, %esi
jle 0x3164d
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x48(%rbx), %rax
movq (%rax,%r14), %rdi
testq %rdi, %rdi
je 0x3163d
cmpb $0x1, 0xc(%rax,%r14)
jne 0x3163d
callq 0x9065
movslq 0x40(%rbx), %rax
cmpq %rax, %r15
jge 0x316bc
movq 0x48(%rbx), %rax
movq $0x0, (%rax,%r14)
incq %r15
movslq 0x40(%rbx), %rsi
addq $0x68, %r14
cmpq %rsi, %r15
jl 0x3160a
movslq 0x30(%rbx), %rax
testq %rax, %rax
jle 0x31698
movq 0x38(%rbx), %rcx
movq 0x48(%rbx), %rdx
movslq %esi, %rsi
imulq $0x68, %rsi, %rsi
addq %rdx, %rsi
xorl %edi, %edi
movq (%rcx,%rdi,8), %r8
movq 0x18(%r8), %r9
cmpq %rdx, %r9
jb 0x31690
cmpq %rsi, %r9
jae 0x31690
movq $0x0, 0x18(%r8)
movq (%rcx,%rdi,8), %r8
movl $0x0, 0x20(%r8)
incq %rdi
cmpq %rdi, %rax
jne 0x3166a
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x316b1
xorl %r14d, %r14d
movq %r14, 0x40(%rbx)
callq 0x9065
movq %r14, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd6ed(%rip), %rdi      # 0x3edb0
leaq 0xd3c9(%rip), %rsi      # 0x3ea93
leaq 0x15d0a(%rip), %rcx     # 0x473db
movl $0x31c, %edx            # imm = 0x31C
callq 0x7140
nop
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImFontAtlas::ClearTexData()
void    ImFontAtlas::ClearTexData()
{
    if (TexPixelsAlpha8)
        ImGui::MemFree(TexPixelsAlpha8);
    if (TexPixelsRGBA32)
        ImGui::MemFree(TexPixelsRGBA32);
    TexPixelsAlpha8 = NULL;
    TexPixelsRGBA32 = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x316f3
callq 0x9065
movq 0x10(%rbx), %rdi
addq $0x8, %rbx
testq %rdi, %rdi
je 0x31705
callq 0x9065
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImFontAtlas::ClearFonts()
void    ImFontAtlas::ClearFonts()
{
    for (int i = 0; i < Fonts.Size; i++)
    {
        Fonts[i]->~ImFont();
        ImGui::MemFree(Fonts[i]);
    }
    Fonts.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x30(%rdi)
jle 0x31754
xorl %r14d, %r14d
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x35b36
movslq 0x30(%rbx), %rax
cmpq %rax, %r14
jge 0x31772
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x9065
incq %r14
movslq 0x30(%rbx), %rax
cmpq %rax, %r14
jl 0x31725
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x3176d
xorl %r14d, %r14d
movq %r14, 0x30(%rbx)
callq 0x9065
movq %r14, 0x38(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xd637(%rip), %rdi      # 0x3edb0
leaq 0xd313(%rip), %rsi      # 0x3ea93
leaq 0xdad2(%rip), %rcx      # 0x3f259
movl $0x31c, %edx            # imm = 0x31C
callq 0x7140
nop
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImFontAtlas::AddFontDefault(ImFontConfig const*)
ImFont* ImFontAtlas::AddFontDefault(const ImFontConfig* font_cfg_template)
{
    ImFontConfig font_cfg = font_cfg_template ? *font_cfg_template : ImFontConfig();
    if (!font_cfg_template)
    {
        font_cfg.OversampleH = font_cfg.OversampleV = 1;
        font_cfg.PixelSnapH = true;
    }
    if (font_cfg.Name[0] == '\0') strcpy(font_cfg.Name, "<default>");

    const char* ttf_compressed_base85 = GetDefaultCompressedFontDataTTFBase85();
    ImFont* font = AddFontFromMemoryCompressedBase85TTF(ttf_compressed_base85, 13.0f, &font_cfg, GetGlyphRangesDefault());
    return font;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, %rdx
movq %rdi, %rax
testq %rsi, %rsi
je 0x3182e
leaq -0x68(%rbp), %rdi
movl $0xd, %ecx
movq %rdx, %rsi
rep  movsq (%rsi), %es:(%rdi)
jmp 0x31864
xorl %ecx, %ecx
movq %rcx, -0x44(%rbp)
movq %rcx, -0x68(%rbp)
movl %ecx, -0x60(%rbp)
movb $0x1, -0x5c(%rbp)
movaps 0x1101a(%rip), %xmm0    # 0x42860
movups %xmm0, -0x58(%rbp)
movb $0x0, -0x48(%rbp)
movl %ecx, -0x44(%rbp)
movq %rcx, -0x8(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, -0x38(%rbp)
movups %xmm0, -0x28(%rbp)
movups %xmm0, -0x1e(%rbp)
testq %rdx, %rdx
jne 0x3187b
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, -0x50(%rbp)
movb $0x1, -0x48(%rbp)
cmpb $0x0, -0x2e(%rbp)
jne 0x31898
leaq -0x2e(%rbp), %rcx
movabsq $0x746c75616665643c, %rdx # imm = 0x746C75616665643C
movq %rdx, (%rcx)
movw $0x3e, 0x8(%rcx)
leaq 0x12051(%rip), %rsi     # 0x438f0
leaq 0x110b6(%rip), %rcx     # 0x4295c
movss 0x10f9a(%rip), %xmm0    # 0x42848
leaq -0x68(%rbp), %rdx
movq %rax, %rdi
callq 0x3479c
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImFontAtlas::GetTexDataAsRGBA32(unsigned char**, int*, int*, int*)
void    ImFontAtlas::GetTexDataAsRGBA32(unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel)
{
    // Convert to RGBA32 format on demand
    // Although it is likely to be the most commonly used format, our font rendering is 1 channel / 8 bpp
    if (!TexPixelsRGBA32)
    {
        unsigned char* pixels;
        GetTexDataAsAlpha8(&pixels, NULL, NULL);
        TexPixelsRGBA32 = (unsigned int*)ImGui::MemAlloc((size_t)(TexWidth * TexHeight * 4));
        const unsigned char* src = pixels;
        unsigned int* dst = TexPixelsRGBA32;
        for (int n = TexWidth * TexHeight; n > 0; n--)
            *dst++ = ((unsigned int)(*src++) << 24) | 0x00FFFFFF;
    }

    *out_pixels = (unsigned char*)TexPixelsRGBA32;
    if (out_width) *out_width = TexWidth;
    if (out_height) *out_height = TexHeight;
    if (out_bytes_per_pixel) *out_bytes_per_pixel = 4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
cmpq $0x0, 0x10(%rdi)
jne 0x34518
leaq -0x30(%rbp), %rsi
movq %r15, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x31792
movl 0x18(%r15), %eax
imull 0x1c(%r15), %eax
shll $0x2, %eax
movslq %eax, %rdi
callq 0x85d9
movq %rax, 0x10(%r15)
movl 0x1c(%r15), %ecx
imull 0x18(%r15), %ecx
testl %ecx, %ecx
jle 0x34518
movq -0x30(%rbp), %rdx
incl %ecx
xorl %esi, %esi
movzbl (%rdx,%rsi), %edi
shll $0x18, %edi
orl $0xffffff, %edi         # imm = 0xFFFFFF
movl %edi, (%rax,%rsi,4)
decl %ecx
incq %rsi
cmpl $0x1, %ecx
jg 0x344fe
movq 0x10(%r15), %rax
movq %rax, (%r13)
testq %r12, %r12
je 0x3452d
movl 0x18(%r15), %eax
movl %eax, (%r12)
testq %r14, %r14
je 0x34539
movl 0x1c(%r15), %eax
movl %eax, (%r14)
testq %rbx, %rbx
je 0x34544
movl $0x4, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImFontAtlas::AddFontFromMemoryCompressedBase85TTF(char const*, float, ImFontConfig const*, unsigned short const*)
ImFont* ImFontAtlas::AddFontFromMemoryCompressedBase85TTF(const char* compressed_ttf_data_base85, float size_pixels, const ImFontConfig* font_cfg, const ImWchar* glyph_ranges)
{
    int compressed_ttf_size = (((int)strlen(compressed_ttf_data_base85) + 4) / 5) * 4;
    void* compressed_ttf = ImGui::MemAlloc(compressed_ttf_size);
    Decode85((const unsigned char*)compressed_ttf_data_base85, (unsigned int*)compressed_ttf);
    ImFont* font = AddFontFromMemoryCompressedTTF(compressed_ttf, compressed_ttf_size, size_pixels, font_cfg, glyph_ranges);
    ImGui::MemFree(compressed_ttf);
    return font;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, -0x38(%rbp)
movq %rdx, %r14
movss %xmm0, -0x2c(%rbp)
movq %rsi, %r12
movq %rdi, %r15
movq %rsi, %rdi
callq 0x72f0
addl $0x4, %eax
cltq
imulq $0x66666667, %rax, %r13 # imm = 0x66666667
movq %r13, %rax
shrq $0x3f, %rax
shrq $0x21, %r13
addl %eax, %r13d
shll $0x2, %r13d
movslq %r13d, %rdi
callq 0x85d9
movq %rax, %rbx
movb (%r12), %cl
testb %cl, %cl
je 0x34894
addq $0x5, %r12
movq %rbx, %rax
movsbl %cl, %edx
xorl %ecx, %ecx
cmpb $0x5c, %dl
setge %cl
xorl $-0x23, %ecx
addl %edx, %ecx
movsbl -0x4(%r12), %esi
xorl %edx, %edx
cmpl $0x5c, %esi
setge %dl
xorl $-0x23, %edx
addl %esi, %edx
movsbl -0x3(%r12), %edi
xorl %esi, %esi
cmpl $0x5c, %edi
setge %sil
xorl $-0x23, %esi
addl %edi, %esi
movsbl -0x2(%r12), %edi
xorl %r8d, %r8d
cmpl $0x5c, %edi
setge %r8b
xorl $-0x23, %r8d
addl %edi, %r8d
movsbl -0x1(%r12), %edi
xorl %r9d, %r9d
cmpl $0x5c, %edi
setge %r9b
xorl $-0x23, %r9d
addl %edi, %r9d
imull $0x55, %r9d, %edi
addl %r8d, %edi
imull $0x55, %edi, %edi
addl %esi, %edi
imull $0x55, %edi, %esi
addl %edx, %esi
imull $0x55, %esi, %edx
addl %ecx, %edx
movl %edx, (%rax)
addq $0x4, %rax
movb (%r12), %cl
addq $0x5, %r12
testb %cl, %cl
jne 0x34803
movq %r15, %rdi
movq %rbx, %rsi
movl %r13d, %edx
movss -0x2c(%rbp), %xmm0
movq %r14, %rcx
movq -0x38(%rbp), %r8
callq 0x34ab8
movq %rax, %r14
movq %rbx, %rdi
callq 0x9065
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImFontAtlas::AddFontFromFileTTF(char const*, float, ImFontConfig const*, unsigned short const*)
ImFont* ImFontAtlas::AddFontFromFileTTF(const char* filename, float size_pixels, const ImFontConfig* font_cfg_template, const ImWchar* glyph_ranges)
{
    int data_size = 0;
    void* data = ImLoadFileToMemory(filename, "rb", &data_size, 0);
    if (!data)
    {
        IM_ASSERT(0); // Could not load file.
        return NULL;
    }
    ImFontConfig font_cfg = font_cfg_template ? *font_cfg_template : ImFontConfig();
    if (font_cfg.Name[0] == '\0')
    {
        // Store a short copy of filename into into the font name for convenience
        const char* p;
        for (p = filename + strlen(filename); p > filename && p[-1] != '/' && p[-1] != '\\'; p--) {}
        snprintf(font_cfg.Name, IM_ARRAYSIZE(font_cfg.Name), "%s", p);
    }
    return AddFontFromMemoryTTF(data, data_size, size_pixels, &font_cfg, glyph_ranges);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %rbx
movq %rdx, %r13
movss %xmm0, -0x2c(%rbp)
movq %rsi, %r12
movq %rdi, %r14
leaq -0x30(%rbp), %rdx
movl $0x0, (%rdx)
leaq 0xa161(%rip), %rsi      # 0x3ea6e
movq %r12, %rdi
xorl %ecx, %ecx
callq 0x8f24
testq %rax, %rax
je 0x349ef
movq %rax, %r15
testq %r13, %r13
je 0x3493c
leaq -0x98(%rbp), %rdi
movl $0xd, %ecx
movq %r13, %rsi
rep  movsq (%rsi), %es:(%rdi)
jmp 0x3497e
xorl %eax, %eax
movq %rax, -0x74(%rbp)
movq %rax, -0x98(%rbp)
movl %eax, -0x90(%rbp)
movb $0x1, -0x8c(%rbp)
movaps 0xdf03(%rip), %xmm0     # 0x42860
movups %xmm0, -0x88(%rbp)
movb $0x0, -0x78(%rbp)
movl %eax, -0x74(%rbp)
movq %rax, -0x38(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, -0x68(%rbp)
movups %xmm0, -0x58(%rbp)
movups %xmm0, -0x4e(%rbp)
cmpb $0x0, -0x5e(%rbp)
jne 0x349c3
leaq -0x5e(%rbp), %r13
movq %r12, %rdi
callq 0x72f0
addq %r12, %rax
movq %rax, %rcx
cmpq %r12, %rax
jbe 0x349ad
movzbl -0x1(%rcx), %edx
cmpl $0x5c, %edx
je 0x349ad
leaq -0x1(%rcx), %rax
cmpl $0x2f, %edx
jne 0x34993
leaq 0xdafc(%rip), %rdx      # 0x424b0
movl $0x20, %esi
movq %r13, %rdi
xorl %eax, %eax
callq 0x73e0
movl -0x30(%rbp), %edx
leaq -0x98(%rbp), %rcx
movq %r14, %rdi
movq %r15, %rsi
movss -0x2c(%rbp), %xmm0
movq %rbx, %r8
callq 0x34a0e
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa21c(%rip), %rdi      # 0x3ec12
leaq 0x11e19(%rip), %rsi     # 0x46816
leaq 0x1204c(%rip), %rcx     # 0x46a50
movl $0x452, %edx            # imm = 0x452
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImFontAtlas::AddFontFromMemoryTTF(void*, int, float, ImFontConfig const*, unsigned short const*)
ImFont* ImFontAtlas::AddFontFromMemoryTTF(void* ttf_data, int ttf_size, float size_pixels, const ImFontConfig* font_cfg_template, const ImWchar* glyph_ranges)
{
    ImFontConfig font_cfg = font_cfg_template ? *font_cfg_template : ImFontConfig();
    IM_ASSERT(font_cfg.FontData == NULL);
    font_cfg.FontData = ttf_data;
    font_cfg.FontDataSize = ttf_size;
    font_cfg.SizePixels = size_pixels;
    if (glyph_ranges)
        font_cfg.GlyphRanges = glyph_ranges;
    return AddFont(&font_cfg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, %r9
movq %rdi, %rax
testq %rcx, %rcx
je 0x34a35
movq %rcx, %r10
leaq -0x68(%rbp), %rdi
movl $0xd, %ecx
movq %r10, %rsi
rep  movsq (%rsi), %es:(%rdi)
jmp 0x34a6b
xorl %ecx, %ecx
movq %rcx, -0x44(%rbp)
movq %rcx, -0x68(%rbp)
movl %ecx, -0x60(%rbp)
movb $0x1, -0x5c(%rbp)
movaps 0xde13(%rip), %xmm1     # 0x42860
movups %xmm1, -0x58(%rbp)
movb $0x0, -0x48(%rbp)
movl %ecx, -0x44(%rbp)
movq %rcx, -0x8(%rbp)
xorps %xmm1, %xmm1
movups %xmm1, -0x38(%rbp)
movups %xmm1, -0x28(%rbp)
movups %xmm1, -0x1e(%rbp)
cmpq $0x0, -0x68(%rbp)
jne 0x34a99
movq %r9, -0x68(%rbp)
movl %edx, -0x60(%rbp)
movss %xmm0, -0x54(%rbp)
testq %r8, %r8
je 0x34a87
movq %r8, -0x38(%rbp)
leaq -0x68(%rbp), %rsi
movq %rax, %rdi
callq 0x34554
addq $0x70, %rsp
popq %rbp
retq
leaq 0x12014(%rip), %rdi     # 0x46ab4
leaq 0x11d6f(%rip), %rsi     # 0x46816
leaq 0x12022(%rip), %rcx     # 0x46ad0
movl $0x464, %edx            # imm = 0x464
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/stb_truetype.h
// Function: stbtt_PackSetOversampling(stbtt_pack_context*, unsigned int, unsigned int)
STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsigned int h_oversample, unsigned int v_oversample)
{
   STBTT_assert(h_oversample <= STBTT_MAX_OVERSAMPLE);
   STBTT_assert(v_oversample <= STBTT_MAX_OVERSAMPLE);
   if (h_oversample <= STBTT_MAX_OVERSAMPLE)
      spc->h_oversample = h_oversample;
   if (v_oversample <= STBTT_MAX_OVERSAMPLE)
      spc->v_oversample = v_oversample;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x9, %esi
jae 0x35128
cmpl $0x9, %edx
jae 0x35147
movl %esi, 0x20(%rdi)
movl %edx, 0x24(%rdi)
popq %rbp
retq
leaq 0x11c24(%rip), %rdi     # 0x46d53
leaq 0x11c2f(%rip), %rsi     # 0x46d65
leaq 0x11c3f(%rip), %rcx     # 0x46d7c
movl $0xa79, %edx            # imm = 0xA79
callq 0x7140
leaq 0x11c7f(%rip), %rdi     # 0x46dcd
leaq 0x11c10(%rip), %rsi     # 0x46d65
leaq 0x11c20(%rip), %rcx     # 0x46d7c
movl $0xa7a, %edx            # imm = 0xA7A
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImFont::FindGlyph(unsigned short) const
const ImFont::Glyph* ImFont::FindGlyph(unsigned short c) const
{
    if (c < IndexLookup.Size)
    {
        const int i = IndexLookup[c];
        if (i != -1)
            return &Glyphs[i];
    }
    return FallbackGlyph;
}

// Assembly:
cmpl %esi, 0x68(%rdi)
jle 0x355b1
movq 0x70(%rdi), %rax
movzwl %si, %ecx
movslq (%rax,%rcx,4), %rcx
cmpq $-0x1, %rcx
je 0x355ab
cmpl %ecx, 0x38(%rdi)
jle 0x355b6
leaq (%rcx,%rcx,4), %rax
shlq $0x3, %rax
addq 0x40(%rdi), %rax
jmp 0x355ab
cmpl $-0x1, %ecx
je 0x355b1
retq
movq 0x48(%rdi), %rax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x97ef(%rip), %rdi      # 0x3edb0
leaq 0x94cb(%rip), %rsi      # 0x3ea93
leaq 0x11f92(%rip), %rcx     # 0x47561
movl $0x31d, %edx            # imm = 0x31D
callq 0x7140
nop
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: ImFont::Clear()
void    ImFont::Clear()
{
    FontSize = 0.0f;
    DisplayOffset = ImVec2(0.0f, 1.0f);
    ConfigData = NULL;
    ConfigDataCount = 0;
    Ascent = Descent = 0.0f;
    ContainerAtlas = NULL;
    Glyphs.clear();
    FallbackGlyph = NULL;
    FallbackXAdvance = 0.0f;
    IndexXAdvance.clear();
    IndexLookup.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, (%rdi)
movabsq $0x3f80000000000000, %rcx # imm = 0x3F80000000000000
movq %rcx, 0x8(%rdi)
movq $0x0, 0x30(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movl %eax, 0x28(%rdi)
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x35aef
xorl %r14d, %r14d
movq %r14, 0x38(%rbx)
callq 0x9065
movq %r14, 0x40(%rbx)
movq $0x0, 0x48(%rbx)
movl $0x0, 0x50(%rbx)
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x35b17
xorl %r14d, %r14d
movq %r14, 0x58(%rbx)
callq 0x9065
movq %r14, 0x60(%rbx)
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x35b30
xorl %r14d, %r14d
movq %r14, 0x68(%rbx)
callq 0x9065
movq %r14, 0x70(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: stb__match(unsigned char*, unsigned int)
static void stb__match(unsigned char *data, unsigned int length)
{
    // INVERSE of memmove... write each byte before copying the next...
    IM_ASSERT (stb__dout + length <= stb__barrier);
    if (stb__dout + length > stb__barrier) { stb__dout += length; return; }
    if (data < stb__barrier4) { stb__dout = stb__barrier+1; return; }
    while (length--) *stb__dout++ = *data++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, %ecx
movq 0x2893d(%rip), %rdx     # 0x5fdb0
addq %rcx, %rdx
movq 0x28923(%rip), %rax     # 0x5fda0
cmpq %rax, %rdx
ja 0x374b8
cmpq %rdi, 0x2891f(%rip)     # 0x5fda8
jbe 0x37490
incq %rax
jmp 0x374af
testl %esi, %esi
je 0x374b6
movq 0x28915(%rip), %rax     # 0x5fdb0
xorl %edx, %edx
movb (%rdi,%rdx), %sil
movb %sil, (%rax,%rdx)
incq %rdx
cmpl %edx, %ecx
jne 0x3749d
addq %rdx, %rax
movq %rax, 0x288fa(%rip)     # 0x5fdb0
popq %rbp
retq
leaq 0xfdf0(%rip), %rdi      # 0x472af
leaq 0xf350(%rip), %rsi      # 0x46816
leaq 0xfe05(%rip), %rcx      # 0x472d2
movl $0x7e3, %edx            # imm = 0x7E3
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_draw.cpp
// Function: stb__lit(unsigned char*, unsigned int)
static void stb__lit(unsigned char *data, unsigned int length)
{
    IM_ASSERT (stb__dout + length <= stb__barrier);
    if (stb__dout + length > stb__barrier) { stb__dout += length; return; }
    if (data < stb__barrier2) { stb__dout = stb__barrier+1; return; }
    memcpy(stb__dout, data, length);
    stb__dout += length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rax
movq 0x288c9(%rip), %rdi     # 0x5fdb0
movl %esi, %edx
leaq (%rdi,%rdx), %rbx
movq 0x288ac(%rip), %rcx     # 0x5fda0
cmpq %rcx, %rbx
ja 0x37520
cmpq %rax, 0x28890(%rip)     # 0x5fd90
jbe 0x3750a
incq %rcx
movq %rcx, %rbx
jmp 0x37512
movq %rax, %rsi
callq 0x7080
movq %rbx, 0x28897(%rip)     # 0x5fdb0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xfd88(%rip), %rdi      # 0x472af
leaq 0xf2e8(%rip), %rsi      # 0x46816
leaq 0xfdcc(%rip), %rcx      # 0x47301
movl $0x7eb, %edx            # imm = 0x7EB
callq 0x7140
nop
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_impl_sdl.cpp
// Function: ImGui_ImplSdl_ProcessEvent(SDL_Event*)
bool ImGui_ImplSdl_ProcessEvent(SDL_Event* event)
{
    ImGuiIO& io = ImGui::GetIO();
    switch (event->type)
    {
    case SDL_MOUSEWHEEL:
        {
            if (event->wheel.y > 0)
                g_MouseWheel = 1;
            if (event->wheel.y < 0)
                g_MouseWheel = -1;
            return true;
        }
    case SDL_MOUSEBUTTONDOWN:
        {
            if (event->button.button == SDL_BUTTON_LEFT) g_MousePressed[0] = true;
            if (event->button.button == SDL_BUTTON_RIGHT) g_MousePressed[1] = true;
            if (event->button.button == SDL_BUTTON_MIDDLE) g_MousePressed[2] = true;
            return true;
        }
    case SDL_TEXTINPUT:
        {
            ImGuiIO& io = ImGui::GetIO();
            io.AddInputCharactersUTF8(event->text.text);
            return true;
        }
    case SDL_KEYDOWN:
    case SDL_KEYUP:
        {
            int key = event->key.keysym.sym & ~SDLK_SCANCODE_MASK;
            io.KeysDown[key] = (event->type == SDL_KEYDOWN);
            io.KeyShift = ((SDL_GetModState() & KMOD_SHIFT) != 0);
            io.KeyCtrl = ((SDL_GetModState() & KMOD_CTRL) != 0);
            io.KeyAlt = ((SDL_GetModState() & KMOD_ALT) != 0);
            return true;
        }
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0xb1e1
movq %rax, %r14
movl (%rbx), %ecx
xorl %eax, %eax
cmpl $0x400, %ecx            # imm = 0x400
jg 0x379b2
leal -0x300(%rcx), %edx
cmpl $0x2, %edx
jae 0x379e4
movslq 0x14(%rbx), %rax
andq $-0x40000001, %rax      # imm = 0xBFFFFFFF
cmpl $0x300, %ecx            # imm = 0x300
sete 0x100(%r14,%rax)
callq 0x76e0
testb $0x3, %al
setne 0xfe(%r14)
callq 0x76e0
testb $-0x40, %al
setne 0xfd(%r14)
callq 0x76e0
testl $0x300, %eax            # imm = 0x300
setne 0xff(%r14)
jmp 0x37a00
cmpl $0x401, %ecx            # imm = 0x401
je 0x37a07
cmpl $0x403, %ecx            # imm = 0x403
jne 0x37a02
movl 0x14(%rbx), %ecx
movb $0x1, %al
testl %ecx, %ecx
je 0x37a02
shrl $0x1f, %ecx
leaq 0x105bb(%rip), %rdx     # 0x47f90
movss (%rdx,%rcx,4), %xmm0
movss %xmm0, 0x283f6(%rip)    # 0x5fdd8
jmp 0x37a02
cmpl $0x303, %ecx            # imm = 0x303
jne 0x37a02
callq 0xb1e1
addq $0xc, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x82a2
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
movzbl 0x10(%rbx), %ecx
movb $0x1, %al
cmpl $0x3, %ecx
je 0x37a2e
cmpl $0x2, %ecx
je 0x37a25
cmpl $0x1, %ecx
jne 0x37a02
movb $0x1, 0x283b9(%rip)     # 0x5fddc
jmp 0x37a02
movb $0x1, 0x283b2(%rip)     # 0x5fdde
jmp 0x37a02
movb $0x1, 0x283a8(%rip)     # 0x5fddd
jmp 0x37a02
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/./imgui/imgui_impl_sdl.cpp
// Function: ImGui_ImplSdl_InvalidateDeviceObjects()
void ImGui_ImplSdl_InvalidateDeviceObjects()
{
    if (g_VboHandle) glDeleteBuffers(1, &g_VboHandle);
    if (g_ElementsHandle) glDeleteBuffers(1, &g_ElementsHandle);

    glDetachShader(g_ShaderHandle, g_VertHandle);
    glDeleteShader(g_VertHandle);
    g_VertHandle = 0;

    glDetachShader(g_ShaderHandle, g_FragHandle);
    glDeleteShader(g_FragHandle);
    g_FragHandle = 0;

    glDeleteProgram(g_ShaderHandle);
    g_ShaderHandle = 0;

    if (g_FontTexture)
    {
        glDeleteTextures(1, &g_FontTexture);
        ImGui::GetIO().Fonts->TexID = 0;
        g_FontTexture = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpl $0x0, 0x2810d(%rip)     # 0x5fdc4
je 0x37cca
leaq 0x28104(%rip), %rsi     # 0x5fdc4
movl $0x1, %edi
callq 0x7850
cmpl $0x0, 0x28103(%rip)     # 0x5fdd4
je 0x37ce4
leaq 0x280fa(%rip), %rsi     # 0x5fdd4
movl $0x1, %edi
callq 0x7850
movl 0x280ce(%rip), %edi     # 0x5fdb8
movl 0x280f0(%rip), %esi     # 0x5fde0
callq 0x7390
movl 0x280e5(%rip), %edi     # 0x5fde0
callq 0x7840
xorl %ebx, %ebx
movl %ebx, 0x280d8(%rip)     # 0x5fde0
movl 0x280aa(%rip), %edi     # 0x5fdb8
movl 0x280d0(%rip), %esi     # 0x5fde4
callq 0x7390
movl 0x280c5(%rip), %edi     # 0x5fde4
callq 0x7840
movl %ebx, 0x280ba(%rip)     # 0x5fde4
movl 0x28088(%rip), %edi     # 0x5fdb8
callq 0x7610
movl %ebx, 0x2807d(%rip)     # 0x5fdb8
cmpl %ebx, 0x280a7(%rip)     # 0x5fde8
je 0x37d71
leaq 0x2809e(%rip), %rsi     # 0x5fde8
movl $0x1, %edi
callq 0x77c0
callq 0xb1e1
movq 0x88(%rax), %rax
movq $0x0, (%rax)
movl $0x0, 0x28077(%rip)     # 0x5fde8
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/donfreiday[P]gb/joypad.cpp
// Function: Joypad::read(unsigned char)
u8 Joypad::read(u8 request) {
  // Directions
  if (!bitTest(request, 5)) {
    return directions;
  }

  // Buttons
  else if (!bitTest(request, 4)) {
    return buttons;
  }

  return 0xFF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testb $0x20, %sil
jne 0x3810b
movb 0x1(%rdi), %al
jmp 0x38116
andl $0x10, %esi
xorl %eax, %eax
negl %esi
sbbl %eax, %eax
orb (%rdi), %al
popq %rbp
retq