LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::CalcTextSize(char const*, char const*, bool, float)
ImVec2 ImGui::CalcTextSize(const char* text, const char* text_end, bool hide_text_after_double_hash, float wrap_width)
{
    ImGuiState& g = *GImGui;

    const char* text_display_end;
    if (hide_text_after_double_hash)
        text_display_end = FindTextDisplayEnd(text, text_end);      // Hide anything after a '##' string
    else
        text_display_end = text_end;

    ImFont* font = g.Font;
    const float font_size = g.FontSize;
    ImVec2 text_size = font->CalcTextSizeA(font_size, FLT_MAX, wrap_width, text, text_display_end, NULL);

    // Cancel out character spacing for the last character of a line (it is baked into glyph->XAdvance field)
    const float font_scale = font_size / font->FontSize;
    const float character_spacing_x = 1.0f * font_scale;
    if (text_size.x > 0.0f)
        text_size.x -= character_spacing_x;

    return text_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movaps %xmm0, %xmm2
movq %rsi, %rax
movq %rdi, %rbx
movq 0x46f61(%rip), %r15     # 0x55480
testl %edx, %edx
je 0xe538
movq %rbx, %rdi
movq %rax, %rsi
movss %xmm2, -0x1c(%rbp)
callq 0xdfc4
movss -0x1c(%rbp), %xmm2
movq 0x1710(%r15), %r14
movss 0x1718(%r15), %xmm0
movss 0x2ee80(%rip), %xmm1    # 0x3d3d0
movq %r14, %rdi
movss %xmm0, -0x1c(%rbp)
movq %rbx, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x35430
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xe582
movss -0x1c(%rbp), %xmm2
divss (%r14), %xmm2
movaps %xmm0, %xmm1
subss %xmm2, %xmm1
movss %xmm1, %xmm0            # xmm0 = xmm1[0],xmm0[1,2,3]
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::RenderFrame(ImVec2, ImVec2, unsigned int, bool, float)
void ImGui::RenderFrame(ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, bool border, float rounding)
{
    ImGuiWindow* window = GetCurrentWindow();

    window->DrawList->AddRectFilled(p_min, p_max, fill_col, rounding);
    if (border && (window->Flags & ImGuiWindowFlags_ShowBorders))
    {
        window->DrawList->AddRect(p_min+ImVec2(1,1), p_max, window->Color(ImGuiCol_BorderShadow), rounding);
        window->DrawList->AddRect(p_min, p_max-ImVec2(1,1), window->Color(ImGuiCol_Border), rounding);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
movl %edi, %ecx
leaq -0x38(%rbp), %rsi
movlps %xmm0, (%rsi)
leaq -0x48(%rbp), %rdx
movlps %xmm1, (%rdx)
movq 0x46ec9(%rip), %rax     # 0x55480
movq 0x1758(%rax), %r15
movb $0x1, 0x72(%r15)
movq 0x270(%r15), %rdi
movss %xmm2, -0x2c(%rbp)
movaps %xmm2, %xmm0
movl $0xf, %r8d
callq 0x2f984
testl %ebx, %ebx
je 0xe6dc
testb $-0x80, 0xc(%r15)
je 0xe6dc
movss 0x2ed98(%rip), %xmm0    # 0x3d390
leaq -0x38(%rbp), %rax
movss (%rax), %xmm1
addss %xmm0, %xmm1
addss 0x4(%rax), %xmm0
movq 0x270(%r15), %r12
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
leaq -0x40(%rbp), %rbx
movlps %xmm1, (%rbx)
movq 0x46e5f(%rip), %rax     # 0x55480
movups 0x14b0(%rax), %xmm0
leaq -0x60(%rbp), %r14
movaps %xmm0, (%r14)
movss 0x13e8(%rax), %xmm0
mulss 0xc(%r14), %xmm0
movss %xmm0, 0xc(%r14)
movq %r14, %rdi
callq 0x8c82
leaq -0x48(%rbp), %r13
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movl %eax, %ecx
movss -0x2c(%rbp), %xmm0
movl $0xf, %r8d
callq 0x2f8b6
movq 0x270(%r15), %r12
movss 0x2ed22(%rip), %xmm0    # 0x3d39c
movss (%r13), %xmm1
addss %xmm0, %xmm1
addss 0x4(%r13), %xmm0
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movlps %xmm1, (%rbx)
movq 0x46de9(%rip), %rax     # 0x55480
movups 0x14a0(%rax), %xmm0
movaps %xmm0, (%r14)
movss 0x13e8(%rax), %xmm0
mulss 0xc(%r14), %xmm0
movss %xmm0, 0xc(%r14)
leaq -0x60(%rbp), %rdi
callq 0x8c82
leaq -0x40(%rbp), %rdx
movq %r12, %rdi
leaq -0x38(%rbp), %rsi
movl %eax, %ecx
movss -0x2c(%rbp), %xmm0
movl $0xf, %r8d
callq 0x2f8b6
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::CalcListClipping(int, float, int*, int*)
void ImGui::CalcListClipping(int items_count, float items_height, int* out_items_display_start, int* out_items_display_end)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = GetCurrentWindowRead();
    if (g.LogEnabled)
    {
        // If logging is active, do not perform any clipping
        *out_items_display_start = 0;
        *out_items_display_end = items_count;
        return;
    }

    const ImVec2 pos = window->DC.CursorPos;
    int start = (int)((window->ClipRect.Min.y - pos.y) / items_height);
    int end = (int)((window->ClipRect.Max.y - pos.y) / items_height);
    start = ImClamp(start, 0, items_count);
    end = ImClamp(end + 1, start, items_count);
    *out_items_display_start = start;
    *out_items_display_end = end;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x467bb(%rip), %rcx     # 0x55480
xorl %eax, %eax
cmpb $0x0, 0x2be8(%rcx)
jne 0xed29
movq 0x1758(%rcx), %rax
movss 0xac(%rax), %xmm1
movss 0x1e4(%rax), %xmm2
subss %xmm1, %xmm2
divss %xmm0, %xmm2
cvttss2si %xmm2, %ecx
movss 0x1ec(%rax), %xmm2
subss %xmm1, %xmm2
divss %xmm0, %xmm2
cvttss2si %xmm2, %r8d
cmpl %edi, %ecx
movl %edi, %r9d
cmovll %ecx, %r9d
xorl %eax, %eax
testl %ecx, %ecx
cmovnsl %r9d, %eax
incl %r8d
cmpl %edi, %r8d
cmovll %r8d, %edi
cmpl %eax, %r8d
cmovll %eax, %edi
movl %eax, (%rsi)
movl %edi, (%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::IsKeyPressed(int, bool)
bool ImGui::IsKeyPressed(int key_index, bool repeat)
{
    ImGuiState& g = *GImGui;
    if (key_index < 0) return false;
    IM_ASSERT(key_index >= 0 && key_index < IM_ARRAYSIZE(g.IO.KeysDown));
    const float t = g.IO.KeysDownDuration[key_index];
    if (t == 0.0f)
        return true;

    if (repeat && t > g.IO.KeyRepeatDelay)
    {
        float delay = g.IO.KeyRepeatDelay, rate = g.IO.KeyRepeatRate;
        if ((fmodf(t - delay, rate) > rate*0.5f) != (fmodf(t - delay - g.IO.DeltaTime, rate) > rate*0.5f))
            return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
testl %edi, %edi
js 0xee9d
cmpl $0x200, %edi            # imm = 0x200
jae 0xeeac
movq 0x46663(%rip), %r14     # 0x55480
movl %edi, %eax
movss 0x3e4(%r14,%rax,4), %xmm0
movb $0x1, %bl
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xee35
jnp 0xee9f
testb %sil, %sil
je 0xee9d
movss 0x80(%r14), %xmm2
ucomiss %xmm2, %xmm0
jbe 0xee9d
movss 0x84(%r14), %xmm1
movss %xmm1, -0x1c(%rbp)
subss %xmm2, %xmm0
movss %xmm0, -0x24(%rbp)
callq 0x78d0
movss 0x2e560(%rip), %xmm2    # 0x3d3cc
movss -0x1c(%rbp), %xmm1
mulss %xmm1, %xmm2
movss %xmm2, -0x20(%rbp)
ucomiss %xmm2, %xmm0
seta %r15b
movss -0x24(%rbp), %xmm0
subss 0x10(%r14), %xmm0
callq 0x78d0
ucomiss -0x20(%rbp), %xmm0
setbe %al
cmpb %al, %r15b
je 0xee9f
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2eb81(%rip), %rdi     # 0x3da34
leaq 0x2e7fb(%rip), %rsi     # 0x3d6b5
leaq 0x2ebc7(%rip), %rcx     # 0x3da88
movl $0xae8, %edx            # imm = 0xAE8
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::IsKeyReleased(int)
bool ImGui::IsKeyReleased(int key_index)
{
    ImGuiState& g = *GImGui;
    if (key_index < 0) return false;
    IM_ASSERT(key_index >= 0 && key_index < IM_ARRAYSIZE(g.IO.KeysDown));
    if (g.IO.KeysDownDurationPrev[key_index] >= 0.0f && !g.IO.KeysDown[key_index])
        return true;
    return false;
}

// Assembly:
testl %edi, %edi
js 0xeefd
cmpl $0x200, %edi            # imm = 0x200
jae 0xef00
movq 0x465a2(%rip), %rcx     # 0x55480
movl %edi, %edx
movss 0xbe4(%rcx,%rdx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0xeefd
movb $0x1, %al
cmpb $0x1, 0x108(%rcx,%rdx)
jne 0xeeff
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x2eb29(%rip), %rdi     # 0x3da34
leaq 0x2e7a3(%rip), %rsi     # 0x3d6b5
leaq 0x2eb93(%rip), %rcx     # 0x3daac
movl $0xafa, %edx            # imm = 0xAFA
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::IsMouseClicked(int, bool)
bool ImGui::IsMouseClicked(int button, bool repeat)
{
    ImGuiState& g = *GImGui;
    IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
    const float t = g.IO.MouseDownDuration[button];
    if (t == 0.0f)
        return true;

    if (repeat && t > g.IO.KeyRepeatDelay)
    {
        float delay = g.IO.KeyRepeatDelay, rate = g.IO.KeyRepeatRate;
        if ((fmodf(t - delay, rate) > rate*0.5f) != (fmodf(t - delay - g.IO.DeltaTime, rate) > rate*0.5f))
            return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
cmpl $0x5, %edi
jae 0xf008
movq 0x46507(%rip), %r14     # 0x55480
movl %edi, %eax
movss 0x3a8(%r14,%rax,4), %xmm0
movb $0x1, %bl
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xef91
jnp 0xeffb
testb %sil, %sil
je 0xeff9
movss 0x80(%r14), %xmm2
ucomiss %xmm2, %xmm0
jbe 0xeff9
movss 0x84(%r14), %xmm1
movss %xmm1, -0x1c(%rbp)
subss %xmm2, %xmm0
movss %xmm0, -0x24(%rbp)
callq 0x78d0
movss 0x2e404(%rip), %xmm2    # 0x3d3cc
movss -0x1c(%rbp), %xmm1
mulss %xmm1, %xmm2
movss %xmm2, -0x20(%rbp)
ucomiss %xmm2, %xmm0
seta %r15b
movss -0x24(%rbp), %xmm0
subss 0x10(%r14), %xmm0
callq 0x78d0
ucomiss -0x20(%rbp), %xmm0
setbe %al
cmpb %al, %r15b
je 0xeffb
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2eabc(%rip), %rdi     # 0x3dacb
leaq 0x2e69f(%rip), %rsi     # 0x3d6b5
leaq 0x2eb1b(%rip), %rcx     # 0x3db38
movl $0xb0a, %edx            # imm = 0xB0A
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::IsMouseDragging(int, float)
bool ImGui::IsMouseDragging(int button, float lock_threshold)
{
    ImGuiState& g = *GImGui;
    IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
    if (!g.IO.MouseDown[button])
        return false;
    if (lock_threshold < 0.0f)
        lock_threshold = g.IO.MouseDragThreshold;
    return g.IO.MouseDragMaxDistanceSqr[button] >= lock_threshold * lock_threshold;
}

// Assembly:
cmpl $0x5, %edi
jae 0xf0d5
movq 0x463db(%rip), %rax     # 0x55480
movl %edi, %ecx
cmpb $0x1, 0xf8(%rax,%rcx)
jne 0xf0d2
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0xf0be
movss 0x30(%rax), %xmm0
movss 0x3d0(%rax,%rcx,4), %xmm1
mulss %xmm0, %xmm0
ucomiss %xmm0, %xmm1
setae %al
retq
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x2e9eb(%rip), %rdi     # 0x3dacb
leaq 0x2e5ce(%rip), %rsi     # 0x3d6b5
leaq 0x2eab7(%rip), %rcx     # 0x3dba5
movl $0xb2a, %edx            # imm = 0xB2A
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::GetMousePosOnOpeningCurrentPopup()
ImVec2 ImGui::GetMousePosOnOpeningCurrentPopup()
{
    ImGuiState& g = *GImGui;
    if (g.CurrentPopupStack.Size > 0)
        return g.OpenedPopupStack[g.CurrentPopupStack.Size-1].MousePosOnOpen;
    return g.IO.MousePos;
}

// Assembly:
movq 0x4636c(%rip), %rax     # 0x55480
movslq 0x1808(%rax), %rcx
testq %rcx, %rcx
jle 0xf13d
cmpl %ecx, 0x17f8(%rax)
jl 0xf148
movq 0x1800(%rax), %rax
leaq (%rcx,%rcx,4), %rcx
leaq (%rax,%rcx,8), %rax
addq $-0xc, %rax
jmp 0xf143
addq $0xf0, %rax
movsd (%rax), %xmm0
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x2fc8d(%rip), %rdi     # 0x3ede0
leaq 0x2f969(%rip), %rsi     # 0x3eac3
leaq 0x301f5(%rip), %rcx     # 0x3f356
movl $0x31c, %edx            # imm = 0x31C
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::GetMouseDragDelta(int, float)
ImVec2 ImGui::GetMouseDragDelta(int button, float lock_threshold)
{
    ImGuiState& g = *GImGui;
    IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
    if (lock_threshold < 0.0f)
        lock_threshold = g.IO.MouseDragThreshold;
    if (g.IO.MouseDown[button])
        if (g.IO.MouseDragMaxDistanceSqr[button] >= lock_threshold * lock_threshold)
            return g.IO.MousePos - g.IO.MouseClickedPos[button];     // Assume we can only get active with left-mouse button (at the moment).
    return ImVec2(0.0f, 0.0f);
}

// Assembly:
cmpl $0x5, %edi
jae 0xf1ce
movaps %xmm0, %xmm1
movq 0x46306(%rip), %rax     # 0x55480
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jbe 0xf187
movss 0x30(%rax), %xmm1
movl %edi, %ecx
xorps %xmm0, %xmm0
cmpb $0x1, 0xf8(%rax,%rcx)
jne 0xf1cd
movss 0x3d0(%rax,%rcx,4), %xmm2
mulss %xmm1, %xmm1
ucomiss %xmm1, %xmm2
jb 0xf1cd
movss 0xf0(%rax), %xmm0
subss 0x35c(%rax,%rcx,8), %xmm0
movss 0xf4(%rax), %xmm1
subss 0x360(%rax,%rcx,8), %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x2e8f2(%rip), %rdi     # 0x3dacb
leaq 0x2e4d5(%rip), %rsi     # 0x3d6b5
leaq 0x2e9e6(%rip), %rcx     # 0x3dbcd
movl $0xb43, %edx            # imm = 0xB43
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::ResetMouseDragDelta(int)
void ImGui::ResetMouseDragDelta(int button)
{
    ImGuiState& g = *GImGui;
    IM_ASSERT(button >= 0 && button < IM_ARRAYSIZE(g.IO.MouseDown));
    // NB: We don't need to reset g.IO.MouseDragMaxDistanceSqr
    g.IO.MouseClickedPos[button] = g.IO.MousePos;
}

// Assembly:
cmpl $0x5, %edi
jae 0xf20f
movq 0x46283(%rip), %rax     # 0x55480
movl %edi, %ecx
movq 0xf0(%rax), %rdx
movq %rdx, 0x35c(%rax,%rcx,8)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x2e8b1(%rip), %rdi     # 0x3dacb
leaq 0x2e494(%rip), %rsi     # 0x3d6b5
leaq 0x2e9d1(%rip), %rcx     # 0x3dbf9
movl $0xb4f, %edx            # imm = 0xB4F
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::IsItemActive()
bool ImGui::IsItemActive()
{
    ImGuiState& g = *GImGui;
    if (g.ActiveId)
    {
        ImGuiWindow* window = GetCurrentWindowRead();
        return g.ActiveId == window->DC.LastItemID;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x461c1(%rip), %rax     # 0x55480
movl 0x1790(%rax), %ecx
testl %ecx, %ecx
je 0xf2db
movq 0x1758(%rax), %rax
cmpl 0xe0(%rax), %ecx
sete %al
jmp 0xf2dd
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::CalcItemRectClosestPoint(ImVec2 const&, bool, float)
ImVec2 ImGui::CalcItemRectClosestPoint(const ImVec2& pos, bool on_edge, float outward)
{
    ImGuiWindow* window = GetCurrentWindowRead();
    ImRect rect = window->DC.LastItemRect;
    rect.Expand(outward);
    return rect.GetClosestPoint(pos, on_edge);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movaps %xmm0, %xmm1
movq 0x4608e(%rip), %rax     # 0x55480
movq 0x1758(%rax), %rax
movss 0xe4(%rax), %xmm3
movss 0xe8(%rax), %xmm2
subss %xmm0, %xmm3
subss %xmm0, %xmm2
movss 0xec(%rax), %xmm4
addss %xmm0, %xmm4
addss 0xf0(%rax), %xmm1
movsd (%rdi), %xmm0
testl %esi, %esi
jne 0xf448
ucomiss %xmm3, %xmm0
jb 0xf448
movaps %xmm0, %xmm5
shufps $0x55, %xmm0, %xmm5     # xmm5 = xmm5[1,1],xmm0[1,1]
ucomiss %xmm2, %xmm5
jb 0xf448
ucomiss %xmm0, %xmm4
jbe 0xf448
ucomiss %xmm5, %xmm1
ja 0xf483
ucomiss %xmm4, %xmm0
jbe 0xf453
movss %xmm4, %xmm0            # xmm0 = xmm4[0],xmm0[1,2,3]
jmp 0xf45c
ucomiss %xmm0, %xmm3
jbe 0xf45c
movss %xmm3, %xmm0            # xmm0 = xmm3[0],xmm0[1,2,3]
movaps %xmm0, %xmm3
shufps $0x55, %xmm0, %xmm3     # xmm3 = xmm3[1,1],xmm0[1,1]
ucomiss %xmm1, %xmm3
jbe 0xf474
movlhps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
shufps $0xe2, %xmm0, %xmm1     # xmm1 = xmm1[2,0],xmm0[2,3]
movaps %xmm1, %xmm0
jmp 0xf483
ucomiss %xmm3, %xmm2
jbe 0xf483
movlhps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
shufps $0xe2, %xmm0, %xmm2     # xmm2 = xmm2[2,0],xmm0[2,3]
movaps %xmm2, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::CloseCurrentPopup()
void ImGui::CloseCurrentPopup()
{
    ImGuiState& g = *GImGui;
    int popup_idx = g.CurrentPopupStack.Size - 1;
    if (popup_idx < 0 || popup_idx > g.OpenedPopupStack.Size || g.CurrentPopupStack[popup_idx].PopupID != g.OpenedPopupStack[popup_idx].PopupID)
        return;
    while (popup_idx > 0 && g.OpenedPopupStack[popup_idx].Window && (g.OpenedPopupStack[popup_idx].Window->Flags & ImGuiWindowFlags_ChildMenu))
        popup_idx--;
    ClosePopupToLevel(popup_idx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x42c7c(%rip), %rdi     # 0x55480
movl 0x1808(%rdi), %eax
testl %eax, %eax
jle 0x12875
leal -0x1(%rax), %ecx
movl 0x17f8(%rdi), %edx
cmpl %edx, %ecx
jg 0x12875
jae 0x12882
movq 0x1800(%rdi), %rsi
movq 0x1810(%rdi), %rdi
movl %ecx, %r8d
shlq $0x3, %r8
leaq (%r8,%r8,4), %r8
movl (%rdi,%r8), %edi
cmpl (%rsi,%r8), %edi
jne 0x12875
xorl %edi, %edi
cmpl $0x1, %eax
je 0x1287f
leal -0x1(%rax), %r8d
cmpl %r8d, %edx
jbe 0x12882
movl %r8d, %r9d
leaq (%r9,%r9,4), %r9
movq 0x8(%rsi,%r9,8), %r9
testq %r9, %r9
je 0x12877
testb $0x8, 0xf(%r9)
je 0x1287b
decl %ecx
movl %r8d, %eax
cmpl $0x1, %r8d
jg 0x12847
jmp 0x1287f
popq %rbp
retq
movl %ecx, %edi
jmp 0x1287f
decl %eax
movl %eax, %edi
popq %rbp
jmp 0x128a1
leaq 0x2c557(%rip), %rdi     # 0x3ede0
leaq 0x2c233(%rip), %rsi     # 0x3eac3
leaq 0x2cabf(%rip), %rcx     # 0x3f356
movl $0x31c, %edx            # imm = 0x31C
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ClosePopupToLevel(int)
static void ClosePopupToLevel(int remaining)
{
    ImGuiState& g = *GImGui;
    if (remaining > 0)
        ImGui::FocusWindow(g.OpenedPopupStack[remaining-1].Window);
    else
        ImGui::FocusWindow(g.OpenedPopupStack[0].ParentWindow);
    g.OpenedPopupStack.resize(remaining);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebx
movq 0x42bcb(%rip), %r15     # 0x55480
movl 0x17f8(%r15), %eax
testl %edi, %edi
jle 0x128df
cmpl %ebx, %eax
jl 0x129a8
movq 0x1800(%r15), %rax
movl %ebx, %ecx
leaq (%rcx,%rcx,4), %rcx
leaq (%rax,%rcx,8), %rax
addq $-0x20, %rax
jmp 0x128f2
testl %eax, %eax
jle 0x129a8
movq 0x1800(%r15), %rax
addq $0x10, %rax
movq (%rax), %rdi
callq 0xce68
movl 0x17fc(%r15), %eax
cmpl %ebx, %eax
jge 0x12998
testl %eax, %eax
je 0x1291f
movl %eax, %r12d
shrl $0x1f, %r12d
addl %eax, %r12d
sarl %r12d
addl %eax, %r12d
jmp 0x12925
movl $0x8, %r12d
cmpl %ebx, %r12d
cmovlel %ebx, %r12d
movslq %r12d, %rax
shlq $0x3, %rax
leaq (%rax,%rax,4), %rdi
movq 0x42b42(%rip), %rax     # 0x55480
incl 0x334(%rax)
callq *0xd0(%rax)
movq %rax, %r14
movq 0x1800(%r15), %rsi
movslq 0x17f8(%r15), %rax
shlq $0x3, %rax
leaq (%rax,%rax,4), %rdx
movq %r14, %rdi
callq 0x7080
movq 0x1800(%r15), %rdi
movq 0x42b07(%rip), %rax     # 0x55480
testq %rdi, %rdi
je 0x12984
decl 0x334(%rax)
callq *0xd8(%rax)
movq %r14, 0x1800(%r15)
movl %r12d, 0x17fc(%r15)
movl %ebx, 0x17f8(%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2c431(%rip), %rdi     # 0x3ede0
leaq 0x2c10d(%rip), %rsi     # 0x3eac3
leaq 0x2c999(%rip), %rcx     # 0x3f356
movl $0x31c, %edx            # imm = 0x31C
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: BeginPopupEx(char const*, int)
static bool BeginPopupEx(const char* str_id, ImGuiWindowFlags extra_flags)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    const ImGuiID id = window->GetID(str_id);
    if (!IsPopupOpen(id))
    {
        ClearSetNextWindowData(); // We behave like Begin() and need to consume those values
        return false;
    }

    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
    ImGuiWindowFlags flags = extra_flags|ImGuiWindowFlags_Popup|ImGuiWindowFlags_NoTitleBar|ImGuiWindowFlags_NoMove|ImGuiWindowFlags_NoResize|ImGuiWindowFlags_NoSavedSettings|ImGuiWindowFlags_AlwaysAutoResize;

    char name[32];
    if (flags & ImGuiWindowFlags_ChildMenu)
        ImFormatString(name, 20, "##menu_%d", g.CurrentPopupStack.Size);    // Recycle windows based on depth
    else
        ImFormatString(name, 20, "##popup_%08x", id); // Not recycling, so we can close/open during the same frame
    float alpha = 1.0f;

    bool opened = ImGui::Begin(name, NULL, ImVec2(0.0f, 0.0f), alpha, flags);
    if (!(window->Flags & ImGuiWindowFlags_ShowBorders))
        g.CurrentWindow->Flags &= ~ImGuiWindowFlags_ShowBorders;
    if (!opened) // opened can be 'false' when the popup is completely clipped (e.g. zero size display)
        ImGui::EndPopup();

    return opened;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %r12d
movq %rdi, %rsi
movq 0x42a8f(%rip), %r13     # 0x55480
movq 0x1758(%r13), %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0xa766
movl %eax, %r15d
movq 0x42a74(%rip), %rax     # 0x55480
movslq 0x1808(%rax), %rcx
cmpl %ecx, 0x17f8(%rax)
jle 0x12a5f
movq 0x1800(%rax), %rdx
leaq (%rcx,%rcx,4), %rcx
cmpl %r15d, (%rdx,%rcx,8)
jne 0x12a5f
xorps %xmm0, %xmm0
movl $0x2, %edi
callq 0x133f5
movl %r12d, %r14d
orl $0x2000147, %r14d       # imm = 0x2000147
btl $0x1b, %r12d
jb 0x12a85
leaq 0x2c258(%rip), %rdx     # 0x3eca9
leaq -0x50(%rbp), %rdi
movl $0x14, %esi
movl %r15d, %ecx
jmp 0x12a9c
xorps %xmm0, %xmm0
movups %xmm0, 0x1834(%rax)
movb $0x0, 0x1844(%rax)
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x1808(%r13), %ecx
leaq 0x2c20c(%rip), %rdx     # 0x3ec9f
leaq -0x50(%rbp), %rdi
movl $0x14, %esi
xorl %eax, %eax
callq 0x8678
leaq -0x30(%rbp), %rdx
movq $0x0, (%rdx)
leaq -0x50(%rbp), %rdi
movss 0x2a8d6(%rip), %xmm0    # 0x3d390
xorl %esi, %esi
movl %r14d, %ecx
callq 0xf554
movl %eax, %r14d
testb $-0x80, 0xc(%rbx)
jne 0x12adb
movq 0x1758(%r13), %rax
andl $0xffffff7f, 0xc(%rax)  # imm = 0xFFFFFF7F
testb %r14b, %r14b
jne 0x12a73
callq 0x12baf
jmp 0x12a73
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::BeginPopupModal(char const*, bool*, int)
bool ImGui::BeginPopupModal(const char* name, bool* p_opened, ImGuiWindowFlags extra_flags)
{
    ImGuiState& g = *GImGui;
    ImGuiWindow* window = g.CurrentWindow;
    const ImGuiID id = window->GetID(name);
    if (!IsPopupOpen(id))
    {
        ClearSetNextWindowData(); // We behave like Begin() and need to consume those values
        return false;
    }

    ImGuiWindowFlags flags = extra_flags|ImGuiWindowFlags_Popup|ImGuiWindowFlags_Modal|ImGuiWindowFlags_NoCollapse|ImGuiWindowFlags_NoSavedSettings;
    bool opened = ImGui::Begin(name, p_opened, ImVec2(0.0f, 0.0f), -1.0f, flags);
    if (!opened || (p_opened && !*p_opened)) // Opened can be 'false' when the popup is completely clipped (e.g. zero size display)
    {
        ImGui::EndPopup();
        if (opened)
            ClosePopup(id);
        return false;
    }

    return opened;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r12
movq 0x4297a(%rip), %rax     # 0x55480
movq 0x1758(%rax), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0xa766
movl %eax, %r14d
movq 0x4295f(%rip), %rax     # 0x55480
movslq 0x1808(%rax), %rcx
cmpl %ecx, 0x17f8(%rax)
jle 0x12b88
movq 0x1800(%rax), %rdx
leaq (%rcx,%rcx,4), %rcx
cmpl %r14d, (%rdx,%rcx,8)
jne 0x12b88
orl $0x6000120, %r15d       # imm = 0x6000120
leaq -0x28(%rbp), %rdx
movq $0x0, (%rdx)
movss 0x2a841(%rip), %xmm0    # 0x3d39c
movq %r12, %rdi
movq %rbx, %rsi
movl %r15d, %ecx
callq 0xf554
testb %al, %al
je 0x12ba8
movb $0x1, %al
testq %rbx, %rbx
je 0x12b9b
cmpb $0x0, (%rbx)
jne 0x12b9b
callq 0x12baf
movl %r14d, %edi
callq 0x12c36
jmp 0x12b99
xorps %xmm0, %xmm0
movups %xmm0, 0x1834(%rax)
movb $0x0, 0x1844(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x12baf
jmp 0x12b99
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::EndPopup()
void ImGui::EndPopup()
{
    ImGuiWindow* window = GetCurrentWindow();
    IM_ASSERT(window->Flags & ImGuiWindowFlags_Popup);
    IM_ASSERT(GImGui->CurrentPopupStack.Size > 0);
    ImGui::End();
    if (!(window->Flags & ImGuiWindowFlags_Modal))
        ImGui::PopStyleVar();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x428c4(%rip), %rax     # 0x55480
movq 0x1758(%rax), %rbx
movb $0x1, 0x72(%rbx)
testb $0x2, 0xf(%rbx)
je 0x12bf8
cmpl $0x0, 0x1808(%rax)
jle 0x12c17
callq 0xcc43
testb $0x4, 0xf(%rbx)
jne 0x12bf1
movl $0x1, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x12c6e
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2b083(%rip), %rdi     # 0x3dc82
leaq 0x2aaaf(%rip), %rsi     # 0x3d6b5
leaq 0x2b09c(%rip), %rcx     # 0x3dca9
movl $0xc71, %edx            # imm = 0xC71
callq 0x7140
leaq 0x2b0a2(%rip), %rdi     # 0x3dcc0
leaq 0x2aa90(%rip), %rsi     # 0x3d6b5
leaq 0x2b07d(%rip), %rcx     # 0x3dca9
movl $0xc72, %edx            # imm = 0xC72
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ClosePopup(unsigned int)
static void ClosePopup(ImGuiID id)
{
    if (!IsPopupOpen(id))
        return;
    ImGuiState& g = *GImGui;
    ClosePopupToLevel(g.OpenedPopupStack.Size - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, %eax
movq 0x4283d(%rip), %rcx     # 0x55480
movl 0x17f8(%rcx), %edi
movslq 0x1808(%rcx), %rdx
cmpl %edx, %edi
jle 0x12c6c
movq 0x1800(%rcx), %rcx
leaq (%rdx,%rdx,4), %rdx
cmpl %eax, (%rcx,%rdx,8)
jne 0x12c6c
decl %edi
popq %rbp
jmp 0x128a1
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::PopStyleVar(int)
void ImGui::PopStyleVar(int count)
{
    ImGuiState& g = *GImGui;
    while (count > 0)
    {
        ImGuiStyleMod& backup = g.StyleModifiers.back();
        if (float* pvar_f = GetStyleVarFloatAddr(backup.Var))
            *pvar_f = backup.PreviousValue.x;
        else if (ImVec2* pvar_v = GetStyleVarVec2Addr(backup.Var))
            *pvar_v = backup.PreviousValue;
        g.StyleModifiers.pop_back();
        count--;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
testl %edi, %edi
jle 0x12d6c
movl %edi, %ebx
movq 0x427f0(%rip), %rcx     # 0x55480
leaq 0x141c(%rcx), %rax
movq %rax, -0x48(%rbp)
leaq 0x1414(%rcx), %rax
movq %rax, -0x40(%rbp)
leaq 0x1408(%rcx), %rax
movq %rax, -0x38(%rbp)
leaq 0x13f4(%rcx), %rax
movq %rax, -0x30(%rbp)
leaq 0x13ec(%rcx), %rax
movq %rax, -0x50(%rbp)
movl 0x17d8(%rcx), %r13d
leaq (,%r13,2), %rax
addq %r13, %rax
leaq -0x8(,%rax,4), %r12
incl %ebx
movq %rcx, -0x58(%rbp)
testl %r13d, %r13d
jle 0x12d7b
movq 0x17e0(%rcx), %r15
movl -0x4(%r15,%r12), %r14d
movl %r14d, %edi
callq 0x14e8b
testq %rax, %rax
je 0x12d15
movss (%r15,%r12), %xmm0
movss %xmm0, (%rax)
jmp 0x12d4f
decl %r14d
cmpl $0x7, %r14d
ja 0x12d4f
leaq 0x2a76f(%rip), %rax     # 0x3d494
movslq (%rax,%r14,4), %rcx
addq %rax, %rcx
movq -0x50(%rbp), %rax
jmpq *%rcx
movq -0x30(%rbp), %rax
jmp 0x12d48
movq -0x38(%rbp), %rax
jmp 0x12d48
movq -0x40(%rbp), %rax
jmp 0x12d48
movq -0x48(%rbp), %rax
movq (%r15,%r12), %rcx
movq %rcx, (%rax)
decl %r13d
movq -0x58(%rbp), %rcx
movl %r13d, 0x17d8(%rcx)
addq $-0xc, %r12
decl %ebx
cmpl $0x1, %ebx
jg 0x12ce7
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x33db3(%rip), %rdi     # 0x46b35
leaq 0x2bd3a(%rip), %rsi     # 0x3eac3
leaq 0x2c7f9(%rip), %rcx     # 0x3f589
movl $0x326, %edx            # imm = 0x326
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::BeginPopupContextWindow(bool, char const*, int)
bool ImGui::BeginPopupContextWindow(bool also_over_items, const char* str_id, int mouse_button)
{
    if (!str_id) str_id = "window_context_menu";
    if (ImGui::IsMouseHoveringWindow() && ImGui::IsMouseClicked(mouse_button))
        if (also_over_items || !ImGui::IsAnyItemHovered())
            ImGui::OpenPopup(str_id);
    return ImGui::BeginPopup(str_id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rsi, %rsi
leaq 0x2aec5(%rip), %rbx     # 0x3dce3
cmovneq %rsi, %rbx
movq 0x42657(%rip), %rax     # 0x55480
movq 0x1778(%rax), %rcx
cmpq 0x1758(%rax), %rcx
je 0x12e4c
movq %rbx, %rdi
movl $0x80, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x129d3
cmpl $0x5, %edx
jae 0x12e89
movl %edx, %ecx
movss 0x3a8(%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x12e39
jp 0x12e39
testb %dil, %dil
je 0x12e75
movq %rbx, %rdi
callq 0x12594
jmp 0x12e39
cmpl $0x0, 0x1788(%rax)
jne 0x12e39
cmpl $0x0, 0x178c(%rax)
jne 0x12e39
jmp 0x12e6b
leaq 0x2ac3b(%rip), %rdi     # 0x3dacb
leaq 0x2a81e(%rip), %rsi     # 0x3d6b5
leaq 0x2ac9a(%rip), %rcx     # 0x3db38
movl $0xb0a, %edx            # imm = 0xB0A
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::BeginPopupContextVoid(char const*, int)
bool ImGui::BeginPopupContextVoid(const char* str_id, int mouse_button)
{
    if (!str_id) str_id = "void_context_menu";
    if (!ImGui::IsMouseHoveringAnyWindow() && ImGui::IsMouseClicked(mouse_button))
        ImGui::OpenPopup(str_id);
    return ImGui::BeginPopup(str_id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
leaq 0x2ae3f(%rip), %rbx     # 0x3dcf7
cmovneq %rdi, %rbx
movq 0x425bd(%rip), %rax     # 0x55480
cmpq $0x0, 0x1778(%rax)
jne 0x12eef
cmpl $0x5, %esi
jae 0x12f02
movl %esi, %ecx
movss 0x3a8(%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x12eef
jp 0x12eef
movq %rbx, %rdi
callq 0x12594
movq %rbx, %rdi
movl $0x80, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x129d3
leaq 0x2abc2(%rip), %rdi     # 0x3dacb
leaq 0x2a7a5(%rip), %rsi     # 0x3d6b5
leaq 0x2ac21(%rip), %rcx     # 0x3db38
movl $0xb0a, %edx            # imm = 0xB0A
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::EndChild()
void ImGui::EndChild()
{
    ImGuiWindow* window = GetCurrentWindow();

    IM_ASSERT(window->Flags & ImGuiWindowFlags_ChildWindow);
    if ((window->Flags & ImGuiWindowFlags_ComboBox) || window->BeginCount > 1)
    {
        ImGui::End();
    }
    else
    {
        // When using auto-filling child window, we don't provide full width/height to ItemSize so that it doesn't feed back into automatic size-fitting.
        ImGuiState& g = *GImGui;
        ImVec2 sz = ImGui::GetWindowSize();
        if (window->Flags & ImGuiWindowFlags_ChildWindowAutoFitX) // Arbitrary minimum zeroish child size of 4.0f
            sz.x = ImMax(4.0f, sz.x - g.Style.WindowPadding.x);
        if (window->Flags & ImGuiWindowFlags_ChildWindowAutoFitY)
            sz.y = ImMax(4.0f, sz.y - g.Style.WindowPadding.y);

        ImGui::End();

        window = GetCurrentWindow();
        ImRect bb(window->DC.CursorPos, window->DC.CursorPos + sz);
        ItemSize(sz);
        ItemAdd(bb, NULL);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
movq 0x42347(%rip), %rax     # 0x55480
movq 0x1758(%rax), %rdx
movb $0x1, 0x72(%rdx)
movl 0xc(%rdx), %ecx
btl $0x14, %ecx
jae 0x1322d
btl $0x17, %ecx
jb 0x1315d
cmpl $0x2, 0x78(%rdx)
jl 0x13168
addq $0x38, %rsp
popq %rbx
popq %rbp
jmp 0xcc43
movsd 0x20(%rdx), %xmm1
movsd %xmm1, -0x10(%rbp)
btl $0x15, %ecx
movaps %xmm1, %xmm2
shufps $0x55, %xmm1, %xmm2     # xmm2 = xmm2[1,1],xmm1[1,1]
jae 0x1319f
movss 0x13ec(%rax), %xmm0
subss %xmm0, %xmm1
movss 0x2a21d(%rip), %xmm0    # 0x3d3b0
maxss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
movaps %xmm0, %xmm1
btl $0x16, %ecx
movaps %xmm1, -0x30(%rbp)
jb 0x131af
movaps %xmm2, -0x20(%rbp)
jmp 0x131cc
subss 0x13f0(%rax), %xmm2
movss 0x2a1f1(%rip), %xmm0    # 0x3d3b0
maxss %xmm2, %xmm0
movss %xmm0, -0xc(%rbp)
movaps %xmm0, -0x20(%rbp)
callq 0xcc43
movq 0x422a8(%rip), %rax     # 0x55480
movq 0x1758(%rax), %rax
movb $0x1, 0x72(%rax)
movaps -0x30(%rbp), %xmm0
addss 0xa8(%rax), %xmm0
movaps -0x20(%rbp), %xmm1
addss 0xac(%rax), %xmm1
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movq 0xa8(%rax), %rax
leaq -0x40(%rbp), %rbx
movq %rax, (%rbx)
movlps %xmm0, 0x8(%rbx)
leaq -0x10(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0xa99d
movq %rbx, %rdi
xorl %esi, %esi
callq 0xaaef
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2aae6(%rip), %rdi     # 0x3dd1a
leaq 0x2a47a(%rip), %rsi     # 0x3d6b5
leaq 0x2ab05(%rip), %rcx     # 0x3dd47
movl $0xcbf, %edx            # imm = 0xCBF
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::BeginChildFrame(unsigned int, ImVec2 const&)
bool ImGui::BeginChildFrame(ImGuiID id, const ImVec2& size)
{
    ImGuiState& g = *GImGui;
    const ImGuiStyle& style = g.Style;
    ImGui::PushStyleColor(ImGuiCol_ChildWindowBg, style.Colors[ImGuiCol_FrameBg]);
    ImGui::PushStyleVar(ImGuiStyleVar_ChildWindowRounding, style.FrameRounding);
    return ImGui::BeginChild(id, size, false, ImGuiWindowFlags_NoMove);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl %edi, %r14d
movq 0x42201(%rip), %r15     # 0x55480
leaq 0x14c0(%r15), %rsi
movl $0x3, %edi
callq 0x132dd
movss 0x1410(%r15), %xmm0
movl $0x4, %edi
callq 0x133f5
leaq 0x2aa65(%rip), %rdx     # 0x3dd0f
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movl $0x20, %esi
movl %r14d, %ecx
xorl %eax, %eax
callq 0x8678
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movl $0x4, %ecx
callq 0x12f21
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::PushStyleColor(int, ImVec4 const&)
void ImGui::PushStyleColor(ImGuiCol idx, const ImVec4& col)
{
    ImGuiState& g = *GImGui;
    ImGuiColMod backup;
    backup.Col = idx;
    backup.PreviousValue = g.Style.Colors[idx];
    g.ColorModifiers.push_back(backup);
    g.Style.Colors[idx] = col;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, %r14d
movq 0x42188(%rip), %r13     # 0x55480
movslq %edi, %rax
shlq $0x4, %rax
leaq (%rax,%r13), %r12
addq $0x1460, %r12           # imm = 0x1460
movups (%r12), %xmm0
movaps %xmm0, -0x40(%rbp)
movl 0x17c8(%r13), %eax
cmpl 0x17cc(%r13), %eax
jne 0x1333b
leal 0x1(%rax), %ebx
testl %eax, %eax
movq %rsi, -0x30(%rbp)
je 0x13344
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x13349
movq 0x17d0(%r13), %r15
jmp 0x133c0
movl $0x8, %ecx
cmpl %ebx, %ecx
cmovgl %ecx, %ebx
movslq %ebx, %rax
shlq $0x2, %rax
leaq (%rax,%rax,4), %rdi
incl 0x334(%r13)
callq *0xd0(%r13)
movq %rax, %r15
movq 0x17d0(%r13), %rsi
movslq 0x17c8(%r13), %rax
shlq $0x2, %rax
leaq (%rax,%rax,4), %rdx
movq %r15, %rdi
callq 0x7080
movq 0x17d0(%r13), %rdi
movq 0x420ea(%rip), %rax     # 0x55480
testq %rdi, %rdi
je 0x133a1
decl 0x334(%rax)
callq *0xd8(%rax)
movq %r15, 0x17d0(%r13)
movl %ebx, 0x17cc(%r13)
movl 0x17c8(%r13), %eax
movq -0x30(%rbp), %rsi
leal 0x1(%rax), %ecx
movl %ecx, 0x17c8(%r13)
cltq
leaq (%rax,%rax,4), %rax
movl %r14d, (%r15,%rax,4)
movaps -0x40(%rbp), %xmm0
movups %xmm0, 0x4(%r15,%rax,4)
movups (%rsi), %xmm0
movups %xmm0, (%r12)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::PushStyleVar(int, float)
void ImGui::PushStyleVar(ImGuiStyleVar idx, float val)
{
    ImGuiState& g = *GImGui;
    float* pvar = GetStyleVarFloatAddr(idx);
    IM_ASSERT(pvar != NULL); // Called function with wrong-type? Variable is not a float.
    ImGuiStyleMod backup;
    backup.Var = idx;
    backup.PreviousValue = ImVec2(*pvar, 0.0f);
    g.StyleModifiers.push_back(backup);
    *pvar = val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movss %xmm0, -0x30(%rbp)
movl %edi, %ebx
movq 0x4206f(%rip), %r12     # 0x55480
callq 0x14e8b
testq %rax, %rax
je 0x13524
movq %rax, %r14
movss (%rax), %xmm0
movl 0x17d8(%r12), %eax
cmpl 0x17dc(%r12), %eax
jne 0x13452
leal 0x1(%rax), %r13d
testl %eax, %eax
movss %xmm0, -0x2c(%rbp)
je 0x1345f
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x13464
movq 0x17e0(%r12), %r15
jmp 0x134e6
movl $0x8, %ecx
cmpl %r13d, %ecx
cmovgl %ecx, %r13d
movslq %r13d, %rax
shlq $0x2, %rax
leaq (%rax,%rax,2), %rdi
incl 0x334(%r12)
callq *0xd0(%r12)
movq %rax, %r15
movq 0x17e0(%r12), %rsi
movslq 0x17d8(%r12), %rax
shlq $0x2, %rax
leaq (%rax,%rax,2), %rdx
movq %r15, %rdi
callq 0x7080
movq 0x17e0(%r12), %rdi
movq 0x41fc8(%rip), %rax     # 0x55480
testq %rdi, %rdi
je 0x134c3
decl 0x334(%rax)
callq *0xd8(%rax)
movq %r15, 0x17e0(%r12)
movl %r13d, 0x17dc(%r12)
movl 0x17d8(%r12), %eax
movss -0x2c(%rbp), %xmm0
leal 0x1(%rax), %ecx
movl %ecx, 0x17d8(%r12)
cltq
leaq (%rax,%rax,2), %rax
movl %ebx, (%r15,%rax,4)
movss %xmm0, 0x4(%r15,%rax,4)
movl $0x0, 0x8(%r15,%rax,4)
movss -0x30(%rbp), %xmm0
movss %xmm0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a945(%rip), %rdi     # 0x3de70
leaq 0x2a183(%rip), %rsi     # 0x3d6b5
leaq 0x2a946(%rip), %rcx     # 0x3de7f
movl $0x10e2, %edx           # imm = 0x10E2
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::PopStyleColor(int)
void ImGui::PopStyleColor(int count)
{
    ImGuiState& g = *GImGui;
    while (count > 0)
    {
        ImGuiColMod& backup = g.ColorModifiers.back();
        g.Style.Colors[backup.Col] = backup.PreviousValue;
        g.ColorModifiers.pop_back();
        count--;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %edi, %edi
jle 0x135bc
movq 0x41f10(%rip), %rax     # 0x55480
leaq 0x1460(%rax), %rcx
movl 0x17c8(%rax), %edx
incl %edi
testl %edx, %edx
jle 0x135dd
movq 0x17d0(%rax), %rsi
movl %edx, %edx
leaq (%rdx,%rdx,4), %rdx
movslq -0x14(%rsi,%rdx,4), %r8
shlq $0x4, %r8
movups -0x10(%rsi,%rdx,4), %xmm0
movups %xmm0, (%rcx,%r8)
movl 0x17c8(%rax), %edx
testl %edx, %edx
jle 0x135be
decl %edx
movl %edx, 0x17c8(%rax)
decl %edi
cmpl $0x1, %edi
jg 0x1357f
popq %rbp
retq
leaq 0x33570(%rip), %rdi     # 0x46b35
leaq 0x2b4f7(%rip), %rsi     # 0x3eac3
leaq 0x2bf7d(%rip), %rcx     # 0x3f550
movl $0x338, %edx            # imm = 0x338
callq 0x7140
leaq 0x33551(%rip), %rdi     # 0x46b35
leaq 0x2b4d8(%rip), %rsi     # 0x3eac3
leaq 0x2bf22(%rip), %rcx     # 0x3f514
movl $0x326, %edx            # imm = 0x326
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: FindWindowByName(char const*)
static ImGuiWindow* FindWindowByName(const char* name)
{
    // FIXME-OPT: Store sorted hashes -> pointers.
    ImGuiState& g = *GImGui;
    ImGuiID id = ImHash(name, 0);
    for (int i = 0; i < g.Windows.Size; i++)
        if (g.Windows[i]->ID == id)
            return g.Windows[i];
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x41e76(%rip), %r14     # 0x55480
xorl %ebx, %ebx
xorl %esi, %esi
xorl %edx, %edx
callq 0x8734
movslq 0x1738(%r14), %rcx
testq %rcx, %rcx
jle 0x1363d
movq 0x1740(%r14), %rdx
xorl %esi, %esi
movq (%rdx,%rsi,8), %rbx
cmpl %eax, 0x8(%rbx)
je 0x1363d
incq %rsi
cmpq %rsi, %rcx
jne 0x1362a
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: PushClipRect(ImRect const&, bool)
static void PushClipRect(const ImRect& clip_rect, bool clipped)
{
    ImGuiWindow* window = ImGui::GetCurrentWindow();

    ImRect cr = clip_rect;
    if (clipped)
    {
        // Clip our argument with the current clip rect
        cr.Clip(window->ClipRect);
    }
    cr.Max.x = ImMax(cr.Min.x, cr.Max.x);
    cr.Max.y = ImMax(cr.Min.y, cr.Max.y);

    IM_ASSERT(cr.Min.x <= cr.Max.x && cr.Min.y <= cr.Max.y);
    window->ClipRect = cr;
    window->DrawList->PushClipRect(ImVec4(cr.Min.x, cr.Min.y, cr.Max.x, cr.Max.y));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x41d43(%rip), %rax     # 0x55480
movq 0x1758(%rax), %rax
movb $0x1, 0x72(%rax)
movss (%rdi), %xmm6
movss 0x4(%rdi), %xmm7
movss 0x8(%rdi), %xmm5
movss 0xc(%rdi), %xmm3
testl %esi, %esi
je 0x13795
movss 0x1e0(%rax), %xmm1
movss 0x1e4(%rax), %xmm0
maxss %xmm6, %xmm1
maxss %xmm7, %xmm0
movss 0x1e8(%rax), %xmm4
minss %xmm5, %xmm4
movss 0x1ec(%rax), %xmm2
ucomiss %xmm2, %xmm3
ja 0x137a1
movaps %xmm3, %xmm2
jmp 0x137a1
movaps %xmm3, %xmm2
movaps %xmm5, %xmm4
movaps %xmm7, %xmm0
movaps %xmm6, %xmm1
movaps %xmm4, %xmm3
cmpless %xmm1, %xmm3
movaps %xmm3, %xmm5
andps %xmm1, %xmm5
andnps %xmm4, %xmm3
orps %xmm5, %xmm3
ucomiss %xmm1, %xmm3
jb 0x1381c
movaps %xmm2, %xmm4
cmpless %xmm0, %xmm4
movaps %xmm4, %xmm5
andps %xmm0, %xmm5
andnps %xmm2, %xmm4
orps %xmm5, %xmm4
ucomiss %xmm0, %xmm4
jb 0x1381c
movss %xmm1, 0x1e0(%rax)
movss %xmm0, 0x1e4(%rax)
movss %xmm3, 0x1e8(%rax)
movss %xmm4, 0x1ec(%rax)
movq 0x270(%rax), %rdi
leaq -0x10(%rbp), %rsi
movss %xmm1, (%rsi)
movss %xmm0, 0x4(%rsi)
movss %xmm3, 0x8(%rsi)
movss %xmm4, 0xc(%rsi)
callq 0x2cfa4
addq $0x10, %rsp
popq %rbp
retq
leaq 0x2b4d2(%rip), %rdi     # 0x3ecf5
leaq 0x29e8b(%rip), %rsi     # 0x3d6b5
leaq 0x2b4f1(%rip), %rcx     # 0x3ed22
movl $0x8cd, %edx            # imm = 0x8CD
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::LogFinish()
void ImGui::LogFinish()
{
    ImGuiState& g = *GImGui;
    if (!g.LogEnabled)
        return;

    ImGui::LogText(IM_NEWLINE);
    g.LogEnabled = false;
    if (g.LogFile != NULL)
    {
        if (g.LogFile == stdout)
            fflush(g.LogFile);
        else
            fclose(g.LogFile);
        g.LogFile = NULL;
    }
    if (g.LogClipboard->size() > 1)
    {
        if (g.IO.SetClipboardTextFn)
            g.IO.SetClipboardTextFn(g.LogClipboard->begin());
        g.LogClipboard->clear();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x40c8d(%rip), %rbx     # 0x55480
cmpb $0x1, 0x2be8(%rbx)
jne 0x14870
leaq 0x2cc35(%rip), %rdi     # 0x41438
xorl %eax, %eax
callq 0xde0d
movb $0x0, 0x2be8(%rbx)
movq 0x2bf0(%rbx), %rdi
testq %rdi, %rdi
je 0x14840
movq 0x407ac(%rip), %rax     # 0x54fd0
cmpq (%rax), %rdi
je 0x14830
callq 0x7330
jmp 0x14835
callq 0x73a0
movq $0x0, 0x2bf0(%rbx)
movq 0x2bf8(%rbx), %rdi
cmpl $0x3, (%rdi)
jl 0x14870
movq 0xc8(%rbx), %rax
testq %rax, %rax
je 0x14865
movq 0x8(%rdi), %rdi
callq *%rax
movq 0x2bf8(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x24658
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::CalcItemWidth()
float ImGui::CalcItemWidth()
{
    ImGuiWindow* window = GetCurrentWindowRead();
    float w = window->DC.ItemWidth;
    if (w < 0.0f)
    {
        // Align to a right-side limit. We include 1 frame padding in the calculation because this is how the width is always used (we add 2 frame padding to it), but we could move that responsibility to the widget as well.
        ImGuiState& g = *GImGui;
        float width_to_right_edge = ImGui::GetContentRegionAvail().x;
        w = ImMax(1.0f, width_to_right_edge + w - g.Style.FramePadding.x * 2.0f);
    }
    w = (float)(int)w;
    return w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x40bf7(%rip), %rbx     # 0x55480
movq 0x1758(%rbx), %r14
movss 0x11c(%r14), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jbe 0x148e4
movaps %xmm1, -0x20(%rbp)
callq 0xaf8c
movss 0xa8(%r14), %xmm1
subss 0x18(%r14), %xmm1
subss %xmm1, %xmm0
movaps -0x20(%rbp), %xmm1
addss %xmm0, %xmm1
movss 0x1408(%rbx), %xmm0
addss %xmm0, %xmm0
subss %xmm0, %xmm1
movss 0x28ab3(%rip), %xmm0    # 0x3d390
maxss %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttps2dq %xmm1, %xmm0
cvtdq2ps %xmm0, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::PushFont(ImFont*)
void ImGui::PushFont(ImFont* font)
{
    ImGuiState& g = *GImGui;
    if (!font)
        font = g.IO.Fonts->Fonts[0];
    SetCurrentFont(font);
    g.FontStack.push_back(font);
    g.CurrentWindow->DrawList->PushTextureID(font->ContainerAtlas->TexID);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x40b77(%rip), %r15     # 0x55480
testq %rdi, %rdi
jne 0x14926
movq 0x90(%r15), %rax
cmpl $0x0, 0x30(%rax)
jle 0x14a02
movq 0x38(%rax), %rax
movq (%rax), %rbx
movq %rbx, %rdi
callq 0xc07e
movl 0x17e8(%r15), %eax
cmpl 0x17ec(%r15), %eax
jne 0x14953
leal 0x1(%rax), %r12d
testl %eax, %eax
je 0x1495c
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
jmp 0x14961
movq 0x17f0(%r15), %r14
jmp 0x149d3
movl $0x8, %ecx
cmpl %r12d, %ecx
cmovgl %ecx, %r12d
movslq %r12d, %rdi
shlq $0x3, %rdi
movq 0x40b0a(%rip), %rax     # 0x55480
incl 0x334(%rax)
callq *0xd0(%rax)
movq %rax, %r14
movq 0x17f0(%r15), %rsi
movslq 0x17e8(%r15), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x7080
movq 0x17f0(%r15), %rdi
movq 0x40ad3(%rip), %rax     # 0x55480
testq %rdi, %rdi
je 0x149b8
decl 0x334(%rax)
callq *0xd8(%rax)
movq %r14, 0x17f0(%r15)
movl %r12d, 0x17ec(%r15)
movl 0x17e8(%r15), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x17e8(%r15)
cltq
movq %rbx, (%r14,%rax,8)
movq 0x1758(%r15), %rax
movq 0x270(%rax), %rdi
movq 0x30(%rbx), %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2d11e
leaq 0x2a3d7(%rip), %rdi     # 0x3ede0
leaq 0x2a0b3(%rip), %rsi     # 0x3eac3
leaq 0x2a872(%rip), %rcx     # 0x3f289
movl $0x31c, %edx            # imm = 0x31C
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: ImGui::PopFont()
void  ImGui::PopFont()
{
    ImGuiState& g = *GImGui;
    g.CurrentWindow->DrawList->PopTextureID();
    g.FontStack.pop_back();
    SetCurrentFont(g.FontStack.empty() ? g.IO.Fonts->Fonts[0] : g.FontStack.back());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x40a52(%rip), %rbx     # 0x55480
movq 0x1758(%rbx), %rax
movq 0x270(%rax), %rdi
callq 0x2d1b6
movl 0x17e8(%rbx), %eax
testl %eax, %eax
jle 0x14a87
decl %eax
movl %eax, 0x17e8(%rbx)
je 0x14a68
movq 0x17f0(%rbx), %rcx
movl %eax, %eax
leaq (%rcx,%rax,8), %rax
addq $-0x8, %rax
jmp 0x14a79
movq 0x90(%rbx), %rax
cmpl $0x0, 0x30(%rax)
jle 0x14aa6
movq 0x38(%rax), %rax
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc07e
leaq 0x320a7(%rip), %rdi     # 0x46b35
leaq 0x2a02e(%rip), %rsi     # 0x3eac3
leaq 0x2aa1a(%rip), %rcx     # 0x3f4b6
movl $0x338, %edx            # imm = 0x338
callq 0x7140
leaq 0x2a333(%rip), %rdi     # 0x3ede0
leaq 0x2a00f(%rip), %rsi     # 0x3eac3
leaq 0x2a7ce(%rip), %rcx     # 0x3f289
movl $0x31c, %edx            # imm = 0x31C
callq 0x7140
// File: /workspace/github_cpp_makefile_star2_O3/donfreiday[P]gb/./imgui/imgui.cpp
// Function: GetStyleVarFloatAddr(int)
static float* GetStyleVarFloatAddr(ImGuiStyleVar idx)
{
    ImGuiState& g = *GImGui;
    switch (idx)
    {
    case ImGuiStyleVar_Alpha: return &g.Style.Alpha;
    case ImGuiStyleVar_WindowRounding: return &g.Style.WindowRounding;
    case ImGuiStyleVar_ChildWindowRounding: return &g.Style.ChildWindowRounding;
    case ImGuiStyleVar_FrameRounding: return &g.Style.FrameRounding;
    case ImGuiStyleVar_IndentSpacing: return &g.Style.IndentSpacing;
    case ImGuiStyleVar_GrabMinSize: return &g.Style.GrabMinSize;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
cmpl $0xa, %edi
ja 0x14ee6
movq 0x405e3(%rip), %rcx     # 0x55480
movl %edi, %edx
leaq 0x2860e(%rip), %rsi     # 0x3d4b4
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
addq $0x13e8, %rcx           # imm = 0x13E8
jmp 0x14ee3
addq $0x1404, %rcx           # imm = 0x1404
jmp 0x14ee3
addq $0x1440, %rcx           # imm = 0x1440
jmp 0x14ee3
addq $0x13fc, %rcx           # imm = 0x13FC
jmp 0x14ee3
addq $0x1410, %rcx           # imm = 0x1410
jmp 0x14ee3
addq $0x1430, %rcx           # imm = 0x1430
movq %rcx, %rax
popq %rbp
retq